@koobiq/components 20.4.1 → 21.0.0

package/{dropdown/index.d.ts → types/koobiq-components-dropdown.d.ts}

@@ -1,26 +1,15 @@
-import { AnimationTriggerMetadata, AnimationEvent } from '@angular/animations';
-import * as i0 from '@angular/core';
-import { OnDestroy, Signal, InjectionToken, TemplateRef, EventEmitter, QueryList, ElementRef, AfterContentInit, OnInit } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, InjectionToken, Signal, WritableSignal, TemplateRef, OutputEmitterRef, ElementRef, AfterContentInit } from '@angular/core';
 import { Subject, Observable } from 'rxjs';
 import { FocusOrigin } from '@angular/cdk/a11y';
-import { KbqPanelWidth, KbqPanelMinWidth, KbqPanelMaxWidth, KbqTitleTextRef, IFocusableOption, Highlightable, KbqComponentColors, KbqSiblingPopup, KbqPanelWidthOrigin, KbqTriangle } from '@koobiq/components/core';
+import { KbqPanelWidth, KbqPanelMinWidth, KbqPanelMaxWidth, KbqTitleTextRef, IFocusableOption, Highlightable, KbqComponentColors, KbqSiblingPopup, KbqPanelWidthOrigin, KbqOverlayOrigin, KbqPoint } from '@koobiq/components/core';
 import * as i2 from '@koobiq/components/icon';
 import { KbqIcon } from '@koobiq/components/icon';
 import { Direction } from '@angular/cdk/bidi';
 import * as _angular_forms from '@angular/forms';
+import * as _koobiq_components_dropdown from '@koobiq/components/dropdown';
 import * as i1 from '@angular/cdk/overlay';
-import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
-
-/**
- * Animations used by the kbq-dropdown component.
- * @docs-private
- */
-declare const kbqDropdownAnimations: {
-    readonly transformDropdown: AnimationTriggerMetadata;
-    readonly fadeInItems: AnimationTriggerMetadata;
-};
-declare const fadeInItems: AnimationTriggerMetadata;
-declare const transformDropdown: AnimationTriggerMetadata;
+import { ScrollStrategy, ScrollDispatcher } from '@angular/cdk/overlay';
 
 /**
  * Dropdown content that will be rendered lazily once the dropdown is opened.
@@ -37,61 +26,36 @@ declare class KbqDropdownContent implements OnDestroy {
     private outlet;
     /**
      * Attaches the content with a particular context.
+     *
      * @docs-private
      */
     attach(context?: any): void;
     /**
      * Detaches the content.
+     *
      * @docs-private
      */
     detach(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownContent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownContent, "ng-template[kbqDropdownContent]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownContent, "ng-template[kbqDropdownContent]", never, {}, {}, never, never, true, never>;
 }
 
-/**
- * Throws an exception for the case when dropdown trigger doesn't have a valid kbq-dropdown instance
- * @docs-private
- */
-declare function throwKbqDropdownMissingError(): void;
-/**
- * Throws an exception for the case when dropdown's x-position value isn't valid.
- * In other words, it doesn't match 'before' or 'after'.
- * @docs-private
- */
-declare function throwKbqDropdownInvalidPositionX(): void;
-/**
- * Throws an exception for the case when dropdown's y-position value isn't valid.
- * In other words, it doesn't match 'above' or 'below'.
- * @docs-private
- */
-declare function throwKbqDropdownInvalidPositionY(): void;
-/**
- * Throws an exception for the case when `kbqDropdownSearch` is applied to a form field that doesn't
- * host a `kbqInput`.
- * @docs-private
- */
-declare function throwKbqDropdownSearchMissingInputError(): void;
-/**
- * Throws an exception for the case when `kbqDropdownSearch`'s input isn't bound to a form control, so
- * there is no query to react to.
- * @docs-private
- */
-declare function throwKbqDropdownSearchMissingNgControlError(): void;
-
 /**
  * Narrow view of `KbqDropdownItem` that `KbqDropdownItemAction` needs. Read through
  * `KBQ_DROPDOWN_ITEM_ACTION_HOST` instead of importing `KbqDropdownItem` directly: the item
  * imports `KbqDropdownItemAction` for its `contentChild` query, so an import back from here would
  * form a circular dependency between the two files, which breaks the query at runtime (the
  * predicate ends up captured as `undefined`).
+ *
  * @docs-private
  */
 interface KbqDropdownItemActionHost {
-    readonly disabled: boolean;
+    readonly disabled: Signal<boolean>;
     readonly progress: Signal<boolean>;
 }
+/** @docs-private */
+declare const KBQ_DROPDOWN_ITEM_ACTION_HOST: InjectionToken<KbqDropdownItemActionHost>;
 /**
  * Marks a secondary, independently-focusable/clickable element (e.g. a settings link) projected
  * inside a `kbq-dropdown-item` alongside the item's own primary action. Requires the item's host
@@ -120,56 +84,44 @@ declare class KbqDropdownItemAction {
      * disabled/loading — `<a>` has no native `disabled`.
      */
     protected onClick(event: MouseEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownItemAction, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownItemAction, "[kbqDropdownItemAction]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownItemAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownItemAction, "[kbqDropdownItemAction]", never, {}, {}, never, never, true, never>;
 }
 
 /** Position of the dropdown panel along the x-axis. */
 type KbqDropdownPositionX = 'before' | 'after' | 'center';
-/**
- * @deprecated Use `KbqDropdownPositionX` instead.
- * @docs-private
- */
-type DropdownPositionX = KbqDropdownPositionX;
 /** Position of the dropdown panel along the y-axis. */
 type KbqDropdownPositionY = 'above' | 'below';
