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

package/menu/context-menu.d.ts

@@ -1,117 +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, 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 { MenuTrigger } from './menu-trigger';
-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>;
-}
-/** Configuration options passed to the context menu. */
-export declare type ContextMenuOptions = {
-    /** The opened menus X coordinate offset from the triggering position. */
-    offsetX: number;
-    /** The opened menus Y coordinate offset from the triggering position. */
-    offsetY: number;
-};
-/** Injection token for the ContextMenu options object. */
-export declare const CDK_CONTEXT_MENU_DEFAULT_OPTIONS: InjectionToken<ContextMenuOptions>;
-/** The coordinates of where the context menu should open. */
-export declare type ContextMenuCoordinates = {
-    x: number;
-    y: number;
-};
-/**
- * A directive which when placed on some element opens a the Menu it is bound to when a user
- * right-clicks within that element. It is aware of nested Context Menus and the lowest level
- * non-disabled context menu will trigger.
- */
-export declare class CdkContextMenuTrigger extends MenuTrigger implements OnDestroy {
-    protected readonly _viewContainerRef: ViewContainerRef;
-    private readonly _overlay;
-    private readonly _contextMenuTracker;
-    private readonly _options;
-    private readonly _directionality?;
-    /** Template reference variable to the menu to open on right click. */
-    private _menuTemplateRef;
-    /** 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>;
-    /** Whether the context menu should be disabled. */
-    get disabled(): boolean;
-    set disabled(value: BooleanInput);
-    private _disabled;
-    /** A reference to the overlay which manages the triggered menu. */
-    private _overlayRef;
-    /** The content of the menu panel opened by this trigger. */
-    private _menuPortal;
-    /** Emits when the element is destroyed. */
-    private readonly _destroyed;
-    /** Emits when the outside pointer events listener on the overlay should be stopped. */
-    private readonly _stopOutsideClicksListener;
-    constructor(injector: Injector, _viewContainerRef: ViewContainerRef, _overlay: Overlay, _contextMenuTracker: ContextMenuTracker, menuStack: MenuStack, _options: ContextMenuOptions, _directionality?: Directionality | undefined);
-    /**
-     * Open the attached menu at the specified location.
-     * @param coordinates where to open the context menu
-     */
-    open(coordinates: ContextMenuCoordinates): void;
-    private _open;
-    /** Close the opened menu. */
-    close(): void;
-    /**
-     * Open the context menu and close any previously open menus.
-     * @param event the mouse event which opens the context menu.
-     */
-    _openOnContextMenu(event: MouseEvent): void;
-    /** Whether the attached menu is open. */
-    isOpen(): boolean;
-    /**
-     * Get the configuration object used to create the overlay.
-     * @param coordinates the location to place the opened menu
-     */
-    private _getOverlayConfig;
-    /**
-     * Build the position strategy for the overlay which specifies where to place the menu.
-     * @param coordinates the location to place the opened menu
-     */
-    private _getOverlayPositionStrategy;
-    /**
-     * Determine and return where to position the opened menu relative to the mouse location.
-     */
-    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 _getMenuContent;
-    /** Subscribe to the menu stack close events and close this menu when requested. */
-    private _setMenuStackListener;
-    /**
-     * Subscribe to the overlays outside pointer events stream and handle closing out the stack if a
-     * click occurs outside the menus.
-     */
-    private _subscribeToOutsideClicks;
-    ngOnDestroy(): void;
-    /** Destroy and unset the overlay reference it if exists. */
-    private _destroyOverlay;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkContextMenuTrigger, [null, null, null, null, null, null, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkContextMenuTrigger, "[cdkContextMenuTriggerFor]", ["cdkContextMenuTriggerFor"], { "_menuTemplateRef": "cdkContextMenuTriggerFor"; "disabled": "cdkContextMenuDisabled"; }, { "opened": "cdkContextMenuOpened"; "closed": "cdkContextMenuClosed"; }, never>;
-}

package/menu/index.d.ts

@@ -1,8 +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
- */
-export * from './public-api';

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,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 {
-    private readonly _ngZone;
-    readonly _elementRef: ElementRef<HTMLElement>;
-    readonly _menuStack: MenuStack;
-    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(_ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _menuStack: MenuStack, _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,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 { 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,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, { optional: true; }, { 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,110 +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, Injector, NgZone, OnDestroy, TemplateRef, 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?;
-    /** Template reference variable to the menu this trigger opens */
-    _menuTemplateRef?: TemplateRef<unknown>;
-    /** 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>;
-    /** A reference to the overlay which manages the triggered menu */
-    private _overlayRef;
-    /** The content of the menu panel opened by this trigger. */
-    private _menuPortal;
-    /** 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(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. */
-    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;
-    ngOnDestroy(): void;
-    /**
-     * 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, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "_menuTemplateRef": "cdkMenuTriggerFor"; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never>;
-}