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
   */
  (function (global, factory) {
  	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/cdk/a11y'), require('@angular/cdk/bidi'), require('@angular/cdk/coercion'), require('@angular/cdk/keycodes'), require('@angular/common'), require('@angular/forms'), require('rxjs'), require('rxjs/operators')) :
  	typeof define === 'function' && define.amd ? define('@angular/cdk/stepper', ['exports', '@angular/core', '@angular/cdk/a11y', '@angular/cdk/bidi', '@angular/cdk/coercion', '@angular/cdk/keycodes', '@angular/common', '@angular/forms', 'rxjs', 'rxjs/operators'], factory) :
  	(factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.stepper = {}),global.ng.core,global.ng.cdk.a11y,global.ng.cdk.bidi,global.ng.cdk.coercion,global.ng.cdk.keycodes,global.ng.common,global.ng.forms,global.rxjs,global.rxjs.operators));
  }(this, (function (exports,core,a11y,bidi,coercion,keycodes,common,forms,rxjs,operators) { 'use strict';
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  var CdkStepLabel = /** @class */ (function () {
      function CdkStepLabel(/** @docs-private */ template) {
          this.template = template;
      }
      CdkStepLabel.decorators = [
          { type: core.Directive, args: [{
                      selector: '[cdkStepLabel]',
                  },] },
      ];
      /** @nocollapse */
      CdkStepLabel.ctorParameters = function () { return [
          { type: core.TemplateRef }
      ]; };
      return CdkStepLabel;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  var CdkStepHeader = /** @class */ (function () {
      function CdkStepHeader(_elementRef) {
          this._elementRef = _elementRef;
      }
      /** Focuses the step header. */
      /**
       * Focuses the step header.
       * @return {?}
       */
      CdkStepHeader.prototype.focus = /**
       * Focuses the step header.
       * @return {?}
       */
      function () {
          this._elementRef.nativeElement.focus();
      };
      CdkStepHeader.decorators = [
          { type: core.Directive, args: [{
                      selector: '[cdkStepHeader]',
                      host: {
                          'role': 'tab',
                      },
                  },] },
      ];
      /** @nocollapse */
      CdkStepHeader.ctorParameters = function () { return [
          { type: core.ElementRef }
      ]; };
      return CdkStepHeader;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  /**
   * Used to generate unique ID for each stepper component.
   * @type {?}
   */
  var nextId = 0;
  /**
   * Change event emitted on selection changes.
   */
  var   /**
   * Change event emitted on selection changes.
   */
  StepperSelectionEvent = /** @class */ (function () {
      function StepperSelectionEvent() {
      }
      return StepperSelectionEvent;
  }());
  /**
   * Enum to represent the different states of the steps.
   * @type {?}
   */
  var STEP_STATE = {
      NUMBER: 'number',
      EDIT: 'edit',
      DONE: 'done',
      ERROR: 'error'
  };
  /**
   * InjectionToken that can be used to specify the global stepper options.
   * @type {?}
   */
  var STEPPER_GLOBAL_OPTIONS = new core.InjectionToken('STEPPER_GLOBAL_OPTIONS');
  /**
   * InjectionToken that can be used to specify the global stepper options.
   * @deprecated Use `STEPPER_GLOBAL_OPTIONS` instead.
   * \@breaking-change 8.0.0.
   * @type {?}
   */
  var MAT_STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS;
  var CdkStep = /** @class */ (function () {
      /** @breaking-change 8.0.0 remove the `?` after `stepperOptions` */
      function CdkStep(_stepper, stepperOptions) {
          this._stepper = _stepper;
          /**
           * Whether user has seen the expanded step content or not.
           */
          this.interacted = false;
          this._editable = true;
          this._optional = false;
          this._customCompleted = null;
          this._customError = null;
          this._stepperOptions = stepperOptions ? stepperOptions : {};
          this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;
          this._showError = !!this._stepperOptions.showError;
      }
      Object.defineProperty(CdkStep.prototype, "editable", {
          /** Whether the user can return to this step once it has been marked as completed. */
          get: /**
           * Whether the user can return to this step once it has been marked as completed.
           * @return {?}
           */
          function () { return this._editable; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._editable = coercion.coerceBooleanProperty(value);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkStep.prototype, "optional", {
          /** Whether the completion of step is optional. */
          get: /**
           * Whether the completion of step is optional.
           * @return {?}
           */
          function () { return this._optional; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._optional = coercion.coerceBooleanProperty(value);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkStep.prototype, "completed", {
          /** Whether step is marked as completed. */
          get: /**
           * Whether step is marked as completed.
           * @return {?}
           */
          function () {
              return this._customCompleted == null ? this._getDefaultCompleted() : this._customCompleted;
          },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._customCompleted = coercion.coerceBooleanProperty(value);
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @private
       * @return {?}
       */
      CdkStep.prototype._getDefaultCompleted = /**
       * @private
       * @return {?}
       */
      function () {
          return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;
      };
      Object.defineProperty(CdkStep.prototype, "hasError", {
          /** Whether step has an error. */
          get: /**
           * Whether step has an error.
           * @return {?}
           */
          function () {
              return this._customError == null ? this._getDefaultError() : this._customError;
          },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) {
              this._customError = coercion.coerceBooleanProperty(value);
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @private
       * @return {?}
       */
      CdkStep.prototype._getDefaultError = /**
       * @private
       * @return {?}
       */
      function () {
          return this.stepControl && this.stepControl.invalid && this.interacted;
      };
      /** Selects this step component. */
      /**
       * Selects this step component.
       * @return {?}
       */
      CdkStep.prototype.select = /**
       * Selects this step component.
       * @return {?}
       */
      function () {
          this._stepper.selected = this;
      };
      /** Resets the step to its initial state. Note that this includes resetting form data. */
      /**
       * Resets the step to its initial state. Note that this includes resetting form data.
       * @return {?}
       */
      CdkStep.prototype.reset = /**
       * Resets the step to its initial state. Note that this includes resetting form data.
       * @return {?}
       */
      function () {
          this.interacted = false;
          if (this._customCompleted != null) {
              this._customCompleted = false;
          }
          if (this._customError != null) {
              this._customError = false;
          }
          if (this.stepControl) {
              this.stepControl.reset();
          }
      };
      /**
       * @return {?}
       */
      CdkStep.prototype.ngOnChanges = /**
       * @return {?}
       */
      function () {
          // Since basically all inputs of the MatStep get proxied through the view down to the
          // underlying MatStepHeader, we have to make sure that change detection runs correctly.
          this._stepper._stateChanged();
      };
      CdkStep.decorators = [
          { type: core.Component, args: [{selector: 'cdk-step',
                      exportAs: 'cdkStep',
                      template: '<ng-template><ng-content></ng-content></ng-template>',
                      encapsulation: core.ViewEncapsulation.None,
                      changeDetection: core.ChangeDetectionStrategy.OnPush,
                  },] },
      ];
      /** @nocollapse */
      CdkStep.ctorParameters = function () { return [
          { type: CdkStepper, decorators: [{ type: core.Inject, args: [core.forwardRef(function () { return CdkStepper; }),] }] },
          { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [STEPPER_GLOBAL_OPTIONS,] }] }
      ]; };
      CdkStep.propDecorators = {
          stepLabel: [{ type: core.ContentChild, args: [CdkStepLabel,] }],
          content: [{ type: core.ViewChild, args: [core.TemplateRef,] }],
          stepControl: [{ type: core.Input }],
          label: [{ type: core.Input }],
          errorMessage: [{ type: core.Input }],
          ariaLabel: [{ type: core.Input, args: ['aria-label',] }],
          ariaLabelledby: [{ type: core.Input, args: ['aria-labelledby',] }],
          state: [{ type: core.Input }],
          editable: [{ type: core.Input }],
          optional: [{ type: core.Input }],
          completed: [{ type: core.Input }],
          hasError: [{ type: core.Input }]
      };
      return CdkStep;
  }());
  var CdkStepper = /** @class */ (function () {
      function CdkStepper(_dir, _changeDetectorRef, _elementRef, _document) {
          this._dir = _dir;
          this._changeDetectorRef = _changeDetectorRef;
          this._elementRef = _elementRef;
          /**
           * Emits when the component is destroyed.
           */
          this._destroyed = new rxjs.Subject();
          this._linear = false;
          this._selectedIndex = 0;
          /**
           * Event emitted when the selected step has changed.
           */
          this.selectionChange = new core.EventEmitter();
          this._orientation = 'horizontal';
          this._groupId = nextId++;
          this._document = _document;
      }
      Object.defineProperty(CdkStepper.prototype, "steps", {
          /** The list of step components that the stepper is holding. */
          get: /**
           * The list of step components that the stepper is holding.
           * @return {?}
           */
          function () {
              return this._steps;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkStepper.prototype, "linear", {
          /** Whether the validity of previous steps should be checked or not. */
          get: /**
           * Whether the validity of previous steps should be checked or not.
           * @return {?}
           */
          function () { return this._linear; },
          set: /**
           * @param {?} value
           * @return {?}
           */
          function (value) { this._linear = coercion.coerceBooleanProperty(value); },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkStepper.prototype, "selectedIndex", {
          /** The index of the selected step. */
          get: /**
           * The index of the selected step.
           * @return {?}
           */
          function () { return this._selectedIndex; },
          set: /**
           * @param {?} index
           * @return {?}
           */
          function (index) {
              if (this.steps) {
                  // Ensure that the index can't be out of bounds.
                  if (index < 0 || index > this.steps.length - 1) {
                      throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');
                  }
                  if (this._selectedIndex != index &&
                      !this._anyControlsInvalidOrPending(index) &&
                      (index >= this._selectedIndex || this.steps.toArray()[index].editable)) {
                      this._updateSelectedItemIndex(index);
                  }
              }
              else {
                  this._selectedIndex = index;
              }
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(CdkStepper.prototype, "selected", {
          /** The step that is selected. */
          get: /**
           * The step that is selected.
           * @return {?}
           */
          function () {
              // @breaking-change 8.0.0 Change return type to `CdkStep | undefined`.
              return this.steps ? this.steps.toArray()[this.selectedIndex] : (/** @type {?} */ (undefined));
          },
          set: /**
           * @param {?} step
           * @return {?}
           */
          function (step) {
              this.selectedIndex = this.steps ? this.steps.toArray().indexOf(step) : -1;
          },
          enumerable: true,
          configurable: true
      });
      /**
       * @return {?}
       */
      CdkStepper.prototype.ngAfterViewInit = /**
       * @return {?}
       */
      function () {
          var _this = this;
          // Note that while the step headers are content children by default, any components that
          // extend this one might have them as view chidren. We initialize the keyboard handling in
          // AfterViewInit so we're guaranteed for both view and content children to be defined.
          this._keyManager = new a11y.FocusKeyManager(this._stepHeader)
              .withWrap()
              .withVerticalOrientation(this._orientation === 'vertical');
          (this._dir ? (/** @type {?} */ (this._dir.change)) : rxjs.of())
              .pipe(operators.startWith(this._layoutDirection()), operators.takeUntil(this._destroyed))
              .subscribe(function (direction) { return _this._keyManager.withHorizontalOrientation(direction); });
          this._keyManager.updateActiveItemIndex(this._selectedIndex);
          this.steps.changes.pipe(operators.takeUntil(this._destroyed)).subscribe(function () {
              if (!_this.selected) {
                  _this._selectedIndex = Math.max(_this._selectedIndex - 1, 0);
              }
          });
      };
      /**
       * @return {?}
       */
      CdkStepper.prototype.ngOnDestroy = /**
       * @return {?}
       */
      function () {
          this._destroyed.next();
          this._destroyed.complete();
      };
      /** Selects and focuses the next step in list. */
      /**
       * Selects and focuses the next step in list.
       * @return {?}
       */
      CdkStepper.prototype.next = /**
       * Selects and focuses the next step in list.
       * @return {?}
       */
      function () {
          this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);
      };
      /** Selects and focuses the previous step in list. */
      /**
       * Selects and focuses the previous step in list.
       * @return {?}
       */
      CdkStepper.prototype.previous = /**
       * Selects and focuses the previous step in list.
       * @return {?}
       */
      function () {
          this.selectedIndex = Math.max(this._selectedIndex - 1, 0);
      };
      /** Resets the stepper to its initial state. Note that this includes clearing form data. */
      /**
       * Resets the stepper to its initial state. Note that this includes clearing form data.
       * @return {?}
       */
      CdkStepper.prototype.reset = /**
       * Resets the stepper to its initial state. Note that this includes clearing form data.
       * @return {?}
       */
      function () {
          this._updateSelectedItemIndex(0);
          this.steps.forEach(function (step) { return step.reset(); });
          this._stateChanged();
      };
      /** Returns a unique id for each step label element. */
      /**
       * Returns a unique id for each step label element.
       * @param {?} i
       * @return {?}
       */
      CdkStepper.prototype._getStepLabelId = /**
       * Returns a unique id for each step label element.
       * @param {?} i
       * @return {?}
       */
      function (i) {
          return "cdk-step-label-" + this._groupId + "-" + i;
      };
      /** Returns unique id for each step content element. */
      /**
       * Returns unique id for each step content element.
       * @param {?} i
       * @return {?}
       */
      CdkStepper.prototype._getStepContentId = /**
       * Returns unique id for each step content element.
       * @param {?} i
       * @return {?}
       */
      function (i) {
          return "cdk-step-content-" + this._groupId + "-" + i;
      };
      /** Marks the component to be change detected. */
      /**
       * Marks the component to be change detected.
       * @return {?}
       */
      CdkStepper.prototype._stateChanged = /**
       * Marks the component to be change detected.
       * @return {?}
       */
      function () {
          this._changeDetectorRef.markForCheck();
      };
      /** Returns position state of the step with the given index. */
      /**
       * Returns position state of the step with the given index.
       * @param {?} index
       * @return {?}
       */
      CdkStepper.prototype._getAnimationDirection = /**
       * Returns position state of the step with the given index.
       * @param {?} index
       * @return {?}
       */
      function (index) {
          /** @type {?} */
          var position = index - this._selectedIndex;
          if (position < 0) {
              return this._layoutDirection() === 'rtl' ? 'next' : 'previous';
          }
          else if (position > 0) {
              return this._layoutDirection() === 'rtl' ? 'previous' : 'next';
          }
          return 'current';
      };
      /** Returns the type of icon to be displayed. */
      /**
       * Returns the type of icon to be displayed.
       * @param {?} index
       * @param {?=} state
       * @return {?}
       */
      CdkStepper.prototype._getIndicatorType = /**
       * Returns the type of icon to be displayed.
       * @param {?} index
       * @param {?=} state
       * @return {?}
       */
      function (index, state) {
          if (state === void 0) { state = STEP_STATE.NUMBER; }
          /** @type {?} */
          var step = this.steps.toArray()[index];
          /** @type {?} */
          var isCurrentStep = this._isCurrentStep(index);
          return step._displayDefaultIndicatorType
              ? this._getDefaultIndicatorLogic(step, isCurrentStep)
              : this._getGuidelineLogic(step, isCurrentStep, state);
      };
      /**
       * @private
       * @param {?} step
       * @param {?} isCurrentStep
       * @return {?}
       */
      CdkStepper.prototype._getDefaultIndicatorLogic = /**
       * @private
       * @param {?} step
       * @param {?} isCurrentStep
       * @return {?}
       */
      function (step, isCurrentStep) {
          if (step._showError && step.hasError && !isCurrentStep) {
              return STEP_STATE.ERROR;
          }
          else if (!step.completed || isCurrentStep) {
              return STEP_STATE.NUMBER;
          }
          else {
              return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;
          }
      };
      /**
       * @private
       * @param {?} step
       * @param {?} isCurrentStep
       * @param {?=} state
       * @return {?}
       */
      CdkStepper.prototype._getGuidelineLogic = /**
       * @private
       * @param {?} step
       * @param {?} isCurrentStep
       * @param {?=} state
       * @return {?}
       */
      function (step, isCurrentStep, state) {
          if (state === void 0) { state = STEP_STATE.NUMBER; }
          if (step._showError && step.hasError && !isCurrentStep) {
              return STEP_STATE.ERROR;
          }
          else if (step.completed && !isCurrentStep) {
              return STEP_STATE.DONE;
          }
          else if (step.completed && isCurrentStep) {
              return state;
          }
          else if (step.editable && isCurrentStep) {
              return STEP_STATE.EDIT;
          }
          else {
              return state;
          }
      };
      /**
       * @private
       * @param {?} index
       * @return {?}
       */
      CdkStepper.prototype._isCurrentStep = /**
       * @private
       * @param {?} index
       * @return {?}
       */
      function (index) {
          return this._selectedIndex === index;
      };
      /** Returns the index of the currently-focused step header. */
      /**
       * Returns the index of the currently-focused step header.
       * @return {?}
       */
      CdkStepper.prototype._getFocusIndex = /**
       * Returns the index of the currently-focused step header.
       * @return {?}
       */
      function () {
          return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;
      };
      /**
       * @private
       * @param {?} newIndex
       * @return {?}
       */
      CdkStepper.prototype._updateSelectedItemIndex = /**
       * @private
       * @param {?} newIndex
       * @return {?}
       */
      function (newIndex) {
          /** @type {?} */
          var stepsArray = this.steps.toArray();
          this.selectionChange.emit({
              selectedIndex: newIndex,
              previouslySelectedIndex: this._selectedIndex,
              selectedStep: stepsArray[newIndex],
              previouslySelectedStep: stepsArray[this._selectedIndex],
          });
          // If focus is inside the stepper, move it to the next header, otherwise it may become
          // lost when the active step content is hidden. We can't be more granular with the check
          // (e.g. checking whether focus is inside the active step), because we don't have a
          // reference to the elements that are rendering out the content.
          this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :
              this._keyManager.updateActiveItemIndex(newIndex);
          this._selectedIndex = newIndex;
          this._stateChanged();
      };
      /**
       * @param {?} event
       * @return {?}
       */
      CdkStepper.prototype._onKeydown = /**
       * @param {?} event
       * @return {?}
       */
      function (event) {
          /** @type {?} */
          var hasModifier = keycodes.hasModifierKey(event);
          /** @type {?} */
          var keyCode = event.keyCode;
          /** @type {?} */
          var manager = this._keyManager;
          if (manager.activeItemIndex != null && !hasModifier &&
              (keyCode === keycodes.SPACE || keyCode === keycodes.ENTER)) {
              this.selectedIndex = manager.activeItemIndex;
              event.preventDefault();
          }
          else if (keyCode === keycodes.HOME) {
              manager.setFirstItemActive();
              event.preventDefault();
          }
          else if (keyCode === keycodes.END) {
              manager.setLastItemActive();
              event.preventDefault();
          }
          else {
              manager.onKeydown(event);
          }
      };
      /**
       * @private
       * @param {?} index
       * @return {?}
       */
      CdkStepper.prototype._anyControlsInvalidOrPending = /**
       * @private
       * @param {?} index
       * @return {?}
       */
      function (index) {
          /** @type {?} */
          var steps = this.steps.toArray();
          steps[this._selectedIndex].interacted = true;
          if (this._linear && index >= 0) {
              return steps.slice(0, index).some(function (step) {
                  /** @type {?} */
                  var control = step.stepControl;
                  /** @type {?} */
                  var isIncomplete = control ?
                      (control.invalid || control.pending || !step.interacted) :
                      !step.completed;
                  return isIncomplete && !step.optional;
              });
          }
          return false;
      };
      /**
       * @private
       * @return {?}
       */
      CdkStepper.prototype._layoutDirection = /**
       * @private
       * @return {?}
       */
      function () {
          return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
      };
      /** Checks whether the stepper contains the focused element. */
      /**
       * Checks whether the stepper contains the focused element.
       * @private
       * @return {?}
       */
      CdkStepper.prototype._containsFocus = /**
       * Checks whether the stepper contains the focused element.
       * @private
       * @return {?}
       */
      function () {
          if (!this._document || !this._elementRef) {
              return false;
          }
          /** @type {?} */
          var stepperElement = this._elementRef.nativeElement;
          /** @type {?} */
          var focusedElement = this._document.activeElement;
          return stepperElement === focusedElement || stepperElement.contains(focusedElement);
      };
      CdkStepper.decorators = [
          { type: core.Directive, args: [{
                      selector: '[cdkStepper]',
                      exportAs: 'cdkStepper',
                  },] },
      ];
      /** @nocollapse */
      CdkStepper.ctorParameters = function () { return [
          { type: bidi.Directionality, decorators: [{ type: core.Optional }] },
          { type: core.ChangeDetectorRef },
          { type: core.ElementRef },
          { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] }
      ]; };
      CdkStepper.propDecorators = {
          _steps: [{ type: core.ContentChildren, args: [CdkStep,] }],
          _stepHeader: [{ type: core.ContentChildren, args: [CdkStepHeader,] }],
          linear: [{ type: core.Input }],
          selectedIndex: [{ type: core.Input }],
          selected: [{ type: core.Input }],
          selectionChange: [{ type: core.Output }]
      };
      return CdkStepper;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  /**
   * Button that moves to the next step in a stepper workflow.
   */
  var CdkStepperNext = /** @class */ (function () {
      function CdkStepperNext(_stepper) {
          this._stepper = _stepper;
          /**
           * Type of the next button. Defaults to "submit" if not specified.
           */
          this.type = 'submit';
      }
      CdkStepperNext.decorators = [
          { type: core.Directive, args: [{
                      selector: 'button[cdkStepperNext]',
                      host: {
                          '(click)': '_stepper.next()',
                          '[type]': 'type',
                      }
                  },] },
      ];
      /** @nocollapse */
      CdkStepperNext.ctorParameters = function () { return [
          { type: CdkStepper }
      ]; };
      CdkStepperNext.propDecorators = {
          type: [{ type: core.Input }]
      };
      return CdkStepperNext;
  }());
  /**
   * Button that moves to the previous step in a stepper workflow.
   */
  var CdkStepperPrevious = /** @class */ (function () {
      function CdkStepperPrevious(_stepper) {
          this._stepper = _stepper;
          /**
           * Type of the previous button. Defaults to "button" if not specified.
           */
          this.type = 'button';
      }
      CdkStepperPrevious.decorators = [
          { type: core.Directive, args: [{
                      selector: 'button[cdkStepperPrevious]',
                      host: {
                          '(click)': '_stepper.previous()',
                          '[type]': 'type',
                      }
                  },] },
      ];
      /** @nocollapse */
      CdkStepperPrevious.ctorParameters = function () { return [
          { type: CdkStepper }
      ]; };
      CdkStepperPrevious.propDecorators = {
          type: [{ type: core.Input }]
      };
      return CdkStepperPrevious;
  }());
  
  /**
   * @fileoverview added by tsickle
   * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  var CdkStepperModule = /** @class */ (function () {
      function CdkStepperModule() {
      }
      CdkStepperModule.decorators = [
          { type: core.NgModule, args: [{
                      imports: [bidi.BidiModule, common.CommonModule],
                      exports: [
                          CdkStep,
                          CdkStepper,
                          CdkStepHeader,
                          CdkStepLabel,
                          CdkStepperNext,
                          CdkStepperPrevious,
                      ],
                      declarations: [
                          CdkStep,
                          CdkStepper,
                          CdkStepHeader,
                          CdkStepLabel,
                          CdkStepperNext,
                          CdkStepperPrevious,
                      ]
                  },] },
      ];
      return CdkStepperModule;
  }());
  
  exports.StepperSelectionEvent = StepperSelectionEvent;
  exports.STEP_STATE = STEP_STATE;
  exports.STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS;
  exports.MAT_STEPPER_GLOBAL_OPTIONS = MAT_STEPPER_GLOBAL_OPTIONS;
  exports.CdkStep = CdkStep;
  exports.CdkStepper = CdkStepper;
  exports.CdkStepLabel = CdkStepLabel;
  exports.CdkStepperNext = CdkStepperNext;
  exports.CdkStepperPrevious = CdkStepperPrevious;
  exports.CdkStepperModule = CdkStepperModule;
  exports.CdkStepHeader = CdkStepHeader;
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  //# sourceMappingURL=cdk-stepper.umd.js.map
  