import * as _angular_core from '@angular/core';
import { TemplateRef, AfterContentInit } from '@angular/core';
import { OverlayAlign, OverlaySide } from '@edsis/component/overlay';

type MenuItemVariant = 'default' | 'destructive';
declare abstract class MenuFocusableItem {
    private readonly el;
    readonly disabledInput: _angular_core.InputSignal<boolean>;
    readonly inset: _angular_core.InputSignal<boolean>;
    readonly class: _angular_core.InputSignal<string>;
    readonly variant: _angular_core.InputSignal<MenuItemVariant>;
    readonly selected: _angular_core.OutputEmitterRef<MouseEvent | KeyboardEvent>;
    get disabled(): boolean;
    focus(): void;
    getLabel(): string;
    protected buildItemClasses(extraClass?: string): string;
    protected emitSelection(event: MouseEvent | KeyboardEvent): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuFocusableItem, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuFocusableItem, never, never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
}
declare class MenuGroupComponent {
    readonly class: _angular_core.InputSignal<string>;
    protected readonly classes: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuGroupComponent, "MenuGroup", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare abstract class MenuRadioGroupBase {
    abstract isChecked(value: string): boolean;
    abstract select(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioGroupBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuRadioGroupBase, never, never, {}, {}, never, never, true, never>;
}
declare class MenuRadioGroupComponent extends MenuRadioGroupBase {
    readonly value: _angular_core.ModelSignal<string | null>;
    readonly class: _angular_core.InputSignal<string>;
    protected readonly classes: _angular_core.Signal<string>;
    isChecked(value: string): boolean;
    select(value: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuRadioGroupComponent, "MenuRadioGroup", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
}
declare class MenuItemComponent extends MenuFocusableItem {
    protected readonly classes: _angular_core.Signal<string>;
    protected handleClick(e: MouseEvent | KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "MenuItem, button[MenuItem]", never, {}, {}, never, ["*"], true, never>;
}
declare class MenuCheckboxItemComponent extends MenuFocusableItem {
    readonly checked: _angular_core.ModelSignal<boolean>;
    protected readonly classes: _angular_core.Signal<string>;
    protected toggle(event: MouseEvent | KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuCheckboxItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuCheckboxItemComponent, "MenuCheckboxItem, button[MenuCheckboxItem]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, never>;
}
declare class MenuRadioItemComponent extends MenuFocusableItem {
    private readonly group;
    readonly value: _angular_core.InputSignal<string>;
    protected readonly checked: _angular_core.Signal<boolean>;
    protected readonly classes: _angular_core.Signal<string>;
    protected select(event: MouseEvent | KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuRadioItemComponent, "MenuRadioItem, button[MenuRadioItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class MenuSeparatorComponent {
    readonly class: _angular_core.InputSignal<string>;
    protected readonly classes: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuSeparatorComponent, "MenuSeparator", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}
declare class MenuLabelComponent {
    readonly inset: _angular_core.InputSignal<boolean>;
    readonly class: _angular_core.InputSignal<string>;
    protected readonly classes: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuLabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuLabelComponent, "MenuLabel", never, { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}
declare class MenuShortcutComponent {
    readonly class: _angular_core.InputSignal<string>;
    protected readonly classes: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuShortcutComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuShortcutComponent, "MenuShortcut, span[MenuShortcut]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Surface rendered inside the overlay. Hosts keyboard navigation for its items.
 */
declare class MenuSurfaceComponent implements AfterContentInit {
    readonly class: _angular_core.InputSignal<string>;
    private readonly items;
    private readonly injector;
    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
    private keyManager;
    protected readonly classes: _angular_core.Signal<string>;
    ngAfterContentInit(): void;
    protected onArrow(e: KeyboardEvent, delta: number): void;
    protected onHome(e: KeyboardEvent): void;
    protected onEnd(e: KeyboardEvent): void;
    protected onTab(e: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSurfaceComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuSurfaceComponent, "MenuSurface", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "closeRequested": "closeRequested"; }, ["items"], ["*"], true, never>;
}
/**
 * Wraps an `<ng-template>` that holds `<MenuSurface>` + items.
 */
declare class MenuContentDirective {
    readonly template: TemplateRef<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContentDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuContentDirective, "ng-template[MenuContent]", ["MenuContent"], {}, {}, never, never, true, never>;
}

type MenuSide = OverlaySide;
type MenuAlign = OverlayAlign;
/**
 * Opens an `<ng-template MenuContent>` anchored to the trigger element.
 */
declare class MenuTriggerDirective {
    private readonly overlay;
    private readonly vcr;
    private readonly el;
    private readonly destroyRef;
    readonly MenuTrigger: _angular_core.InputSignal<MenuContentDirective>;
    readonly side: _angular_core.InputSignal<OverlaySide>;
    readonly align: _angular_core.InputSignal<OverlayAlign>;
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
    private overlayRef;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    constructor();
    toggle(): void;
    protected openAndFocus(e: KeyboardEvent): void;
    protected openForSide(e: KeyboardEvent, side: MenuSide): void;
    open(): void;
    close(options?: {
        restoreFocus?: boolean;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[MenuTrigger]", ["MenuTrigger"], { "MenuTrigger": { "alias": "MenuTrigger"; "required": true; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
}

export { MenuCheckboxItemComponent, MenuContentDirective, MenuFocusableItem, MenuGroupComponent, MenuItemComponent, MenuLabelComponent, MenuRadioGroupBase, MenuRadioGroupComponent, MenuRadioItemComponent, MenuSeparatorComponent, MenuShortcutComponent, MenuSurfaceComponent, MenuTriggerDirective };
export type { MenuAlign, MenuItemVariant, MenuSide };