@angular/cdk 14.0.0-next.9 → 14.0.0-rc.2

package/tree/index.d.ts

@@ -1,8 +1,500 @@
+import { AfterContentChecked } from '@angular/core';
+import { AfterContentInit } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ChangeDetectorRef } from '@angular/core';
+import { CollectionViewer } from '@angular/cdk/collections';
+import { DataSource } from '@angular/cdk/collections';
+import { Directionality } from '@angular/cdk/bidi';
+import { ElementRef } from '@angular/core';
+import { FocusableOption } from '@angular/cdk/a11y';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { IterableDiffer } from '@angular/core';
+import { IterableDiffers } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { QueryList } from '@angular/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Subject } from 'rxjs';
+import { TemplateRef } from '@angular/core';
+import { TrackByFunction } from '@angular/core';
+import { ViewContainerRef } from '@angular/core';
+
+/** Base tree control. It has basic toggle/expand/collapse operations on a single data node. */
+export declare abstract class BaseTreeControl<T, K = T> implements TreeControl<T, K> {
+    /** Gets a list of descendent data nodes of a subtree rooted at given data node recursively. */
+    abstract getDescendants(dataNode: T): T[];
+    /** Expands all data nodes in the tree. */
+    abstract expandAll(): void;
+    /** Saved data node for `expandAll` action. */
+    dataNodes: T[];
+    /** A selection model with multi-selection to track expansion status. */
+    expansionModel: SelectionModel<K>;
+    /**
+     * Returns the identifier by which a dataNode should be tracked, should its
+     * reference change.
+     *
+     * Similar to trackBy for *ngFor
+     */
+    trackBy?: (dataNode: T) => K;
+    /** Get depth of a given data node, return the level number. This is for flat tree node. */
+    getLevel: (dataNode: T) => number;
+    /**
+     * Whether the data node is expandable. Returns true if expandable.
+     * This is for flat tree node.
+     */
+    isExpandable: (dataNode: T) => boolean;
+    /** Gets a stream that emits whenever the given data node's children change. */
+    getChildren: (dataNode: T) => Observable<T[]> | T[] | undefined | null;
+    /** Toggles one single data node's expanded/collapsed state. */
+    toggle(dataNode: T): void;
+    /** Expands one single data node. */
+    expand(dataNode: T): void;
+    /** Collapses one single data node. */
+    collapse(dataNode: T): void;
+    /** Whether a given data node is expanded or not. Returns true if the data node is expanded. */
+    isExpanded(dataNode: T): boolean;
+    /** Toggles a subtree rooted at `node` recursively. */
+    toggleDescendants(dataNode: T): void;
+    /** Collapse all dataNodes in the tree. */
+    collapseAll(): void;
+    /** Expands a subtree rooted at given data node recursively. */
+    expandDescendants(dataNode: T): void;
+    /** Collapses a subtree rooted at given data node recursively. */
+    collapseDescendants(dataNode: T): void;
+    protected _trackByValue(value: T | K): K;
+}
+
 /**
- * @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
+ * Injection token used to provide a `CdkTreeNode` to its outlet.
+ * Used primarily to avoid circular imports.
+ * @docs-private
  */
