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

package/menu/menu-bar.d.ts

@@ -1,88 +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 { AfterContentInit, OnDestroy, NgZone, ElementRef } 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 * as i0 from "@angular/core";
-/**
- * Directive applied to an element which configures it as a MenuBar by setting the appropriate
- * role, aria attributes, and accessible keyboard and mouse handling logic. The component that
- * 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);
-    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.
-     */
-    _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.
-     */
-    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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], { "orientation": "cdkMenuBarOrientation"; }, {}, ["_allItems"]>;
-}

package/menu/menu-errors.d.ts

@@ -1,22 +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 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
- */
-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,33 +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, 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.
- */
-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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuGroup, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuGroup, "[cdkMenuGroup]", ["cdkMenuGroup"], {}, { "change": "change"; }, ["_selectableItems"]>;
-}

package/menu/menu-interface.d.ts

@@ -1,23 +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, ElementRef } 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';
-    /** 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,12 +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. */
-    trigger(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemCheckbox, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemCheckbox, "[cdkMenuItemCheckbox]", ["cdkMenuItemCheckbox"], {}, {}, never>;
-}

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

@@ -1,35 +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 { OnDestroy, ElementRef, NgZone } from '@angular/core';
-import { Directionality } from '@angular/cdk/bidi';
-import { CdkMenuItemSelectable } from './menu-item-selectable';
-import { CdkMenuItemTrigger } from './menu-item-trigger';
-import { Menu } from './menu-interface';
-import { MenuAim } from './menu-aim';
-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 {
-    private readonly _selectionDispatcher;
-    /** Function to unregister the selection dispatcher */
-    private _removeDispatcherListener;
-    constructor(_selectionDispatcher: UniqueSelectionDispatcher, element: ElementRef<HTMLElement>, ngZone: NgZone, parentMenu?: Menu, menuAim?: MenuAim, dir?: Directionality, 
-    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
-    menuTrigger?: CdkMenuItemTrigger);
-    /** 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 ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemRadio, "[cdkMenuItemRadio]", ["cdkMenuItemRadio"], {}, {}, never>;
-}

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

@@ -1,31 +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 { EventEmitter } from '@angular/core';
-import { CdkMenuItem } from './menu-item';
-import * as i0 from "@angular/core";
-/**
- * Base class providing checked state for MenuItems along with outputting a clicked event when the
- * element is triggered. It provides functionality for selectable elements.
- */
-export declare abstract class CdkMenuItemSelectable extends CdkMenuItem {
-    /** Event emitted when the selectable item is clicked */
-    readonly toggled: EventEmitter<CdkMenuItemSelectable>;
-    /** Whether the element is checked */
-    get checked(): boolean;
-    set checked(value: BooleanInput);
-    private _checked;
-    /** The name of the selectable element with a default value */
-    name: string;
-    /** The id of the selectable element with a default value */
-    id: string;
-    /** If the element is not disabled emit the click event */
-    trigger(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemSelectable, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemSelectable, never, never, { "checked": "checked"; "name": "name"; "id": "id"; }, { "toggled": "cdkMenuItemToggled"; }, never>;
-}

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

@@ -1,119 +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, ElementRef, ViewContainerRef, OnDestroy, NgZone } from '@angular/core';
-import { Directionality } from '@angular/cdk/bidi';
-import { Overlay } from '@angular/cdk/overlay';
-import { CdkMenuPanel } from './menu-panel';
-import { Menu } from './menu-interface';
-import { MenuStack } from './menu-stack';
-import { MenuAim } from './menu-aim';
-import * as i0 from "@angular/core";
-/**
- * Whether the target element is a menu item to be ignored by the overlay background click handler.
- */
-export declare function isClickInsideMenuOverlay(target: Element): boolean;
-/**
- * A directive to be combined with CdkMenuItem which opens the Menu it is bound to. If the
- * element is in a top level MenuBar it will open the menu on click, or if a sibling is already
- * opened it will open on hover. If it is inside of a Menu it will open the attached Submenu on
- * hover regardless of its sibling state.
- *
- * The directive must be placed along with the `cdkMenuItem` directive in order to enable full
- * functionality.
- */
-export declare class CdkMenuItemTrigger implements OnDestroy {
-    private readonly _elementRef;
-    protected readonly _viewContainerRef: ViewContainerRef;
-    private readonly _overlay;
-    private readonly _ngZone;
-    private readonly _parentMenu?;
-    private readonly _menuAim?;
-    private readonly _directionality?;
-    /** Template reference variable to the menu this trigger opens */
-    get menuPanel(): CdkMenuPanel | undefined;
-    set menuPanel(panel: CdkMenuPanel | undefined);
-    /** Reference to the MenuPanel this trigger toggles. */
-    private _menuPanel?;
-    /** 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>;
-    /** The menu stack for this trigger and its sub-menus. */
-    _menuStack: MenuStack;
-    /** A reference to the overlay which manages the triggered menu */
-    private _overlayRef;
-    /** The content of the menu panel opened by this trigger. */
-    private _panelContent;
-    /** Emits when this trigger is destroyed. */
-    private readonly _destroyed;
-    /** Emits when the outside pointer events listener on the overlay should be stopped. */
-    private readonly _stopOutsideClicksListener;
-    constructor(_elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _overlay: Overlay, _ngZone: NgZone, _parentMenu?: Menu | undefined, _menuAim?: MenuAim | undefined, _directionality?: Directionality | undefined);
-    /** Open/close the attached menu if the trigger has been configured with one */
-    toggle(): void;
-    /** Open the attached menu. */
-    openMenu(): void;
-    /** Close the opened menu. */
-    closeMenu(): void;
-    /** Return true if the trigger has an attached menu */
-    hasMenu(): boolean;
-    /** Whether the menu this button is a trigger for 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;
-    /**
-     * Subscribe to the mouseenter events and close any sibling menu items if this element is moused
-     * into.
-     */
-    private _subscribeToMouseEnter;
-    /**
-     * Handles keyboard events for the menu item, specifically opening/closing the attached menu and
-     * focusing the appropriate submenu item.
-     * @param event the keyboard event to handle
-     */
-    _toggleOnKeydown(event: KeyboardEvent): void;
-    /** Close out any sibling menu trigger menus. */
-    private _closeSiblingTriggers;
-    /** Get the configuration object used to create the overlay */
-    private _getOverlayConfig;
-    /** Build the position strategy for the overlay which specifies where to place the menu */
-    private _getOverlayPositionStrategy;
-    /** Determine and return where to position the opened menu relative to the menu item */
-    private _getOverlayPositions;
-    /**
-     * 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.
-     */
-    private _getPortal;
-    /**
-     * @return true if if the enclosing parent menu is configured in a vertical orientation.
-     */
-    private _isParentVertical;
-    /**
-     * Subscribe to the MenuStack close events if this is a standalone trigger and close out the menu
-     * this triggers when requested.
-     */
-    private _registerCloseHandler;
-    /** Get the menu stack for this trigger - either from the parent or this trigger. */
-    private _getMenuStack;
-    ngOnDestroy(): void;
-    /** Set the menu panels menu stack back to null. */
-    private _resetPanelMenuStack;
-    /**
-     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
-     * click occurs outside the menus.
-     */
-    private _subscribeToOutsideClicks;
-    /** Destroy and unset the overlay reference it if exists */
-    private _destroyOverlay;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemTrigger, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "menuPanel": "cdkMenuTriggerFor"; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never>;
-}

package/menu/menu-item.d.ts

@@ -1,100 +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 { CdkMenuItemTrigger } from './menu-item-trigger';
-import { Menu } from './menu-interface';
-import { FocusableElement } from './pointer-focus-tracker';
-import { Toggler, MenuAim } 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 {
-    readonly _elementRef: ElementRef<HTMLElement>;
-    private readonly _ngZone;
-    private readonly _parentMenu?;
-    private readonly _menuAim?;
-    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;
-    /**
-     * If this MenuItem is a regular MenuItem, outputs when it is triggered by a keyboard or mouse
-     * event.
-     */
-    readonly triggered: EventEmitter<void>;
-    /**
-     * The tabindex for this menu item managed internally and used for implementing roving a
-     * tab index.
-     */
-    _tabindex: 0 | -1;
-    /** Emits when the menu item is destroyed. */
-    private readonly _destroyed;
-    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone, _parentMenu?: Menu | undefined, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined, 
-    /** Reference to the CdkMenuItemTrigger directive if one is added to the same element */
-    _menuTrigger?: CdkMenuItemTrigger | undefined);
-    /** Place focus on the element. */
-    focus(): void;
-    /** 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;
-    /** Whether this menu item is standalone or within a menu or menu bar. */
-    _isStandaloneItem(): boolean;
-    /**
-     * 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.
-     */
-    trigger(): void;
-    /** Whether the menu item opens a menu. */
-    hasMenu(): boolean;
-    /** 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 MenuItemTrigger associated with this element. */
-    getMenuTrigger(): CdkMenuItemTrigger | undefined;
-    /** Get the label for this element which is required by the FocusableOption interface. */
-    getLabel(): string;
-    /**
-     * 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;
-    /**
-     * 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;
-    /** Get the MenuStack from the parent menu. */
-    private _getMenuStack;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItem, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItem, "[cdkMenuItem]", ["cdkMenuItem"], { "disabled": "disabled"; }, { "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-panel";
-import * as i4 from "./menu-item";
-import * as i5 from "./menu-item-radio";
-import * as i6 from "./menu-item-checkbox";
-import * as i7 from "./menu-item-trigger";
-import * as i8 from "./menu-group";
-import * as i9 from "./context-menu";
-import * as i10 from "./menu-aim";
-import * as i11 from "@angular/cdk/overlay";
-export declare class CdkMenuModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuPanel, typeof i4.CdkMenuItem, typeof i5.CdkMenuItemRadio, typeof i6.CdkMenuItemCheckbox, typeof i7.CdkMenuItemTrigger, typeof i8.CdkMenuGroup, typeof i9.CdkContextMenuTrigger, typeof i10.CdkTargetMenuAim], [typeof i11.OverlayModule], [typeof i1.CdkMenuBar, typeof i2.CdkMenu, typeof i3.CdkMenuPanel, typeof i4.CdkMenuItem, typeof i5.CdkMenuItemRadio, typeof i6.CdkMenuItemCheckbox, typeof i7.CdkMenuItemTrigger, typeof i8.CdkMenuGroup, typeof i9.CdkContextMenuTrigger, typeof i10.CdkTargetMenuAim]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
-}

