@angular/cdk-experimental 14.0.0-next.9 → 14.0.0-rc.0

package/menu/menu-aim.d.ts

@@ -1,96 +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 { NgZone, OnDestroy, InjectionToken } from '@angular/core';
-import { PointerFocusTracker, FocusableElement } from './pointer-focus-tracker';
-import { Menu } from './menu-interface';
-import * as i0 from "@angular/core";
-/**
- * MenuAim is responsible for determining if a sibling menuitem's menu should be closed when a
- * Toggler item is hovered into. It is up to the hovered in item to call the MenuAim service in
- * order to determine if it may perform its close actions.
- */
-export interface MenuAim {
-    /** Set the Menu and its PointerFocusTracker. */
-    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
-    /**
-     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
-     * the submenu.
-     * @param doToggle the function called when the user is not moving towards the submenu.
-     */
-    toggle(doToggle: () => void): void;
-}
-/** 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.
- */
-export interface Toggler {
-    getMenu(): Menu | undefined;
-}
-/**
- * TargetMenuAim predicts if a user is moving into a submenu. It calculates the
- * trajectory of the user's mouse movement in the current menu to determine if the
- * mouse is moving towards an open submenu.
- *
- * The determination is made by calculating the slope of the users last NUM_POINTS moves where each
- * pair of points determines if the trajectory line points into the submenu. It uses consensus
- * approach by checking if at least NUM_POINTS / 2 pairs determine that the user is moving towards
- * to submenu.
- */
-export declare class TargetMenuAim implements MenuAim, OnDestroy {
-    private readonly _ngZone;
-    /** The last NUM_POINTS mouse move events. */
-    private readonly _points;
-    /** Reference to the root menu in which we are tracking mouse moves. */
-    private _menu;
-    /** Reference to the root menu's mouse manager. */
-    private _pointerTracker;
-    /** The id associated with the current timeout call waiting to resolve. */
-    private _timeoutId;
-    /** Emits when this service is destroyed. */
-    private readonly _destroyed;
-    constructor(_ngZone: NgZone);
-    /** Set the Menu and its PointerFocusTracker. */
-    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
-    /**
-     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
-     * the submenu.
-     * @param doToggle the function called when the user is not moving towards the submenu.
-     */
-    toggle(doToggle: () => void): void;
-    /**
-     * Start the delayed toggle handler if one isn't running already.
-     *
-     * 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.
-     */
-    private _startTimeout;
-    /** Whether the user is heading towards the open submenu. */
-    private _isMovingToSubmenu;
-    /** Get the bounding DOMRect for the open submenu. */
-    private _getSubmenuBounds;
-    /**
-     * Check if a reference to the PointerFocusTracker and menu element is provided.
-     * @throws an error if neither reference is provided.
-     */
-    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
- * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
- */
-export declare class CdkTargetMenuAim {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTargetMenuAim, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTargetMenuAim, "[cdkTargetMenuAim]", ["cdkTargetMenuAim"], {}, {}, never>;
-}

package/menu/menu-bar.d.ts

@@ -1,47 +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, ElementRef, NgZone, OnDestroy } from '@angular/core';
-import { Directionality } from '@angular/cdk/bidi';
-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
- * 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 CdkMenuBase implements AfterContentInit, OnDestroy {
-    private readonly _ngZone;
-    private readonly _menuAim?;
-    readonly orientation: 'horizontal' | 'vertical';
-    menuStack: MenuStack;
-    constructor(_ngZone: NgZone, elementRef: ElementRef<HTMLElement>, menuStack: MenuStack, _menuAim?: MenuAim | undefined, dir?: Directionality);
-    ngAfterContentInit(): void;
-    ngOnDestroy(): 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;
-    /**
-     * 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;
-    /**
-     * Set focus to either the current, previous or next item based on the FocusNext event, then
-     * open the previous or next item.
-     */
-    private _toggleOpenMenu;
-    private _subscribeToMenuStackEmptied;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], {}, {}, never>;
-}

package/menu/menu-base.d.ts