-export * from './public-api';
+export declare const CDK_TREE_NODE_OUTLET_NODE: InjectionToken<{}>;
+
+/**
+ * Nested node is a child of `<cdk-tree>`. It works with nested tree.
+ * By using `cdk-nested-tree-node` component in tree node template, children of the parent node will
+ * be added in the `cdkTreeNodeOutlet` in tree node template.
+ * The children of node will be automatically added to `cdkTreeNodeOutlet`.
+ */
+export declare class CdkNestedTreeNode<T, K = T> extends CdkTreeNode<T, K> implements AfterContentInit, OnDestroy, OnInit {
+    protected _differs: IterableDiffers;
+    /** Differ used to find the changes in the data provided by the data source. */
+    private _dataDiffer;
+    /** The children data dataNodes of current node. They will be placed in `CdkTreeNodeOutlet`. */
+    protected _children: T[];
+    /** The children node placeholder. */
+    nodeOutlet: QueryList<CdkTreeNodeOutlet>;
+    constructor(elementRef: ElementRef<HTMLElement>, tree: CdkTree<T, K>, _differs: IterableDiffers);
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Add children dataNodes to the NodeOutlet */
+    protected updateChildrenNodes(children?: T[]): void;
+    /** Clear the children dataNodes. */
+    protected _clear(): void;
+    /** Gets the outlet for the current node. */
+    private _getNodeOutlet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkNestedTreeNode<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkNestedTreeNode<any, any>, "cdk-nested-tree-node", ["cdkNestedTreeNode"], { "role": "role"; "disabled": "disabled"; "tabIndex": "tabIndex"; }, {}, ["nodeOutlet"], never, false>;
+}
+
+/**
+ * CDK tree component that connects with a data source to retrieve data of type `T` and renders
+ * dataNodes with hierarchy. Updates the dataNodes when new data is provided by the data source.
+ */
+export declare class CdkTree<T, K = T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {
+    private _differs;
+    private _changeDetectorRef;
+    /** Subject that emits when the component has been destroyed. */
+    private readonly _onDestroy;
+    /** Differ used to find the changes in the data provided by the data source. */
+    private _dataDiffer;
+    /** Stores the node definition that does not have a when predicate. */
+    private _defaultNodeDef;
+    /** Data subscription */
+    private _dataSubscription;
+    /** Level of nodes */
+    private _levels;
+    /**
+     * Provides a stream containing the latest data array to render. Influenced by the tree's
+     * stream of view window (what dataNodes are currently on screen).
+     * Data source can be an observable of data array, or a data array to render.
+     */
+    get dataSource(): DataSource<T> | Observable<T[]> | T[];
+    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]);
+    private _dataSource;
+    /** The tree controller */
+    treeControl: TreeControl<T, K>;
+    /**
+     * Tracking function that will be used to check the differences in data changes. Used similarly
+     * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data
+     * relative to the function to know if a node should be added/removed/moved.
+     * Accepts a function that takes two parameters, `index` and `item`.
+     */
+    trackBy: TrackByFunction<T>;
+    _nodeOutlet: CdkTreeNodeOutlet;
+    /** The tree node template for the tree */
+    _nodeDefs: QueryList<CdkTreeNodeDef<T>>;
+    /**
+     * Stream containing the latest information on what rows are being displayed on screen.
+     * Can be used by the data source to as a heuristic of what data should be provided.
+     */
+    readonly viewChange: BehaviorSubject<{
+        start: number;
+        end: number;
+    }>;
+    constructor(_differs: IterableDiffers, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterContentChecked(): void;
+    /**
+     * Switch to the provided data source by resetting the data and unsubscribing from the current
+     * render change subscription if one exists. If the data source is null, interpret this by
+     * clearing the node outlet. Otherwise start listening for new data.
+     */
+    private _switchDataSource;
+    /** Set up a subscription for the data provided by the data source. */
+    private _observeRenderChanges;
+    /** Check for changes made in the data and render each change (node added/removed/moved). */
+    renderNodeChanges(data: readonly T[], dataDiffer?: IterableDiffer<T>, viewContainer?: ViewContainerRef, parentData?: T): void;
+    /**
+     * Finds the matching node definition that should be used for this node data. If there is only
+     * one node definition, it is returned. Otherwise, find the node definition that has a when
+     * predicate that returns true with the data. If none return true, return the default node
+     * definition.
+     */
+    _getNodeDef(data: T, i: number): CdkTreeNodeDef<T>;
+    /**
+     * Create the embedded view for the data node template and place it in the correct index location
+     * within the data node view container.
+     */
+    insertNode(nodeData: T, index: number, viewContainer?: ViewContainerRef, parentData?: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTree<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CdkTree<any, any>, "cdk-tree", ["cdkTree"], { "dataSource": "dataSource"; "treeControl": "treeControl"; "trackBy": "trackBy"; }, {}, ["_nodeDefs"], never, false>;
+}
+
+export declare class CdkTreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkTreeModule, [typeof i1.CdkNestedTreeNode, typeof i2.CdkTreeNodeDef, typeof i3.CdkTreeNodePadding, typeof i4.CdkTreeNodeToggle, typeof i5.CdkTree, typeof i5.CdkTreeNode, typeof i6.CdkTreeNodeOutlet], never, [typeof i1.CdkNestedTreeNode, typeof i2.CdkTreeNodeDef, typeof i3.CdkTreeNodePadding, typeof i4.CdkTreeNodeToggle, typeof i5.CdkTree, typeof i5.CdkTreeNode, typeof i6.CdkTreeNodeOutlet]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkTreeModule>;
+}
+
+/**
+ * Tree node for CdkTree. It contains the data in the tree node.
+ */
+export declare class CdkTreeNode<T, K = T> implements FocusableOption, OnDestroy, OnInit {
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _tree: CdkTree<T, K>;
+    /**
+     * The role of the tree node.
+     * @deprecated The correct role is 'treeitem', 'group' should not be used. This input will be
+     *   removed in a future version.
+     * @breaking-change 12.0.0 Remove this input
+     */
+    get role(): 'treeitem' | 'group';
+    set role(_role: 'treeitem' | 'group');
+    /**
+     * The most recently created `CdkTreeNode`. We save it in static variable so we can retrieve it
+     * in `CdkTree` and set the data to it.
+     */
+    static mostRecentTreeNode: CdkTreeNode<any> | null;
+    /** Subject that emits when the component has been destroyed. */
+    protected readonly _destroyed: Subject<void>;
+    /** Emits when the node's data has changed. */
+    readonly _dataChanges: Subject<void>;
+    private _parentNodeAriaLevel;
+    /** The tree node's data. */
+    get data(): T;
+    set data(value: T);
+    protected _data: T;
+    get isExpanded(): boolean;
+    get level(): number;
+    constructor(_elementRef: ElementRef<HTMLElement>, _tree: CdkTree<T, K>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** Focuses the menu item. Implements for FocusableOption. */
+    focus(): void;
+    protected _setRoleFromData(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTreeNode<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTreeNode<any, any>, "cdk-tree-node", ["cdkTreeNode"], { "role": "role"; }, {}, never, never, false>;
+}
+
+/**
+ * Data node definition for the CdkTree.
+ * Captures the node's template and a when predicate that describes when this node should be used.
+ */
+export declare class CdkTreeNodeDef<T> {
+    template: TemplateRef<any>;
+    /**
+     * Function that should return true if this node template should be used for the provided node
+     * data and index. If left undefined, this node will be considered the default node template to
+     * use when no other when functions return true for the data.
+     * For every node, there must be at least one when function that passes or an undefined to
+     * default.
+     */
+    when: (index: number, nodeData: T) => boolean;
+    /** @docs-private */
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTreeNodeDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTreeNodeDef<any>, "[cdkTreeNodeDef]", never, { "when": "cdkTreeNodeDefWhen"; }, {}, never, never, false>;
+}
+
+/**
+ * Outlet for nested CdkNode. Put `[cdkTreeNodeOutlet]` on a tag to place children dataNodes
+ * inside the outlet.
+ */
+export declare class CdkTreeNodeOutlet {
+    viewContainer: ViewContainerRef;
+    _node?: any;
+    constructor(viewContainer: ViewContainerRef, _node?: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTreeNodeOutlet, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTreeNodeOutlet, "[cdkTreeNodeOutlet]", never, {}, {}, never, never, false>;
+}
+
+/** Context provided to the tree node component. */
+export declare class CdkTreeNodeOutletContext<T> {
+    /** Data for the node. */
+    $implicit: T;
+    /** Depth of the node. */
+    level: number;
+    /** Index location of the node. */
+    index?: number;
+    /** Length of the number of total dataNodes. */
+    count?: number;
+    constructor(data: T);
+}
+
+/**
+ * Indent for the children tree dataNodes.
+ * This directive will add left-padding to the node to show hierarchy.
+ */
+export declare class CdkTreeNodePadding<T, K = T> implements OnDestroy {
+    private _treeNode;
+    private _tree;
+    private _element;
+    private _dir;
+    /** Current padding value applied to the element. Used to avoid unnecessarily hitting the DOM. */
+    private _currentPadding;
+    /** Subject that emits when the component has been destroyed. */
+    private readonly _destroyed;
+    /** CSS units used for the indentation value. */
+    indentUnits: string;
+    /** The level of depth of the tree node. The padding will be `level * indent` pixels. */
+    get level(): number;
+    set level(value: NumberInput);
+    _level: number;
+    /**
+     * The indent for each level. Can be a number or a CSS string.
+     * Default number 40px from material design menu sub-menu spec.
+     */
+    get indent(): number | string;
+    set indent(indent: number | string);
+    _indent: number;
+    constructor(_treeNode: CdkTreeNode<T, K>, _tree: CdkTree<T, K>, _element: ElementRef<HTMLElement>, _dir: Directionality);
+    ngOnDestroy(): void;
+    /** The padding indent value for the tree node. Returns a string with px numbers if not null. */
+    _paddingIndent(): string | null;
+    _setPadding(forceChange?: boolean): void;
+    /**
+     * This has been extracted to a util because of TS 4 and VE.
+     * View Engine doesn't support property rename inheritance.
+     * TS 4.0 doesn't allow properties to override accessors or vice-versa.
+     * @docs-private
+     */
+    protected _setLevelInput(value: NumberInput): void;
+    /**
+     * This has been extracted to a util because of TS 4 and VE.
+     * View Engine doesn't support property rename inheritance.
+     * TS 4.0 doesn't allow properties to override accessors or vice-versa.
+     * @docs-private
+     */
+    protected _setIndentInput(indent: number | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTreeNodePadding<any, any>, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTreeNodePadding<any, any>, "[cdkTreeNodePadding]", never, { "level": "cdkTreeNodePadding"; "indent": "cdkTreeNodePaddingIndent"; }, {}, never, never, false>;
+}
+
+/**
+ * Node toggle to expand/collapse the node.
+ */
+export declare class CdkTreeNodeToggle<T, K = T> {
+    protected _tree: CdkTree<T, K>;
+    protected _treeNode: CdkTreeNode<T, K>;
+    /** Whether expand/collapse the node recursively. */
+    get recursive(): boolean;
+    set recursive(value: BooleanInput);
+    protected _recursive: boolean;
+    constructor(_tree: CdkTree<T, K>, _treeNode: CdkTreeNode<T, K>);
+    _toggle(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTreeNodeToggle<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTreeNodeToggle<any, any>, "[cdkTreeNodeToggle]", never, { "recursive": "cdkTreeNodeToggleRecursive"; }, {}, never, never, false>;
+}
+
+/** Flat tree control. Able to expand/collapse a subtree recursively for flattened tree. */
+export declare class FlatTreeControl<T, K = T> extends BaseTreeControl<T, K> {
+    getLevel: (dataNode: T) => number;
+    isExpandable: (dataNode: T) => boolean;
+    options?: FlatTreeControlOptions<T, K> | undefined;
+    /** Construct with flat tree data node functions getLevel and isExpandable. */
+    constructor(getLevel: (dataNode: T) => number, isExpandable: (dataNode: T) => boolean, options?: FlatTreeControlOptions<T, K> | undefined);
+    /**
+     * Gets a list of the data node's subtree of descendent data nodes.
+     *
+     * To make this working, the `dataNodes` of the TreeControl must be flattened tree nodes
+     * with correct levels.
+     */
+    getDescendants(dataNode: T): T[];
+    /**
+     * Expands all data nodes in the tree.
+     *
+     * To make this working, the `dataNodes` variable of the TreeControl must be set to all flattened
+     * data nodes of the tree.
+     */
+    expandAll(): void;
+}
+
+/** Optional set of configuration that can be provided to the FlatTreeControl. */
+export declare interface FlatTreeControlOptions<T, K> {
+    trackBy?: (dataNode: T) => K;
+}
+
+/**
+ * Returns an error to be thrown when tree control did not implement functions for flat/nested node.
+ * @docs-private
+ */
+export declare function getTreeControlFunctionsMissingError(): Error;
+
+/**
+ * Returns an error to be thrown when there are tree control.
+ * @docs-private
+ */
+export declare function getTreeControlMissingError(): Error;
+
+/**
+ * Returns an error to be thrown when there are no matching node defs for a particular set of data.
+ * @docs-private
+ */
+export declare function getTreeMissingMatchingNodeDefError(): Error;
+
+/**
+ * Returns an error to be thrown when there are multiple nodes that are missing a when function.
+ * @docs-private
+ */
+export declare function getTreeMultipleDefaultNodeDefsError(): Error;
+
+
+/**
+ * Returns an error to be thrown when there is no usable data.
+ * @docs-private
+ */
+export declare function getTreeNoValidDataSourceError(): Error;
+
+declare namespace i1 {
+    export {
+        CdkNestedTreeNode
+    }
+}
+
+declare namespace i2 {
+    export {
+        CdkTreeNodeOutletContext,
+        CdkTreeNodeDef
+    }
+}
+
+declare namespace i3 {
+    export {
+        CdkTreeNodePadding
+    }
+}
+
+declare namespace i4 {
+    export {
+        CdkTreeNodeToggle
+    }
+}
+
+declare namespace i5 {
+    export {
+        CdkTree,
+        CdkTreeNode
+    }
+}
+
+declare namespace i6 {
+    export {
+        CDK_TREE_NODE_OUTLET_NODE,
+        CdkTreeNodeOutlet
+    }
+}
+
+/** Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type. */
+export declare class NestedTreeControl<T, K = T> extends BaseTreeControl<T, K> {
+    getChildren: (dataNode: T) => Observable<T[]> | T[] | undefined | null;
+    options?: NestedTreeControlOptions<T, K> | undefined;
+    /** Construct with nested tree function getChildren. */
+    constructor(getChildren: (dataNode: T) => Observable<T[]> | T[] | undefined | null, options?: NestedTreeControlOptions<T, K> | undefined);
+    /**
+     * Expands all dataNodes in the tree.
+     *
+     * To make this working, the `dataNodes` variable of the TreeControl must be set to all root level
+     * data nodes of the tree.
+     */
+    expandAll(): void;
+    /** Gets a list of descendant dataNodes of a subtree rooted at given data node recursively. */
+    getDescendants(dataNode: T): T[];
+    /** A helper function to get descendants recursively. */
+    protected _getDescendants(descendants: T[], dataNode: T): void;
+}
+
+/** Optional set of configuration that can be provided to the NestedTreeControl. */
+export declare interface NestedTreeControlOptions<T, K> {
+    trackBy?: (dataNode: T) => K;
+}
+
+/**
+ * Tree control interface. User can implement TreeControl to expand/collapse dataNodes in the tree.
+ * The CDKTree will use this TreeControl to expand/collapse a node.
+ * User can also use it outside the `<cdk-tree>` to control the expansion status of the tree.
+ */
+export declare interface TreeControl<T, K = T> {
+    /** The saved tree nodes data for `expandAll` action. */
+    dataNodes: T[];
+    /** The expansion model */
+    expansionModel: SelectionModel<K>;
+    /** Whether the data node is expanded or collapsed. Return true if it's expanded. */
+    isExpanded(dataNode: T): boolean;
+    /** Get all descendants of a data node */
+    getDescendants(dataNode: T): any[];
+    /** Expand or collapse data node */
+    toggle(dataNode: T): void;
+    /** Expand one data node */
+    expand(dataNode: T): void;
+    /** Collapse one data node */
+    collapse(dataNode: T): void;
+    /** Expand all the dataNodes in the tree */
+    expandAll(): void;
+    /** Collapse all the dataNodes in the tree */
+    collapseAll(): void;
+    /** Toggle a data node by expand/collapse it and all its descendants */
+    toggleDescendants(dataNode: T): void;
+    /** Expand a data node and all its descendants */
+    expandDescendants(dataNode: T): void;
+    /** Collapse a data node and all its descendants */
+    collapseDescendants(dataNode: T): void;
+    /** Get depth of a given data node, return the level number. This is for flat tree node. */
+    readonly getLevel: (dataNode: T) => number;
+    /**
+     * Whether the data node is expandable. Returns true if expandable.
+     * This is for flat tree node.
+     */
+    readonly isExpandable: (dataNode: T) => boolean;
+    /** Gets a stream that emits whenever the given data node's children change. */
+    readonly getChildren: (dataNode: T) => Observable<T[]> | T[] | undefined | null;
+}
+
+export { }

package/a11y/a11y-module.d.ts

@@ -1,12 +0,0 @@
-import { HighContrastModeDetector } from './high-contrast-mode/high-contrast-mode-detector';
-import * as i0 from "@angular/core";
-import * as i1 from "./live-announcer/live-announcer";
-import * as i2 from "./focus-trap/focus-trap";
-import * as i3 from "./focus-monitor/focus-monitor";
-import * as i4 from "@angular/cdk/observers";
-export declare class A11yModule {
-    constructor(highContrastModeDetector: HighContrastModeDetector);
-    static ɵfac: i0.ɵɵFactoryDeclaration<A11yModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<A11yModule, [typeof i1.CdkAriaLive, typeof i2.CdkTrapFocus, typeof i3.CdkMonitorFocus], [typeof i4.ObserversModule], [typeof i1.CdkAriaLive, typeof i2.CdkTrapFocus, typeof i3.CdkMonitorFocus]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<A11yModule>;
-}

package/a11y/a11y_public_index.d.ts

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

package/a11y/aria-describer/aria-describer.d.ts

@@ -1,101 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { Platform } from '@angular/cdk/platform';
-import * as i0 from "@angular/core";
-/**
- * Interface used to register message elements and keep a count of how many registrations have
- * the same message and the reference to the message element used for the `aria-describedby`.
- */
-export interface RegisteredMessage {
-    /** The element containing the message. */
-    messageElement: Element;
-    /** The number of elements that reference this message element via `aria-describedby`. */
-    referenceCount: number;
-}
-/**
- * ID used for the body container where all messages are appended.
- * @deprecated No longer being used. To be removed.
- * @breaking-change 14.0.0
- */
-export declare const MESSAGES_CONTAINER_ID = "cdk-describedby-message-container";
-/**
- * ID prefix used for each created message element.
- * @deprecated To be turned into a private variable.
- * @breaking-change 14.0.0
- */
-export declare const CDK_DESCRIBEDBY_ID_PREFIX = "cdk-describedby-message";
-/**
- * Attribute given to each host element that is described by a message element.
- * @deprecated To be turned into a private variable.
- * @breaking-change 14.0.0
- */
-export declare const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = "cdk-describedby-host";
-/**
- * Utility that creates visually hidden elements with a message content. Useful for elements that
- * want to use aria-describedby to further describe themselves without adding additional visual
- * content.
- */
-export declare class AriaDescriber implements OnDestroy {
-    /**
-     * @deprecated To be turned into a required parameter.
-     * @breaking-change 14.0.0
-     */
-    private _platform?;
-    private _document;
-    /** Map of all registered message elements that have been placed into the document. */
-    private _messageRegistry;
-    /** Container for all registered messages. */
-    private _messagesContainer;
-    /** Unique ID for the service. */
-    private readonly _id;
-    constructor(_document: any, 
-    /**
-     * @deprecated To be turned into a required parameter.
-     * @breaking-change 14.0.0
-     */
-    _platform?: Platform | undefined);
-    /**
-     * Adds to the host element an aria-describedby reference to a hidden element that contains
-     * the message. If the same message has already been registered, then it will reuse the created
-     * message element.
-     */
-    describe(hostElement: Element, message: string, role?: string): void;
-    /**
-     * Adds to the host element an aria-describedby reference to an already-existing message element.
-     */
-    describe(hostElement: Element, message: HTMLElement): void;
-    /** Removes the host element's aria-describedby reference to the message. */
-    removeDescription(hostElement: Element, message: string, role?: string): void;
-    /** Removes the host element's aria-describedby reference to the message element. */
-    removeDescription(hostElement: Element, message: HTMLElement): void;
-    /** Unregisters all created message elements and removes the message container. */
-    ngOnDestroy(): void;
-    /**
-     * Creates a new element in the visually hidden message container element with the message
-     * as its content and adds it to the message registry.
-     */
-    private _createMessageElement;
-    /** Deletes the message element from the global messages container. */
-    private _deleteMessageElement;
-    /** Creates the global container for all aria-describedby messages. */
-    private _createMessagesContainer;
-    /** Removes all cdk-describedby messages that are hosted through the element. */
-    private _removeCdkDescribedByReferenceIds;
-    /**
-     * Adds a message reference to the element using aria-describedby and increments the registered
-     * message's reference count.
-     */
-    private _addMessageReference;
-    /**
-     * Removes a message reference from the element using aria-describedby
-     * and decrements the registered message's reference count.
-     */
-    private _removeMessageReference;
-    /** Returns true if the element has been described by the provided message ID. */
-    private _isElementDescribedByMessage;
-    /** Determines whether a message can be described on a particular element. */
-    private _canBeDescribed;
-    /** Checks whether a node is an Element node. */
-    private _isElementNode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AriaDescriber, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AriaDescriber>;
-}

package/a11y/aria-describer/aria-reference.d.ts

@@ -1,22 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-/**
- * Adds the given ID to the specified ARIA attribute on an element.
- * Used for attributes such as aria-labelledby, aria-owns, etc.
- */
-export declare function addAriaReferencedId(el: Element, attr: string, id: string): void;
-/**
- * Removes the given ID from the specified ARIA attribute on an element.
- * Used for attributes such as aria-labelledby, aria-owns, etc.
- */
-export declare function removeAriaReferencedId(el: Element, attr: string, id: string): void;
-/**
- * Gets the list of IDs referenced by the given ARIA attribute on an element.
- * Used for attributes such as aria-labelledby, aria-owns, etc.
- */
-export declare function getAriaReferenceIds(el: Element, attr: string): string[];

package/a11y/fake-event-detection.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
- */
-/** Gets whether an event could be a faked `mousedown` event dispatched by a screen reader. */
-export declare function isFakeMousedownFromScreenReader(event: MouseEvent): boolean;
-/** Gets whether an event could be a faked `touchstart` event dispatched by a screen reader. */
-export declare function isFakeTouchstartFromScreenReader(event: TouchEvent): boolean;