import * as i2 from '@angular/cdk/overlay';
import { Overlay, OverlayRef } from '@angular/cdk/overlay';
import * as _angular_core from '@angular/core';
import { Injector, ViewContainerRef, TemplateRef, Type, OnDestroy, ChangeDetectorRef, AfterContentInit, AfterViewInit, ElementRef } from '@angular/core';
import { Observable } from 'rxjs';
import * as i6 from '@daffodil/design';
import { DaffLazyComponent, DaffPrefixDirective } from '@daffodil/design';
import * as i1 from '@angular/common';
import { ConfigurableFocusTrapFactory, FocusableOption } from '@angular/cdk/a11y';

/**
 * The horizontal alignment of the menu relative to its activator.
 *
 * - `after` lines the menu's left edge up with the activator's left edge.
 * - `before` lines the menu's right edge up with the activator's right edge.
 */
type DaffMenuXPosition = 'before' | 'after';
/**
 * The vertical position of the menu relative to its activator.
 *
 * - `below` drops the menu down from the activator's bottom edge.
 * - `above` raises the menu up from the activator's top edge.
 */
type DaffMenuYPosition = 'above' | 'below';

/**
 * Configuration for a menu instance.
 */
interface DaffMenuConfig {
    /**
     * A unique identifier for the menu instance.
     */
    menuId?: string;
    /**
     * The horizontal alignment of the menu relative to its activator. Defaults to `after`.
     */
    xPosition?: DaffMenuXPosition;
    /**
     * The vertical position of the menu relative to its activator. Defaults to `below`.
     */
    yPosition?: DaffMenuYPosition;
}

type DaffMenuSlot = TemplateRef<unknown> | DaffLazyComponent | Type<unknown>;
declare class DaffMenuService {
    protected overlay: Overlay;
    private injector;
    protected _overlay: OverlayRef | null;
    private _activator;
    private $_open;
    open$: Observable<boolean>;
    constructor(overlay: Overlay, injector: Injector);
    /**
     * @docs-private
     */
    protected _createOverlay(activatorElement: ViewContainerRef, component: DaffMenuSlot, config?: DaffMenuConfig): Promise<void>;
    /**
     * @docs-private
     */
    protected _destroyOverlay(): void;
    close(): void;
    open(activator: ViewContainerRef, component: DaffMenuSlot, config?: DaffMenuConfig): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DaffMenuService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DaffMenuService>;
}

/**
 * Directive that triggers the menu to open/close. Applied to the button that activates the menu. The selector doubles as an input for the menu content to display.
 *
 * @example
 * ```html
 * <button [daffMenuActivator]="menu">
 *   Open Menu
 * </button>
 * ```
 */
