@angular/cdk-experimental 14.0.0-next.11 → 14.0.0-next.12

package/menu/menu-base.d.ts

@@ -1,104 +0,0 @@
-/**
- * @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

@@ -1,17 +0,0 @@
-/**
- * @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
- */
-/**
- * Throws an exception when an instance of the PointerFocusTracker is not provided.
- * @docs-private
- */
-export declare function throwMissingPointerFocusTracker(): void;
-/**
- * Throws an exception when a reference to the parent menu is not provided.
- * @docs-private
- */
-export declare function throwMissingMenuReference(): void;

package/menu/menu-group.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * A grouping container for `CdkMenuItemRadio` instances, similar to a `role="radiogroup"` element.
- */
-export declare class CdkMenuGroup {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuGroup, "[cdkMenuGroup]", ["cdkMenuGroup"], {}, {}, never>;
-}

package/menu/menu-interface.d.ts

@@ -1,25 +0,0 @@
-/**
- * @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 { 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 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. */
-    focusLastItem(focusOrigin: FocusOrigin): void;
-}

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

@@ -1,18 +0,0 @@
-import { CdkMenuItemSelectable } from './menu-item-selectable';
-import * as i0 from "@angular/core";
-/**
- * A directive providing behavior for the "menuitemcheckbox" ARIA role, which behaves similarly to a
- * conventional checkbox.
- */
-export declare class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
-    /**
-     * 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

@@ -1,59 +0,0 @@
-/**
- * @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 { UniqueSelectionDispatcher } from '@angular/cdk/collections';
-import { ElementRef, NgZone, OnDestroy } from '@angular/core';
-import { Directionality } from '@angular/cdk/bidi';
-import { CdkMenuItemSelectable } from './menu-item-selectable';
-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
- * a conventional radio-button. Any sibling `CdkMenuItemRadio` instances within the same `CdkMenu`
- * 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(
-    /** 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?: 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;
-    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>;
-}

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

@@ -1,21 +0,0 @@
-/**
- * @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 { BooleanInput } from '@angular/cdk/coercion';
-import { CdkMenuItem } from './menu-item';
-import * as i0 from "@angular/core";
-/** Base class providing checked state for selectable MenuItems. */
-export declare abstract class CdkMenuItemSelectable extends CdkMenuItem {
-    /** Whether the element is checked */
-    get checked(): boolean;
-    set checked(value: BooleanInput);
-    private _checked;
-    /** Whether the item should close the menu if triggered by the spacebar. */
-    protected closeOnSpacebarTrigger: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemSelectable, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemSelectable, never, never, { "checked": "cdkMenuItemChecked"; }, {}, never>;
-}

package/menu/menu-item.d.ts

