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

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 { 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;
-    /**
-     * 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 | undefined, _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, { optional: true; }, { 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,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>;
-}

package/menu/menu-stack.d.ts

@@ -1,79 +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 { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-/** 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;
-}
-/** Injection token used for an implementation of MenuStack. */
-export declare const MENU_STACK: InjectionToken<MenuStack>;
-/**
- * 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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MenuStack, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MenuStack>;
-}

package/menu/menu-trigger.d.ts

@@ -1,24 +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, Injector } from '@angular/core';
-import { Menu } from './menu-interface';
-import { MenuStack } from './menu-stack';
-import * as i0 from "@angular/core";
-/** Injection token used for an implementation of MenuStack. */
-export declare const MENU_TRIGGER: InjectionToken<MenuTrigger>;
-export declare class MenuTrigger {
-    protected injector: Injector;
-    protected menuStack: MenuStack;
-    private _childMenuInjector?;
-    protected childMenu?: Menu;
-    constructor(injector: Injector, menuStack: MenuStack);
-    protected getChildMenuInjector(): Injector;
-    registerChildMenu(child: Menu): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MenuTrigger, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MenuTrigger>;
-}

package/menu/menu.d.ts

@@ -1,97 +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, EventEmitter, NgZone, OnDestroy, OnInit } from '@angular/core';
-import { FocusOrigin } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { CdkMenuGroup } from './menu-group';
-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";
-/**
- * Directive which configures the element as a Menu which should contain child elements marked as
- * CdkMenuItem or CdkMenuGroup. Sets the appropriate role and aria-attributes for a menu and
- * contains accessible keyboard and mouse handling logic.
- *
- * It also acts as a RadioGroup for elements marked with role `menuitemradio`.
- */
-export declare class CdkMenu extends CdkMenuGroup implements Menu, AfterContentInit, OnInit, OnDestroy {
-    private readonly _ngZone;
-    readonly _elementRef: ElementRef<HTMLElement>;
-    readonly _menuStack?: MenuStack | undefined;
-    private _parentTrigger?;
-    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';
-    /** Event emitted when the menu is closed. */
-    readonly closed: EventEmitter<void | 'click' | 'tab' | 'escape'>;
-    /** Handles keyboard events for the menu. */
-    private _keyManager;
-    /** Manages items under mouse focus. */
-    private _pointerTracker?;
-    /** List of nested CdkMenuGroup elements */
-    private readonly _nestedGroups;
-    /** All child MenuItem elements nested in this Menu. */
-    private readonly _allItems;
-    /** The Menu Item which triggered the open submenu. */
-    private _openItem?;
-    constructor(_ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _menuStack?: MenuStack | undefined, _parentTrigger?: MenuTrigger | undefined, _menuAim?: MenuAim | undefined, _dir?: Directionality | undefined);
-    ngOnInit(): void;
-    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 for the Menu. */
-    _handleKeyEvent(event: KeyboardEvent): void;
-    /**
-     * Complete the change emitter if there are any nested MenuGroups or register to complete the
-     * change emitter if a MenuGroup is rendered at some point
-     */
-    private _completeChangeEmitter;
-    /** Return true if there are nested CdkMenuGroup elements within the Menu */
-    private _hasNestedGroups;
-    /** Setup the FocusKeyManager with the correct orientation for the menu. */
-    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 the either the current, previous or next item based on the FocusNext event. */
-    private _toggleMenuFocus;
-    /**
-     * 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 this menu has been configured in a horizontal orientation. */
-    private _isHorizontal;
-    /**
-     * Return true if this menu is an inline menu. That is, it does not exist in a pop-up and is
-     * always visible in the dom.
-     */
-    _isInline(): boolean;
-    ngOnDestroy(): void;
-    /** Emit and complete the closed event emitter */
-    private _emitClosedEvent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenu, [null, null, { optional: true; }, { optional: true; }, { optional: true; self: true; }, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenu, "[cdkMenu]", ["cdkMenu"], { "orientation": "cdkMenuOrientation"; }, { "closed": "closed"; }, ["_nestedGroups", "_allItems"]>;
-}

package/menu/menu_public_index.d.ts

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

package/menu/package.json

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

package/menu/pointer-focus-tracker.d.ts

@@ -1,44 +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 { QueryList, ElementRef } from '@angular/core';
-import { Observable } from 'rxjs';
-/** Item to track for mouse focus events. */
-export interface FocusableElement {
-    /** A reference to the element to be tracked. */
-    _elementRef: ElementRef<HTMLElement>;
-}
-/**
- * PointerFocusTracker keeps track of the currently active item under mouse focus. It also has
- * observables which emit when the users mouse enters and leaves a tracked element.
- */
-export declare class PointerFocusTracker<T extends FocusableElement> {
-    private readonly _items;
-    /** Emits when an element is moused into. */
-    readonly entered: Observable<T>;
-    /** Emits when an element is moused out. */
-    readonly exited: Observable<T>;
-    /** The element currently under mouse focus. */
-    activeElement?: T;
-    /** The element previously under mouse focus. */
-    previousElement?: T;
-    /** Emits when this is destroyed. */
-    private readonly _destroyed;
-    constructor(_items: QueryList<T>);
-    /**
-     * Gets a stream of pointer (mouse) entries into the given items.
-     * This should typically run outside the Angular zone.
-     */
-    private _getItemPointerEntries;
-    /**
-     * Gets a stream of pointer (mouse) exits out of the given items.
-     * This should typically run outside the Angular zone.
-     */
-    private _getItemPointerExits;
-    /** Stop the managers listeners. */
-    destroy(): void;
-}

package/menu/public-api.d.ts

@@ -1,20 +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 './menu-module';
-export * from './menu-bar';
-export * from './menu';
-export * from './menu-item';
-export * from './menu-item-checkbox';
-export * from './menu-item-radio';
-export * from './menu-item-trigger';
-export * from './menu-group';
-export * from './context-menu';
-export * from './menu-trigger';
-export { MenuStack, MenuStackItem, MENU_STACK } from './menu-stack';
-export { CDK_MENU } from './menu-interface';
-export { TargetMenuAim, MenuAim, MENU_AIM, CdkTargetMenuAim } from './menu-aim';

package/popover-edit/constants.d.ts

@@ -1,19 +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
- */
-/** Selector for finding table cells. */
-export declare const CELL_SELECTOR = ".cdk-cell, .mat-cell, td";
-/** Selector for finding editable table cells. */
-export declare const EDITABLE_CELL_SELECTOR = ".cdk-popover-edit-cell, .mat-popover-edit-cell";
-/** Selector for finding table rows. */
-export declare const ROW_SELECTOR = ".cdk-row, .mat-row, tr";
-/** Selector for finding the table element. */
-export declare const TABLE_SELECTOR = "table, cdk-table, mat-table";
-/** CSS class added to the edit lens pane. */
-export declare const EDIT_PANE_CLASS = "cdk-edit-pane";
-/** Selector for finding the edit lens pane. */
-export declare const EDIT_PANE_SELECTOR: string;

package/popover-edit/edit-event-dispatcher.d.ts

@@ -1,99 +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 } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
-import * as i0 from "@angular/core";
-/**
- * The possible states for hover content:
- * OFF - Not rendered.
- * FOCUSABLE - Rendered in the dom and styled for its contents to be focusable but invisible.
- * ON - Rendered and fully visible.
- */
-export declare const enum HoverContentState {
-    OFF = 0,
-    FOCUSABLE = 1,
-    ON = 2
-}
-/**
- * Service for sharing delegated events and state for triggering table edits.
- */
-export declare class EditEventDispatcher<R> {
-    private readonly _ngZone;
-    /** A subject that indicates which table cell is currently editing (unless it is disabled). */
-    readonly editing: Subject<Element | null>;
-    /** A subject that indicates which table row is currently hovered. */
-    readonly hovering: Subject<Element | null>;
-    /** A subject that indicates which table row currently contains focus. */
-    readonly focused: Subject<Element | null>;
-    /** A subject that indicates all elements in the table matching ROW_SELECTOR. */
-    readonly allRows: Subject<NodeList>;
-    /** A subject that emits mouse move events from the table indicating the targeted row. */
-    readonly mouseMove: Subject<Element | null>;
-    /**
-     * Tracks the currently disabled editable cells - edit calls will be ignored
-     * for these cells.
-     */
-    readonly disabledCells: WeakMap<Element, boolean>;
-    /** The EditRef for the currently active edit lens (if any). */
-    get editRef(): R | null;
-    private _editRef;
-    private readonly _distinctUntilChanged;
-    private readonly _startWithNull;
-    private readonly _distinctShare;
-    private readonly _startWithNullDistinct;
-    readonly editingAndEnabled: Observable<Element | null>;
-    /** An observable that emits the row containing focus or an active edit. */
-    readonly editingOrFocused: Observable<Element | null>;
-    /** Tracks rows that contain hover content with a reference count. */
-    private _rowsWithHoverContent;
-    /** The table cell that has an active edit lens (or null). */
-    private _currentlyEditing;
-    /** The combined set of row hover content states organized by row. */
-    private readonly _hoveredContentStateDistinct;
-    private readonly _editingAndEnabledDistinct;
-    private _lastSeenRow;
-    private _lastSeenRowHoverOrFocus;
-    constructor(_ngZone: NgZone);
-    /**
-     * Gets an Observable that emits true when the specified element's cell
-     * is editing and false when not.
-     */
-    editingCell(element: Element | EventTarget): Observable<boolean>;
-    /**
-     * Stops editing for the specified cell. If the specified cell is not the current
-     * edit cell, does nothing.
-     */
-    doneEditingCell(element: Element | EventTarget): void;
-    /** Sets the currently active EditRef. */
-    setActiveEditRef(ref: R): void;
-    /** Unsets the currently active EditRef, if the specified editRef is active. */
-    unsetActiveEditRef(ref: R): void;
-    /** Adds the specified table row to be tracked for first/last row comparisons. */
-    registerRowWithHoverContent(row: Element): void;
-    /**
-     * Reference decrements and ultimately removes the specified table row from first/last row
-     * comparisons.
-     */
-    deregisterRowWithHoverContent(row: Element): void;
-    /**
-     * Gets an Observable that emits true when the specified element's row
-     * contains the focused element or is being hovered over and false when not.
-     * Hovering is defined as when the mouse has momentarily stopped moving over the cell.
-     */
-    hoverOrFocusOnRow(row: Element): Observable<HoverContentState>;
-    /**
-     * RxJS operator that enters the Angular zone, used to reduce boilerplate in
-     * re-entering the zone for stream pipelines.
-     */
-    private _enterZone;
-    private _getFirstRowWithHoverContent;
-    private _getLastRowWithHoverContent;
-    private _mapAllRowsToSingleRow;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EditEventDispatcher<any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EditEventDispatcher<any>>;
-}

