text: /* */ 
  "format cjs";
  /**
   * @license
   * Copyright Google Inc. 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
   */
  var __extends = (this && this.__extends) || function (d, b) {
      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  };
  import { Directive, Host, Inject, Input, Optional, Self, SkipSelf, forwardRef } from '@angular/core';
  import { NG_ASYNC_VALIDATORS, NG_VALIDATORS } from '../../validators';
  import { AbstractFormGroupDirective } from '../abstract_form_group_directive';
  import { ControlContainer } from '../control_container';
  import { ReactiveErrors } from '../reactive_errors';
  import { composeAsyncValidators, composeValidators, controlPath } from '../shared';
  import { FormGroupDirective } from './form_group_directive';
  export var /** @type {?} */ formGroupNameProvider = {
      provide: ControlContainer,
      useExisting: forwardRef(function () { return FormGroupName; })
  };
  /**
   * \@whatItDoes Syncs a nested {\@link FormGroup} to a DOM element.
   *
   * \@howToUse
   *
   * This directive can only be used with a parent {\@link FormGroupDirective} (selector:
   * `[formGroup]`).
   *
   * It accepts the string name of the nested {\@link FormGroup} you want to link, and
   * will look for a {\@link FormGroup} registered with that name in the parent
   * {\@link FormGroup} instance you passed into {\@link FormGroupDirective}.
   *
   * Nested form groups can come in handy when you want to validate a sub-group of a
   * form separately from the rest or when you'd like to group the values of certain
   * controls into their own nested object.
   *
   * **Access the group**: You can access the associated {\@link FormGroup} using the
   * {\@link AbstractControl.get} method. Ex: `this.form.get('name')`.
   *
   * You can also access individual controls within the group using dot syntax.
   * Ex: `this.form.get('name.first')`
   *
   * **Get the value**: the `value` property is always synced and available on the
   * {\@link FormGroup}. See a full list of available properties in {\@link AbstractControl}.
   *
   * **Set the value**: You can set an initial value for each child control when instantiating
   * the {\@link FormGroup}, or you can set it programmatically later using
   * {\@link AbstractControl.setValue} or {\@link AbstractControl.patchValue}.
   *
   * **Listen to value**: If you want to listen to changes in the value of the group, you can
   * subscribe to the {\@link AbstractControl.valueChanges} event.  You can also listen to
   * {\@link AbstractControl.statusChanges} to be notified when the validation status is
   * re-calculated.
   *
   * ### Example
   *
   * {\@example forms/ts/nestedFormGroup/nested_form_group_example.ts region='Component'}
   *
   * * **npm package**: `\@angular/forms`
   *
   * * **NgModule**: `ReactiveFormsModule`
   *
   * \@stable
   */
  export var FormGroupName = (function (_super) {
      __extends(FormGroupName, _super);
      /**
       * @param {?} parent
       * @param {?} validators
       * @param {?} asyncValidators
       */
      function FormGroupName(parent, validators, asyncValidators) {
          _super.call(this);
          this._parent = parent;
          this._validators = validators;
          this._asyncValidators = asyncValidators;
      }
      /**
       * \@internal
       * @return {?}
       */
      FormGroupName.prototype._checkParentType = function () {
          if (_hasInvalidParent(this._parent)) {
              ReactiveErrors.groupParentException();
          }
      };
      FormGroupName.decorators = [
          { type: Directive, args: [{ selector: '[formGroupName]', providers: [formGroupNameProvider] },] },
      ];
      /** @nocollapse */
      FormGroupName.ctorParameters = function () { return [
          { type: ControlContainer, decorators: [{ type: Optional }, { type: Host }, { type: SkipSelf },] },
          { type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_VALIDATORS,] },] },
          { type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_ASYNC_VALIDATORS,] },] },
      ]; };
      FormGroupName.propDecorators = {
          'name': [{ type: Input, args: ['formGroupName',] },],
      };
      return FormGroupName;
  }(AbstractFormGroupDirective));
  function FormGroupName_tsickle_Closure_declarations() {
      /** @type {?} */
      FormGroupName.decorators;
      /**
       * @nocollapse
       * @type {?}
       */
      FormGroupName.ctorParameters;
      /** @type {?} */
      FormGroupName.propDecorators;
      /** @type {?} */
      FormGroupName.prototype.name;
  }
  export var /** @type {?} */ formArrayNameProvider = {
      provide: ControlContainer,
      useExisting: forwardRef(function () { return FormArrayName; })
  };
  /**
   * \@whatItDoes Syncs a nested {\@link FormArray} to a DOM element.
   *
   * \@howToUse
   *
   * This directive is designed to be used with a parent {\@link FormGroupDirective} (selector:
   * `[formGroup]`).
   *
   * It accepts the string name of the nested {\@link FormArray} you want to link, and
   * will look for a {\@link FormArray} registered with that name in the parent
   * {\@link FormGroup} instance you passed into {\@link FormGroupDirective}.
   *
   * Nested form arrays can come in handy when you have a group of form controls but
   * you're not sure how many there will be. Form arrays allow you to create new
   * form controls dynamically.
   *
   * **Access the array**: You can access the associated {\@link FormArray} using the
   * {\@link AbstractControl.get} method on the parent {\@link FormGroup}.
   * Ex: `this.form.get('cities')`.
   *
   * **Get the value**: the `value` property is always synced and available on the
   * {\@link FormArray}. See a full list of available properties in {\@link AbstractControl}.
   *
   * **Set the value**: You can set an initial value for each child control when instantiating
   * the {\@link FormArray}, or you can set the value programmatically later using the
   * {\@link FormArray}'s {\@link AbstractControl.setValue} or {\@link AbstractControl.patchValue}
   * methods.
   *
   * **Listen to value**: If you want to listen to changes in the value of the array, you can
   * subscribe to the {\@link FormArray}'s {\@link AbstractControl.valueChanges} event.  You can also
   * listen to its {\@link AbstractControl.statusChanges} event to be notified when the validation
   * status is re-calculated.
   *
   * **Add new controls**: You can add new controls to the {\@link FormArray} dynamically by
   * calling its {\@link FormArray.push} method.
   *  Ex: `this.form.get('cities').push(new FormControl());`
   *
   * ### Example
   *
   * {\@example forms/ts/nestedFormArray/nested_form_array_example.ts region='Component'}
   *
   * * **npm package**: `\@angular/forms`
   *
   * * **NgModule**: `ReactiveFormsModule`
   *
   * \@stable
   */
  export var FormArrayName = (function (_super) {
      __extends(FormArrayName, _super);
      /**
       * @param {?} parent
       * @param {?} validators
       * @param {?} asyncValidators
       */
      function FormArrayName(parent, validators, asyncValidators) {
          _super.call(this);
          this._parent = parent;
          this._validators = validators;
          this._asyncValidators = asyncValidators;
      }
      /**
       * @return {?}
       */
      FormArrayName.prototype.ngOnInit = function () {
          this._checkParentType();
          this.formDirective.addFormArray(this);
      };
      /**
       * @return {?}
       */
      FormArrayName.prototype.ngOnDestroy = function () {
          if (this.formDirective) {
              this.formDirective.removeFormArray(this);
          }
      };
      Object.defineProperty(FormArrayName.prototype, "control", {
          /**
           * @return {?}
           */
          get: function () { return this.formDirective.getFormArray(this); },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(FormArrayName.prototype, "formDirective", {
          /**
           * @return {?}
           */
          get: function () {
              return this._parent ? (this._parent.formDirective) : null;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(FormArrayName.prototype, "path", {
          /**
           * @return {?}
           */
          get: function () { return controlPath(this.name, this._parent); },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(FormArrayName.prototype, "validator", {
          /**
           * @return {?}
           */
          get: function () { return composeValidators(this._validators); },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(FormArrayName.prototype, "asyncValidator", {
          /**
           * @return {?}
           */
          get: function () { return composeAsyncValidators(this._asyncValidators); },
          enumerable: true,
          configurable: true
      });
      /**
       * @return {?}
       */
      FormArrayName.prototype._checkParentType = function () {
          if (_hasInvalidParent(this._parent)) {
              ReactiveErrors.arrayParentException();
          }
      };
      FormArrayName.decorators = [
          { type: Directive, args: [{ selector: '[formArrayName]', providers: [formArrayNameProvider] },] },
      ];
      /** @nocollapse */
      FormArrayName.ctorParameters = function () { return [
          { type: ControlContainer, decorators: [{ type: Optional }, { type: Host }, { type: SkipSelf },] },
          { type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_VALIDATORS,] },] },
          { type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_ASYNC_VALIDATORS,] },] },
      ]; };
      FormArrayName.propDecorators = {
          'name': [{ type: Input, args: ['formArrayName',] },],
      };
      return FormArrayName;
  }(ControlContainer));
  function FormArrayName_tsickle_Closure_declarations() {
      /** @type {?} */
      FormArrayName.decorators;
      /**
       * @nocollapse
       * @type {?}
       */
      FormArrayName.ctorParameters;
      /** @type {?} */
      FormArrayName.propDecorators;
      /**
       * \@internal
       * @type {?}
       */
      FormArrayName.prototype._parent;
      /**
       * \@internal
       * @type {?}
       */
      FormArrayName.prototype._validators;
      /**
       * \@internal
       * @type {?}
       */
      FormArrayName.prototype._asyncValidators;
      /** @type {?} */
      FormArrayName.prototype.name;
  }
  /**
   * @param {?} parent
   * @return {?}
   */
  function _hasInvalidParent(parent) {
      return !(parent instanceof FormGroupName) && !(parent instanceof FormGroupDirective) &&
          !(parent instanceof FormArrayName);
  }
  //# sourceMappingURL=form_group_name.js.map