@@ -1,140 +0,0 @@
-/**
- * @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 { ElementRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
-import { BooleanInput } from '@angular/cdk/coercion';
-import { FocusableOption } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { Subject } from 'rxjs';
-import { CdkMenuTrigger } from './menu-trigger';
-import { Menu } from './menu-interface';
-import { MenuStack } from './menu-stack';
-import { FocusableElement } from './pointer-focus-tracker';
-import { MenuAim, Toggler } from './menu-aim';
-import * as i0 from "@angular/core";
-/**
- * Directive which provides the ability for an element to be focused and navigated to using the
- * keyboard when residing in a CdkMenu, CdkMenuBar, or CdkMenuGroup. It performs user defined
- * behavior when clicked.
- */
-export declare class CdkMenuItem implements FocusableOption, FocusableElement, Toggler, OnDestroy {
-    /** The host element for this item. */
-    readonly _elementRef: ElementRef<HTMLElement>;
-    /** The Angular zone. */
-    private readonly _ngZone;
-    /** The menu stack this item belongs to. */
-    private readonly _menuStack;
-    /** The parent menu this item belongs to. */
-    private readonly _parentMenu?;
-    /** The menu aim service used for this item. */
-    private readonly _menuAim?;
-    /** The directionality of the page. */
-    private readonly _dir?;
-    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
-    private readonly _menuTrigger?;
-    /**  Whether the CdkMenuItem is disabled - defaults to false */
-    get disabled(): boolean;
-    set disabled(value: BooleanInput);
-    private _disabled;
-    /**
-     * The text used to locate this item during menu typeahead. If not specified,
-     * the `textContent` of the item will be used.
-     */
-    typeaheadLabel: string | null;
-    /**
-     * If this MenuItem is a regular MenuItem, outputs when it is triggered by a keyboard or mouse
-     * event.
-     */
-    readonly triggered: EventEmitter<void>;
-    /** Whether the menu item opens a menu. */
-    readonly hasMenu: boolean;
-    /**
-     * The tabindex for this menu item managed internally and used for implementing roving a
-     * tab index.
-     */
-    _tabindex: 0 | -1;
-    /** Whether the item should close the menu if triggered by the spacebar. */
-    protected closeOnSpacebarTrigger: boolean;
-    /** Emits when the menu item is destroyed. */
-    protected readonly destroyed: Subject<void>;
-    constructor(
-    /** The host element for this item. */
-    _elementRef: ElementRef<HTMLElement>, 
-    /** The Angular zone. */
-    _ngZone: NgZone, 
-    /** The menu stack this item belongs to. */
-    _menuStack: MenuStack, 
-    /** The parent menu this item belongs to. */
-    _parentMenu?: Menu | undefined, 
-    /** The menu aim service used for this item. */
-    _menuAim?: MenuAim | undefined, 
-    /** The directionality of the page. */
-    _dir?: Directionality | undefined, 
-    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
-    _menuTrigger?: CdkMenuTrigger | undefined);
-    ngOnDestroy(): void;
-    /** Place focus on the element. */
-    focus(): void;
-    /**
-     * If the menu item is not disabled and the element does not have a menu trigger attached, emit
-     * on the cdkMenuItemTriggered emitter and close all open menus.
-     * @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;
-    /** Return true if this MenuItem has an attached menu and it is open. */
-    isMenuOpen(): boolean;
-    /**
-     * Get a reference to the rendered Menu if the Menu is open and it is visible in the DOM.
-     * @return the menu if it is open, otherwise undefined.
-     */
-    getMenu(): Menu | undefined;
-    /** Get the CdkMenuTrigger associated with this element. */
-    getMenuTrigger(): CdkMenuTrigger | undefined;
-    /** Get the label for this element which is required by the FocusableOption interface. */
-    getLabel(): string;
-    /** Reset the tabindex to -1. */
-    _resetTabIndex(): void;
-    /**
-     * Set the tab index to 0 if not disabled and it's a focus event, or a mouse enter if this element
-     * is not in a menu bar.
-     */
-    _setTabIndex(event?: MouseEvent): void;
-    /**
-     * Handles keyboard events for the menu item, specifically either triggering the user defined
-     * callback or opening/closing the current menu based on whether the left or right arrow key was
-     * pressed.
-     * @param event the keyboard event to handle
-     */
-    _onKeydown(event: KeyboardEvent): void;
-    /** Whether this menu item is standalone or within a menu or menu bar. */
-    private _isStandaloneItem;
-    /**
-     * Handles the user pressing the back arrow key.
-     * @param event The keyboard event.
-     */
-    private _backArrowPressed;
-    /**
-     * Handles the user pressing the forward arrow key.
-     * @param event The keyboard event.
-     */
-    private _forwardArrowPressed;
-    /**
-     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
-     * into.
-     */
-    private _setupMouseEnter;
-    /**
-     * Return true if the enclosing parent menu is configured in a horizontal orientation, false
-     * otherwise or if no parent.
-     */
-    private _isParentVertical;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItem, [null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItem, "[cdkMenuItem]", ["cdkMenuItem"], { "disabled": "cdkMenuItemDisabled"; "typeaheadLabel": "cdkMenuitemTypeaheadLabel"; }, { "triggered": "cdkMenuItemTriggered"; }, never>;
-}

package/menu/menu-module.d.ts

@@ -1,17 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./menu-bar";
-import * as i2 from "./menu";
-import * as i3 from "./menu-item";
-import * as i4 from "./menu-item-radio";
-import * as i5 from "./menu-item-checkbox";
-import * as i6 from "./menu-trigger";
-import * as i7 from "./menu-group";
-import * as i8 from "./context-menu-trigger";
-import * as i9 from "./menu-aim";
-import * as i10 from "@angular/cdk/overlay";
-/** Module that declares components and directives for the CDK menu. */
-export declare class CdkMenuModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuItem, typeof i4.CdkMenuItemRadio, typeof i5.CdkMenuItemCheckbox, typeof i6.CdkMenuTrigger, typeof i7.CdkMenuGroup, typeof i8.CdkContextMenuTrigger, typeof i9.CdkTargetMenuAim], [typeof i10.OverlayModule], [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuItem, typeof i4.CdkMenuItemRadio, typeof i5.CdkMenuItemCheckbox, typeof i6.CdkMenuTrigger, typeof i7.CdkMenuGroup, typeof i8.CdkContextMenuTrigger, typeof i9.CdkTargetMenuAim]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
-}