@@ -1,64 +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, 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 * as i0 from "@angular/core";
-export declare abstract class CdkMenuBase extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
-    readonly _elementRef: ElementRef<HTMLElement>;
-    readonly menuStack: MenuStack;
-    protected readonly dir?: Directionality | undefined;
-    /**
-     * Sets the aria-orientation attribute and determines where menus will be opened.
-     * Does not affect styling/layout.
-     */
-    orientation: 'horizontal' | 'vertical';
-    /** All child MenuItem elements nested in this Menu. */
-    protected readonly items: QueryList<CdkMenuItem>;
-    /** 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 openItem?: CdkMenuItem;
-    /** Manages items under mouse focus */
-    protected pointerTracker?: PointerFocusTracker<CdkMenuItem>;
-    protected constructor(_elementRef: ElementRef<HTMLElement>, menuStack: MenuStack, dir?: Directionality | undefined);
-    ngAfterContentInit(): void;
-    ngOnDestroy(): 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;
-    /** Return true if this menu has been configured in a horizontal orientation. */
-    protected isHorizontal(): boolean;
-    /** Return true if the MenuBar has an open submenu. */
-    protected hasOpenSubmenu(): boolean;
-    /**
-     * Close the open menu if the current active item opened the requested MenuStackItem.
-     * @param item the MenuStackItem requested to be closed.
-     */
-    protected closeOpenMenu(menu: MenuStackItem | undefined): 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 and empty observables. */
-    private _subscribeToMenuStackClosed;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBase, [null, null, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBase, never, never, {}, {}, ["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,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 { AfterContentInit, EventEmitter, 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;
-    ngOnDestroy(): 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;
-    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 */
-    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,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,36 +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 { CdkMenuItemTrigger } from './menu-item-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 {
-    private readonly _selectionDispatcher;
-    /** Function to unregister the selection dispatcher */
-    private _removeDispatcherListener;
-    constructor(_selectionDispatcher: UniqueSelectionDispatcher, element: ElementRef<HTMLElement>, ngZone: NgZone, menuStack: MenuStack, 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, 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,89 +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, Injector, NgZone, OnDestroy, ViewContainerRef } from '@angular/core';
-import { Directionality } from '@angular/cdk/bidi';
-import { Overlay } from '@angular/cdk/overlay';
-import { Menu } from './menu-interface';
-import { MenuStack } from './menu-stack';
-import { MenuAim } from './menu-aim';
-import { MenuTrigger } from './menu-trigger';
-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 extends MenuTrigger implements OnDestroy {
-    private readonly _elementRef;
-    protected readonly _viewContainerRef: ViewContainerRef;
-    private readonly _overlay;
-    private readonly _ngZone;
-    private readonly _parentMenu?;
-    private readonly _menuAim?;
-    private readonly _directionality?;
-    constructor(injector: Injector, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _overlay: Overlay, _ngZone: NgZone, menuStack: MenuStack, _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. */
-    open(): void;
-    /** Close the opened menu. */
-    close(): void;
-    /**
-     * 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;
-    /**
-     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
-     * click occurs outside the menus.
-     */
-    private _subscribeToOutsideClicks;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemTrigger, [null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "_menuTemplateRef": "cdkMenuTriggerFor"; "menuPosition": "cdkMenuPosition"; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never>;
-}

package/menu/menu-item.d.ts

@@ -1,105 +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 { 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 {
-    readonly _elementRef: ElementRef<HTMLElement>;
-    private readonly _ngZone;
-    private readonly _menuStack;
-    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;
-    /**
-     * The text used to locate this item during menu typeahead. If not specified,
-     * the `textContent` of the item will be used.
-     */
-    typeahead: string;
-    /**
-     * 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, _menuStack: MenuStack, _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;
-    ngOnDestroy(): void;
-    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": "disabled"; "typeahead": "typeahead"; }, { "triggered": "cdkMenuItemTriggered"; }, never>;
-}

package/menu/menu-module.d.ts

@@ -1,16 +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-item-trigger";
-import * as i7 from "./menu-group";
-import * as i8 from "./context-menu";
-import * as i9 from "./menu-aim";
-import * as i10 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.CdkMenuItem, typeof i4.CdkMenuItemRadio, typeof i5.CdkMenuItemCheckbox, typeof i6.CdkMenuItemTrigger, 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.CdkMenuItemTrigger, typeof i7.CdkMenuGroup, typeof i8.CdkContextMenuTrigger, typeof i9.CdkTargetMenuAim]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
-}