package/menu/menu-panel.d.ts

@@ -1,30 +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 { TemplateRef } from '@angular/core';
-import { Menu } from './menu-interface';
-import { MenuStack } from './menu-stack';
-import * as i0 from "@angular/core";
-/**
- * Directive applied to an ng-template which wraps a CdkMenu and provides a reference to the
- * child element it wraps which allows for opening of the CdkMenu in an overlay.
- */
-export declare class CdkMenuPanel {
-    readonly _templateRef: TemplateRef<unknown>;
-    /** Reference to the child menu component */
-    _menu?: Menu;
-    /** Keep track of open Menus. */
-    _menuStack: MenuStack | null;
-    constructor(_templateRef: TemplateRef<unknown>);
-    /**
-     * Set the Menu component on the menu panel. Since we cannot use ContentChild to fetch the
-     * child Menu component, the child Menu must register its self with the parent MenuPanel.
-     */
-    _registerMenu(child: Menu): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuPanel, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuPanel, "ng-template[cdkMenuPanel]", ["cdkMenuPanel"], {}, {}, never>;
-}

package/menu/menu-stack.d.ts

@@ -1,78 +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 { Observable } from 'rxjs';
-/** Events to emit as specified by the caller once the MenuStack is empty. */
-export declare const enum FocusNext {
-    nextItem = 0,
-    previousItem = 1,
-    currentItem = 2
-}
-/**
- * Interface for the elements tracked in the MenuStack.
- */
-export interface MenuStackItem {
-    /** A reference to the previous Menus MenuStack instance. */
-    _menuStack: MenuStack | null;
-}
-/**
- * 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 {
-    /** 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;
-    /** Observable which emits the MenuStackItem which has been requested to close. */
-    readonly closed: Observable<MenuStackItem | undefined>;
-    /**
-     * 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>;
-    /** @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 focusNext the event to emit on the `empty` observable if the method call resulted in an
-     * empty stack. Does not emit if the stack was initially empty or if `lastItem` was not on the
-     * stack.
-     */
-    close(lastItem: MenuStackItem, focusNext?: FocusNext): 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 focusNext the event to emit on the `empty` observable once the stack is emptied. Does
-     * not emit if the stack was initially empty.
-     */
-    closeAll(focusNext?: FocusNext): 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;
-}
-/** NoopMenuStack is a placeholder MenuStack used for inline menus. */
-export declare class NoopMenuStack extends MenuStack {
-    /** Noop push - does not add elements to the MenuStack. */
-    push(_: MenuStackItem): void;
-}