import * as i0 from '@angular/core';
import { AfterViewInit, QueryList, EventEmitter } from '@angular/core';
import { FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
import { Router } from '@angular/router';
import * as i1 from '@angular/cdk/menu';

/**
 * Type of the callback function that is called when the MenuLink is selected.
 *
 * ### Import
 *
 * ```typescript
 * import { TSelectCallback } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuComponent}
 */
type TSelectCallback = (menuLink: MenuLinkComponent) => void;
/**
 * MenuLink is a container for links in a Menu. It requires a label and can optionally have an icon on the left.
 *
 * MenuLink can have a router link and/or a callback. The callback will be called before the router link is navigated
 * to. If there is no select callback and no router link the MenuLink will be displayed as disabled.
 *
 * MenuLink can have an action icon which will be displayed on the right-hand side. The action icon can be displayed as
 * disabled.
 *
 * ```html
 * <talenra-menu-link label="Menu" routerLink="/menu" />
 * <talenra-menu-link label="Refresh" icon="ini" [selectCallback]="menuItemSelected" />
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { MenuLinkComponent } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuComponent}
 *
 * <example-url>../../#/menu</example-url>
 */
declare class MenuLinkComponent implements FocusableOption {
    /**
     * The label of the MenuLink.
     * @required
     */
    label: i0.InputSignal<string>;
    /**
     * The icon of the MenuLink.
     * @optional
     */
    icon: i0.InputSignal<string | undefined>;
    /**
     * The router link of the MenuLink.
     * @optional
     */
    routerLink: i0.InputSignal<string | undefined>;
    /**
     * The shortcut of the MenuLink.
     * @optional
     *
     * If a shortcut is provided the actionIcon will be ignored
     */
    shortcut: i0.InputSignal<string | undefined>;
    /**
     * The action icon of the MenuLink.
     * @optional
     *
     * If a shortcut is provided the actionIcon will be ignored
     */
    actionIcon: i0.InputSignal<string | undefined>;
    /**
     * The callback function that is called when the MenuLink is selected.
     * @optional
     */
    selectCallback?: TSelectCallback;
    /**
     * Whether the action icon is disabled.
     * @optional
     */
    actionIconDisabled: boolean;
    /**
     * Whether the MenuLink is disabled.
     * @optional
     */
    disabled?: boolean;
    /** @internal */
    router: Router;
    private get pointerDisabled();
    /** @internal */
    focus(_origin?: FocusOrigin | undefined): void;
    /** @internal */
    getLabel?(): string;
    private onSelect;
    private onSelectByEnter;
    private onClickOrSelect;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuLinkComponent, "talenra-menu-link", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "shortcut": { "alias": "shortcut"; "required": false; "isSignal": true; }; "actionIcon": { "alias": "actionIcon"; "required": false; "isSignal": true; }; "selectCallback": { "alias": "selectCallback"; "required": false; }; "actionIconDisabled": { "alias": "actionIconDisabled"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CdkMenuItem; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_actionIconDisabled: unknown;
    static ngAcceptInputType_disabled: unknown;
}

/**
 * Menu is a container for a list of menu items.
 *
 * There are three different menu items
 * - MenuLink: A clickable menu item that navigates to a different page and/or triggers a given callback
 * - MenuActionItem: A non-clickable menu item that can be used as container for action items
 * - MenuSeparator: A horizontal line that separates menu items
 *
 * ```html
 * <talenra-menu>
 *   <talenra-menu-link routerLink="/home">Home</talenra-menu-link>
 *   <talenra-menu-link routerLink="/about">About</talenra-menu-link>
 *   <talenra-menu-link routerLink="/contact">Contact</talenra-menu-link>
 *   <talenra-menu-separator></talenra-menu-separator>
 *   <talenra-menu-action-item>
 *     <talenra-icon name="flag-circle" (click)="setPriority('high')"></talenra-icon>
 *     <talenra-icon name="flag-circle" (click)="setPriority('medium')"></talenra-icon>
 *     <talenra-icon name="flag-circle" (click)="setPriority('low')"></talenra-icon>
 *   </talenra-menu-action-item>
 * </talenra-menu>
 *
 * ### Import
 *
 * ```typescript
 * import { MenuComponent } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuLinkComponent}
 * @see {@link MenuActionItemComponent}
 * @see {@link MenuSeparatorComponent}
 * @see {@link MenuAnchorDirective}
 *
 * <example-url>../../#/menu</example-url>
 */
declare class MenuComponent implements AfterViewInit {
    /** @internal */
    menuItems: QueryList<MenuLinkComponent>;
    private keyManager;
    /**
     * Attaches the key manager to the menu items
     *
     * @internal
     */
    ngAfterViewInit(): void;
    /**
     * Handles keyboard events for menu navigation
     *
     * @internal
     */
    onKeydown(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuComponent, "talenra-menu", never, {}, {}, ["menuItems"], ["*"], true, [{ directive: typeof i1.CdkMenu; inputs: {}; outputs: {}; }]>;
}

/**
 * MenuActionItem is a container for action items in a menu.
 *
 * ```html
 * <talenra-menu-action-item>
 *   <talenra-icon name="flag-circle" (click)="setPriority('high')"></talenra-icon>
 *   <talenra-icon name="flag-circle" (click)="setPriority('medium')"></talenra-icon>
 *   <talenra-icon name="flag-circle" (click)="setPriority('low')"></talenra-icon>
 * </talenra-menu-action-item>
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { MenuActionItemComponent } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuComponent}
 *
 * <example-url>../../../#/menu</example-url>
 */
declare class MenuActionItemComponent {
    /**
     * The label of the action item.
     *
     * @required
     */
    label: i0.InputSignal<string>;
    /**
     * The icon of the action item.
     *
     * @optional
     */
    icon: i0.InputSignal<string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuActionItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuActionItemComponent, "talenra-menu-action-item", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Assigned to an element, MenuAnchor triggers the associated Menu. MenuAnchor provides `triggerFor` input property. It
 * will trigger the template with a matching id.
 *
 * ```html
 * <span talenraMenuAnchor [triggerFor]="myMenu">My Menu</span>
 * <ng-template #myMenu>
 *   <talenra-menu><!-- Menu content goes here --></talenra-menu>
 * </ng-template>
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { MenuAnchorDirective } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuComponent}
 *
 * <example-url>../../../#/menu</example-url>
 */
declare class MenuAnchorDirective implements FocusableOption, AfterViewInit {
    /**
     * Emits when the associated menu is opened.
     *
     * @internal
     */
    menuOpen: EventEmitter<void>;
    /**
     * Emits when the associated menu is closed.
     *
     * @internal
     */
    menuClose: EventEmitter<void>;
    private elementRef;
    private cdkMenuTrigger;
    private destroyRef;
    /**
     * Implements the FocusableOption interface.
     *
     * @internal
     */
    disabled?: boolean | undefined;
    private handleScroll;
    /** @internal */
    ngAfterViewInit(): void;
    /**
     * Implements the FocusableOption interface.
     *
     * @internal
     */
    focus(): void;
    /** @internal */
    getLabel(): string;
    /**
     * Opens the associated menu.
     *
     * This method triggers the `cdkMenuTrigger` to open the menu associated with this anchor.
     * It can be used to programmatically open the menu.
     *
     * @internal
     */
    open(): void;
    /**
     * Closes the associated menu.
     *
     * This method triggers the `cdkMenuTrigger` to close the menu associated with this anchor.
     * It can be used to programmatically close the menu.
     *
     * @internal
     */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuAnchorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MenuAnchorDirective, "[talenraMenuAnchor]", never, {}, { "menuOpen": "menuOpen"; "menuClose": "menuClose"; }, never, never, true, [{ directive: typeof i1.CdkMenuItem; inputs: {}; outputs: {}; }, { directive: typeof i1.CdkMenuTrigger; inputs: { "cdkMenuTriggerFor": "triggerFor"; }; outputs: {}; }]>;
}

/**
 * MenuSeparator is used to organize Menu content.
 *
 * ```html
 * <talenra-menu>
 *   <talenra-menu-link>Home</talenra-menu-link>
 *   <talenra-menu-separator></talenra-menu-separator>
 *   <talenra-menu-link>About</talenra-menu-link>
 * </talenra-menu>
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { MenuSeparatorComponent } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuComponent}
 *
 * <example-url>../../#/menu</example-url>
 */
declare class MenuSeparatorComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuSeparatorComponent, "talenra-menu-separator", never, {}, {}, never, never, true, never>;
}

/**
 * MenuBar is a container for a group of related Menus.
 *
 * It handles closing other menus when a menu is opened and thus helps preventing a stack of open menus.
 *
 * ```html
 * <talenra-menu-bar>
 *   <span talenraMenuAnchor [triggerFor]="mymenu">My Menu</span>
 *   <span talenraMenuAnchor [triggerFor]="yourmenu">Your Menu</span>
 * </talenra-menu-bar>
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { MenuBarComponent } from '@talenra/ngx-base/menu';
 * ```
 *
 * @see {@link MenuComponent}
 * @see {@link MenuAnchorDirective}
 *
 * <example-url>../../#/menu</example-url>
 */
declare class MenuBarComponent implements AfterViewInit {
    private destroyRef;
    private openedMenuItem;
    private lastOpenedIndex;
    private numberOfMenuItems;
    private keyManager;
    private firstKeyboardInteraction;
    /** @internal */
    menuItems: QueryList<MenuAnchorDirective>;
    /** @internal */
    ngAfterViewInit(): void;
    /** @internal */
    onKeydown(event: KeyboardEvent): void;
    private getMenuAnchorIndex;
    private openMenuItemAtIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuBarComponent, "talenra-menu-bar", never, {}, {}, ["menuItems"], ["*"], true, [{ directive: typeof i1.CdkMenuBar; inputs: {}; outputs: {}; }]>;
}

/**
 * MenuTitle is used to organize menu content.
 *
 * It requires a label to display the title.
 *
 * ```html
 * <talenra-menu-title label="Menu" />
 * ```
 *
 * ### Import
 *
 * ```typescript
 * import { MenuTitleComponent } from '@talenra/ngx-base/menu';
 * ```
 *
 * <example-url>../../#/menu</example-url>
 */
declare class MenuTitleComponent {
    /**
     * The label to display for the title.
     */
    label: i0.InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MenuTitleComponent, "talenra-menu-title", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

export { MenuActionItemComponent, MenuAnchorDirective, MenuBarComponent, MenuComponent, MenuLinkComponent, MenuSeparatorComponent, MenuTitleComponent };
export type { TSelectCallback };