@ojiepermana/angular 22.1.13 → 22.2.0

package/types/ojiepermana-angular-component-dropdown-menu.d.ts

@@ -1,113 +1,190 @@
-import * as _angular_core from '@angular/core';
-import { InjectionToken, TemplateRef, AfterContentInit } from '@angular/core';
-import * as i1 from '@ojiepermana/angular/component/utils/scale';
-import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
-import { OverlayAlign, OverlaySide } from '@ojiepermana/angular/component/utils/overlay';
-
-type MenuItemVariant = 'default' | 'destructive';
-declare abstract class MenuFocusableItem {
-    private readonly el;
-    /** Present whenever the item is rendered inside a `MenuTrigger` overlay. */
-    private readonly overlay;
-    /** True when this same element also opens a submenu. */
-    private readonly opensSubmenu;
-    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;
-    /**
-     * Consume the keystroke that activated the item.
-     *
-     * Items render on `button` hosts, and a button turns Enter and Space into an
-     * activation click of its own. With `(click)` and `(keydown.enter|space)` both
-     * wired to the same handler that click runs the handler a SECOND time: a
-     * checkbox toggled on keydown flipped straight back, so `aria-checked` never
-     * moved, and a plain item emitted `selected` twice whenever the menu was told
-     * not to close. Preventing the default suppresses the synthesised click, which
-     * leaves exactly one activation per keystroke on native and non-native hosts
-     * alike. It also stops Space from scrolling the page behind the menu.
-     */
-    protected emitSelection(event: MouseEvent | KeyboardEvent): boolean;
-    /**
-     * Close the menu and return focus to the trigger, which is the menu pattern.
-     *
-     * Call this AFTER the item has updated its own state: closing tears down the
-     * overlay view, and a checkbox or radio that wrote its model afterwards would
-     * never propagate the change. A consumer that already closes the menu by hand
-     * is fine, closing twice is a no-op.
-     */
-    protected finishSelection(): void;
-    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>;
+import * as i0 from "@angular/core";
+import { AfterContentInit, InjectionToken, TemplateRef } from "@angular/core";
+import * as i1 from "@ojiepermana/angular/component/utils/scale";
+import { ComponentScaleDirective } from "@ojiepermana/angular/component/utils/scale";
+import { OverlayAlign, OverlaySide } from "@ojiepermana/angular/component/utils/overlay";
+export type MenuItemVariant = 'default' | 'destructive';
+export declare abstract class MenuFocusableItem {
+  private readonly el;
+  /** Present whenever the item is rendered inside a `MenuTrigger` overlay. */
+  private readonly overlay;
+  /** True when this same element also opens a submenu. */
+  private readonly opensSubmenu;
+  readonly disabledInput: import("@angular/core").InputSignal<boolean>;
+  readonly inset: import("@angular/core").InputSignal<boolean>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  readonly variant: import("@angular/core").InputSignal<MenuItemVariant>;
+  readonly selected: import("@angular/core").OutputEmitterRef<MouseEvent | KeyboardEvent>;
+  get disabled(): boolean;
+  focus(): void;
+  getLabel(): string;
+  protected buildItemClasses(extraClass?: string): string;
+  /**
+   * Consume the keystroke that activated the item.
+   *
+   * Items render on `button` hosts, and a button turns Enter and Space into an
+   * activation click of its own. With `(click)` and `(keydown.enter|space)` both
+   * wired to the same handler that click runs the handler a SECOND time: a
+   * checkbox toggled on keydown flipped straight back, so `aria-checked` never
+   * moved, and a plain item emitted `selected` twice whenever the menu was told
+   * not to close. Preventing the default suppresses the synthesised click, which
+   * leaves exactly one activation per keystroke on native and non-native hosts
+   * alike. It also stops Space from scrolling the page behind the menu.
+   */
+  protected emitSelection(event: MouseEvent | KeyboardEvent): boolean;
+  /**
+   * Close the menu and return focus to the trigger, which is the menu pattern.
+   *
+   * Call this AFTER the item has updated its own state: closing tears down the
+   * overlay view, and a checkbox or radio that wrote its model afterwards would
+   * never propagate the change. A consumer that already closes the menu by hand
+   * is fine, closing twice is a no-op.
+   */
+  protected finishSelection(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuFocusableItem, never>;
+  static ɵdir: i0.ɵɵ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>;
+export declare class MenuGroupComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuGroupComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare abstract class MenuRadioGroupBase {
+  abstract isChecked(value: string): boolean;
+  abstract select(value: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuRadioGroupBase, never>;
+  static ɵdir: i0.ɵɵ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>;
+export declare class MenuRadioGroupComponent extends MenuRadioGroupBase {
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  isChecked(value: string): boolean;
+  select(value: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuRadioGroupComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare class MenuItemComponent extends MenuFocusableItem {
+  protected readonly classes: import("@angular/core").Signal<string>;
+  protected handleClick(e: MouseEvent | KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare class MenuCheckboxItemComponent extends MenuFocusableItem {
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  protected toggle(event: MouseEvent | KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuCheckboxItemComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare class MenuRadioItemComponent extends MenuFocusableItem {
+  private readonly group;
+  readonly value: import("@angular/core").InputSignal<string>;
+  protected readonly checked: import("@angular/core").Signal<boolean>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  protected select(event: MouseEvent | KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuRadioItemComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare class MenuSeparatorComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare class MenuLabelComponent {
+  readonly inset: import("@angular/core").InputSignal<boolean>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuLabelComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+export declare class MenuShortcutComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuShortcutComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenuShortcutComponent, "MenuShortcut, span[MenuShortcut]", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-
 /**
  * Internal bridge from a menu surface (and its items) back to the trigger that
  * opened it.
@@ -125,26 +202,26 @@ declare class MenuShortcutComponent {
  * It is a coordination token between library entry points, not something a
  * consumer needs to provide or inject.
  */
-interface MenuOverlayController {
-    /** Id given to the surface element, so the trigger can point `aria-controls` at it. */
-    readonly surfaceId: string;
-    /** Id of the trigger element, so the surface can point `aria-labelledby` back. */
-    readonly triggerId: string;
-    /**
-     * True when this menu was opened from an item of another menu.
-     *
-     * It is what tells the surface whether ArrowLeft is its own key. A submenu
-     * closes on ArrowLeft and hands focus back to the item that opened it; a root
-     * menu must let the key through, because the row of menus above it (a
-     * `Menubar`) uses left and right to walk between menus.
-     */
-    readonly isSubmenu: boolean;
-    /** Close the overlay and hand focus back to the trigger. Safe to call twice. */
-    close(): void;
-    /** Close after an item was chosen, unless this menu opted out with `closeOnSelect`. */
-    closeAfterSelect(): void;
+export interface MenuOverlayController {
+  /** Id given to the surface element, so the trigger can point `aria-controls` at it. */
+  readonly surfaceId: string;
+  /** Id of the trigger element, so the surface can point `aria-labelledby` back. */
+  readonly triggerId: string;
+  /**
+   * True when this menu was opened from an item of another menu.
+   *
+   * It is what tells the surface whether ArrowLeft is its own key. A submenu
+   * closes on ArrowLeft and hands focus back to the item that opened it; a root
+   * menu must let the key through, because the row of menus above it (a
+   * `Menubar`) uses left and right to walk between menus.
+   */
+  readonly isSubmenu: boolean;
+  /** Close the overlay and hand focus back to the trigger. Safe to call twice. */
+  close(): void;
+  /** Close after an item was chosen, unless this menu opted out with `closeOnSelect`. */
+  closeAfterSelect(): void;
 }
-declare const MENU_OVERLAY: InjectionToken<MenuOverlayController>;
+export declare const MENU_OVERLAY: InjectionToken<MenuOverlayController>;
 /**
  * Marker every `MenuTrigger` provides on its own element.
  *
@@ -152,97 +229,142 @@ declare const MENU_OVERLAY: InjectionToken<MenuOverlayController>;
  * submenu, not close the menu it lives in, so an item that finds this marker on
  * itself skips the close-after-select step.
  */
-declare const MENU_SUBMENU_TRIGGER: InjectionToken<boolean>;
-
+export declare const MENU_SUBMENU_TRIGGER: InjectionToken<boolean>;
 /**
  * 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;
-    /** Present whenever the surface is rendered by a `MenuTrigger`. */
-    private readonly overlay;
-    /**
-     * Emitted when the surface asks to be closed (today: on Tab). The trigger now
-     * closes itself, so consumers no longer have to wire this up; it stays for
-     * anyone who already listens to it.
-     */
-    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
-    /** Tied to the trigger's `aria-controls`, so the pair references each other. */
-    readonly surfaceId: string;
-    /** Names the menu after the control that opened it. */
-    readonly labelledBy: string | null;
-    private keyManager;
-    protected readonly classes: _angular_core.Signal<string>;
-    ngAfterContentInit(): void;
-    protected onArrow(e: KeyboardEvent, delta: number): void;
-    protected onArrowLeft(e: KeyboardEvent): void;
-    protected onHome(e: KeyboardEvent): void;
-    protected onEnd(e: KeyboardEvent): void;
-    protected onTypeAhead(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, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+export declare class MenuSurfaceComponent implements AfterContentInit {
+  readonly class: import("@angular/core").InputSignal<string>;
+  private readonly items;
+  /** Present whenever the surface is rendered by a `MenuTrigger`. */
+  private readonly overlay;
+  /**
+   * Emitted when the surface asks to be closed (today: on Tab). The trigger now
+   * closes itself, so consumers no longer have to wire this up; it stays for
+   * anyone who already listens to it.
+   */
+  readonly closeRequested: import("@angular/core").OutputEmitterRef<void>;
+  /** Tied to the trigger's `aria-controls`, so the pair references each other. */
+  readonly surfaceId: string;
+  /** Names the menu after the control that opened it. */
+  readonly labelledBy: string | null;
+  private keyManager;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  ngAfterContentInit(): void;
+  protected onArrow(e: KeyboardEvent, delta: number): void;
+  protected onArrowLeft(e: KeyboardEvent): void;
+  protected onHome(e: KeyboardEvent): void;
+  protected onEnd(e: KeyboardEvent): void;
+  protected onTypeAhead(e: KeyboardEvent): void;
+  protected onTab(e: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuSurfaceComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenuSurfaceComponent, "MenuSurface", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closeRequested": "closeRequested";
+  }, ["items"], ["*"], true, [{
+    directive: typeof i1.ComponentScaleDirective;
+    inputs: {
+      "radius": "radius";
+      "density": "density";
+    };
+    outputs: {};
+  }]>;
 }
 /**
  * Wraps an `<ng-template>` that holds `<MenuSurface>` + items.
  */
-declare class MenuContentDirective {
-    protected readonly componentScale: ComponentScaleDirective;
-    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
-    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
-    readonly template: TemplateRef<unknown>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuContentDirective, "ng-template[MenuContent]", ["MenuContent"], {}, {}, never, never, true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+export declare class MenuContentDirective {
+  protected readonly componentScale: ComponentScaleDirective;
+  readonly radius: import("@angular/core").InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+  readonly density: import("@angular/core").InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+  readonly template: TemplateRef<unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MenuContentDirective, "ng-template[MenuContent]", ["MenuContent"], {}, {}, never, never, true, [{
+    directive: typeof i1.ComponentScaleDirective;
+    inputs: {
+      "radius": "radius";
+      "density": "density";
+    };
+    outputs: {};
+  }]>;
 }
-
-type MenuSide = OverlaySide;
-type MenuAlign = OverlayAlign;
+export type MenuSide = OverlaySide;
+export 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;
-    private readonly injector;
-    /**
-     * The controller of the menu this trigger lives in, if any. Present only when
-     * the trigger is itself an item of another menu, which is exactly what makes
-     * the menu it opens a submenu.
-     */
-    private readonly parentMenu;
-    readonly MenuTrigger: _angular_core.InputSignal<MenuContentDirective>;
-    readonly side: _angular_core.InputSignal<OverlaySide>;
-    readonly align: _angular_core.InputSignal<OverlayAlign>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    /**
-     * Close the menu when an item is chosen, which is the WAI ARIA menu pattern
-     * and the default here. Set it to `false` for a menu that stays open, for
-     * example a list of checkbox items the user toggles several of in a row.
-     */
-    readonly closeOnSelect: _angular_core.InputSignal<boolean>;
-    /**
-     * Id used for `aria-controls` and for the surface's `aria-labelledby`. A
-     * consumer's own `id` on the trigger element always wins.
-     */
-    readonly triggerId: string;
-    readonly surfaceId: string;
-    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; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
-}
-
-export { MENU_OVERLAY, MENU_SUBMENU_TRIGGER, MenuCheckboxItemComponent, MenuContentDirective, MenuFocusableItem, MenuGroupComponent, MenuItemComponent, MenuLabelComponent, MenuRadioGroupBase, MenuRadioGroupComponent, MenuRadioItemComponent, MenuSeparatorComponent, MenuShortcutComponent, MenuSurfaceComponent, MenuTriggerDirective };
-export type { MenuAlign, MenuItemVariant, MenuOverlayController, MenuSide };
+export declare class MenuTriggerDirective {
+  private readonly overlay;
+  private readonly vcr;
+  private readonly el;
+  private readonly destroyRef;
+  private readonly injector;
+  /**
+   * The controller of the menu this trigger lives in, if any. Present only when
+   * the trigger is itself an item of another menu, which is exactly what makes
+   * the menu it opens a submenu.
+   */
+  private readonly parentMenu;
+  readonly MenuTrigger: import("@angular/core").InputSignal<MenuContentDirective>;
+  readonly side: import("@angular/core").InputSignal<OverlaySide>;
+  readonly align: import("@angular/core").InputSignal<OverlayAlign>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Close the menu when an item is chosen, which is the WAI ARIA menu pattern
+   * and the default here. Set it to `false` for a menu that stays open, for
+   * example a list of checkbox items the user toggles several of in a row.
+   */
+  readonly closeOnSelect: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Id used for `aria-controls` and for the surface's `aria-labelledby`. A
+   * consumer's own `id` on the trigger element always wins.
+   */
+  readonly triggerId: string;
+  readonly surfaceId: string;
+  readonly openedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  private overlayRef;
+  readonly isOpen: import("@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: i0.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵ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;
+    };
+    "closeOnSelect": {
+      "alias": "closeOnSelect";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "openedChange": "openedChange";
+  }, never, never, true, never>;
+}