@angular/cdk 14.0.0-next.12 → 14.0.0-next.13

package/layout/layout_public_index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';

package/layout/media-matcher.d.ts

@@ -1,18 +0,0 @@
-import { Platform } from '@angular/cdk/platform';
-import * as i0 from "@angular/core";
-/** A utility for calling matchMedia queries. */
-export declare class MediaMatcher {
-    private _platform;
-    /** The internal matchMedia method to return back a MediaQueryList like object. */
-    private _matchMedia;
-    constructor(_platform: Platform);
-    /**
-     * Evaluates the given media query and returns the native MediaQueryList from which results
-     * can be retrieved.
-     * Confirms the layout engine will trigger for the selector query provided and returns the
-     * MediaQueryList for the query provided.
-     */
-    matchMedia(query: string): MediaQueryList;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MediaMatcher, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MediaMatcher>;
-}

package/layout/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@angular/cdk/layout",
-  "fesm2020": "../fesm2020/layout.mjs",
-  "fesm2015": "../fesm2015/layout.mjs",
-  "esm2020": "../esm2020/layout/layout_public_index.mjs",
-  "typings": "./layout_public_index.d.ts",
-  "module": "../fesm2015/layout.mjs",
-  "es2020": "../fesm2020/layout.mjs"
-}

package/layout/public-api.d.ts

@@ -1,11 +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 { LayoutModule } from './layout-module';
-export { BreakpointObserver, BreakpointState } from './breakpoints-observer';
-export { Breakpoints } from './breakpoints';
-export { MediaMatcher } from './media-matcher';

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

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

package/menu/menu-aim.d.ts

@@ -1,107 +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.
-     * @param menu The menu that this menu aim service controls.
-     * @param pointerTracker The `PointerFocusTracker` for the given menu.
-     */
-    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
-    /**
-     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
-     * 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 open or close a menu. */
-export interface Toggler {
-    /** Gets the open menu, or undefined if no menu is open. */
-    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 {
-    /** The Angular zone. */
-    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(
-    /** The Angular zone. */
-    _ngZone: NgZone);
-    ngOnDestroy(): void;
-    /**
-     * Set the Menu and its PointerFocusTracker.
-     * @param menu The menu that this menu aim service controls.
-     * @param pointerTracker The `PointerFocusTracker` for the given menu.
-     */
-    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
-    /**
-     * Calls the `doToggle` callback when it is deemed that the user is not moving towards
-     * 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.
-     *
-     * @param doToggle the function called when the user is not moving towards the submenu.
-     */
-    private _startTimeout;
-    /** Whether the user is heading towards the open submenu. */
-    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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TargetMenuAim, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TargetMenuAim>;
-}
-/**
- * CdkTargetMenuAim is a provider for the TargetMenuAim service. It can be added to an
- * element with either the `cdkMenu` or `cdkMenuBar` directive and child menu items.
- */
-export declare class CdkTargetMenuAim {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTargetMenuAim, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTargetMenuAim, "[cdkTargetMenuAim]", ["cdkTargetMenuAim"], {}, {}, never, never, false>;
-}

package/menu/menu-bar.d.ts

@@ -1,52 +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 } 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 {
-    /** The direction items in the menu flow. */
-    readonly orientation = "horizontal";
-    /** Whether the menu is displayed inline (i.e. always present vs a conditional popup that the user triggers with a trigger element). */
-    readonly isInline = true;
-    constructor(
-    /** The host element. */
-    elementRef: ElementRef<HTMLElement>, 
-    /** The Angular zone. */
-    ngZone: NgZone, 
-    /** The menu stack this menu is part of. */
-    menuStack: MenuStack, 
-    /** The menu aim service used by this menu. */
-    menuAim?: MenuAim, 
-    /** The directionality of the page. */
-    dir?: Directionality);
-    ngAfterContentInit(): void;
-    /**
-     * Handle keyboard events for the Menu.
-     * @param event The keyboard event to be handled.
-     */
-    _handleKeyEvent(event: KeyboardEvent): void;
-    /**
-     * Set focus to either the current, previous or next item based on the FocusNext event, then
-     * open the previous or next item.
-     * @param focusNext The element to focus.
-     */
-    private _toggleOpenMenu;
-    /** Subscribe to the MenuStack emptied events. */
-    private _subscribeToMenuStackEmptied;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, [null, null, null, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], {}, {}, never, never, false>;
-}

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"], never, false>;
-}

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, never, false>;
-}

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, never, false>;
-}

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, never, false>;
-}

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, never, false>;
-}