package/menu/menu-stack.d.ts

@@ -1,122 +0,0 @@
-/**
- * @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 { InjectionToken, Optional } from '@angular/core';
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-/** The relative item in the inline menu to focus after closing all popup menus. */
-export declare const enum FocusNext {
-    nextItem = 0,
-    previousItem = 1,
-    currentItem = 2
-}
-/** A single item (menu) in the menu stack. */
-export interface MenuStackItem {
-    /** A reference to the menu stack this menu stack item belongs to. */
-    menuStack?: MenuStack;
-}
-/** Injection token used for an implementation of MenuStack. */
-export declare const MENU_STACK: InjectionToken<MenuStack>;
-/** Provider that provides the parent menu stack, or a new menu stack if there is no parent one. */
-export declare const PARENT_OR_NEW_MENU_STACK_PROVIDER: {
-    provide: InjectionToken<MenuStack>;
-    deps: Optional[][];
-    useFactory: (parentMenuStack?: MenuStack | undefined) => MenuStack;
-};
-/** Provider that provides the parent menu stack, or a new inline menu stack if there is no parent one. */
-export declare const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER: (orientation: 'vertical' | 'horizontal') => {
-    provide: InjectionToken<MenuStack>;
-    deps: Optional[][];
-    useFactory: (parentMenuStack?: MenuStack | undefined) => MenuStack;
-};
-/** Options that can be provided to the close or closeAll methods. */
-export interface CloseOptions {
-    /** The element to focus next if the close operation causes the menu stack to become empty. */
-    focusNextOnEmpty?: FocusNext;
-    /** Whether to focus the parent trigger after closing the menu. */
-    focusParentTrigger?: boolean;
-}
-/** Event dispatched when a menu is closed. */
-export interface MenuStackCloseEvent {
-    /** The menu being closed. */
-    item: MenuStackItem;
-    /** Whether to focus the parent trigger after closing the menu. */
-    focusParentTrigger?: boolean;
-}
-/**
- * MenuStack allows subscribers to listen for close events (when a MenuStackItem is popped off
- * of the stack) in order to perform closing actions. Upon the MenuStack being empty it emits
- * from the `empty` observable specifying the next focus action which the listener should perform
- * as requested by the closer.
- */
-export declare class MenuStack {
-    /** The ID of this menu stack. */
-    readonly id: string;
-    /** All MenuStackItems tracked by this MenuStack. */
-    private readonly _elements;
-    /** Emits the element which was popped off of the stack when requested by a closer. */
-    private readonly _close;
-    /** Emits once the MenuStack has become empty after popping off elements. */
-    private readonly _empty;
-    /** Emits whether any menu in the menu stack has focus. */
-    private readonly _hasFocus;
-    /** Observable which emits the MenuStackItem which has been requested to close. */
-    readonly closed: Observable<MenuStackCloseEvent>;
-    /** Observable which emits whether any menu in the menu stack has focus. */
-    readonly hasFocus: Observable<boolean>;
-    /**
-     * Observable which emits when the MenuStack is empty after popping off the last element. It
-     * emits a FocusNext event which specifies the action the closer has requested the listener
-     * perform.
-     */
-    readonly emptied: Observable<FocusNext | undefined>;
-    /**
-     * Whether the inline menu associated with this menu stack is vertical or horizontal.
-     * `null` indicates there is no inline menu associated with this menu stack.
-     */
-    private _inlineMenuOrientation;
-    /** Creates a menu stack that originates from an inline menu. */
-    static inline(orientation: 'vertical' | 'horizontal'): MenuStack;
-    /**
-     * Adds an item to the menu stack.
-     * @param menu the MenuStackItem to put on the stack.
-     */
-    push(menu: MenuStackItem): void;
-    /**
-     * Pop items off of the stack up to and including `lastItem` and emit each on the close
-     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
-     * @param lastItem the last item to pop off the stack.
-     * @param options Options that configure behavior on close.
-     */
-    close(lastItem: MenuStackItem, options?: CloseOptions): void;
-    /**
-     * Pop items off of the stack up to but excluding `lastItem` and emit each on the close
-     * observable. If the stack is empty or `lastItem` is not on the stack it does nothing.
-     * @param lastItem the element which should be left on the stack
-     * @return whether or not an item was removed from the stack
-     */
-    closeSubMenuOf(lastItem: MenuStackItem): boolean;
-    /**
-     * Pop off all MenuStackItems and emit each one on the `close` observable one by one.
-     * @param options Options that configure behavior on close.
-     */
-    closeAll(options?: CloseOptions): void;
-    /** Return true if this stack is empty. */
-    isEmpty(): boolean;
-    /** Return the length of the stack. */
-    length(): number;
-    /** Get the top most element on the stack. */
-    peek(): MenuStackItem | undefined;
-    /** Whether the menu stack is associated with an inline menu. */
-    hasInlineMenu(): boolean;
-    /** The orientation of the associated inline menu. */
-    inlineMenuOrientation(): "vertical" | "horizontal" | null;
-    /** Sets whether the menu stack contains the focused element. */
-    setHasFocus(hasFocus: boolean): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MenuStack, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MenuStack>;
-}

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

