@angular/cdk-experimental 13.3.3 → 14.0.0-next.10

package/listbox/listbox.d.ts

@@ -5,17 +5,20 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { AfterContentInit, ElementRef, EventEmitter, InjectionToken, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, OnInit, QueryList } from '@angular/core';
 import { ActiveDescendantKeyManager, Highlightable, ListKeyManagerOption } from '@angular/cdk/a11y';
 import { BooleanInput } from '@angular/cdk/coercion';
 import { SelectionModel } from '@angular/cdk/collections';
 import { Observable } from 'rxjs';
 import { ControlValueAccessor } from '@angular/forms';
-import { CdkComboboxPanel } from '@angular/cdk-experimental/combobox';
 import { Directionality } from '@angular/cdk/bidi';
+import { CdkCombobox } from '@angular/cdk-experimental/combobox';
 import * as i0 from "@angular/core";
-export declare const CDK_LISTBOX_VALUE_ACCESSOR: any;
-export declare const PANEL: InjectionToken<CdkComboboxPanel<unknown>>;
+export declare const CDK_LISTBOX_VALUE_ACCESSOR: {
+    provide: import("@angular/core").InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: import("@angular/core").Type<any>;
+    multi: boolean;
+};
 export declare class CdkOption<T = unknown> implements ListKeyManagerOption, Highlightable {
     private readonly _elementRef;
     readonly listbox: CdkListbox<T>;
@@ -32,6 +35,11 @@ export declare class CdkOption<T = unknown> implements ListKeyManagerOption, Hig
     /** The form value of the option. */
     get value(): T;
     set value(value: T);
+    /**
+     * The text used to locate this item during menu typeahead. If not specified,
+     * the `textContent` of the item will be used.
+     */
+    typeahead: string;
     readonly selectionChange: EventEmitter<OptionSelectionChangeEvent<T>>;
     constructor(_elementRef: ElementRef, listbox: CdkListbox<T>);
     /** Toggles the selected state, emits a change event through the injected listbox. */
@@ -54,18 +62,15 @@ export declare class CdkOption<T = unknown> implements ListKeyManagerOption, Hig
     _getTabIndex(): string | null;
     /** Get the label for this element which is required by the FocusableOption interface. */
     getLabel(): string;
-    /** Remove any child from the given element which can be identified as an icon. */
-    private _removeIcons;
-    getElementRef(): ElementRef<any>;
     /** Sets the active property to true to enable the active css class. */
     setActiveStyles(): void;
     /** Sets the active property to false to disable the active css class. */
     setInactiveStyles(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkOption<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOption<any>, "[cdkOption]", ["cdkOption"], { "id": "id"; "selected": "selected"; "disabled": "disabled"; "value": "value"; }, { "selectionChange": "selectionChange"; }, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOption<any>, "[cdkOption]", ["cdkOption"], { "id": "id"; "selected": "selected"; "disabled": "disabled"; "value": "value"; "typeahead": "typeahead"; }, { "selectionChange": "selectionChange"; }, never>;
 }
 export declare class CdkListbox<T> implements AfterContentInit, OnDestroy, OnInit, ControlValueAccessor {
-    readonly _parentPanel?: CdkComboboxPanel<T> | undefined;
+    private readonly _combobox;
     private readonly _dir?;
     _listKeyManager: ActiveDescendantKeyManager<CdkOption<T>>;
     _selectionModel: SelectionModel<CdkOption<T>>;
@@ -101,12 +106,10 @@ export declare class CdkListbox<T> implements AfterContentInit, OnDestroy, OnIni
     /** Determines the orientation for the list key manager. Affects keyboard interaction. */
     orientation: 'horizontal' | 'vertical';
     compareWith: (o1: T, o2: T) => boolean;
-    private readonly _explicitPanel;
-    constructor(_parentPanel?: CdkComboboxPanel<T> | undefined, _dir?: Directionality | undefined);
+    constructor(_combobox: CdkCombobox, _dir?: Directionality | undefined);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
-    private _registerWithPanel;
     private _initKeyManager;
     private _initSelectionModel;
     _keydown(event: KeyboardEvent): void;
@@ -151,7 +154,7 @@ export declare class CdkListbox<T> implements AfterContentInit, OnDestroy, OnIni
     /** Selects an option that has the corresponding given value. */
     private _setSelectionByValue;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkListbox<any>, [{ optional: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkListbox<any>, "[cdkListbox]", ["cdkListbox"], { "id": "id"; "multiple": "multiple"; "disabled": "disabled"; "useActiveDescendant": "useActiveDescendant"; "autoFocus": "autoFocus"; "orientation": "listboxOrientation"; "compareWith": "compareWith"; "_explicitPanel": "parentPanel"; }, { "selectionChange": "selectionChange"; }, ["_options"]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkListbox<any>, "[cdkListbox]", ["cdkListbox"], { "id": "id"; "multiple": "multiple"; "disabled": "disabled"; "useActiveDescendant": "useActiveDescendant"; "autoFocus": "autoFocus"; "orientation": "listboxOrientation"; "compareWith": "compareWith"; }, { "selectionChange": "selectionChange"; }, ["_options"]>;
 }
 /** Change event that is being fired whenever the selected state of an option changes. */
 export interface ListboxSelectionChangeEvent<T> {

package/menu/context-menu-trigger.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injector, OnDestroy, ViewContainerRef } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay } from '@angular/cdk/overlay';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MenuStack } from './menu-stack';
+import { CdkMenuTriggerBase } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+/** Tracks the last open context menu trigger across the entire application. */
+export declare class ContextMenuTracker {
+    /** The last open context menu trigger. */
+    private static _openContextMenuTrigger?;
+    /**
+     * Close the previous open context menu and set the given one as being open.
+     * @param trigger The trigger for the currently open Context Menu.
+     */
+    update(trigger: CdkContextMenuTrigger): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTracker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuTracker>;
+}
+/** The coordinates where the context menu should open. */
+export declare type ContextMenuCoordinates = {
+    x: number;
+    y: number;
+};
+/**
+ * A directive that opens a menu when a user right-clicks within its host element.
+ * It is aware of nested context menus and will trigger only the lowest level non-disabled context menu.
+ */
+export declare class CdkContextMenuTrigger extends CdkMenuTriggerBase implements OnDestroy {
+    /** The CDK overlay service */
+    private readonly _overlay;
+    /** The app's context menu tracking registry */
+    private readonly _contextMenuTracker;
+    /** The directionality of the current page */
+    private readonly _directionality?;
+    /** Whether the context menu is disabled. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    constructor(
+    /** The DI injector for this component */
+    injector: Injector, 
+    /** The view container ref for this component */
+    viewContainerRef: ViewContainerRef, 
+    /** The CDK overlay service */
+    _overlay: Overlay, 
+    /** The app's context menu tracking registry */
+    _contextMenuTracker: ContextMenuTracker, 
+    /** The menu stack this menu is part of. */
+    menuStack: MenuStack, 
+    /** The directionality of the current page */
+    _directionality?: Directionality | undefined);
+    /**
+     * Open the attached menu at the specified location.
+     * @param coordinates where to open the context menu
+     */
+    open(coordinates: ContextMenuCoordinates): void;
+    /** Close the currently opened context menu. */
+    close(): void;
+    /**
+     * Open the context menu and closes any previously open menus.
+     * @param event the mouse event which opens the context menu.
+     */
+    _openOnContextMenu(event: MouseEvent): void;
+    /**
+     * Get the configuration object used to create the overlay.
+     * @param coordinates the location to place the opened menu
+     */
+    private _getOverlayConfig;
+    /**
+     * Get the position strategy for the overlay which specifies where to place the menu.
+     * @param coordinates the location to place the opened menu
+     */
+    private _getOverlayPositionStrategy;
+    /** Subscribe to the menu stack close events and close this menu when requested. */
+    private _setMenuStackCloseListener;
+    /**
+     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
+     * click occurs outside the menus.
+     * @param ignoreFirstAuxClick Whether to ignore the first auxclick event outside the menu.
+     */
+    private _subscribeToOutsideClicks;
+    /**
+     * Open the attached menu at the specified location.
+     * @param coordinates where to open the context menu
+     * @param ignoreFirstOutsideAuxClick Whether to ignore the first auxclick outside the menu after opening.
+     */
+    private _open;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkContextMenuTrigger, [null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkContextMenuTrigger, "[cdkContextMenuTriggerFor]", ["cdkContextMenuTriggerFor"], { "menuTemplateRef": "cdkContextMenuTriggerFor"; "menuPosition": "cdkContextMenuPosition"; "disabled": "cdkContextMenuDisabled"; }, { "opened": "cdkContextMenuOpened"; "closed": "cdkContextMenuClosed"; }, never>;
+}

package/menu/menu-aim.d.ts

@@ -15,7 +15,11 @@ import * as i0 from "@angular/core";
  * order to determine if it may perform its close actions.
  */
 export interface MenuAim {
-    /** Set the Menu and its PointerFocusTracker. */
+    /**
+     * Set the Menu and its PointerFocusTracker.
+     * @param menu The menu that this menu aim service controls.
+     * @param pointerTracker The `PointerFocusTracker` for the given menu.
+     */
     initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
     /**
      * Calls the `doToggle` callback when it is deemed that the user is not moving towards
@@ -26,11 +30,9 @@ export interface MenuAim {
 }
 /** Injection token used for an implementation of MenuAim. */
 export declare const MENU_AIM: InjectionToken<MenuAim>;
-/**
- * An element which when hovered over may perform closing actions on the open submenu and
- * potentially open its own menu.
- */
+/** An element which when hovered over may open or close a menu. */
 export interface Toggler {
+    /** Gets the open menu, or undefined if no menu is open. */
     getMenu(): Menu | undefined;
 }
 /**
@@ -44,6 +46,7 @@ export interface Toggler {
  * to submenu.
  */
 export declare class TargetMenuAim implements MenuAim, OnDestroy {
+    /** The Angular zone. */
     private readonly _ngZone;
     /** The last NUM_POINTS mouse move events. */
     private readonly _points;
@@ -55,8 +58,15 @@ export declare class TargetMenuAim implements MenuAim, OnDestroy {
     private _timeoutId;
     /** Emits when this service is destroyed. */
     private readonly _destroyed;
-    constructor(_ngZone: NgZone);
-    /** Set the Menu and its PointerFocusTracker. */
+    constructor(
+    /** The Angular zone. */
+    _ngZone: NgZone);
+    ngOnDestroy(): void;
+    /**
+     * Set the Menu and its PointerFocusTracker.
+     * @param menu The menu that this menu aim service controls.
+     * @param pointerTracker The `PointerFocusTracker` for the given menu.
+     */
     initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
     /**
      * Calls the `doToggle` callback when it is deemed that the user is not moving towards
@@ -69,6 +79,8 @@ export declare class TargetMenuAim implements MenuAim, OnDestroy {
      *
      * The delayed toggle handler executes the `doToggle` callback after some period of time iff the
      * users mouse is on an item in the current menu.
+     *
+     * @param doToggle the function called when the user is not moving towards the submenu.
      */
     private _startTimeout;
     /** Whether the user is heading towards the open submenu. */
@@ -82,12 +94,11 @@ export declare class TargetMenuAim implements MenuAim, OnDestroy {
     private _checkConfigured;
     /** Subscribe to the root menus mouse move events and update the tracked mouse points. */
     private _subscribeToMouseMoves;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TargetMenuAim, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TargetMenuAim>;
 }
 /**
- * CdkTargetMenuAim is a provider for the TargetMenuAim service. It should be added to an
+ * CdkTargetMenuAim is a provider for the TargetMenuAim service. It can be added to an
  * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
  */
 export declare class CdkTargetMenuAim {

package/menu/menu-bar.d.ts

@@ -5,13 +5,11 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { AfterContentInit, OnDestroy, NgZone, ElementRef } from '@angular/core';
+import { AfterContentInit, ElementRef, NgZone } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
-import { FocusOrigin } from '@angular/cdk/a11y';
-import { CdkMenuGroup } from './menu-group';
-import { Menu } from './menu-interface';
 import { MenuStack } from './menu-stack';
 import { MenuAim } from './menu-aim';
+import { CdkMenuBase } from './menu-base';
 import * as i0 from "@angular/core";
 /**
  * Directive applied to an element which configures it as a MenuBar by setting the appropriate
@@ -19,70 +17,36 @@ import * as i0 from "@angular/core";
  * this directive is applied to should contain components marked with CdkMenuItem.
  *
  */
-export declare class CdkMenuBar extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
-    readonly _menuStack: MenuStack;
-    private readonly _ngZone;
-    readonly _elementRef: ElementRef<HTMLElement>;
-    private readonly _menuAim?;
-    private readonly _dir?;
-    /**
-     * Sets the aria-orientation attribute and determines where menus will be opened.
-     * Does not affect styling/layout.
-     */
-    orientation: 'horizontal' | 'vertical';
-    /** Handles keyboard events for the MenuBar. */
-    private _keyManager;
-    /** Manages items under mouse focus */
-    private _pointerTracker?;
-    /** Emits when the MenuBar is destroyed. */
-    private readonly _destroyed;
-    /** All child MenuItem elements nested in this MenuBar. */
-    private readonly _allItems;
-    /** The Menu Item which triggered the open submenu. */
-    private _openItem?;
-    constructor(_menuStack: MenuStack, _ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined);
+export declare class CdkMenuBar extends CdkMenuBase implements AfterContentInit {
+    /** The direction items in the menu flow. */
+    readonly orientation = "horizontal";
+    /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+    readonly isInline = true;
+    constructor(
+    /** The host element. */
+    elementRef: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The menu stack this menu is part of. */
+    menuStack: MenuStack, 
+    /** The menu aim service used by this menu. */
+    menuAim?: MenuAim, 
+    /** The directionality of the page. */
+    dir?: Directionality);
     ngAfterContentInit(): void;
-    /** Place focus on the first MenuItem in the menu and set the focus origin. */
-    focusFirstItem(focusOrigin?: FocusOrigin): void;
-    /** Place focus on the last MenuItem in the menu and set the focus origin. */
-    focusLastItem(focusOrigin?: FocusOrigin): void;
     /**
-     * Handle keyboard events, specifically changing the focused element and/or toggling the active
-     * items menu.
-     * @param event the KeyboardEvent to handle.
+     * Handle keyboard events for the Menu.
+     * @param event The keyboard event to be handled.
      */
     _handleKeyEvent(event: KeyboardEvent): void;
-    /** Setup the FocusKeyManager with the correct orientation for the menu bar. */
-    private _setKeyManager;
-    /**
-     * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
-     * with the latest menu item under mouse focus.
-     */
-    private _subscribeToMouseManager;
-    /** Subscribe to the MenuStack close and empty observables. */
-    private _subscribeToMenuStack;
-    /**
-     * Close the open menu if the current active item opened the requested MenuStackItem.
-     * @param item the MenuStackItem requested to be closed.
-     */
-    private _closeOpenMenu;
     /**
      * Set focus to either the current, previous or next item based on the FocusNext event, then
      * open the previous or next item.
+     * @param focusNext The element to focus.
      */
     private _toggleOpenMenu;
-    /**
-     * @return true if the menu bar is configured to be horizontal.
-     */
-    private _isHorizontal;
-    /**
-     * Subscribe to the menu trigger's open events in order to track the trigger which opened the menu
-     * and stop tracking it when the menu is closed.
-     */
-    private _subscribeToMenuOpen;
-    /** Return true if the MenuBar has an open submenu. */
-    private _hasOpenSubmenu;
-    ngOnDestroy(): void;
+    /** Subscribe to the MenuStack emptied events. */
+    private _subscribeToMenuStackEmptied;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], { "orientation": "cdkMenuBarOrientation"; }, {}, ["_allItems"]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], {}, {}, never>;
 }

package/menu/menu-base.d.ts

@@ -0,0 +1,104 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { CdkMenuGroup } from './menu-group';
+import { AfterContentInit, ElementRef, NgZone, OnDestroy, QueryList } from '@angular/core';
+import { FocusKeyManager, FocusOrigin } from '@angular/cdk/a11y';
+import { CdkMenuItem } from './menu-item';
+import { Subject } from 'rxjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { MenuStack, MenuStackItem } from './menu-stack';
+import { Menu } from './menu-interface';
+import { PointerFocusTracker } from './pointer-focus-tracker';
+import { MenuAim } from './menu-aim';
+import * as i0 from "@angular/core";
+/**
+ * Abstract directive that implements shared logic common to all menus.
+ * This class can be extended to create custom menu types.
+ */
+export declare abstract class CdkMenuBase extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
+    /** The Angular zone. */
+    protected ngZone: NgZone;
+    /** The stack of menus this menu belongs to. */
+    readonly menuStack: MenuStack;
+    /** The menu aim service used by this menu. */
+    protected readonly menuAim?: MenuAim | undefined;
+    /** The directionality of the current page. */
+    protected readonly dir?: Directionality | undefined;
+    /** The id of the menu's host element. */
+    id: string;
+    /** All child MenuItem elements nested in this Menu. */
+    readonly items: QueryList<CdkMenuItem>;
+    /** The direction items in the menu flow. */
+    orientation: 'horizontal' | 'vertical';
+    /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
+    isInline: boolean;
+    /** The menu's native DOM host element. */
+    readonly nativeElement: HTMLElement;
+    /** Handles keyboard events for the menu. */
+    protected keyManager: FocusKeyManager<CdkMenuItem>;
+    /** Emits when the MenuBar is destroyed. */
+    protected readonly destroyed: Subject<void>;
+    /** The Menu Item which triggered the open submenu. */
+    protected triggerItem?: CdkMenuItem;
+    /** Tracks the users mouse movements over the menu. */
+    protected pointerTracker?: PointerFocusTracker<CdkMenuItem>;
+    /** Whether this menu's menu stack has focus. */
+    private _menuStackHasFocus;
+    protected constructor(
+    /** The host element. */
+    elementRef: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The stack of menus this menu belongs to. */
+    menuStack: MenuStack, 
+    /** The menu aim service used by this menu. */
+    menuAim?: MenuAim | undefined, 
+    /** The directionality of the current page. */
+    dir?: Directionality | undefined);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Place focus on the first MenuItem in the menu and set the focus origin.
+     * @param focusOrigin The origin input mode of the focus event.
+     */
+    focusFirstItem(focusOrigin?: FocusOrigin): void;
+    /**
+     * Place focus on the last MenuItem in the menu and set the focus origin.
+     * @param focusOrigin The origin input mode of the focus event.
+     */
+    focusLastItem(focusOrigin?: FocusOrigin): void;
+    /** Gets the tabindex for this menu. */
+    _getTabIndex(): 0 | -1 | null;
+    /**
+     * Close the open menu if the current active item opened the requested MenuStackItem.
+     * @param menu The menu requested to be closed.
+     * @param options Options to configure the behavior on close.
+     *   - `focusParentTrigger` Whether to focus the parent trigger after closing the menu.
+     */
+    protected closeOpenMenu(menu: MenuStackItem, options?: {
+        focusParentTrigger?: boolean;
+    }): void;
+    /** Setup the FocusKeyManager with the correct orientation for the menu. */
+    private _setKeyManager;
+    /**
+     * Subscribe to the menu trigger's open events in order to track the trigger which opened the menu
+     * and stop tracking it when the menu is closed.
+     */
+    private _subscribeToMenuOpen;
+    /** Subscribe to the MenuStack close events. */
+    private _subscribeToMenuStackClosed;
+    /** Subscribe to the MenuStack hasFocus events. */
+    private _subscribeToMenuStackHasFocus;
+    /**
+     * Set the PointerFocusTracker and ensure that when mouse focus changes the key manager is updated
+     * with the latest menu item under mouse focus.
+     */
+    private _setUpPointerTracker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBase, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBase, never, never, { "id": "id"; }, {}, ["items"]>;
+}

package/menu/menu-errors.d.ts

@@ -5,11 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-/**
- * Throws an exception when a menu panel already has a menu stack.
- * @docs-private
- */
-export declare function throwExistingMenuStackError(): void;
 /**
  * Throws an exception when an instance of the PointerFocusTracker is not provided.
  * @docs-private

package/menu/menu-group.d.ts

@@ -1,33 +1,8 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { EventEmitter, AfterContentInit, OnDestroy } from '@angular/core';
-import { CdkMenuItem } from './menu-item';
 import * as i0 from "@angular/core";
 /**
- * Directive which acts as a grouping container for `CdkMenuItem` instances with
- * `role="menuitemradio"`, similar to a `role="radiogroup"` element.
+ * A grouping container for `CdkMenuItemRadio` instances, similar to a `role="radiogroup"` element.
  */
-export declare class CdkMenuGroup implements AfterContentInit, OnDestroy {
-    /** Emits the element when checkbox or radiobutton state changed  */
-    readonly change: EventEmitter<CdkMenuItem>;
-    /** List of menuitemcheckbox or menuitemradio elements which reside in this group */
-    private readonly _selectableItems;
-    /** Emits when the _selectableItems QueryList triggers a change */
-    private readonly _selectableChanges;
-    ngAfterContentInit(): void;
-    /**
-     * Register the child selectable elements with the change emitter and ensure any new child
-     * elements do so as well.
-     */
-    private _registerMenuSelectionListeners;
-    /** Register each selectable to emit on the change Emitter when clicked */
-    private _registerClickListener;
-    ngOnDestroy(): void;
+export declare class CdkMenuGroup {
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuGroup, "[cdkMenuGroup]", ["cdkMenuGroup"], {}, { "change": "change"; }, ["_selectableItems"]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuGroup, "[cdkMenuGroup]", ["cdkMenuGroup"], {}, {}, never>;
 }

package/menu/menu-interface.d.ts

@@ -5,17 +5,19 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { InjectionToken, ElementRef } from '@angular/core';
+import { InjectionToken } from '@angular/core';
 import { MenuStackItem } from './menu-stack';
 import { FocusOrigin } from '@angular/cdk/a11y';
 /** Injection token used to return classes implementing the Menu interface */
 export declare const CDK_MENU: InjectionToken<Menu>;
 /** Interface which specifies Menu operations and used to break circular dependency issues */
 export interface Menu extends MenuStackItem {
-    /** The element the Menu directive is placed on. */
-    _elementRef: ElementRef<HTMLElement>;
-    /** The orientation of the menu */
-    orientation: 'horizontal' | 'vertical';
+    /** The id of the menu's host element. */
+    id: string;
+    /** The menu's native DOM host element. */
+    nativeElement: HTMLElement;
+    /** The direction items in the menu flow. */
+    readonly orientation: 'horizontal' | 'vertical';
     /** Place focus on the first MenuItem in the menu. */
     focusFirstItem(focusOrigin: FocusOrigin): void;
     /** Place focus on the last MenuItem in the menu. */

package/menu/menu-item-checkbox.d.ts

@@ -5,8 +5,14 @@ import * as i0 from "@angular/core";
  * conventional checkbox.
  */
 export declare class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
-    /** Toggle the checked state of the checkbox. */
-    trigger(): void;
+    /**
+     * Toggle the checked state of the checkbox.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemCheckbox, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemCheckbox, "[cdkMenuItemCheckbox]", ["cdkMenuItemCheckbox"], {}, {}, never>;
 }

package/menu/menu-item-radio.d.ts

@@ -6,12 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { OnDestroy, ElementRef, NgZone } from '@angular/core';
+import { ElementRef, NgZone, OnDestroy } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { CdkMenuItemSelectable } from './menu-item-selectable';
-import { CdkMenuItemTrigger } from './menu-item-trigger';
+import { CdkMenuTrigger } from './menu-trigger';
 import { Menu } from './menu-interface';
 import { MenuAim } from './menu-aim';
+import { MenuStack } from './menu-stack';
 import * as i0 from "@angular/core";
 /**
  * A directive providing behavior for the "menuitemradio" ARIA role, which behaves similarly to
@@ -19,17 +20,40 @@ import * as i0 from "@angular/core";
  * or `CdkMenuGroup` comprise a radio group with unique selection enforced.
  */
 export declare class CdkMenuItemRadio extends CdkMenuItemSelectable implements OnDestroy {
+    /** The unique selection dispatcher for this radio's `CdkMenuGroup`. */
     private readonly _selectionDispatcher;
+    /** An ID to identify this radio item to the `UniqueSelectionDisptcher`. */
+    private _id;
     /** Function to unregister the selection dispatcher */
     private _removeDispatcherListener;
-    constructor(_selectionDispatcher: UniqueSelectionDispatcher, element: ElementRef<HTMLElement>, ngZone: NgZone, parentMenu?: Menu, menuAim?: MenuAim, dir?: Directionality, 
+    constructor(
+    /** The host element for this radio item. */
+    element: ElementRef<HTMLElement>, 
+    /** The Angular zone. */
+    ngZone: NgZone, 
+    /** The unique selection dispatcher for this radio's `CdkMenuGroup`. */
+    _selectionDispatcher: UniqueSelectionDispatcher, 
+    /** The menu stack this item belongs to. */
+    menuStack: MenuStack, 
+    /** The parent menu for this item. */
+    parentMenu?: Menu, 
+    /** The menu aim used for this item. */
+    menuAim?: MenuAim, 
+    /** The directionality of the page. */
+    dir?: Directionality, 
     /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
-    menuTrigger?: CdkMenuItemTrigger);
+    menuTrigger?: CdkMenuTrigger);
+    ngOnDestroy(): void;
+    /**
+     * Toggles the checked state of the radio-button.
+     * @param options Options the configure how the item is triggered
+     *   - keepOpen: specifies that the menu should be kept open after triggering the item.
+     */
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
     /** Configure the unique selection dispatcher listener in order to toggle the checked state  */
     private _registerDispatcherListener;
-    /** Toggles the checked state of the radio-button. */
-    trigger(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemRadio, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemRadio, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemRadio, "[cdkMenuItemRadio]", ["cdkMenuItemRadio"], {}, {}, never>;
 }