declare class DaffMenuActivatorDirective implements OnDestroy {
    private service;
    private viewContainerRef;
    private cdRef;
    private _destroyed$;
    private _defaultMenuId;
    protected _open: boolean;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    /**
     * The menu content to display when activated.
     */
    daffMenuActivator: _angular_core.InputSignal<Type<unknown> | TemplateRef<unknown>>;
    /**
     * An optional ID for the activator.
     * When set, the menu's ID is derived as `${id}-menu`.
     */
    id: _angular_core.InputSignal<string>;
    /**
     * The horizontal alignment of the menu relative to the activator. Defaults to `after`.
     */
    xPosition: _angular_core.InputSignal<DaffMenuXPosition>;
    /**
     * The vertical position of the menu relative to the activator. Defaults to `below`.
     */
    yPosition: _angular_core.InputSignal<DaffMenuYPosition>;
    /**
     * The resolved menu ID.
     */
    protected menuId: _angular_core.Signal<string>;
    /**
     * @docs-private
     */
    get ariaExpanded(): "true" | "false";
    constructor(service: DaffMenuService, viewContainerRef: ViewContainerRef, cdRef: ChangeDetectorRef);
    /**
     * @docs-private
     */
    ngOnDestroy(): void;
    /**
     * @docs-private
     */
    focus(): void;
    /**
     * @docs-private
     */
    onClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DaffMenuActivatorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DaffMenuActivatorDirective, "[daffMenuActivator]", ["daffMenuActivator"], { "daffMenuActivator": { "alias": "daffMenuActivator"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "xPosition": { "alias": "xPosition"; "required": false; "isSignal": true; }; "yPosition": { "alias": "yPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The floating panel that contains menu items.
 *
 * @example
 * ```html
 * <daff-menu>
 *  <button daff-menu-item>
 *    <fa-icon [icon]="faEdit" daffPrefix></fa-icon>
 *      Edit
 *    </button>
 *    <button daff-menu-item>
 *      <fa-icon [icon]="faTrash" daffPrefix></fa-icon>
 *      Delete
 *    </button>
 *    <a href="/settings" daff-menu-item>
 *      <fa-icon [icon]="faCog" daffPrefix></fa-icon>
 *      Settings
 *    </a>
 * </daff-menu>
 * ```
 */
declare class DaffMenuComponent implements AfterContentInit, AfterViewInit {
    private _focusTrapFactory;
    private _elementRef;
    private menuService;
    /**
     * @docs-private
     */
    readonly config: DaffMenuConfig;
    private _focusTrap;
    private _keyManager;
    /**
     * @docs-private
     *
     * Content children that provide `DAFF_MENU_ITEM_TOKEN` are treated as menu items.
     * This includes both `daff-menu-item` components and any custom directives that also provide the token.
     */
    private _items;
    constructor(_focusTrapFactory: ConfigurableFocusTrapFactory, _elementRef: ElementRef<HTMLElement>, menuService: DaffMenuService, 
    /**
     * @docs-private
     */
    config: DaffMenuConfig);
    /**
     * @docs-private
     *
     * Handles keyboard navigation.
     */
    handleKeydown(event: KeyboardEvent): void;
    /**
     * @docs-private
     */
    ngAfterContentInit(): void;
    /**
     * @docs-private
     */
    ngAfterViewInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DaffMenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DaffMenuComponent, "daff-menu", never, {}, {}, ["_items"], ["*"], true, never>;
}

/**
 * Individual clickable items within the menu. Applied to `<button>` or `<a>` elements.
 *
 * @example
 * ```
 * <a daff-menu-item href="/">Settings</a>
 * <button daff-menu-item href="/">Settings</button>
 * ```
 */
declare class DaffMenuItemComponent implements FocusableOption {
    private _elementRef;
    private _menuService;
    /**
     * @docs-private
     */
    _prefix: DaffPrefixDirective;
    constructor(_elementRef: ElementRef<HTMLElement>, _menuService: DaffMenuService);
    /**
     * @docs-private
     */
    onClick(): void;
    /**
     * Focus the menu item.
     */
    focus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DaffMenuItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DaffMenuItemComponent, "a[daff-menu-item],button[daff-menu-item]", never, {}, {}, ["_prefix"], ["[daffPrefix]", "*"], true, never>;
}

/**
 * @deprecated in favor of {@link DAFF_MENU_COMPONENTS} Deprecated in version 0.92.0. Will be removed in version 0.95.0.
 */
declare class DaffMenuModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DaffMenuModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DaffMenuModule, never, [typeof i1.CommonModule, typeof i2.OverlayModule, typeof DaffMenuActivatorDirective, typeof DaffMenuComponent, typeof DaffMenuItemComponent, typeof i6.DaffPrefixDirective], [typeof DaffMenuActivatorDirective, typeof DaffMenuComponent, typeof DaffMenuItemComponent, typeof i6.DaffPrefixDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DaffMenuModule>;
}

/**
 * @docs-private
 */
declare const DAFF_MENU_COMPONENTS: readonly [typeof DaffMenuComponent, typeof DaffMenuActivatorDirective, typeof DaffMenuItemComponent, typeof DaffPrefixDirective];

/**
 * Injection token/provider pair used to identify menu items.
 *
 * `DaffMenuComponent` uses `@ContentChildren(DAFF_MENU_ITEM_TOKEN)` to discover
 * its menu items. Use `provideDaffMenuItemToken` in component providers to register
 * custom directives and components as menu items alongside native `daff-menu-item` elements.
 */
declare const DAFF_MENU_ITEM_TOKEN: _angular_core.InjectionToken<FocusableOption>;
declare const provideDaffMenuItemToken: <R extends FocusableOption = FocusableOption>(klass: _angular_core.Type<R>) => _angular_core.ExistingProvider;

export { DAFF_MENU_COMPONENTS, DAFF_MENU_ITEM_TOKEN, DaffMenuActivatorDirective, DaffMenuComponent, DaffMenuItemComponent, DaffMenuModule, DaffMenuService, provideDaffMenuItemToken };
export type { DaffMenuConfig, DaffMenuSlot, DaffMenuXPosition, DaffMenuYPosition };