text: /**
   * @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 { SelectionModel } from '@angular/cdk/collections';
  import { __extends } from 'tslib';
  import { take, takeUntil } from 'rxjs/operators';
  import { Directive, TemplateRef, ViewContainerRef, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, ElementRef, Input, IterableDiffers, ViewChild, ViewEncapsulation, Optional, Renderer2, NgModule } from '@angular/core';
  import { of, BehaviorSubject, Observable, Subject } from 'rxjs';
  import { Directionality } from '@angular/cdk/bidi';
  import { coerceNumberProperty, coerceBooleanProperty } from '@angular/cdk/coercion';
  import { FocusMonitor } from '@angular/cdk/a11y';
  import { CommonModule } from '@angular/common';
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Base tree control. It has basic toggle/expand/collapse operations on a single data node.
   * @abstract
   * @template T
   */
  var  /**
   * Base tree control. It has basic toggle/expand/collapse operations on a single data node.
   * @abstract
   * @template T
   */
  BaseTreeControl = /** @class */ (function () {
      function BaseTreeControl() {
          /**
           * A selection model with multi-selection to track expansion status.
           */
          this.expansionModel = new SelectionModel(true);
      }
      /** Toggles one single data node's expanded/collapsed state. */
      /**
       * Toggles one single data node's expanded/collapsed state.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.toggle = /**
       * Toggles one single data node's expanded/collapsed state.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          this.expansionModel.toggle(dataNode);
      };
      /** Expands one single data node. */
      /**
       * Expands one single data node.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.expand = /**
       * Expands one single data node.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          this.expansionModel.select(dataNode);
      };
      /** Collapses one single data node. */
      /**
       * Collapses one single data node.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.collapse = /**
       * Collapses one single data node.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          this.expansionModel.deselect(dataNode);
      };
      /** Whether a given data node is expanded or not. Returns true if the data node is expanded. */
      /**
       * Whether a given data node is expanded or not. Returns true if the data node is expanded.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.isExpanded = /**
       * Whether a given data node is expanded or not. Returns true if the data node is expanded.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          return this.expansionModel.isSelected(dataNode);
      };
      /** Toggles a subtree rooted at `node` recursively. */
      /**
       * Toggles a subtree rooted at `node` recursively.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.toggleDescendants = /**
       * Toggles a subtree rooted at `node` recursively.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          this.expansionModel.isSelected(dataNode)
              ? this.collapseDescendants(dataNode)
              : this.expandDescendants(dataNode);
      };
      /** Collapse all dataNodes in the tree. */
      /**
       * Collapse all dataNodes in the tree.
       * @return {?}
       */
      BaseTreeControl.prototype.collapseAll = /**
       * Collapse all dataNodes in the tree.
       * @return {?}
       */
      function () {
          this.expansionModel.clear();
      };
      /** Expands a subtree rooted at given data node recursively. */
      /**
       * Expands a subtree rooted at given data node recursively.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.expandDescendants = /**
       * Expands a subtree rooted at given data node recursively.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          var /** @type {?} */ toBeProcessed = [dataNode];
          toBeProcessed.push.apply(toBeProcessed, this.getDescendants(dataNode));
          (_a = this.expansionModel).select.apply(_a, toBeProcessed);
          var _a;
      };
      /** Collapses a subtree rooted at given data node recursively. */
      /**
       * Collapses a subtree rooted at given data node recursively.
       * @param {?} dataNode
       * @return {?}
       */
      BaseTreeControl.prototype.collapseDescendants = /**
       * Collapses a subtree rooted at given data node recursively.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          var /** @type {?} */ toBeProcessed = [dataNode];
          toBeProcessed.push.apply(toBeProcessed, this.getDescendants(dataNode));
          (_a = this.expansionModel).deselect.apply(_a, toBeProcessed);
          var _a;
      };
      return BaseTreeControl;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Flat tree control. Able to expand/collapse a subtree recursively for flattened tree.
   * @template T
   */
  var  /**
   * Flat tree control. Able to expand/collapse a subtree recursively for flattened tree.
   * @template T
   */
  FlatTreeControl = /** @class */ (function (_super) {
      __extends(FlatTreeControl, _super);
      /** Construct with flat tree data node functions getLevel and isExpandable. */
      function FlatTreeControl(getLevel, isExpandable) {
          var _this = _super.call(this) || this;
          _this.getLevel = getLevel;
          _this.isExpandable = isExpandable;
          return _this;
      }
      /**
       * 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.
       */
      /**
       * 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.
       * @param {?} dataNode
       * @return {?}
       */
      FlatTreeControl.prototype.getDescendants = /**
       * 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.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          var /** @type {?} */ startIndex = this.dataNodes.indexOf(dataNode);
          var /** @type {?} */ results = [];
          // Goes through flattened tree nodes in the `dataNodes` array, and get all descendants.
          // The level of descendants of a tree node must be greater than the level of the given
          // tree node.
          // If we reach a node whose level is equal to the level of the tree node, we hit a sibling.
          // If we reach a node whose level is greater than the level of the tree node, we hit a
          // sibling of an ancestor.
          for (var /** @type {?} */ i = startIndex + 1; i < this.dataNodes.length && this.getLevel(dataNode) < this.getLevel(this.dataNodes[i]); i++) {
              results.push(this.dataNodes[i]);
          }
          return results;
      };
      /**
       * 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.
       */
      /**
       * 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.
       * @return {?}
       */
      FlatTreeControl.prototype.expandAll = /**
       * 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.
       * @return {?}
       */
      function () {
          (_a = this.expansionModel).select.apply(_a, this.dataNodes);
          var _a;
      };
      return FlatTreeControl;
  }(BaseTreeControl));
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type.
   * @template T
   */
  var  /**
   * Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type.
   * @template T
   */
  NestedTreeControl = /** @class */ (function (_super) {
      __extends(NestedTreeControl, _super);
      /** Construct with nested tree function getChildren. */
      function NestedTreeControl(getChildren) {
          var _this = _super.call(this) || this;
          _this.getChildren = getChildren;
          return _this;
      }
      /**
       * 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.
       */
      /**
       * 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.
       * @return {?}
       */
      NestedTreeControl.prototype.expandAll = /**
       * 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.
       * @return {?}
       */
      function () {
          var _this = this;
          this.expansionModel.clear();
          var /** @type {?} */ allNodes = this.dataNodes.reduce(function (accumulator, dataNode) {
              return accumulator.concat(_this.getDescendants(dataNode), [dataNode]);
          }, []);
          (_a = this.expansionModel).select.apply(_a, allNodes);
          var _a;
      };
      /** Gets a list of descendant dataNodes of a subtree rooted at given data node recursively. */
      /**
       * Gets a list of descendant dataNodes of a subtree rooted at given data node recursively.
       * @param {?} dataNode
       * @return {?}
       */
      NestedTreeControl.prototype.getDescendants = /**
       * Gets a list of descendant dataNodes of a subtree rooted at given data node recursively.
       * @param {?} dataNode
       * @return {?}
       */
      function (dataNode) {
          var /** @type {?} */ descendants = [];
          this._getDescendants(descendants, dataNode);
          // Remove the node itself
          return descendants.splice(1);
      };
      /** A helper function to get descendants recursively. */
      /**
       * A helper function to get descendants recursively.
       * @param {?} descendants
       * @param {?} dataNode
       * @return {?}
       */
      NestedTreeControl.prototype._getDescendants = /**
       * A helper function to get descendants recursively.
       * @param {?} descendants
       * @param {?} dataNode
       * @return {?}
       */
      function (descendants, dataNode) {
          var _this = this;
          descendants.push(dataNode);
          this.getChildren(dataNode).pipe(take(1)).subscribe(function (children) {
              if (children && children.length > 0) {
                  children.forEach(function (child) { return _this._getDescendants(descendants, child); });
              }
          });
      };
      return NestedTreeControl;
  }(BaseTreeControl));
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Context provided to the tree node component.
   * @template T
   */
  var  /**
   * Context provided to the tree node component.
   * @template T
   */
  CdkTreeNodeOutletContext = /** @class */ (function () {
      function CdkTreeNodeOutletContext(data) {
          this.$implicit = data;
      }
      return CdkTreeNodeOutletContext;
  }());
  /**
   * Data node definition for the CdkTree.
   * Captures the node's template and a when predicate that describes when this node should be used.
   * @template T
   */
  var CdkTreeNodeDef = /** @class */ (function () {
      /** @docs-private */
      function CdkTreeNodeDef(template) {
          this.template = template;
      }
      CdkTreeNodeDef.decorators = [
          { type: Directive, args: [{
                      selector: '[cdkTreeNodeDef]',
                      inputs: [
                          'when: cdkTreeNodeDefWhen'
                      ],
                  },] },
      ];
      /** @nocollapse */
      CdkTreeNodeDef.ctorParameters = function () { return [
          { type: TemplateRef, },
      ]; };
      return CdkTreeNodeDef;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Outlet for nested CdkNode. Put `[cdkTreeNodeOutlet]` on a tag to place children dataNodes
   * inside the outlet.
   */
  var CdkTreeNodeOutlet = /** @class */ (function () {
      function CdkTreeNodeOutlet(viewContainer) {
          this.viewContainer = viewContainer;
      }
      CdkTreeNodeOutlet.decorators = [
          { type: Directive, args: [{
                      selector: '[cdkTreeNodeOutlet]'
                  },] },
      ];
      /** @nocollapse */
      CdkTreeNodeOutlet.ctorParameters = function () { return [
          { type: ViewContainerRef, },
      ]; };
      return CdkTreeNodeOutlet;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * Returns an error to be thrown when there is no usable data.
   * \@docs-private
   * @return {?}
   */
  function getTreeNoValidDataSourceError() {
      return Error("A valid data source must be provided.");
  }
  /**
   * Returns an error to be thrown when there are multiple nodes that are missing a when function.
   * \@docs-private
   * @return {?}
   */
  function getTreeMultipleDefaultNodeDefsError() {
      return Error("There can only be one default row without a when predicate function.");
  }
  /**
   * Returns an error to be thrown when there are no matching node defs for a particular set of data.
   * \@docs-private
   * @return {?}
   */
  function getTreeMissingMatchingNodeDefError() {
      return Error("Could not find a matching node definition for the provided node data.");
  }
  /**
   * Returns an error to be thrown when there are tree control.
   * \@docs-private
   * @return {?}
   */
  function getTreeControlMissingError() {
      return Error("Could not find a tree control for the tree.");
  }
  /**
   * Returns an error to be thrown when tree control did not implement functions for flat/nested node.
   * \@docs-private
   * @return {?}
   */
  function getTreeControlFunctionsMissingError() {
      return Error("Could not find functions for nested/flat tree in tree control.");
  }
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Tree node for CdkTree. It contains the data in the tree node.
   * @template T
   */
  var CdkTreeNode = /** @class */ (function () {
      function CdkTreeNode(_elementRef, _tree) {
          this._elementRef = _elementRef;
          this._tree = _tree;
          /**
           * Subject that emits when the component has been destroyed.
           */
          this._destroyed = new Subject();
          /**
           * The role of the node should be 'group' if it's an internal node,
           * and 'treeitem' if it's a leaf node.
           */
          this.role = 'treeitem';
          CdkTreeNode.mostRecentTreeNode = /** @type {?} */ (this);
      }
      Object.defineProperty(CdkTreeNode.prototype, "data", {
          /** The tree node's data. */
          get: /**
           * The tree node's data.
           * @return {?}
           */
          function () { return this._data; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._data = value;
              this._setRoleFromData();
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkTreeNode.prototype, "isExpanded", {
          get: /**
           * @return {?}
           */
          function () {
              return this._tree.treeControl.isExpanded(this._data);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkTreeNode.prototype, "level", {
          get: /**
           * @return {?}
           */
          function () {
              return this._tree.treeControl.getLevel ? this._tree.treeControl.getLevel(this._data) : 0;
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @return {?}
       */
      CdkTreeNode.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._destroyed.next();
          this._destroyed.complete();
      };
      /** Focuses the menu item. Implements for FocusableOption. */
      /**
       * Focuses the menu item. Implements for FocusableOption.
       * @return {?}
       */
      CdkTreeNode.prototype.focus = /**
       * Focuses the menu item. Implements for FocusableOption.
       * @return {?}
       */
      function () {
          this._elementRef.nativeElement.focus();
      };
      /**
       * @return {?}
       */
      CdkTreeNode.prototype._setRoleFromData = /**
       * @return {?}
       */
      function () {
          var _this = this;
          if (this._tree.treeControl.isExpandable) {
              this.role = this._tree.treeControl.isExpandable(this._data) ? 'group' : 'treeitem';
          }
          else {
              if (!this._tree.treeControl.getChildren) {
                  throw getTreeControlFunctionsMissingError();
              }
              this._tree.treeControl.getChildren(this._data).pipe(takeUntil(this._destroyed))
                  .subscribe(function (children) {
                  _this.role = children && children.length ? 'group' : 'treeitem';
              });
          }
      };
      /**
       * The most recently created `CdkTreeNode`. We save it in static variable so we can retrieve it
       * in `CdkTree` and set the data to it.
       */
      CdkTreeNode.mostRecentTreeNode = null;
      CdkTreeNode.decorators = [
          { type: Directive, args: [{
                      selector: 'cdk-tree-node',
                      exportAs: 'cdkTreeNode',
                      host: {
                          '[attr.aria-expanded]': 'isExpanded',
                          '[attr.aria-level]': 'role === "treeitem" ? level : null',
                          '[attr.role]': 'role',
                          'class': 'cdk-tree-node',
                      },
                  },] },
      ];
      /** @nocollapse */
      CdkTreeNode.ctorParameters = function () { return [
          { type: ElementRef, },
          { type: CdkTree, },
      ]; };
      CdkTreeNode.propDecorators = {
          "role": [{ type: Input },],
      };
      return CdkTreeNode;
  }());
  /**
   * 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.
   * @template T
   */
  var CdkTree = /** @class */ (function () {
      function CdkTree(_differs, _changeDetectorRef) {
          this._differs = _differs;
          this._changeDetectorRef = _changeDetectorRef;
          /**
           * Subject that emits when the component has been destroyed.
           */
          this._onDestroy = new Subject();
          /**
           * Level of nodes
           */
          this._levels = new Map();
          /**
           * 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.
           */
          this.viewChange = new BehaviorSubject({ start: 0, end: Number.MAX_VALUE });
      }
      Object.defineProperty(CdkTree.prototype, "dataSource", {
          get: /**
           * 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 dara array to render.
           * @return {?}
           */
          function () { return this._dataSource; },
          set: /**
           * @param {?} dataSource
           * @return {?}
           */
          function (dataSource) {
              if (this._dataSource !== dataSource) {
                  this._switchDataSource(dataSource);
              }
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @return {?}
       */
      CdkTree.prototype.ngOnInit = /**
       * @return {?}
       */
      function () {
          this._dataDiffer = this._differs.find([]).create();
          if (!this.treeControl) {
              throw getTreeControlMissingError();
          }
      };
      /**
       * @return {?}
       */
      CdkTree.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._nodeOutlet.viewContainer.clear();
          this._onDestroy.next();
          this._onDestroy.complete();
          if (this._dataSource && typeof (/** @type {?} */ (this._dataSource)).disconnect === 'function') {
              (/** @type {?} */ (this.dataSource)).disconnect(this);
          }
          if (this._dataSubscription) {
              this._dataSubscription.unsubscribe();
              this._dataSubscription = null;
          }
      };
      /**
       * @return {?}
       */
      CdkTree.prototype.ngAfterContentChecked = /**
       * @return {?}
       */
      function () {
          var /** @type {?} */ defaultNodeDefs = this._nodeDefs.filter(function (def) { return !def.when; });
          if (defaultNodeDefs.length > 1) {
              throw getTreeMultipleDefaultNodeDefsError();
          }
          this._defaultNodeDef = defaultNodeDefs[0];
          if (this.dataSource && this._nodeDefs && !this._dataSubscription) {
              this._observeRenderChanges();
          }
      };
      /**
       * 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.
       * @param {?} dataSource
       * @return {?}
       */
      CdkTree.prototype._switchDataSource = /**
       * 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.
       * @param {?} dataSource
       * @return {?}
       */
      function (dataSource) {
          if (this._dataSource && typeof (/** @type {?} */ (this._dataSource)).disconnect === 'function') {
              (/** @type {?} */ (this.dataSource)).disconnect(this);
          }
          if (this._dataSubscription) {
              this._dataSubscription.unsubscribe();
              this._dataSubscription = null;
          }
          // Remove the all dataNodes if there is now no data source
          if (!dataSource) {
              this._nodeOutlet.viewContainer.clear();
          }
          this._dataSource = dataSource;
          if (this._nodeDefs) {
              this._observeRenderChanges();
          }
      };
      /**
       * Set up a subscription for the data provided by the data source.
       * @return {?}
       */
      CdkTree.prototype._observeRenderChanges = /**
       * Set up a subscription for the data provided by the data source.
       * @return {?}
       */
      function () {
          var _this = this;
          var /** @type {?} */ dataStream;
          // Cannot use `instanceof DataSource` since the data source could be a literal with
          // `connect` function and may not extends DataSource.
          if (typeof (/** @type {?} */ (this._dataSource)).connect === 'function') {
              dataStream = (/** @type {?} */ (this._dataSource)).connect(this);
          }
          else if (this._dataSource instanceof Observable) {
              dataStream = this._dataSource;
          }
          else if (Array.isArray(this._dataSource)) {
              dataStream = of(this._dataSource);
          }
          if (dataStream) {
              this._dataSubscription = dataStream.pipe(takeUntil(this._onDestroy))
                  .subscribe(function (data) { return _this.renderNodeChanges(data); });
          }
          else {
              throw getTreeNoValidDataSourceError();
          }
      };
      /** Check for changes made in the data and render each change (node added/removed/moved). */
      /**
       * Check for changes made in the data and render each change (node added/removed/moved).
       * @param {?} data
       * @param {?=} dataDiffer
       * @param {?=} viewContainer
       * @param {?=} parentData
       * @return {?}
       */
      CdkTree.prototype.renderNodeChanges = /**
       * Check for changes made in the data and render each change (node added/removed/moved).
       * @param {?} data
       * @param {?=} dataDiffer
       * @param {?=} viewContainer
       * @param {?=} parentData
       * @return {?}
       */
      function (data, dataDiffer, viewContainer, parentData) {
          var _this = this;
          if (dataDiffer === void 0) { dataDiffer = this._dataDiffer; }
          if (viewContainer === void 0) { viewContainer = this._nodeOutlet.viewContainer; }
          var /** @type {?} */ changes = dataDiffer.diff(data);
          if (!changes) {
              return;
          }
          changes.forEachOperation(function (item, adjustedPreviousIndex, currentIndex) {
              if (item.previousIndex == null) {
                  _this.insertNode(data[currentIndex], currentIndex, viewContainer, parentData);
              }
              else if (currentIndex == null) {
                  viewContainer.remove(adjustedPreviousIndex);
                  _this._levels.delete(item.item);
              }
              else {
                  var /** @type {?} */ view = viewContainer.get(adjustedPreviousIndex);
                  viewContainer.move(/** @type {?} */ ((view)), currentIndex);
              }
          });
          this._changeDetectorRef.detectChanges();
      };
      /**
       * 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.
       */
      /**
       * 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.
       * @param {?} data
       * @param {?} i
       * @return {?}
       */
      CdkTree.prototype._getNodeDef = /**
       * 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.
       * @param {?} data
       * @param {?} i
       * @return {?}
       */
      function (data, i) {
          if (this._nodeDefs.length === 1) {
              return this._nodeDefs.first;
          }
          var /** @type {?} */ nodeDef = this._nodeDefs.find(function (def) { return def.when && def.when(i, data); }) || this._defaultNodeDef;
          if (!nodeDef) {
              throw getTreeMissingMatchingNodeDefError();
          }
          return nodeDef;
      };
      /**
       * Create the embedded view for the data node template and place it in the correct index location
       * within the data node view container.
       */
      /**
       * Create the embedded view for the data node template and place it in the correct index location
       * within the data node view container.
       * @param {?} nodeData
       * @param {?} index
       * @param {?=} viewContainer
       * @param {?=} parentData
       * @return {?}
       */
      CdkTree.prototype.insertNode = /**
       * Create the embedded view for the data node template and place it in the correct index location
       * within the data node view container.
       * @param {?} nodeData
       * @param {?} index
       * @param {?=} viewContainer
       * @param {?=} parentData
       * @return {?}
       */
      function (nodeData, index, viewContainer, parentData) {
          var /** @type {?} */ node = this._getNodeDef(nodeData, index);
          // Node context that will be provided to created embedded view
          var /** @type {?} */ context = new CdkTreeNodeOutletContext(nodeData);
          // If the tree is flat tree, then use the `getLevel` function in flat tree control
          // Otherwise, use the level of parent node.
          if (this.treeControl.getLevel) {
              context.level = this.treeControl.getLevel(nodeData);
          }
          else if (typeof parentData !== 'undefined' && this._levels.has(parentData)) {
              context.level = /** @type {?} */ ((this._levels.get(parentData))) + 1;
          }
          else {
              context.level = 0;
          }
          this._levels.set(nodeData, context.level);
          // Use default tree nodeOutlet, or nested node's nodeOutlet
          var /** @type {?} */ container = viewContainer ? viewContainer : this._nodeOutlet.viewContainer;
          container.createEmbeddedView(node.template, context, index);
          // Set the data to just created `CdkTreeNode`.
          // The `CdkTreeNode` created from `createEmbeddedView` will be saved in static variable
          //     `mostRecentTreeNode`. We get it from static variable and pass the node data to it.
          if (CdkTreeNode.mostRecentTreeNode) {
              CdkTreeNode.mostRecentTreeNode.data = nodeData;
          }
      };
      CdkTree.decorators = [
          { type: Component, args: [{selector: 'cdk-tree',
                      exportAs: 'cdkTree',
                      template: "<ng-container cdkTreeNodeOutlet></ng-container>",
                      host: {
                          'class': 'cdk-tree',
                          'role': 'tree',
                      },
                      encapsulation: ViewEncapsulation.None,
                      changeDetection: ChangeDetectionStrategy.OnPush
                  },] },
      ];
      /** @nocollapse */
      CdkTree.ctorParameters = function () { return [
          { type: IterableDiffers, },
          { type: ChangeDetectorRef, },
      ]; };
      CdkTree.propDecorators = {
          "dataSource": [{ type: Input },],
          "treeControl": [{ type: Input },],
          "_nodeOutlet": [{ type: ViewChild, args: [CdkTreeNodeOutlet,] },],
          "_nodeDefs": [{ type: ContentChildren, args: [CdkTreeNodeDef,] },],
      };
      return CdkTree;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * 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.
   * For example:
   *   ```html
   *   <cdk-mested-tree-node>
   *     {{node.name}}
   *     <ng-template cdkTreeNodeOutlet></ng-template>
   *   </cdk-tree-node>
   *   ```
   * The children of node will be automatically added to `cdkTreeNodeOutlet`, the result dom will be
   * like this:
   *   ```html
   *   <cdk-nested-tree-node>
   *     {{node.name}}
   *      <cdk-nested-tree-node>{{child1.name}}</cdk-tree-node>
   *      <cdk-nested-tree-node>{{child2.name}}</cdk-tree-node>
   *   </cdk-tree-node>
   *   ```
   * @template T
   */
  var CdkNestedTreeNode = /** @class */ (function (_super) {
      __extends(CdkNestedTreeNode, _super);
      function CdkNestedTreeNode(_elementRef, _tree, _differs) {
          var _this = _super.call(this, _elementRef, _tree) || this;
          _this._elementRef = _elementRef;
          _this._tree = _tree;
          _this._differs = _differs;
          return _this;
      }
      /**
       * @return {?}
       */
      CdkNestedTreeNode.prototype.ngAfterContentInit = /**
       * @return {?}
       */
      function () {
          var _this = this;
          this._dataDiffer = this._differs.find([]).create();
          if (!this._tree.treeControl.getChildren) {
              throw getTreeControlFunctionsMissingError();
          }
          this._tree.treeControl.getChildren(this.data).pipe(takeUntil(this._destroyed))
              .subscribe(function (result) {
              _this._children = result;
              _this.updateChildrenNodes();
          });
          this.nodeOutlet.changes.pipe(takeUntil(this._destroyed))
              .subscribe(function () { return _this.updateChildrenNodes(); });
      };
      /**
       * @return {?}
       */
      CdkNestedTreeNode.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._clear();
          _super.prototype.ngOnDestroy.call(this);
      };
      /** Add children dataNodes to the NodeOutlet */
      /**
       * Add children dataNodes to the NodeOutlet
       * @return {?}
       */
      CdkNestedTreeNode.prototype.updateChildrenNodes = /**
       * Add children dataNodes to the NodeOutlet
       * @return {?}
       */
      function () {
          if (this.nodeOutlet.length && this._children) {
              var /** @type {?} */ viewContainer = this.nodeOutlet.first.viewContainer;
              this._tree.renderNodeChanges(this._children, this._dataDiffer, viewContainer, this._data);
          }
          else {
              // Reset the data differ if there's no children nodes displayed
              this._dataDiffer.diff([]);
          }
      };
      /** Clear the children dataNodes. */
      /**
       * Clear the children dataNodes.
       * @return {?}
       */
      CdkNestedTreeNode.prototype._clear = /**
       * Clear the children dataNodes.
       * @return {?}
       */
      function () {
          if (this.nodeOutlet && this.nodeOutlet.first) {
              this.nodeOutlet.first.viewContainer.clear();
              this._dataDiffer.diff([]);
          }
      };
      CdkNestedTreeNode.decorators = [
          { type: Directive, args: [{
                      selector: 'cdk-nested-tree-node',
                      exportAs: 'cdkNestedTreeNode',
                      host: {
                          '[attr.aria-expanded]': 'isExpanded',
                          '[attr.role]': 'role',
                          'class': 'cdk-tree-node cdk-nested-tree-node',
                      },
                      providers: [{ provide: CdkTreeNode, useExisting: CdkNestedTreeNode }]
                  },] },
      ];
      /** @nocollapse */
      CdkNestedTreeNode.ctorParameters = function () { return [
          { type: ElementRef, },
          { type: CdkTree, },
          { type: IterableDiffers, },
      ]; };
      CdkNestedTreeNode.propDecorators = {
          "nodeOutlet": [{ type: ContentChildren, args: [CdkTreeNodeOutlet,] },],
      };
      return CdkNestedTreeNode;
  }(CdkTreeNode));
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Indent for the children tree dataNodes.
   * This directive will add left-padding to the node to show hierarchy.
   * @template T
   */
  var CdkTreeNodePadding = /** @class */ (function () {
      function CdkTreeNodePadding(_treeNode, _tree, _renderer, _element, _dir) {
          var _this = this;
          this._treeNode = _treeNode;
          this._tree = _tree;
          this._renderer = _renderer;
          this._element = _element;
          this._dir = _dir;
          /**
           * Subject that emits when the component has been destroyed.
           */
          this._destroyed = new Subject();
          this._indent = 40;
          this._setPadding();
          if (this._dir) {
              this._dir.change.pipe(takeUntil(this._destroyed)).subscribe(function () { return _this._setPadding(); });
          }
      }
      Object.defineProperty(CdkTreeNodePadding.prototype, "level", {
          get: /**
           * The level of depth of the tree node. The padding will be `level * indent` pixels.
           * @return {?}
           */
          function () { return this._level; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._level = coerceNumberProperty(value);
              this._setPadding();
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkTreeNodePadding.prototype, "indent", {
          get: /**
           * The indent for each level. Default number 40px from material design menu sub-menu spec.
           * @return {?}
           */
          function () { return this._indent; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._indent = coerceNumberProperty(value);
              this._setPadding();
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @return {?}
       */
      CdkTreeNodePadding.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._destroyed.next();
          this._destroyed.complete();
      };
      /** The padding indent value for the tree node. Returns a string with px numbers if not null. */
      /**
       * The padding indent value for the tree node. Returns a string with px numbers if not null.
       * @return {?}
       */
      CdkTreeNodePadding.prototype._paddingIndent = /**
       * The padding indent value for the tree node. Returns a string with px numbers if not null.
       * @return {?}
       */
      function () {
          var /** @type {?} */ nodeLevel = (this._treeNode.data && this._tree.treeControl.getLevel)
              ? this._tree.treeControl.getLevel(this._treeNode.data)
              : null;
          var /** @type {?} */ level = this._level || nodeLevel;
          return level ? level * this._indent + "px" : null;
      };
      /**
       * @return {?}
       */
      CdkTreeNodePadding.prototype._setPadding = /**
       * @return {?}
       */
      function () {
          var /** @type {?} */ padding = this._paddingIndent();
          var /** @type {?} */ paddingProp = this._dir && this._dir.value === 'rtl' ? 'paddingRight' : 'paddingLeft';
          this._renderer.setStyle(this._element.nativeElement, paddingProp, padding);
      };
      CdkTreeNodePadding.decorators = [
          { type: Directive, args: [{
                      selector: '[cdkTreeNodePadding]',
                  },] },
      ];
      /** @nocollapse */
      CdkTreeNodePadding.ctorParameters = function () { return [
          { type: CdkTreeNode, },
          { type: CdkTree, },
          { type: Renderer2, },
          { type: ElementRef, },
          { type: Directionality, decorators: [{ type: Optional },] },
      ]; };
      CdkTreeNodePadding.propDecorators = {
          "level": [{ type: Input, args: ['cdkTreeNodePadding',] },],
          "indent": [{ type: Input, args: ['cdkTreeNodePaddingIndent',] },],
      };
      return CdkTreeNodePadding;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  /**
   * Node toggle to expand/collapse the node.
   * @template T
   */
  var CdkTreeNodeToggle = /** @class */ (function () {
      function CdkTreeNodeToggle(_tree, _treeNode) {
          this._tree = _tree;
          this._treeNode = _treeNode;
          this._recursive = false;
      }
      Object.defineProperty(CdkTreeNodeToggle.prototype, "recursive", {
          get: /**
           * Whether expand/collapse the node recursively.
           * @return {?}
           */
          function () { return this._recursive; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) { this._recursive = coerceBooleanProperty(value); },
          enumerable: true,
          configurable: true
      });
      /**
       * @param {?} event
       * @return {?}
       */
      CdkTreeNodeToggle.prototype._toggle = /**
       * @param {?} event
       * @return {?}
       */
      function (event) {
          this.recursive
              ? this._tree.treeControl.toggleDescendants(this._treeNode.data)
              : this._tree.treeControl.toggle(this._treeNode.data);
          event.stopPropagation();
      };
      CdkTreeNodeToggle.decorators = [
          { type: Directive, args: [{
                      selector: '[cdkTreeNodeToggle]',
                      host: {
                          '(click)': '_toggle($event)',
                      }
                  },] },
      ];
      /** @nocollapse */
      CdkTreeNodeToggle.ctorParameters = function () { return [
          { type: CdkTree, },
          { type: CdkTreeNode, },
      ]; };
      CdkTreeNodeToggle.propDecorators = {
          "recursive": [{ type: Input, args: ['cdkTreeNodeToggleRecursive',] },],
      };
      return CdkTreeNodeToggle;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  var /** @type {?} */ EXPORTED_DECLARATIONS = [
      CdkNestedTreeNode,
      CdkTreeNodeDef,
      CdkTreeNodePadding,
      CdkTreeNodeToggle,
      CdkTree,
      CdkTreeNode,
      CdkTreeNodeOutlet,
  ];
  var CdkTreeModule = /** @class */ (function () {
      function CdkTreeModule() {
      }
      CdkTreeModule.decorators = [
          { type: NgModule, args: [{
                      imports: [CommonModule],
                      exports: EXPORTED_DECLARATIONS,
                      declarations: EXPORTED_DECLARATIONS,
                      providers: [FocusMonitor, CdkTreeNodeDef]
                  },] },
      ];
      return CdkTreeModule;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes} checked by tsc
   */
  
  export { BaseTreeControl, FlatTreeControl, NestedTreeControl, CdkNestedTreeNode, CdkTreeNodeOutletContext, CdkTreeNodeDef, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTreeNode, CdkTree, getTreeNoValidDataSourceError, getTreeMultipleDefaultNodeDefsError, getTreeMissingMatchingNodeDefError, getTreeControlMissingError, getTreeControlFunctionsMissingError, CdkTreeModule, CdkTreeNodeToggle };
  //# sourceMappingURL=tree.es5.js.map
  