@@ -1,77 +0,0 @@
-/**
- * @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, InjectionToken, Injector, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
-import { Menu } from './menu-interface';
-import { MenuStack } from './menu-stack';
-import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
-import { TemplatePortal } from '@angular/cdk/portal';
-import { Subject } from 'rxjs';
-import * as i0 from "@angular/core";
-/** Injection token used for an implementation of MenuStack. */
-export declare const MENU_TRIGGER: InjectionToken<CdkMenuTriggerBase>;
-/**
- * Abstract directive that implements shared logic common to all menu triggers.
- * This class can be extended to create custom menu trigger types.
- */
-export declare abstract class CdkMenuTriggerBase implements OnDestroy {
-    /** The DI injector for this component */
-    protected readonly injector: Injector;
-    /** The view container ref for this component */
-    protected readonly viewContainerRef: ViewContainerRef;
-    /** The menu stack this menu is part of. */
-    protected readonly menuStack: MenuStack;
-    /** A list of preferred menu positions to be used when constructing the `FlexibleConnectedPositionStrategy` for this trigger's menu. */
-    menuPosition: ConnectedPosition[];
-    /** Emits when the attached menu is requested to open */
-    readonly opened: EventEmitter<void>;
-    /** Emits when the attached menu is requested to close */
-    readonly closed: EventEmitter<void>;
-    /** Template reference variable to the menu this trigger opens */
-    menuTemplateRef: TemplateRef<unknown>;
-    /** A reference to the overlay which manages the triggered menu */
-    protected overlayRef: OverlayRef | null;
-    /** Emits when this trigger is destroyed. */
-    protected readonly destroyed: Subject<void>;
-    /** Emits when the outside pointer events listener on the overlay should be stopped. */
-    protected readonly stopOutsideClicksListener: import("rxjs").Observable<void>;
-    /** The child menu opened by this trigger. */
-    protected childMenu?: Menu;
-    /** The content of the menu panel opened by this trigger. */
-    private _menuPortal;
-    /** The injector to use for the child menu opened by this trigger. */
-    private _childMenuInjector?;
-    protected constructor(
-    /** The DI injector for this component */
-    injector: Injector, 
-    /** The view container ref for this component */
-    viewContainerRef: ViewContainerRef, 
-    /** The menu stack this menu is part of. */
-    menuStack: MenuStack);
-    ngOnDestroy(): void;
-    /** Whether the attached menu is open. */
-    isOpen(): boolean;
-    /** Registers a child menu as having been opened by this trigger. */
-    registerChildMenu(child: Menu): void;
-    /**
-     * Get the portal to be attached to the overlay which contains the menu. Allows for the menu
-     * content to change dynamically and be reflected in the application.
-     */
-    protected getMenuContentPortal(): TemplatePortal<any>;
-    /**
-     * Whether the given element is inside the scope of this trigger's menu stack.
-     * @param element The element to check.
-     * @return Whether the element is inside the scope of this trigger's menu stack.
-     */
-    protected isElementInsideMenuStack(element: Element): boolean;
-    /** Destroy and unset the overlay reference it if exists */
-    private _destroyOverlay;
-    /** Gets the injector to use when creating a child menu. */
-    private _getChildMenuInjector;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuTriggerBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuTriggerBase, never, never, {}, {}, never>;
-}