-/**
- * @deprecated Use `KbqDropdownPositionY` instead.
- * @docs-private
- */
-type DropdownPositionY = KbqDropdownPositionY;
 /** Reason why the menu was closed. */
 type DropdownCloseReason = void | 'click' | 'keydown' | 'tab';
 /**
  * Interface for a custom dropdown panel that can be used with `kbqDropdownTriggerFor`.
+ *
  * @docs-private
  */
 interface KbqDropdownPanel {
-    xPosition: KbqDropdownPositionX;
-    yPosition: KbqDropdownPositionY;
-    overlapTriggerX: boolean;
-    overlapTriggerY: boolean;
-    templateRef: TemplateRef<any>;
-    closed: EventEmitter<DropdownCloseReason>;
+    xPosition: WritableSignal<KbqDropdownPositionX>;
+    yPosition: WritableSignal<KbqDropdownPositionY>;
+    overlapTriggerX: WritableSignal<boolean>;
+    overlapTriggerY: WritableSignal<boolean>;
+    templateRef: Signal<TemplateRef<any>>;
+    closed: OutputEmitterRef<DropdownCloseReason>;
     parent?: KbqDropdownPanel | undefined;
-    /**
-     * @deprecated Has no effect. Use `KbqDropdownTrigger.widthOrigin` to make the panel match
-     * an element other than the trigger. Will be removed in v21.
-     */
-    triggerWidth?: string;
     panelWidth?: Signal<KbqPanelWidth>;
     panelMinWidth?: Signal<KbqPanelMinWidth>;
     panelMaxWidth?: Signal<KbqPanelMaxWidth>;
     direction?: Direction;
-    lazyContent?: KbqDropdownContent;
-    backdropClass?: string;
-    hasBackdrop?: boolean;
-    items: QueryList<KbqDropdownItem>;
+    lazyContent?: Signal<KbqDropdownContent | undefined>;
+    backdropClass?: Signal<string>;
+    hasBackdrop?: Signal<boolean>;
+    items: Signal<readonly KbqDropdownItem[]>;
     /** Whether the panel highlights the active item instead of focusing it, see `KbqDropdownSearch`. */
     readonly inSearchMode?: Signal<boolean>;
     focusFirstItem(origin?: FocusOrigin): void;
     resetActiveItem(): void;
     setPositionClasses?(x: KbqDropdownPositionX, y: KbqDropdownPositionY): void;
+    /** Lends the panel the parent's items, for a submenu initialised as a child of the root panel. */
+    adoptItems?(items: readonly KbqDropdownItem[]): void;
 }
 /** Default `kbq-dropdown` options that can be overridden. */
 interface KbqDropdownDefaultOptions {
@@ -206,6 +158,7 @@ interface KbqDropdownDefaultOptions {
 }
 /**
  * Injection token used to provide the parent dropdown to dropdown-specific components.
+ *
  * @docs-private
  */
 declare const KBQ_DROPDOWN_PANEL: InjectionToken<KbqDropdownPanel>;
@@ -214,35 +167,53 @@ declare const KBQ_DROPDOWN_DEFAULT_OPTIONS: InjectionToken<KbqDropdownDefaultOpt
 /** @docs-private */
 declare function KBQ_DROPDOWN_DEFAULT_OPTIONS_FACTORY(): KbqDropdownDefaultOptions;
 
+/** Secondary line of a `kbq-dropdown-item`, shown under the item's text. */
+declare class KbqDropdownItemCaption {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownItemCaption, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownItemCaption, "[kbqDropdownItemCaption]", never, {}, {}, never, never, true, never>;
+}
 /**
  * This directive is intended to be used inside an kbq-dropdown tag.
- * It exists mostly to set the role attribute.
+ *
+ * Note that it sets no ARIA role: neither the panel nor its items currently carry menu semantics, so
+ * triggers must not advertise a popup they cannot describe.
  */
 declare class KbqDropdownItem implements KbqTitleTextRef, KbqDropdownItemActionHost, IFocusableOption, Highlightable, OnDestroy {
     private elementRef;
     private focusMonitor;
     parentDropdownPanel?: KbqDropdownPanel | null | undefined;
-    textElement: ElementRef;
-    icon: KbqIcon;
+    private readonly textElementQuery;
+    /** Element holding the text of the item, measured by `kbq-title`. */
+    get textElement(): ElementRef;
+    readonly icon: _angular_core.Signal<KbqIcon | undefined>;
     /** Secondary, independently-focusable icon action projected into the item (e.g. a settings link). */
-    readonly itemAction: i0.Signal<KbqDropdownItemAction | undefined>;
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    private _disabled;
+    readonly itemAction: _angular_core.Signal<KbqDropdownItemAction | undefined>;
+    /** Whether the dropdown item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the dropdown item is in a loading state. */
-    readonly progress: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly progress: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Stream that emits when the dropdown item is hovered. */
     readonly hovered: Subject<KbqDropdownItem>;
     /** Stream that emits when the menu item is focused. */
     readonly focused: Subject<KbqDropdownItem>;
     /** Whether the dropdown item is highlighted. */
-    highlighted: boolean;
+    get highlighted(): boolean;
+    set highlighted(value: boolean);
+    private readonly highlightedState;
     /** Whether the item is the panel's active item while DOM focus is held elsewhere. */
-    protected readonly active: i0.WritableSignal<boolean>;
+    protected readonly active: _angular_core.WritableSignal<boolean>;
     /** Whether the dropdown item acts as a trigger for a nested dropdown. */
     isNested: boolean;
     /** @docs-private */
     protected readonly componentColors: typeof KbqComponentColors;
+    /**
+     * Whether the progress shimmer stands still.
+     *
+     * @docs-private
+     */
+    protected readonly animationsDisabled: boolean;
+    /** Memoised `getLabel()` result, keyed on the raw text it was derived from. */
+    private cachedLabel?;
     constructor();
     ngOnDestroy(): void;
     resetStyles(): void;
@@ -258,6 +229,8 @@ declare class KbqDropdownItem implements KbqTitleTextRef, KbqDropdownItemActionH
      * the meantime. `preventScroll` is therefore always forced on, overriding `options`.
      */
     focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Body of `focus()`. */
+    private focusItem;
     /** Returns the host DOM element. */
     getHostElement(): HTMLElement;
     /** Used to set the `tabindex`. */
@@ -266,19 +239,24 @@ declare class KbqDropdownItem implements KbqTitleTextRef, KbqDropdownItemActionH
     checkDisabled(event: Event): void;
     /** Emits to the hover stream. Bound via `host` metadata. */
     handleMouseEnter(): void;
+    /** Handles key presses on the item. Bound via `host` metadata. */
+    protected handleKeydown(event: KeyboardEvent): void;
+    /** Replays ENTER/SPACE as a click on a non-interactive host (e.g. a `<div>` item with a secondary action). */
+    private handleActivationKeydown;
     /**
      * Lets Tab move focus between the host and `itemAction` without leaving the dropdown
      * (`stopPropagation` only — the browser's native focus move still happens). Any other Tab
      * press, i.e. actually leaving the item, is left untouched and still closes the dropdown via
-     * the panel's `FocusKeyManager.tabOut`. Bound via `host` metadata.
+     * the panel's `FocusKeyManager.tabOut`.
      */
-    protected handleActionKeydown(event: KeyboardEvent): void;
+    private handleActionKeydown;
     /** Gets the label to be used when determining whether the option should be focused. */
     getLabel(): string;
+    /** Concatenates the item's own text, skipping icons and the projected action. */
+    private readLabel;
     haltDisabledEvents(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownItem, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDropdownItem, "kbq-dropdown-item, [kbq-dropdown-item]", ["kbqDropdownItem"], { "disabled": { "alias": "disabled"; "required": false; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, ["itemAction", "icon"], ["[kbq-icon]", "*", "[kbqDropdownItemAction]"], true, never>;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqDropdownItem, "kbq-dropdown-item, [kbq-dropdown-item]", ["kbqDropdownItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, ["icon", "itemAction"], ["[kbq-icon]", "*", "[kbqDropdownItemAction]"], true, never>;
 }
 
 /**
@@ -292,9 +270,10 @@ declare class KbqDropdownSearch implements AfterContentInit {
     /**
      * Panel this field searches. A nested panel declared inside its parent's content shares the view with
      * it, so the parent has to be able to tell which of the projected fields is its own.
+     *
      * @docs-private
      */
-    readonly panel: KbqDropdownPanel | null;
+    readonly panel: _koobiq_components_dropdown.KbqDropdownPanel | null;
     /** The form control the query is bound to. */
     get ngControl(): _angular_forms.NgControl | null;
     ngAfterContentInit(): void;
@@ -310,8 +289,8 @@ declare class KbqDropdownSearch implements AfterContentInit {
     protected handleKeydown(event: KeyboardEvent): void;
     /** Whether the key still has caret to travel inside the field, rather than acting on the panel. */
     private movesCaret;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownSearch, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownSearch, "[kbqDropdownSearch]", ["kbqDropdownSearch"], {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownSearch, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownSearch, "[kbqDropdownSearch]", ["kbqDropdownSearch"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -320,23 +299,17 @@ declare class KbqDropdownSearch implements AfterContentInit {
  */
 declare const KBQ_DROPDOWN_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
 /** @docs-private */
-declare function KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
-/** @docs-private */
+declare function KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY(scrollDispatcher: ScrollDispatcher): () => ScrollStrategy;
+/**
+ * Redundant to the root factory of the token; kept so an app can restore the default under its own override (#DS-2196).
+ *
+ * @docs-private
+ */
 declare const KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY_PROVIDER: {
     provide: InjectionToken<() => ScrollStrategy>;
-    deps: (typeof Overlay)[];
+    deps: (typeof ScrollDispatcher)[];
     useFactory: typeof KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY;
 };
-/**
- * Marker provided by host components that create their own stacking context at
- * the default overlay z-index (e.g. `KbqTopBar`, `KbqNavbar` use
- * `position: sticky` + `z-index: $overlay-z-index`). When this token is
- * available in the injector tree, `KbqDropdownTrigger` defaults `demoteOverlay`
- * to `false` so the dropdown overlay is not lowered below the host.
- *
- * An explicit `[demoteOverlay]` binding on the trigger still wins.
- */
-declare const KBQ_DROPDOWN_HOST: InjectionToken<unknown>;
 /** Default top padding of the nested dropdown panel. */
 declare const NESTED_PANEL_TOP_PADDING = 4;
 declare const NESTED_PANEL_LEFT_PADDING = 8;
@@ -346,57 +319,58 @@ declare const NESTED_PANEL_LEFT_PADDING = 8;
  */
 declare class KbqDropdownTrigger implements AfterContentInit, OnDestroy, KbqSiblingPopup {
     private overlay;
+    private readonly overlayLayers;
     private elementRef;
     private viewContainerRef;
     private scrollStrategy;
     private parent;
     private dropdownItemInstance;
     private _dir;
-    private changeDetectorRef;
     private focusMonitor;
-    private readonly overlayContainer;
-    private readonly renderer;
-    private readonly ngZone;
+    private readonly document;
+    private readonly injector;
     protected readonly isBrowser: boolean;
-    private readonly host;
     lastDestroyReason: DropdownCloseReason;
     /**
      * Element whose width the panel should match. Defaults to the trigger itself.
      * Useful when the trigger is only a part of a larger control, e.g. `kbq-split-button`.
+     *
      * @docs-private
      */
     widthOrigin?: KbqPanelWidthOrigin;
     /** Position offset of the dropdown in the X axis. */
-    offsetX: number;
+    readonly offsetX: _angular_core.ModelSignal<number | undefined>;
     /** Position offset of the dropdown in the Y axis. */
-    offsetY: number;
+    readonly offsetY: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
     /** Data to be passed along to any lazily-rendered content. */
-    data: any;
-    openByArrowDown: boolean;
+    readonly data: _angular_core.InputSignal<any>;
+    /** Whether the Down Arrow opens the dropdown when the trigger is focused. Written by `kbq-navbar-item`. */
+    readonly openByArrowDown: _angular_core.ModelSignal<boolean>;
     /**
-     * Whether to demote the overlay container z-index so that dropdown overlays
-     * sit below sibling overlays (tooltips, modals, etc.). Set to `false` to
-     * keep the dropdown overlay at the default overlay container z-index.
+     * What the panel is positioned against: an element, or a rectangle in viewport coordinates such as the one
+     * `kbqCreateCaretOrigin` keeps on the caret. `null` anchors the panel to the trigger element.
+     *
+     * Call {@link updatePosition} to move an open panel to a new origin.
      */
-    demoteOverlay: boolean;
+    readonly origin: _angular_core.InputSignal<KbqOverlayOrigin | null>;
+    /**
+     * Whether opening the dropdown moves the keyboard focus into the panel. Turn it off to leave focus where it
+     * is — in the editor the panel is anchored to, for instance — and pair it with `activeDescendantNavigation`
+     * on the panel so the arrow keys still work.
+     */
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * Whether focus should be restored when the menu is closed.
      * Note that disabling this option can have accessibility implications
      * and it's up to you to manage focus, if you decide to turn it off.
      */
-    restoreFocus: boolean;
+    readonly restoreFocus: _angular_core.ModelSignal<boolean>;
     /** References the dropdown instance that the trigger is associated with. */
-    get dropdown(): KbqDropdownPanel;
-    set dropdown(dropdown: KbqDropdownPanel);
-    private _dropdown;
+    readonly dropdown: _angular_core.InputSignal<KbqDropdownPanel>;
     /** Event emitted when the associated dropdown is opened. */
-    readonly dropdownOpened: i0.OutputEmitterRef<void>;
-    /**
-     * Event emitted when the associated dropdown is closed. Kept as an `@Output()` EventEmitter
-     * (not `output()`): `KbqOptionActionComponent` subscribes to it via `.pipe()` through the
-     * KBQ_OPTION_ACTION_PARENT contract, which an `OutputEmitterRef` does not support — see #DS-5079.
-     */
-    readonly dropdownClosed: EventEmitter<void>;
+    readonly dropdownOpened: _angular_core.OutputEmitterRef<void>;
+    /** Event emitted when the associated dropdown is closed. */
+    readonly dropdownClosed: _angular_core.OutputEmitterRef<void>;
     /** Emits `true` when the dropdown opens and `false` when it closes. Part of the `KbqSiblingPopup` contract. */
     readonly openedChange: Observable<boolean>;
     openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
@@ -404,36 +378,63 @@ declare class KbqDropdownTrigger implements AfterContentInit, OnDestroy, KbqSibl
     get dir(): Direction;
     /** Whether the dropdown is open. */
     get opened(): boolean;
+    /**
+     * `aria-expanded` only where a role allows it: on a generic `<div>`/`<span>` it fails `aria-allowed-attr`.
+     *
+     * @docs-private
+     */
+    protected get ariaExpanded(): boolean | null;
+    private get hasExpandableRole();
     /**
      * Whether the dropdown overlay is currently attached. Part of the `KbqSiblingPopup` contract.
      *
-     * `opened` is set synchronously right after the overlay is attached and, on close, only once the exit
-     * animation is done — i.e. it stays `true` for the whole time the trigger is busy with its panel,
-     * including the moment `destroy()` restores focus to the trigger.
+     * Set right after the overlay is attached and cleared right after it is detached, once `destroy()` has
+     * restored focus to the trigger, so a tooltip on the trigger stays muted for that focus.
      */
     get isAttached(): boolean;
-    private _opened;
+    private readonly openedState;
     private portal;
     private overlayRef;
-    private closeSubscription;
+    /** Per-session subscription to `closingActions()`; torn down on every close. */
+    private closingActionsSubscription;
     private hoverSubscription;
-    private widthLockSubscription;
-    private classAddedToOverlayContainer;
+    private widthLockRef;
     constructor();
+    /**
+     * Subscribes the triggers of a panel to its `closed` once, so that an emission closes the triggers that had the
+     * panel open when it began: a trigger that a `dropdownClosed` handler opens on the way stays open.
+     *
+     * @returns Teardown that unbinds the trigger.
+     */
+    private static bindToPanel;
+    /** Closes the panel this trigger has open on its `closed`, and the chain of panels it is nested in. */
+    private closeFromPanel;
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
     /** Whether the dropdown triggers a nested dropdown or a top-level one. */
     isNested(): boolean;
     /** Toggles the dropdown between the open and closed states. */
     toggle(): void;
+    /** Moves an open panel to the current origin and re-applies its position. */
+    updatePosition(): void;
     /** Opens the dropdown. */
     open(): void;
+    /** Body of `open()`. */
+    private openPanel;
     /** Closes the dropdown. */
     close(): void;
     /**
      * Focuses the dropdown trigger.
      */
     focus(origin?: FocusOrigin, options?: FocusOptions): void;
+    /** Whether focus is still the overlay's to give back, i.e. an outside click hasn't moved it elsewhere. */
+    private overlayHoldsFocus;
+    /**
+     * Takes the focus off the detached panel. A renderer can keep its view in the document for a while
+     * (`provideAnimations()` does, until its engine flushes), and the panel this one is nested in would not count
+     * the focus left there as its own to restore.
+     */
+    private releaseFocus;
     /** Handles mouse presses on the trigger. */
     handleMousedown(event: MouseEvent): void;
     /**
@@ -468,22 +469,27 @@ declare class KbqDropdownTrigger implements AfterContentInit, OnDestroy, KbqSibl
      * OverlayRef so that it can be attached to the DOM when open is called.
      */
     private createOverlay;
+    /** Whether the panel is anchored to a rectangle in viewport coordinates rather than to an element. */
+    private get hasPointOrigin();
+    /** The origin the position strategy is connected to. */
+    private getResolvedOrigin;
     /** Whether the panel should be at least as wide as its trigger. */
     private get shouldMatchTriggerWidth();
     /**
      * This method builds the configuration object needed to create the overlay, the OverlayState.
+     *
      * @returns OverlayConfig
      */
     private getOverlayConfig;
     /**
-     * Listens to changes in the position of the overlay and sets the correct classes
-     * on the dropdown based on the new position. This ensures the animation origin is always
-     * correct, even if a fallback position is used for the overlay.
+     * Listens to changes in the position of the overlay and sets the matching position classes on the dropdown,
+     * so they follow a fallback position too.
      */
     private subscribeToPositions;
     /**
      * Sets the appropriate positions on a position strategy
      * so the overlay connects with the trigger correctly.
+     *
      * @param positionStrategy Strategy whose position to update.
      */
     private setPosition;
@@ -504,13 +510,8 @@ declare class KbqDropdownTrigger implements AfterContentInit, OnDestroy, KbqSibl
     private lockOverlayWidthForSearch;
     /** Freezes the overlay pane at its rendered width. */
     private pinOverlayWidth;
-    private addClassToOverlayContainer;
-    private removeClassFromOverlayContainer;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownTrigger, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownTrigger, "[kbqDropdownTriggerFor]", ["kbqDropdownTrigger"], { "offsetX": { "alias": "offsetX"; "required": false; }; "offsetY": { "alias": "offsetY"; "required": false; }; "data": { "alias": "kbqDropdownTriggerData"; "required": false; }; "openByArrowDown": { "alias": "openByArrowDown"; "required": false; }; "demoteOverlay": { "alias": "demoteOverlay"; "required": false; }; "restoreFocus": { "alias": "kbqDropdownTriggerRestoreFocus"; "required": false; }; "dropdown": { "alias": "kbqDropdownTriggerFor"; "required": false; }; }, { "dropdownOpened": "dropdownOpened"; "dropdownClosed": "dropdownClosed"; }, never, never, true, never>;
-    static ngAcceptInputType_offsetX: unknown;
-    static ngAcceptInputType_offsetY: unknown;
-    static ngAcceptInputType_demoteOverlay: unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownTrigger, "[kbqDropdownTriggerFor]", ["kbqDropdownTrigger"], { "offsetX": { "alias": "offsetX"; "required": false; "isSignal": true; }; "offsetY": { "alias": "offsetY"; "required": false; "isSignal": true; }; "data": { "alias": "kbqDropdownTriggerData"; "required": false; "isSignal": true; }; "openByArrowDown": { "alias": "openByArrowDown"; "required": false; "isSignal": true; }; "origin": { "alias": "kbqDropdownTriggerOrigin"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "kbqDropdownTriggerAutoFocus"; "required": false; "isSignal": true; }; "restoreFocus": { "alias": "kbqDropdownTriggerRestoreFocus"; "required": false; "isSignal": true; }; "dropdown": { "alias": "kbqDropdownTriggerFor"; "required": false; "isSignal": true; }; }, { "offsetX": "offsetXChange"; "openByArrowDown": "openByArrowDownChange"; "restoreFocus": "kbqDropdownTriggerRestoreFocusChange"; "dropdownOpened": "dropdownOpened"; "dropdownClosed": "dropdownClosed"; }, never, never, true, never>;
 }
 
 /**
@@ -520,124 +521,121 @@ declare class KbqDropdownTrigger implements AfterContentInit, OnDestroy, KbqSibl
  */
 declare const NESTED_HOVER_SWITCH_DELAY = 50;
 declare class KbqDropdownStaticContent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownStaticContent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownStaticContent, "[kbqDropdownStaticContent]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownStaticContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownStaticContent, "[kbqDropdownStaticContent]", never, {}, {}, never, never, true, never>;
 }
 /** Footer that is rendered below the dropdown options panel. */
 declare class KbqDropdownFooter {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownFooter, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<KbqDropdownFooter, "[kbqDropdownFooter], kbq-dropdown-footer", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownFooter, "[kbqDropdownFooter], kbq-dropdown-footer", never, {}, {}, never, never, true, never>;
 }
-declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit, OnDestroy {
+/** Header of a group of items in the dropdown panel. */
+declare class KbqDropdownGroupHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownGroupHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KbqDropdownGroupHeader, "[kbqDropdownGroupHeader]", never, {}, {}, never, never, true, never>;
+}
+declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnDestroy {
     private elementRef;
     private ngZone;
+    private readonly injector;
+    /** The pending deferred initial focus, see `focusFirstItem`. */
+    private initialFocusRef;
     private document;
+    private readonly renderer;
     private defaultOptions;
     private readonly destroyRef;
     private readonly panelFormField;
     /**
      * Signal content queries carry `descendants: true`, and a nested panel declared inside this one's
      * content is part of the same view — so the match has to be narrowed to the fields this panel owns,
-     * the way `updateDirectDescendants` narrows the items.
+     * the way `syncDirectDescendants` narrows the items.
      */
     private readonly searches;
     private readonly search;
     /** Whether the dropdown projects a search form-field. @docs-private */
     readonly hasSearch: Signal<boolean>;
+    /**
+     * Whether the arrow keys move a highlight instead of the DOM focus. Turn it on when the keyboard belongs to
+     * something outside the panel — an editor whose caret the panel is anchored to, for instance — and forward
+     * the keys with {@link handleKeydown}.
+     */
+    readonly activeDescendantNavigation: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Whether the panel highlights the active item instead of focusing it. @docs-private */
     readonly inSearchMode: Signal<boolean>;
-    readonly navigationWithWrap: i0.InputSignal<boolean>;
+    readonly navigationWithWrap: _angular_core.InputSignal<boolean>;
     /** Position of the dropdown in the X axis. */
-    get xPosition(): KbqDropdownPositionX;
-    set xPosition(value: KbqDropdownPositionX);
+    readonly xPosition: _angular_core.ModelSignal<KbqDropdownPositionX>;
     /** Position of the dropdown in the Y axis. */
-    get yPosition(): KbqDropdownPositionY;
-    set yPosition(value: KbqDropdownPositionY);
+    readonly yPosition: _angular_core.ModelSignal<KbqDropdownPositionY>;
     /** Whether the dropdown should overlap its trigger vertically. */
-    get overlapTriggerY(): boolean;
-    set overlapTriggerY(value: boolean);
+    readonly overlapTriggerY: _angular_core.ModelSignal<boolean>;
     /** Whether the dropdown should overlap its trigger horizontally. */
-    get overlapTriggerX(): boolean;
-    set overlapTriggerX(value: boolean);
+    readonly overlapTriggerX: _angular_core.ModelSignal<boolean>;
     /** Whether the dropdown has a backdrop. */
-    get hasBackdrop(): boolean;
-    set hasBackdrop(value: boolean);
-    /**
-     * This method takes classes set on the host kbq-dropdown element and applies them on the
-     * dropdown template that displays in the overlay container.  Otherwise, it's difficult
-     * to style the containing dropdown from outside the component.
-     * @param classes list of class names
-     */
-    set panelClass(classes: string);
-    private _xPosition;
-    private _yPosition;
-    private _overlapTriggerX;
-    private _overlapTriggerY;
-    private _hasBackdrop;
-    /**
-     * @deprecated Has no effect. Use `KbqDropdownTrigger.widthOrigin` to make the panel match
-     * an element other than the trigger. Will be removed in v21.
-     */
-    triggerWidth: string;
-    /** Config object to be passed into the dropdown panel's `[class]` binding */
-    classList: {
-        [key: string]: boolean;
-    };
-    /** Current state of the panel animation. */
-    panelAnimationState: 'void' | 'enter';
-    /** Emits whenever an animation on the dropdown completes. */
-    animationDone: Subject<AnimationEvent>;
-    /** Whether the dropdown is animating. */
-    isAnimating: boolean;
+    readonly hasBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Classes set on the host `kbq-dropdown` element, transferred onto the panel in the overlay container. */
+    readonly panelClass: _angular_core.InputSignal<string>;
+    /** The position the trigger resolved; supersedes the inputs until one of them changes. */
+    private readonly positionOverride;
+    /** Whether a safe area is protecting an open submenu, see `activateSafeArea`. */
+    private readonly safeAreaActive;
+    /** Config object passed into the dropdown panel's `[class]` binding. */
+    protected readonly classList: Signal<Record<string, boolean>>;
+    /** Whether a trigger has the panel attached, see `setOpened`. */
+    private opened;
+    private openedRender?;
     /** Parent dropdown of the current dropdown panel. */
     parent: KbqDropdownPanel | undefined;
     /** Layout direction of the dropdown. */
     direction: Direction;
     /** Class to be added to the backdrop element. */
-    backdropClass: string;
+    readonly backdropClass: _angular_core.InputSignal<string>;
     /**
      * Width of the panel. If set to `auto`, the panel will match the trigger width, but will never be
      * narrower than `panelMinWidth`. If set to null, the panel will grow to match its content.
      * Any other value is used as an exact width, and `panelMinWidth` is not applied.
      */
-    readonly panelWidth: i0.InputSignal<KbqPanelWidth>;
+    readonly panelWidth: _angular_core.InputSignal<KbqPanelWidth>;
     /**
      * Minimum width of the panel in pixels. The panel is never narrower than this, nor than its trigger.
      */
-    readonly panelMinWidth: i0.InputSignalWithTransform<KbqPanelMinWidth, unknown>;
+    readonly panelMinWidth: _angular_core.InputSignalWithTransform<KbqPanelMinWidth, unknown>;
     /**
      * Maximum width of the panel in pixels. Caps how far the panel grows with its content — it never makes
      * the panel narrower than the trigger, and never clamps an explicit `panelWidth`.
      * When null, the `--kbq-dropdown-size-container-width-max` token applies.
      */
-    readonly panelMaxWidth: i0.InputSignalWithTransform<KbqPanelMaxWidth, unknown>;
+    readonly panelMaxWidth: _angular_core.InputSignalWithTransform<KbqPanelMaxWidth, unknown>;
     /**
      * Whether nested dropdowns opened from this dropdown's items use a "safe area": while the
      * pointer moves from a trigger toward its open submenu, sibling items it crosses over on the way
-     * don't prematurely close the submenu.
+     * don't prematurely close the submenu. Set on the panel that contains the nested triggers.
      */
-    readonly safeArea: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly safeArea: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
-     * `panelMinWidth` rendered as a CSS length for the `--kbq-dropdown-size-container-width-min`
-     * token, so the panel's CSS `min-width` floor tracks the input — mirroring how `panelMaxWidth`
-     * drives `max-width`. Non-finite input (e.g. `null`) leaves the token's static default in place.
+     * `panelMinWidth` as a CSS length for `--kbq-dropdown-size-container-width-min`.
+     *
      * @docs-private
      */
-    protected readonly panelMinWidthToken: Signal<string | null>;
+    protected readonly panelMinWidthToken: Signal<string>;
     /** @docs-private */
-    templateRef: TemplateRef<any>;
+    readonly templateRef: Signal<TemplateRef<any>>;
+    private readonly scrollbarViewport;
+    private readonly queriedItems;
+    /** Items borrowed from the parent panel, see `adoptItems`. Used only while this panel has none of its own. */
+    private readonly adoptedItems;
     /**
      * List of the items inside of a dropdown.
      */
-    items: QueryList<KbqDropdownItem>;
+    readonly items: Signal<readonly KbqDropdownItem[]>;
     /**
      * Dropdown content that will be rendered lazily.
+     *
      * @docs-private
      */
-    lazyContent: KbqDropdownContent;
+    readonly lazyContent: Signal<KbqDropdownContent | undefined>;
     /** Event emitted when the dropdown is closed. */
-    readonly closed: EventEmitter<void | "click" | "keydown" | "tab">;
-    private previousPanelClass;
+    readonly closed: _angular_core.OutputEmitterRef<void | "click" | "keydown" | "tab">;
     private keyManager;
     private activeDescendantKeyManager?;
     private focusKeyManager?;
@@ -663,44 +661,42 @@ declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit,
     /** Watches for a forced switch to a sibling trigger while a safe area is active. */
     private switchTargetSubscription;
     constructor();
-    ngOnInit(): void;
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
     /** Stream that emits whenever the hovered dropdown item changes. */
     hovered(): Observable<KbqDropdownItem>;
     /**
-     * Tracks the pointer against `triangle` to protect `owner`'s open submenu, closing it via
-     * `onExit` if the pointer leaves the triangle without first reaching `panelRect`. Meanwhile, if a
-     * different nested trigger is hovered, `switchTarget()` emits it — immediately if it's outside
-     * the triangle, otherwise after a grace period (see `NESTED_HOVER_SWITCH_DELAY`). Replaces any
-     * safe area already being tracked.
+     * Tracks the pointer against the triangle spanned by `origin` and the protected submenu, closing
+     * `owner`'s submenu via `onExit` if the pointer leaves the triangle without first reaching the
+     * panel. Meanwhile, if a different nested trigger is hovered, `switchTarget()` emits it —
+     * immediately if it's outside the triangle, otherwise after a grace period (see
+     * `NESTED_HOVER_SWITCH_DELAY`). Replaces any safe area already being tracked.
+     *
      * @docs-private
      */
-    activateSafeArea(owner: KbqDropdownItem, triangle: KbqTriangle, panelRect: DOMRect, onExit: () => void): void;
+    activateSafeArea(owner: KbqDropdownItem, origin: KbqPoint, getPanelRect: () => DOMRect, onExit: () => void): void;
     /**
      * Stops tracking the current safe area, if any.
+     *
      * @docs-private
      */
     deactivateSafeArea(): void;
     /**
      * Whether a safe area is currently being tracked.
+     *
      * @docs-private
      */
     isSafeAreaActive(): boolean;
     /**
      * Whether `item` is the nested trigger currently protected by an active safe area.
+     *
      * @docs-private
      */
     isSafeAreaOwner(item: KbqDropdownItem): boolean;
-    /**
-     * Stream that emits when the pointer reaches the panel the active safe area protects (as opposed
-     * to leaving the safe area, which closes the panel instead).
-     * @docs-private
-     */
-    onPanelReached(): Observable<void>;
     /**
      * Stream that emits the sibling trigger that should open once a forced safe-area switch has
      * closed the trigger it was protecting.
+     *
      * @docs-private
      */
     onSwitchTarget(): Observable<KbqDropdownItem>;
@@ -708,9 +704,11 @@ declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit,
     handleKeydown(event: KeyboardEvent): void;
     /**
      * Applies the panel's initial focus, see `applyInitialFocus`.
+     *
      * @param origin Action from which the focus originated. Used to set the correct styling.
      */
     focusFirstItem(origin?: FocusOrigin): void;
+    private applyInitialFocusAfterRender;
     /**
      * Applies focus when the dropdown is opened.
      *
@@ -725,6 +723,7 @@ declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit,
      * Moves focus back into the projected search field, reporting whether there was one. A nested panel
      * restores focus through this instead of onto its trigger item, which would strand the caret outside
      * the query.
+     *
      * @docs-private
      */
     restoreFocus(): boolean;
@@ -735,21 +734,29 @@ declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit,
      * the user to start from the first option when pressing the down arrow.
      */
     resetActiveItem(): void;
+    /**
+     * Lends this panel the parent's items, for a submenu whose own items were initialised as children of
+     * the root panel. Ignored once the panel has items of its own.
+     *
+     * @docs-private
+     */
+    adoptItems(items: readonly KbqDropdownItem[]): void;
     /**
      * Adds classes to the dropdown panel based on its position. Can be used by
      * consumers to add specific styling based on the position.
+     *
      * @param posX Position of the dropdown along the x axis.
      * @param posY Position of the dropdown along the y axis.
+     *
      * @docs-private
      */
     setPositionClasses(posX?: KbqDropdownPositionX, posY?: KbqDropdownPositionY): void;
-    /** Starts the enter animation. */
-    startAnimation(): void;
-    /** Resets the panel animation to its initial state. */
-    resetAnimation(): void;
-    /** Callback that is invoked when the panel animation completes. */
-    onAnimationDone(event: AnimationEvent): void;
-    onAnimationStart(event: AnimationEvent): void;
+    /**
+     * Called by the trigger when it attaches the panel and when it detaches it.
+     *
+     * @docs-private
+     */
+    setOpened(opened: boolean): void;
     close(): void;
     /**
      * With a search field the caret has to stay in the input, so the active item is only highlighted and
@@ -767,21 +774,20 @@ declare class KbqDropdown implements AfterContentInit, KbqDropdownPanel, OnInit,
      */
     private revealActiveItem;
     /**
-     * Sets up a stream that will keep track of any newly-added menu items and will update the list
-     * of direct descendants. We collect the descendants this way, because `items` can include
-     * items that are part of child menus, and using a custom way of registering items is unreliable
-     * when it comes to maintaining the item order.
+     * Narrows `items` down to the ones this panel owns. We collect the descendants this way, because
+     * `items` can include items that are part of child menus, and using a custom way of registering
+     * items is unreliable when it comes to maintaining the item order.
      */
-    private updateDirectDescendants;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdown, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<KbqDropdown, "kbq-dropdown", ["kbqDropdown"], { "navigationWithWrap": { "alias": "navigationWithWrap"; "required": false; "isSignal": true; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "overlapTriggerY": { "alias": "overlapTriggerY"; "required": false; }; "overlapTriggerX": { "alias": "overlapTriggerX"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "panelClass": { "alias": "class"; "required": false; }; "backdropClass": { "alias": "backdropClass"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; "isSignal": true; }; "panelMaxWidth": { "alias": "panelMaxWidth"; "required": false; "isSignal": true; }; "safeArea": { "alias": "safeArea"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, ["panelFormField", "searches", "lazyContent", "items"], ["*", "[kbqDropdownFooter], kbq-dropdown-footer", "[kbqDropdownStaticContent]"], true, never>;
+    private syncDirectDescendants;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KbqDropdown, "kbq-dropdown", ["kbqDropdown"], { "activeDescendantNavigation": { "alias": "activeDescendantNavigation"; "required": false; "isSignal": true; }; "navigationWithWrap": { "alias": "navigationWithWrap"; "required": false; "isSignal": true; }; "xPosition": { "alias": "xPosition"; "required": false; "isSignal": true; }; "yPosition": { "alias": "yPosition"; "required": false; "isSignal": true; }; "overlapTriggerY": { "alias": "overlapTriggerY"; "required": false; "isSignal": true; }; "overlapTriggerX": { "alias": "overlapTriggerX"; "required": false; "isSignal": true; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; "isSignal": true; }; "panelClass": { "alias": "class"; "required": false; "isSignal": true; }; "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "panelWidth": { "alias": "panelWidth"; "required": false; "isSignal": true; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; "isSignal": true; }; "panelMaxWidth": { "alias": "panelMaxWidth"; "required": false; "isSignal": true; }; "safeArea": { "alias": "safeArea"; "required": false; "isSignal": true; }; }, { "xPosition": "xPositionChange"; "yPosition": "yPositionChange"; "overlapTriggerY": "overlapTriggerYChange"; "overlapTriggerX": "overlapTriggerXChange"; "closed": "closed"; }, ["panelFormField", "searches", "queriedItems", "lazyContent"], ["*", "[kbqDropdownFooter], kbq-dropdown-footer", "[kbqDropdownStaticContent]"], true, never>;
 }
 
 declare class KbqDropdownModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<KbqDropdownModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<KbqDropdownModule, never, [typeof i1.OverlayModule, typeof i2.KbqIconModule, typeof KbqDropdownStaticContent, typeof KbqDropdown, typeof KbqDropdownItem, typeof KbqDropdownItemAction, typeof KbqDropdownTrigger, typeof KbqDropdownContent, typeof KbqDropdownFooter, typeof KbqDropdownSearch], [typeof KbqDropdown, typeof KbqDropdownItem, typeof KbqDropdownItemAction, typeof KbqDropdownTrigger, typeof KbqDropdownContent, typeof KbqDropdownStaticContent, typeof KbqDropdownFooter, typeof KbqDropdownSearch]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<KbqDropdownModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KbqDropdownModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<KbqDropdownModule, never, [typeof i1.OverlayModule, typeof i2.KbqIconModule, typeof KbqDropdownStaticContent, typeof KbqDropdown, typeof KbqDropdownItem, typeof KbqDropdownItemCaption, typeof KbqDropdownItemAction, typeof KbqDropdownTrigger, typeof KbqDropdownContent, typeof KbqDropdownFooter, typeof KbqDropdownGroupHeader, typeof KbqDropdownSearch], [typeof KbqDropdown, typeof KbqDropdownItem, typeof KbqDropdownItemCaption, typeof KbqDropdownItemAction, typeof KbqDropdownTrigger, typeof KbqDropdownContent, typeof KbqDropdownStaticContent, typeof KbqDropdownFooter, typeof KbqDropdownGroupHeader, typeof KbqDropdownSearch]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<KbqDropdownModule>;
 }
 
-export { KBQ_DROPDOWN_DEFAULT_OPTIONS, KBQ_DROPDOWN_DEFAULT_OPTIONS_FACTORY, KBQ_DROPDOWN_HOST, KBQ_DROPDOWN_PANEL, KBQ_DROPDOWN_SCROLL_STRATEGY, KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY, KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqDropdown, KbqDropdownContent, KbqDropdownFooter, KbqDropdownItem, KbqDropdownItemAction, KbqDropdownModule, KbqDropdownSearch, KbqDropdownStaticContent, KbqDropdownTrigger, NESTED_HOVER_SWITCH_DELAY, NESTED_PANEL_LEFT_PADDING, NESTED_PANEL_TOP_PADDING, fadeInItems, kbqDropdownAnimations, throwKbqDropdownInvalidPositionX, throwKbqDropdownInvalidPositionY, throwKbqDropdownMissingError, throwKbqDropdownSearchMissingInputError, throwKbqDropdownSearchMissingNgControlError, transformDropdown };
-export type { DropdownCloseReason, DropdownPositionX, DropdownPositionY, KbqDropdownDefaultOptions, KbqDropdownPanel, KbqDropdownPositionX, KbqDropdownPositionY };
+export { KBQ_DROPDOWN_DEFAULT_OPTIONS, KBQ_DROPDOWN_DEFAULT_OPTIONS_FACTORY, KBQ_DROPDOWN_ITEM_ACTION_HOST, KBQ_DROPDOWN_PANEL, KBQ_DROPDOWN_SCROLL_STRATEGY, KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY, KBQ_DROPDOWN_SCROLL_STRATEGY_FACTORY_PROVIDER, KbqDropdown, KbqDropdownContent, KbqDropdownFooter, KbqDropdownGroupHeader, KbqDropdownItem, KbqDropdownItemAction, KbqDropdownItemCaption, KbqDropdownModule, KbqDropdownSearch, KbqDropdownStaticContent, KbqDropdownTrigger, NESTED_HOVER_SWITCH_DELAY, NESTED_PANEL_LEFT_PADDING, NESTED_PANEL_TOP_PADDING };
+export type { DropdownCloseReason, KbqDropdownDefaultOptions, KbqDropdownItemActionHost, KbqDropdownPanel, KbqDropdownPositionX, KbqDropdownPositionY };