@ojiepermana/angular 22.1.14 → 22.2.1

package/types/ojiepermana-angular-component-menubar.d.ts

@@ -1,93 +1,123 @@
-import * as _angular_core from '@angular/core';
-import { TemplateRef } from '@angular/core';
-
-type MenubarAlign = 'start' | 'center' | 'end';
-declare class MenubarComponent {
-    readonly class: _angular_core.InputSignal<string>;
-    readonly loop: _angular_core.InputSignal<boolean>;
-    private readonly triggers;
-    private readonly host;
-    private readonly row;
-    protected readonly classes: _angular_core.Signal<string>;
-    setActiveTrigger(trigger: MenubarTriggerDirective): void;
-    tabIndexFor(trigger: MenubarTriggerDirective): number;
-    hasOpenTrigger(except?: MenubarTriggerDirective): boolean;
-    notifyOpen(trigger: MenubarTriggerDirective): void;
-    notifyClosed(trigger: MenubarTriggerDirective): void;
-    /**
-     * Move from an open menu to the neighbouring menubar item.
-     *
-     * A trigger calls this when a left or right arrow arrives while focus is
-     * inside its overlay, which the menubar itself cannot see: the overlay renders
-     * at the end of the document, so the keydown never bubbles up to here. The
-     * open menu closes, focus lands on the neighbour, and the neighbour's menu
-     * opens, which is the menubar keyboard pattern.
-     */
-    moveToSiblingMenu(from: MenubarTriggerDirective, direction: 'previous' | 'next'): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenubarComponent, "Menubar", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, {}, ["triggers"], ["*"], true, never>;
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+export type MenubarAlign = 'start' | 'center' | 'end';
+export declare class MenubarComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  readonly loop: import("@angular/core").InputSignal<boolean>;
+  private readonly triggers;
+  private readonly host;
+  private readonly row;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  setActiveTrigger(trigger: MenubarTriggerDirective): void;
+  tabIndexFor(trigger: MenubarTriggerDirective): number;
+  hasOpenTrigger(except?: MenubarTriggerDirective): boolean;
+  notifyOpen(trigger: MenubarTriggerDirective): void;
+  notifyClosed(trigger: MenubarTriggerDirective): void;
+  /**
+   * Move from an open menu to the neighbouring menubar item.
+   *
+   * A trigger calls this when a left or right arrow arrives while focus is
+   * inside its overlay, which the menubar itself cannot see: the overlay renders
+   * at the end of the document, so the keydown never bubbles up to here. The
+   * open menu closes, focus lands on the neighbour, and the neighbour's menu
+   * opens, which is the menubar keyboard pattern.
+   */
+  moveToSiblingMenu(from: MenubarTriggerDirective, direction: 'previous' | 'next'): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenubarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenubarComponent, "Menubar", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "loop": {
+      "alias": "loop";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["triggers"], ["*"], true, never>;
 }
-declare class MenubarMenuComponent {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarMenuComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenubarMenuComponent, "MenubarMenu", never, {}, {}, never, ["*"], true, never>;
+export declare class MenubarMenuComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenubarMenuComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MenubarMenuComponent, "MenubarMenu", never, {}, {}, never, ["*"], true, never>;
 }
-declare class MenubarContentDirective {
-    readonly template: TemplateRef<unknown>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenubarContentDirective, "ng-template[MenubarContent]", ["MenubarContent"], {}, {}, never, never, true, never>;
+export declare class MenubarContentDirective {
+  readonly template: TemplateRef<unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenubarContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MenubarContentDirective, "ng-template[MenubarContent]", ["MenubarContent"], {}, {}, never, never, true, never>;
 }
-declare class MenubarTriggerDirective {
-    readonly MenubarTrigger: _angular_core.InputSignal<MenubarContentDirective>;
-    readonly align: _angular_core.InputSignal<MenubarAlign>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    /**
-     * Close the menu when an item is chosen, which is the menu pattern and the
-     * default. Matches the input of the same name on `[MenuTrigger]`, because both
-     * render the same `MenuSurface` and `MenuItem` components.
-     */
-    readonly closeOnSelect: _angular_core.InputSignal<boolean>;
-    /** Ties `aria-controls` here to `aria-labelledby` on the surface. */
-    readonly triggerId: string;
-    readonly surfaceId: string;
-    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
-    readonly isOpen: _angular_core.WritableSignal<boolean>;
-    private readonly overlay;
-    private readonly vcr;
-    private readonly el;
-    private readonly menubar;
-    private readonly destroyRef;
-    private readonly injector;
-    private overlayRef;
-    constructor();
-    toggle(): void;
-    open(options?: {
-        focusFirstItem?: boolean;
-    }): void;
-    close(options?: {
-        restoreFocus?: boolean;
-        emitOpenedChange?: boolean;
-    }): void;
-    focus(): void;
-    containsTarget(target: EventTarget | null): boolean;
-    protected tabIndex(): number;
-    /**
-     * A disabled trigger normally carries the native `disabled` attribute, which
-     * takes it out of the tab order for free. The one exception is the trigger
-     * holding the menubar's only tab stop, which happens when every sibling is
-     * disabled too: there the native attribute would undo the tab stop the
-     * menubar just handed out, so the state travels as `aria-disabled` alone.
-     * Every action on this directive already refuses on `disabled()`, so nothing
-     * becomes operable by dropping the attribute.
-     */
-    protected nativeDisabled(): boolean;
-    protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;
-    protected syncActiveState(): void;
-    protected openFromHover(): void;
-    private focusFirstItem;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenubarTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenubarTriggerDirective, "[MenubarTrigger]", ["MenubarTrigger"], { "MenubarTrigger": { "alias": "MenubarTrigger"; "required": true; "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 { MenubarComponent, MenubarContentDirective, MenubarMenuComponent, MenubarTriggerDirective };
-export type { MenubarAlign };
+export declare class MenubarTriggerDirective {
+  readonly MenubarTrigger: import("@angular/core").InputSignal<MenubarContentDirective>;
+  readonly align: import("@angular/core").InputSignal<MenubarAlign>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Close the menu when an item is chosen, which is the menu pattern and the
+   * default. Matches the input of the same name on `[MenuTrigger]`, because both
+   * render the same `MenuSurface` and `MenuItem` components.
+   */
+  readonly closeOnSelect: import("@angular/core").InputSignal<boolean>;
+  /** Ties `aria-controls` here to `aria-labelledby` on the surface. */
+  readonly triggerId: string;
+  readonly surfaceId: string;
+  readonly openedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  private readonly overlay;
+  private readonly vcr;
+  private readonly el;
+  private readonly menubar;
+  private readonly destroyRef;
+  private readonly injector;
+  private overlayRef;
+  constructor();
+  toggle(): void;
+  open(options?: {
+    focusFirstItem?: boolean;
+  }): void;
+  close(options?: {
+    restoreFocus?: boolean;
+    emitOpenedChange?: boolean;
+  }): void;
+  focus(): void;
+  containsTarget(target: EventTarget | null): boolean;
+  protected tabIndex(): number;
+  /**
+   * A disabled trigger normally carries the native `disabled` attribute, which
+   * takes it out of the tab order for free. The one exception is the trigger
+   * holding the menubar's only tab stop, which happens when every sibling is
+   * disabled too: there the native attribute would undo the tab stop the
+   * menubar just handed out, so the state travels as `aria-disabled` alone.
+   * Every action on this directive already refuses on `disabled()`, so nothing
+   * becomes operable by dropping the attribute.
+   */
+  protected nativeDisabled(): boolean;
+  protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;
+  protected syncActiveState(): void;
+  protected openFromHover(): void;
+  private focusFirstItem;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenubarTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MenubarTriggerDirective, "[MenubarTrigger]", ["MenubarTrigger"], {
+    "MenubarTrigger": {
+      "alias": "MenubarTrigger";
+      "required": true;
+      "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>;
+}

package/types/ojiepermana-angular-component-native-select.d.ts

@@ -1,26 +1,39 @@
-import * as _angular_core from '@angular/core';
-
-declare class NativeSelectComponent {
-    private readonly el;
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly classes: _angular_core.Signal<string>;
-    focus(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeSelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NativeSelectComponent, "select[NativeSelect]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+import * as i0 from "@angular/core";
+export declare class NativeSelectComponent {
+  private readonly el;
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  focus(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NativeSelectComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<NativeSelectComponent, "select[NativeSelect]", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-
-declare class NativeSelectOptionDirective {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeSelectOptionDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NativeSelectOptionDirective, "option[NativeSelectOption]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+export declare class NativeSelectOptionDirective {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NativeSelectOptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NativeSelectOptionDirective, "option[NativeSelectOption]", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-
-declare class NativeSelectOptGroupDirective {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeSelectOptGroupDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NativeSelectOptGroupDirective, "optgroup[NativeSelectOptGroup]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { NativeSelectComponent, NativeSelectOptGroupDirective, NativeSelectOptionDirective };
+export declare class NativeSelectOptGroupDirective {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NativeSelectOptGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NativeSelectOptGroupDirective, "optgroup[NativeSelectOptGroup]", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

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

@@ -1,104 +1,163 @@
-import * as _angular_core from '@angular/core';
-import { ElementRef, TemplateRef } from '@angular/core';
-
-type NavigationMenuAlign = 'start' | 'center' | 'end';
-type NavigationMenuLinkVariant = 'trigger' | 'content';
-declare abstract class NavigationMenuRootItem {
-    protected readonly elementRef: ElementRef<HTMLElement>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    isWithin(container: HTMLElement): boolean;
-    focus(): void;
-    containsTarget(target: EventTarget | null): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuRootItem, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuRootItem, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+import * as i0 from "@angular/core";
+import { ElementRef, TemplateRef } from "@angular/core";
+export type NavigationMenuAlign = 'start' | 'center' | 'end';
+export type NavigationMenuLinkVariant = 'trigger' | 'content';
+export declare abstract class NavigationMenuRootItem {
+  protected readonly elementRef: ElementRef<HTMLElement>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  isWithin(container: HTMLElement): boolean;
+  focus(): void;
+  containsTarget(target: EventTarget | null): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuRootItem, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationMenuRootItem, never, never, {
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
 }
-declare class NavigationMenuComponent {
-    readonly class: _angular_core.InputSignal<string>;
-    readonly ariaLabel: _angular_core.InputSignal<string>;
-    readonly loop: _angular_core.InputSignal<boolean>;
-    private readonly items;
-    private readonly host;
-    private readonly row;
-    protected readonly classes: _angular_core.Signal<string>;
-    setActiveItem(item: NavigationMenuRootItem): void;
-    tabIndexFor(item: NavigationMenuRootItem): number;
-    hasOpenTrigger(except?: NavigationMenuTriggerDirective): boolean;
-    notifyOpen(trigger: NavigationMenuTriggerDirective): void;
-    notifyClosed(trigger: NavigationMenuTriggerDirective): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    private enter;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMenuComponent, "NavigationMenu", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+export declare class NavigationMenuComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  readonly loop: import("@angular/core").InputSignal<boolean>;
+  private readonly items;
+  private readonly host;
+  private readonly row;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  setActiveItem(item: NavigationMenuRootItem): void;
+  tabIndexFor(item: NavigationMenuRootItem): number;
+  hasOpenTrigger(except?: NavigationMenuTriggerDirective): boolean;
+  notifyOpen(trigger: NavigationMenuTriggerDirective): void;
+  notifyClosed(trigger: NavigationMenuTriggerDirective): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  private enter;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuComponent, "NavigationMenu", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "loop": {
+      "alias": "loop";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["items"], ["*"], true, never>;
 }
-declare class NavigationMenuListComponent {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuListComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMenuListComponent, "NavigationMenuList", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+export declare class NavigationMenuListComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuListComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuListComponent, "NavigationMenuList", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-declare class NavigationMenuItemComponent {
-    readonly class: _angular_core.InputSignal<string>;
-    protected readonly classes: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuItemComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationMenuItemComponent, "NavigationMenuItem", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+export declare class NavigationMenuItemComponent {
+  readonly class: import("@angular/core").InputSignal<string>;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<NavigationMenuItemComponent, "NavigationMenuItem", never, {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-declare class NavigationMenuContentDirective {
-    readonly template: TemplateRef<unknown>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuContentDirective, "ng-template[NavigationMenuContent]", ["NavigationMenuContent"], {}, {}, never, never, true, never>;
+export declare class NavigationMenuContentDirective {
+  readonly template: TemplateRef<unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationMenuContentDirective, "ng-template[NavigationMenuContent]", ["NavigationMenuContent"], {}, {}, never, never, true, never>;
 }
-declare class NavigationMenuTriggerDirective extends NavigationMenuRootItem {
-    readonly NavigationMenuTrigger: _angular_core.InputSignal<NavigationMenuContentDirective>;
-    readonly align: _angular_core.InputSignal<NavigationMenuAlign>;
-    readonly class: _angular_core.InputSignal<string>;
-    /** Ties `aria-controls` here to the overlay this trigger discloses. */
-    readonly panelId: string;
-    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
-    readonly isOpen: _angular_core.WritableSignal<boolean>;
-    private readonly overlay;
-    private readonly vcr;
-    private readonly navigationMenu;
-    private readonly destroyRef;
-    private overlayRef;
-    constructor();
-    protected readonly classes: _angular_core.Signal<string>;
-    toggle(): void;
-    open(options?: {
-        focusFirstItem?: boolean;
-    }): void;
-    close(options?: {
-        restoreFocus?: boolean;
-        emitOpenedChange?: boolean;
-    }): void;
-    protected tabIndex(): number;
-    /**
-     * A disabled trigger normally carries the native `disabled` attribute, which
-     * takes it out of the tab order for free. The one exception is the trigger
-     * holding the menu's only tab stop, which happens when every sibling is
-     * disabled too: there the native attribute would undo the tab stop, so the
-     * state travels as `aria-disabled` alone. Every action here already refuses
-     * on `disabled()`, so nothing becomes operable by dropping the attribute.
-     */
-    protected nativeDisabled(): boolean;
-    protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;
-    protected syncActiveState(): void;
-    protected openFromHover(): void;
-    private focusFirstItem;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuTriggerDirective, "[NavigationMenuTrigger]", ["NavigationMenuTrigger"], { "NavigationMenuTrigger": { "alias": "NavigationMenuTrigger"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+export declare class NavigationMenuTriggerDirective extends NavigationMenuRootItem {
+  readonly NavigationMenuTrigger: import("@angular/core").InputSignal<NavigationMenuContentDirective>;
+  readonly align: import("@angular/core").InputSignal<NavigationMenuAlign>;
+  readonly class: import("@angular/core").InputSignal<string>;
+  /** Ties `aria-controls` here to the overlay this trigger discloses. */
+  readonly panelId: string;
+  readonly openedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  private readonly overlay;
+  private readonly vcr;
+  private readonly navigationMenu;
+  private readonly destroyRef;
+  private overlayRef;
+  constructor();
+  protected readonly classes: import("@angular/core").Signal<string>;
+  toggle(): void;
+  open(options?: {
+    focusFirstItem?: boolean;
+  }): void;
+  close(options?: {
+    restoreFocus?: boolean;
+    emitOpenedChange?: boolean;
+  }): void;
+  protected tabIndex(): number;
+  /**
+   * A disabled trigger normally carries the native `disabled` attribute, which
+   * takes it out of the tab order for free. The one exception is the trigger
+   * holding the menu's only tab stop, which happens when every sibling is
+   * disabled too: there the native attribute would undo the tab stop, so the
+   * state travels as `aria-disabled` alone. Every action here already refuses
+   * on `disabled()`, so nothing becomes operable by dropping the attribute.
+   */
+  protected nativeDisabled(): boolean;
+  protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;
+  protected syncActiveState(): void;
+  protected openFromHover(): void;
+  private focusFirstItem;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationMenuTriggerDirective, "[NavigationMenuTrigger]", ["NavigationMenuTrigger"], {
+    "NavigationMenuTrigger": {
+      "alias": "NavigationMenuTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "openedChange": "openedChange";
+  }, never, never, true, never>;
 }
-declare class NavigationMenuLinkDirective extends NavigationMenuRootItem {
-    readonly class: _angular_core.InputSignal<string>;
-    readonly variant: _angular_core.InputSignal<NavigationMenuLinkVariant>;
-    private readonly navigationMenu;
-    protected readonly classes: _angular_core.Signal<string>;
-    protected tabIndex(): number;
-    focus(): void;
-    protected syncActiveState(): void;
-    protected preventDisabled(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationMenuLinkDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavigationMenuLinkDirective, "a[NavigationMenuLink], button[NavigationMenuLink]", ["NavigationMenuLink"], { "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { NavigationMenuComponent, NavigationMenuContentDirective, NavigationMenuItemComponent, NavigationMenuLinkDirective, NavigationMenuListComponent, NavigationMenuRootItem, NavigationMenuTriggerDirective };
-export type { NavigationMenuAlign, NavigationMenuLinkVariant };
+export declare class NavigationMenuLinkDirective extends NavigationMenuRootItem {
+  readonly class: import("@angular/core").InputSignal<string>;
+  readonly variant: import("@angular/core").InputSignal<NavigationMenuLinkVariant>;
+  private readonly navigationMenu;
+  protected readonly classes: import("@angular/core").Signal<string>;
+  protected tabIndex(): number;
+  focus(): void;
+  protected syncActiveState(): void;
+  protected preventDisabled(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<NavigationMenuLinkDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationMenuLinkDirective, "a[NavigationMenuLink], button[NavigationMenuLink]", ["NavigationMenuLink"], {
+    "class": {
+      "alias": "class";
+      "required": false;
+      "isSignal": true;
+    };
+    "variant": {
+      "alias": "variant";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}