package/popover-edit/edit-ref.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 { OnDestroy, NgZone } from '@angular/core';
-import { ControlContainer } from '@angular/forms';
-import { Observable } from 'rxjs';
-import { EditEventDispatcher } from './edit-event-dispatcher';
-import * as i0 from "@angular/core";
-/**
- * Used for communication between the form within the edit lens and the
- * table that launched it. Provided by CdkEditControl within the lens.
- */
-export declare class EditRef<FormValue> implements OnDestroy {
-    private readonly _form;
-    private readonly _editEventDispatcher;
-    private readonly _ngZone;
-    /** Emits the final value of this edit instance before closing. */
-    private readonly _finalValueSubject;
-    readonly finalValue: Observable<FormValue>;
-    /** Emits when the user tabs out of this edit lens before closing. */
-    private readonly _blurredSubject;
-    readonly blurred: Observable<void>;
-    /** The value to set the form back to on revert. */
-    private _revertFormValue;
-    constructor(_form: ControlContainer, _editEventDispatcher: EditEventDispatcher<EditRef<FormValue>>, _ngZone: NgZone);
-    /**
-     * Called by the host directive's OnInit hook. Reads the initial state of the
-     * form and overrides it with persisted state from previous openings, if
-     * applicable.
-     */
-    init(previousFormValue: FormValue | undefined): void;
-    ngOnDestroy(): void;
-    /** Whether the attached form is in a valid state. */
-    isValid(): boolean | null;
-    /** Set the form's current value as what it will be set to on revert/reset. */
-    updateRevertValue(): void;
-    /** Tells the table to close the edit popup. */
-    close(): void;
-    /** Notifies the active edit that the user has moved focus out of the lens. */
-    blur(): void;
-    /**
-     * Resets the form value to the specified value or the previously set
-     * revert value.
-     */
-    reset(value?: FormValue): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EditRef<any>, [{ self: true; }, null, null]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EditRef<any>>;
-}

package/popover-edit/edit-services.d.ts

@@ -1,37 +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 } from '@angular/core';
-import { FocusTrapFactory } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { Overlay } from '@angular/cdk/overlay';
-import { ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';
-import { EditEventDispatcher } from './edit-event-dispatcher';
-import { FocusDispatcher } from './focus-dispatcher';
-import { PopoverEditPositionStrategyFactory } from './popover-edit-position-strategy-factory';
-import { EditRef } from './edit-ref';
-import * as i0 from "@angular/core";
-/**
- * Optimization
- * Collects multiple Injectables into a singleton shared across the table. By reducing the
- * number of services injected into each CdkPopoverEdit, this saves about 0.023ms of cpu time
- * and 56 bytes of memory per instance.
- */
-export declare class EditServices {
-    readonly directionality: Directionality;
-    readonly editEventDispatcher: EditEventDispatcher<EditRef<unknown>>;
-    readonly focusDispatcher: FocusDispatcher;
-    readonly focusTrapFactory: FocusTrapFactory;
-    readonly ngZone: NgZone;
-    readonly overlay: Overlay;
-    readonly positionFactory: PopoverEditPositionStrategyFactory;
-    readonly scrollDispatcher: ScrollDispatcher;
-    readonly viewportRuler: ViewportRuler;
-    constructor(directionality: Directionality, editEventDispatcher: EditEventDispatcher<EditRef<unknown>>, focusDispatcher: FocusDispatcher, focusTrapFactory: FocusTrapFactory, ngZone: NgZone, overlay: Overlay, positionFactory: PopoverEditPositionStrategyFactory, scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler);
-    static ɵfac: i0.ɵɵFactoryDeclaration<EditServices, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<EditServices>;
-}

package/popover-edit/focus-dispatcher.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 { Directionality } from '@angular/cdk/bidi';
-import { PartialObserver } from 'rxjs';
-import * as i0 from "@angular/core";
-/**
- * Service responsible for moving cell focus around in response to keyboard events.
- * May be overridden to customize the keyboard behavior of popover edit.
- */
-export declare class FocusDispatcher {
-    protected readonly directionality: Directionality;
-    /** Observes keydown events triggered from the table. */
-    readonly keyObserver: PartialObserver<KeyboardEvent>;
-    constructor(directionality: Directionality);
-    /**
-     * Moves focus to earlier or later cells (in dom order) by offset cells relative to
-     * currentCell.
-     */
-    moveFocusHorizontally(currentCell: HTMLElement, offset: number): void;
-    /** Moves focus to up or down by row by offset cells relative to currentCell. */
-    moveFocusVertically(currentCell: HTMLElement, offset: number): void;
-    /** Translates arrow keydown events into focus move operations. */
-    protected handleKeyboardEvent(event: KeyboardEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FocusDispatcher, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FocusDispatcher>;
-}