text: import { Component, ViewEncapsulation, ChangeDetectionStrategy, ViewChild, TemplateRef, Input, ContentChildren, Pipe, Injectable, ElementRef, ChangeDetectorRef, Renderer2, EventEmitter, NgZone, ViewChildren, Output, Host, Optional, forwardRef, Directive, NgModule } from '@angular/core';
  import { __decorate, __metadata } from 'tslib';
  import { InputBoolean, isNotNil, isNil, zoomMotion, NzNoAnimationDirective, toBoolean, slideMotion, NzAddOnModule, NzOverlayModule, NzNoAnimationModule } from 'ng-zorro-antd/core';
  import { Subject, BehaviorSubject, ReplaySubject, combineLatest, merge, fromEvent, EMPTY } from 'rxjs';
  import { distinctUntilChanged, map, filter, skip, share, tap, takeUntil, pairwise, startWith, flatMap } from 'rxjs/operators';
  import { TAB, SPACE, BACKSPACE, ENTER, DOWN_ARROW, UP_ARROW } from '@angular/cdk/keycodes';
  import { CdkOverlayOrigin, CdkConnectedOverlay, OverlayModule } from '@angular/cdk/overlay';
  import { Platform, PlatformModule } from '@angular/cdk/platform';
  import { NG_VALUE_ACCESSOR, FormsModule } from '@angular/forms';
  import { CommonModule } from '@angular/common';
  import { NzEmptyModule } from 'ng-zorro-antd/empty';
  import { NzI18nModule } from 'ng-zorro-antd/i18n';
  import { NzIconModule } from 'ng-zorro-antd/icon';
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-option.component.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzOptionComponent {
      constructor() {
          this.changes = new Subject();
          this.nzDisabled = false;
          this.nzHide = false;
          this.nzCustomContent = false;
      }
      /**
       * @return {?}
       */
      ngOnChanges() {
          this.changes.next();
      }
  }
  NzOptionComponent.decorators = [
      { type: Component, args: [{
                  selector: 'nz-option',
                  exportAs: 'nzOption',
                  encapsulation: ViewEncapsulation.None,
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  template: "<ng-template>\n  <ng-content></ng-content>\n</ng-template>"
              }] }
  ];
  NzOptionComponent.propDecorators = {
      template: [{ type: ViewChild, args: [TemplateRef, { static: false },] }],
      nzLabel: [{ type: Input }],
      nzValue: [{ type: Input }],
      nzDisabled: [{ type: Input }],
      nzHide: [{ type: Input }],
      nzCustomContent: [{ type: Input }]
  };
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzOptionComponent.prototype, "nzDisabled", void 0);
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzOptionComponent.prototype, "nzHide", void 0);
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzOptionComponent.prototype, "nzCustomContent", void 0);
  if (false) {
      /** @type {?} */
      NzOptionComponent.prototype.changes;
      /** @type {?} */
      NzOptionComponent.prototype.template;
      /** @type {?} */
      NzOptionComponent.prototype.nzLabel;
      /** @type {?} */
      NzOptionComponent.prototype.nzValue;
      /** @type {?} */
      NzOptionComponent.prototype.nzDisabled;
      /** @type {?} */
      NzOptionComponent.prototype.nzHide;
      /** @type {?} */
      NzOptionComponent.prototype.nzCustomContent;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-option-group.component.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzOptionGroupComponent {
      constructor() {
          this.isLabelString = false;
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzLabel(value) {
          this.label = value;
          this.isLabelString = !(this.nzLabel instanceof TemplateRef);
      }
      /**
       * @return {?}
       */
      get nzLabel() {
          return this.label;
      }
  }
  NzOptionGroupComponent.decorators = [
      { type: Component, args: [{
                  selector: 'nz-option-group',
                  exportAs: 'nzOptionGroup',
                  encapsulation: ViewEncapsulation.None,
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  template: "<ng-content></ng-content>"
              }] }
  ];
  NzOptionGroupComponent.propDecorators = {
      listOfNzOptionComponent: [{ type: ContentChildren, args: [NzOptionComponent,] }],
      nzLabel: [{ type: Input }]
  };
  if (false) {
      /** @type {?} */
      NzOptionGroupComponent.prototype.isLabelString;
      /** @type {?} */
      NzOptionGroupComponent.prototype.label;
      /** @type {?} */
      NzOptionGroupComponent.prototype.listOfNzOptionComponent;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-option.pipe.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzFilterOptionPipe {
      /**
       * @param {?} options
       * @param {?} searchValue
       * @param {?} filterOption
       * @param {?} serverSearch
       * @return {?}
       */
      transform(options, searchValue, filterOption, serverSearch) {
          if (serverSearch || !searchValue) {
              return (/** @type {?} */ (options));
          }
          else {
              return ((/** @type {?} */ (options))).filter((/**
               * @param {?} o
               * @return {?}
               */
              o => filterOption(searchValue, o)));
          }
      }
  }
  NzFilterOptionPipe.decorators = [
      { type: Pipe, args: [{ name: 'nzFilterOption' },] }
  ];
  class NzFilterGroupOptionPipe {
      /**
       * @param {?} groups
       * @param {?} searchValue
       * @param {?} filterOption
       * @param {?} serverSearch
       * @return {?}
       */
      transform(groups, searchValue, filterOption, serverSearch) {
          if (serverSearch || !searchValue) {
              return groups;
          }
          else {
              return ((/** @type {?} */ (groups))).filter((/**
               * @param {?} g
               * @return {?}
               */
              g => {
                  return g.listOfNzOptionComponent.some((/**
                   * @param {?} o
                   * @return {?}
                   */
                  o => filterOption(searchValue, o)));
              }));
          }
      }
  }
  NzFilterGroupOptionPipe.decorators = [
      { type: Pipe, args: [{ name: 'nzFilterGroupOption' },] }
  ];
  /**
   * @param {?} searchValue
   * @param {?} option
   * @return {?}
   */
  function defaultFilterOption(searchValue, option) {
      if (option && option.nzLabel) {
          return option.nzLabel.toLowerCase().indexOf(searchValue.toLowerCase()) > -1;
      }
      else {
          return false;
      }
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-select.service.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzSelectService {
      constructor() {
          /**
           * Input params *
           */
          this.autoClearSearchValue = true;
          this.serverSearch = false;
          this.filterOption = defaultFilterOption;
          this.mode = 'default';
          this.maxMultipleCount = Infinity;
          this.disabled = false;
          // tslint:disable-next-line:no-any
          this.compareWith = (/**
           * @param {?} o1
           * @param {?} o2
           * @return {?}
           */
          (o1, o2) => o1 === o2);
          /**
           * selectedValueChanged should emit ngModelChange or not *
           */
          // tslint:disable-next-line:no-any
          this.listOfSelectedValueWithEmit$ = new BehaviorSubject({
              value: [],
              emit: false
          });
          /**
           * ContentChildren Change *
           */
          this.mapOfTemplateOption$ = new BehaviorSubject({
              listOfNzOptionComponent: [],
              listOfNzOptionGroupComponent: []
          });
          /**
           * searchValue Change *
           */
          this.searchValueRaw$ = new BehaviorSubject('');
          this.listOfFilteredOption = [];
          this.openRaw$ = new Subject();
          this.checkRaw$ = new Subject();
          this.open = false;
          this.clearInput$ = new Subject();
          this.searchValue = '';
          this.isShowNotFound = false;
          /**
           * animation event *
           */
          this.animationEvent$ = new Subject();
          /**
           * open event *
           */
          this.open$ = this.openRaw$.pipe(distinctUntilChanged());
          this.activatedOption$ = new ReplaySubject(1);
          this.listOfSelectedValue$ = this.listOfSelectedValueWithEmit$.pipe(map((/**
           * @param {?} data
           * @return {?}
           */
          data => data.value)));
          this.modelChange$ = this.listOfSelectedValueWithEmit$.pipe(filter((/**
           * @param {?} item
           * @return {?}
           */
          item => item.emit)), map((/**
           * @param {?} data
           * @return {?}
           */
          data => {
              /** @type {?} */
              const selectedList = data.value;
              /** @type {?} */
              let modelValue = null;
              if (this.isSingleMode) {
                  if (selectedList.length) {
                      modelValue = selectedList[0];
                  }
              }
              else {
                  modelValue = selectedList;
              }
              return modelValue;
          })));
          this.searchValue$ = this.searchValueRaw$.pipe(distinctUntilChanged(), skip(1), share(), tap((/**
           * @param {?} value
           * @return {?}
           */
          value => {
              this.searchValue = value;
              if (value) {
                  this.updateActivatedOption(this.listOfFilteredOption[0]);
              }
              this.updateListOfFilteredOption();
          })));
          // tslint:disable-next-line:no-any
          this.listOfSelectedValue = [];
          /**
           * flat ViewChildren *
           */
          this.listOfTemplateOption = [];
          /**
           * tag option *
           */
          this.listOfTagOption = [];
          /**
           * tag option concat template option *
           */
          this.listOfTagAndTemplateOption = [];
          /**
           * ViewChildren *
           */
          this.listOfNzOptionComponent = [];
          this.listOfNzOptionGroupComponent = [];
          /**
           * display in top control *
           */
          this.listOfCachedSelectedOption = [];
          /**
           * selected value or ViewChildren change *
           */
          this.valueOrOption$ = combineLatest([this.listOfSelectedValue$, this.mapOfTemplateOption$]).pipe(tap((/**
           * @param {?} data
           * @return {?}
           */
          data => {
              const [listOfSelectedValue, mapOfTemplateOption] = data;
              this.listOfSelectedValue = listOfSelectedValue;
              this.listOfNzOptionComponent = mapOfTemplateOption.listOfNzOptionComponent;
              this.listOfNzOptionGroupComponent = mapOfTemplateOption.listOfNzOptionGroupComponent;
              this.listOfTemplateOption = this.listOfNzOptionComponent.concat(this.listOfNzOptionGroupComponent.reduce((/**
               * @param {?} pre
               * @param {?} cur
               * @return {?}
               */
              (pre, cur) => [...pre, ...cur.listOfNzOptionComponent.toArray()]), (/** @type {?} */ ([]))));
              this.updateListOfTagOption();
              this.updateListOfFilteredOption();
              this.resetActivatedOptionIfNeeded();
              this.updateListOfCachedOption();
          })), share());
          this.check$ = merge(this.checkRaw$, this.valueOrOption$, this.searchValue$, this.activatedOption$, this.open$, this.modelChange$).pipe(share());
      }
      /**
       * @param {?} option
       * @return {?}
       */
      clickOption(option) {
          /** update listOfSelectedOption -> update listOfSelectedValue -> next listOfSelectedValue$ **/
          if (!option.nzDisabled) {
              this.updateActivatedOption(option);
              /** @type {?} */
              let listOfSelectedValue = [...this.listOfSelectedValue];
              if (this.isMultipleOrTags) {
                  /** @type {?} */
                  const targetValue = listOfSelectedValue.find((/**
                   * @param {?} o
                   * @return {?}
                   */
                  o => this.compareWith(o, option.nzValue)));
                  if (isNotNil(targetValue)) {
                      listOfSelectedValue.splice(listOfSelectedValue.indexOf(targetValue), 1);
                      this.updateListOfSelectedValue(listOfSelectedValue, true);
                  }
                  else if (listOfSelectedValue.length < this.maxMultipleCount) {
                      listOfSelectedValue.push(option.nzValue);
                      this.updateListOfSelectedValue(listOfSelectedValue, true);
                  }
              }
              else if (!this.compareWith(listOfSelectedValue[0], option.nzValue)) {
                  listOfSelectedValue = [option.nzValue];
                  this.updateListOfSelectedValue(listOfSelectedValue, true);
              }
              if (this.isSingleMode) {
                  this.setOpenState(false);
              }
              else if (this.autoClearSearchValue) {
                  this.clearInput();
              }
          }
      }
      /**
       * @return {?}
       */
      updateListOfCachedOption() {
          if (this.isSingleMode) {
              /** @type {?} */
              const selectedOption = this.listOfTemplateOption.find((/**
               * @param {?} o
               * @return {?}
               */
              o => this.compareWith(o.nzValue, this.listOfSelectedValue[0])));
              if (!isNil(selectedOption)) {
                  this.listOfCachedSelectedOption = [selectedOption];
              }
          }
          else {
              /** @type {?} */
              const listOfCachedSelectedOption = [];
              this.listOfSelectedValue.forEach((/**
               * @param {?} v
               * @return {?}
               */
              v => {
                  /** @type {?} */
                  const listOfMixedOption = [...this.listOfTagAndTemplateOption, ...this.listOfCachedSelectedOption];
                  /** @type {?} */
                  const option = listOfMixedOption.find((/**
                   * @param {?} o
                   * @return {?}
                   */
                  o => this.compareWith(o.nzValue, v)));
                  if (option) {
                      listOfCachedSelectedOption.push(option);
                  }
              }));
              this.listOfCachedSelectedOption = listOfCachedSelectedOption;
          }
      }
      /**
       * @return {?}
       */
      updateListOfTagOption() {
          if (this.isTagsMode) {
              /** @type {?} */
              const listOfMissValue = this.listOfSelectedValue.filter((/**
               * @param {?} value
               * @return {?}
               */
              value => !this.listOfTemplateOption.find((/**
               * @param {?} o
               * @return {?}
               */
              o => this.compareWith(o.nzValue, value)))));
              this.listOfTagOption = listOfMissValue.map((/**
               * @param {?} value
               * @return {?}
               */
              value => {
                  /** @type {?} */
                  const cachedOption = this.listOfCachedSelectedOption.find((/**
                   * @param {?} o
                   * @return {?}
                   */
                  o => this.compareWith(o.nzValue, value)));
                  if (cachedOption) {
                      return cachedOption;
                  }
                  else {
                      /** @type {?} */
                      const nzOptionComponent = new NzOptionComponent();
                      nzOptionComponent.nzValue = value;
                      nzOptionComponent.nzLabel = value;
                      return nzOptionComponent;
                  }
              }));
              this.listOfTagAndTemplateOption = [...this.listOfTemplateOption.concat(this.listOfTagOption)];
          }
          else {
              this.listOfTagAndTemplateOption = [...this.listOfTemplateOption];
          }
      }
      /**
       * @return {?}
       */
      updateAddTagOption() {
          /** @type {?} */
          const isMatch = this.listOfTagAndTemplateOption.find((/**
           * @param {?} item
           * @return {?}
           */
          item => item.nzLabel === this.searchValue));
          if (this.isTagsMode && this.searchValue && !isMatch) {
              /** @type {?} */
              const option = new NzOptionComponent();
              option.nzValue = this.searchValue;
              option.nzLabel = this.searchValue;
              this.addedTagOption = option;
              this.updateActivatedOption(option);
          }
          else {
              this.addedTagOption = null;
          }
      }
      /**
       * @return {?}
       */
      updateListOfFilteredOption() {
          this.updateAddTagOption();
          /** @type {?} */
          const listOfFilteredOption = new NzFilterOptionPipe().transform(this.listOfTagAndTemplateOption, this.searchValue, this.filterOption, this.serverSearch);
          this.listOfFilteredOption = this.addedTagOption
              ? [this.addedTagOption, ...listOfFilteredOption]
              : [...listOfFilteredOption];
          this.isShowNotFound = !this.isTagsMode && !this.listOfFilteredOption.length;
      }
      /**
       * @return {?}
       */
      clearInput() {
          this.clearInput$.next();
      }
      // tslint:disable-next-line:no-any
      /**
       * @param {?} value
       * @param {?} emit
       * @return {?}
       */
      updateListOfSelectedValue(value, emit) {
          this.listOfSelectedValueWithEmit$.next({ value, emit });
      }
      /**
       * @param {?} option
       * @return {?}
       */
      updateActivatedOption(option) {
          this.activatedOption$.next(option);
          this.activatedOption = option;
      }
      /**
       * @param {?} inputValue
       * @param {?} tokenSeparators
       * @return {?}
       */
      tokenSeparate(inputValue, tokenSeparators) {
          /** auto tokenSeparators **/
          if (inputValue &&
              inputValue.length &&
              tokenSeparators.length &&
              this.isMultipleOrTags &&
              this.includesSeparators(inputValue, tokenSeparators)) {
              /** @type {?} */
              const listOfLabel = this.splitBySeparators(inputValue, tokenSeparators);
              this.updateSelectedValueByLabelList(listOfLabel);
              this.clearInput();
          }
      }
      /**
       * @param {?} str
       * @param {?} separators
       * @return {?}
       */
      includesSeparators(str, separators) {
          // tslint:disable-next-line:prefer-for-of
          for (let i = 0; i < separators.length; ++i) {
              if (str.lastIndexOf(separators[i]) > 0) {
                  return true;
              }
          }
          return false;
      }
      /**
       * @param {?} str
       * @param {?} separators
       * @return {?}
       */
      splitBySeparators(str, separators) {
          /** @type {?} */
          const reg = new RegExp(`[${separators.join()}]`);
          /** @type {?} */
          const array = ((/** @type {?} */ (str))).split(reg).filter((/**
           * @param {?} token
           * @return {?}
           */
          token => token));
          return Array.from(new Set(array));
      }
      /**
       * @return {?}
       */
      resetActivatedOptionIfNeeded() {
          /** @type {?} */
          const resetActivatedOption = (/**
           * @return {?}
           */
          () => {
              /** @type {?} */
              const activatedOption = this.listOfFilteredOption.find((/**
               * @param {?} item
               * @return {?}
               */
              item => this.compareWith(item.nzValue, this.listOfSelectedValue[0])));
              this.updateActivatedOption(activatedOption || null);
          });
          if (this.activatedOption) {
              if (!this.listOfFilteredOption.find((/**
               * @param {?} item
               * @return {?}
               */
              item => this.compareWith(item.nzValue, (/** @type {?} */ (this.activatedOption)).nzValue))) ||
                  !this.listOfSelectedValue.find((/**
                   * @param {?} item
                   * @return {?}
                   */
                  item => this.compareWith(item, (/** @type {?} */ (this.activatedOption)).nzValue)))) {
                  resetActivatedOption();
              }
          }
          else {
              resetActivatedOption();
          }
      }
      /**
       * @param {?} listOfNzOptionComponent
       * @param {?} listOfNzOptionGroupComponent
       * @return {?}
       */
      updateTemplateOption(listOfNzOptionComponent, listOfNzOptionGroupComponent) {
          this.mapOfTemplateOption$.next({ listOfNzOptionComponent, listOfNzOptionGroupComponent });
      }
      /**
       * @param {?} value
       * @return {?}
       */
      updateSearchValue(value) {
          this.searchValueRaw$.next(value);
      }
      /**
       * @param {?} listOfLabel
       * @return {?}
       */
      updateSelectedValueByLabelList(listOfLabel) {
          /** @type {?} */
          const listOfSelectedValue = [...this.listOfSelectedValue];
          /** @type {?} */
          const listOfMatchOptionValue = this.listOfTagAndTemplateOption
              .filter((/**
           * @param {?} item
           * @return {?}
           */
          item => listOfLabel.indexOf(item.nzLabel) !== -1))
              .map((/**
           * @param {?} item
           * @return {?}
           */
          item => item.nzValue))
              .filter((/**
           * @param {?} item
           * @return {?}
           */
          item => !isNotNil(this.listOfSelectedValue.find((/**
           * @param {?} v
           * @return {?}
           */
          v => this.compareWith(v, item))))));
          if (this.isMultipleMode) {
              this.updateListOfSelectedValue([...listOfSelectedValue, ...listOfMatchOptionValue], true);
          }
          else {
              /** @type {?} */
              const listOfUnMatchOptionValue = listOfLabel.filter((/**
               * @param {?} label
               * @return {?}
               */
              label => this.listOfTagAndTemplateOption.map((/**
               * @param {?} item
               * @return {?}
               */
              item => item.nzLabel)).indexOf(label) === -1));
              this.updateListOfSelectedValue([...listOfSelectedValue, ...listOfMatchOptionValue, ...listOfUnMatchOptionValue], true);
          }
      }
      /**
       * @param {?} e
       * @return {?}
       */
      onKeyDown(e) {
          if (this.disabled) {
              return;
          }
          /** @type {?} */
          const keyCode = e.keyCode;
          /** @type {?} */
          const eventTarget = (/** @type {?} */ (e.target));
          /** @type {?} */
          const listOfFilteredOptionWithoutDisabledOrHidden = this.listOfFilteredOption.filter((/**
           * @param {?} item
           * @return {?}
           */
          item => !item.nzDisabled && !item.nzHide));
          /** @type {?} */
          const activatedIndex = listOfFilteredOptionWithoutDisabledOrHidden.findIndex((/**
           * @param {?} item
           * @return {?}
           */
          item => item === this.activatedOption));
          switch (keyCode) {
              case UP_ARROW:
                  e.preventDefault();
                  /** @type {?} */
                  const preIndex = activatedIndex > 0 ? activatedIndex - 1 : listOfFilteredOptionWithoutDisabledOrHidden.length - 1;
                  this.updateActivatedOption(listOfFilteredOptionWithoutDisabledOrHidden[preIndex]);
                  break;
              case DOWN_ARROW:
                  e.preventDefault();
                  /** @type {?} */
                  const nextIndex = activatedIndex < listOfFilteredOptionWithoutDisabledOrHidden.length - 1 ? activatedIndex + 1 : 0;
                  this.updateActivatedOption(listOfFilteredOptionWithoutDisabledOrHidden[nextIndex]);
                  if (!this.disabled && !this.open) {
                      this.setOpenState(true);
                  }
                  break;
              case ENTER:
                  e.preventDefault();
                  if (this.open) {
                      if (this.activatedOption && !this.activatedOption.nzDisabled) {
                          this.clickOption(this.activatedOption);
                      }
                  }
                  else {
                      this.setOpenState(true);
                  }
                  break;
              case BACKSPACE:
                  if (this.isMultipleOrTags && !eventTarget.value && this.listOfCachedSelectedOption.length) {
                      e.preventDefault();
                      this.removeValueFormSelected(this.listOfCachedSelectedOption[this.listOfCachedSelectedOption.length - 1]);
                  }
                  break;
              case SPACE:
                  if (!this.disabled && !this.open) {
                      this.setOpenState(true);
                      e.preventDefault();
                  }
                  break;
              case TAB:
                  this.setOpenState(false);
                  break;
          }
      }
      // tslint:disable-next-line:no-any
      /**
       * @param {?} option
       * @return {?}
       */
      removeValueFormSelected(option) {
          if (this.disabled || option.nzDisabled) {
              return;
          }
          /** @type {?} */
          const listOfSelectedValue = this.listOfSelectedValue.filter((/**
           * @param {?} item
           * @return {?}
           */
          item => !this.compareWith(item, option.nzValue)));
          this.updateListOfSelectedValue(listOfSelectedValue, true);
          this.clearInput();
      }
      /**
       * @param {?} value
       * @return {?}
       */
      setOpenState(value) {
          this.openRaw$.next(value);
          this.open = value;
      }
      /**
       * @return {?}
       */
      check() {
          this.checkRaw$.next();
      }
      /**
       * @return {?}
       */
      get isSingleMode() {
          return this.mode === 'default';
      }
      /**
       * @return {?}
       */
      get isTagsMode() {
          return this.mode === 'tags';
      }
      /**
       * @return {?}
       */
      get isMultipleMode() {
          return this.mode === 'multiple';
      }
      /**
       * @return {?}
       */
      get isMultipleOrTags() {
          return this.mode === 'tags' || this.mode === 'multiple';
      }
  }
  NzSelectService.decorators = [
      { type: Injectable }
  ];
  if (false) {
      /**
       * Input params *
       * @type {?}
       */
      NzSelectService.prototype.autoClearSearchValue;
      /** @type {?} */
      NzSelectService.prototype.serverSearch;
      /** @type {?} */
      NzSelectService.prototype.filterOption;
      /** @type {?} */
      NzSelectService.prototype.mode;
      /** @type {?} */
      NzSelectService.prototype.maxMultipleCount;
      /** @type {?} */
      NzSelectService.prototype.disabled;
      /** @type {?} */
      NzSelectService.prototype.compareWith;
      /**
       * selectedValueChanged should emit ngModelChange or not *
       * @type {?}
       * @private
       */
      NzSelectService.prototype.listOfSelectedValueWithEmit$;
      /**
       * ContentChildren Change *
       * @type {?}
       * @private
       */
      NzSelectService.prototype.mapOfTemplateOption$;
      /**
       * searchValue Change *
       * @type {?}
       * @private
       */
      NzSelectService.prototype.searchValueRaw$;
      /**
       * @type {?}
       * @private
       */
      NzSelectService.prototype.listOfFilteredOption;
      /**
       * @type {?}
       * @private
       */
      NzSelectService.prototype.openRaw$;
      /**
       * @type {?}
       * @private
       */
      NzSelectService.prototype.checkRaw$;
      /**
       * @type {?}
       * @private
       */
      NzSelectService.prototype.open;
      /** @type {?} */
      NzSelectService.prototype.clearInput$;
      /** @type {?} */
      NzSelectService.prototype.searchValue;
      /** @type {?} */
      NzSelectService.prototype.isShowNotFound;
      /**
       * animation event *
       * @type {?}
       */
      NzSelectService.prototype.animationEvent$;
      /**
       * open event *
       * @type {?}
       */
      NzSelectService.prototype.open$;
      /** @type {?} */
      NzSelectService.prototype.activatedOption;
      /** @type {?} */
      NzSelectService.prototype.activatedOption$;
      /** @type {?} */
      NzSelectService.prototype.listOfSelectedValue$;
      /** @type {?} */
      NzSelectService.prototype.modelChange$;
      /** @type {?} */
      NzSelectService.prototype.searchValue$;
      /** @type {?} */
      NzSelectService.prototype.listOfSelectedValue;
      /**
       * flat ViewChildren *
       * @type {?}
       */
      NzSelectService.prototype.listOfTemplateOption;
      /**
       * tag option *
       * @type {?}
       */
      NzSelectService.prototype.listOfTagOption;
      /**
       * tag option concat template option *
       * @type {?}
       */
      NzSelectService.prototype.listOfTagAndTemplateOption;
      /**
       * ViewChildren *
       * @type {?}
       */
      NzSelectService.prototype.listOfNzOptionComponent;
      /** @type {?} */
      NzSelectService.prototype.listOfNzOptionGroupComponent;
      /**
       * click or enter add tag option *
       * @type {?}
       */
      NzSelectService.prototype.addedTagOption;
      /**
       * display in top control *
       * @type {?}
       */
      NzSelectService.prototype.listOfCachedSelectedOption;
      /**
       * selected value or ViewChildren change *
       * @type {?}
       */
      NzSelectService.prototype.valueOrOption$;
      /** @type {?} */
      NzSelectService.prototype.check$;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-option-li.component.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzOptionLiComponent {
      /**
       * @param {?} elementRef
       * @param {?} nzSelectService
       * @param {?} cdr
       * @param {?} renderer
       */
      constructor(elementRef, nzSelectService, cdr, renderer) {
          this.elementRef = elementRef;
          this.nzSelectService = nzSelectService;
          this.cdr = cdr;
          this.el = this.elementRef.nativeElement;
          this.selected = false;
          this.active = false;
          this.destroy$ = new Subject();
          renderer.addClass(elementRef.nativeElement, 'ant-select-dropdown-menu-item');
      }
      /**
       * @return {?}
       */
      clickOption() {
          this.nzSelectService.clickOption(this.nzOption);
      }
      /**
       * @return {?}
       */
      ngOnInit() {
          this.nzSelectService.listOfSelectedValue$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} list
           * @return {?}
           */
          list => {
              this.selected = isNotNil(list.find((/**
               * @param {?} v
               * @return {?}
               */
              v => this.nzSelectService.compareWith(v, this.nzOption.nzValue))));
              this.cdr.markForCheck();
          }));
          this.nzSelectService.activatedOption$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} option
           * @return {?}
           */
          option => {
              if (option) {
                  this.active = this.nzSelectService.compareWith(option.nzValue, this.nzOption.nzValue);
              }
              else {
                  this.active = false;
              }
              this.cdr.markForCheck();
          }));
      }
      /**
       * @return {?}
       */
      ngOnDestroy() {
          this.destroy$.next();
          this.destroy$.complete();
      }
  }
  NzOptionLiComponent.decorators = [
      { type: Component, args: [{
                  selector: '[nz-option-li]',
                  exportAs: 'nzOptionLi',
                  template: "<ng-container *ngIf=\"!nzOption.nzCustomContent; else nzOption.template\">\n  {{nzOption.nzLabel}}\n</ng-container>\n<ng-container *ngIf=\"nzSelectService.isMultipleOrTags\">\n  <i nz-icon nzType=\"check\" class=\"ant-select-selected-icon\" *ngIf=\"!nzMenuItemSelectedIcon; else nzMenuItemSelectedIcon\"></i>\n</ng-container>\n",
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  encapsulation: ViewEncapsulation.None,
                  host: {
                      '[class.ant-select-dropdown-menu-item-selected]': 'selected && !nzOption.nzDisabled',
                      '[class.ant-select-dropdown-menu-item-disabled]': 'nzOption.nzDisabled',
                      '[class.ant-select-dropdown-menu-item-active]': 'active && !nzOption.nzDisabled',
                      '[attr.unselectable]': '"unselectable"',
                      '[style.user-select]': '"none"',
                      '(click)': 'clickOption()',
                      '(mousedown)': '$event.preventDefault()'
                  }
              }] }
  ];
  /** @nocollapse */
  NzOptionLiComponent.ctorParameters = () => [
      { type: ElementRef },
      { type: NzSelectService },
      { type: ChangeDetectorRef },
      { type: Renderer2 }
  ];
  NzOptionLiComponent.propDecorators = {
      nzOption: [{ type: Input }],
      nzMenuItemSelectedIcon: [{ type: Input }]
  };
  if (false) {
      /** @type {?} */
      NzOptionLiComponent.prototype.el;
      /** @type {?} */
      NzOptionLiComponent.prototype.selected;
      /** @type {?} */
      NzOptionLiComponent.prototype.active;
      /** @type {?} */
      NzOptionLiComponent.prototype.destroy$;
      /** @type {?} */
      NzOptionLiComponent.prototype.nzOption;
      /** @type {?} */
      NzOptionLiComponent.prototype.nzMenuItemSelectedIcon;
      /**
       * @type {?}
       * @private
       */
      NzOptionLiComponent.prototype.elementRef;
      /** @type {?} */
      NzOptionLiComponent.prototype.nzSelectService;
      /**
       * @type {?}
       * @private
       */
      NzOptionLiComponent.prototype.cdr;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-option-container.component.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzOptionContainerComponent {
      /**
       * @param {?} nzSelectService
       * @param {?} cdr
       * @param {?} ngZone
       */
      constructor(nzSelectService, cdr, ngZone) {
          this.nzSelectService = nzSelectService;
          this.cdr = cdr;
          this.ngZone = ngZone;
          this.destroy$ = new Subject();
          this.lastScrollTop = 0;
          this.nzScrollToBottom = new EventEmitter();
      }
      /**
       * @param {?} option
       * @return {?}
       */
      scrollIntoViewIfNeeded(option) {
          // delay after open
          setTimeout((/**
           * @return {?}
           */
          () => {
              if (this.listOfNzOptionLiComponent && this.listOfNzOptionLiComponent.length && option) {
                  /** @type {?} */
                  const targetOption = this.listOfNzOptionLiComponent.find((/**
                   * @param {?} o
                   * @return {?}
                   */
                  o => this.nzSelectService.compareWith(o.nzOption.nzValue, option.nzValue)));
                  // tslint:disable:no-any
                  if (targetOption && targetOption.el && ((/** @type {?} */ (targetOption.el))).scrollIntoViewIfNeeded) {
                      ((/** @type {?} */ (targetOption.el))).scrollIntoViewIfNeeded(false);
                  }
              }
          }));
      }
      /**
       * @param {?} _index
       * @param {?} option
       * @return {?}
       */
      trackLabel(_index, option) {
          return option.nzLabel;
      }
      // tslint:disable-next-line:no-any
      /**
       * @param {?} _index
       * @param {?} option
       * @return {?}
       */
      trackValue(_index, option) {
          return option.nzValue;
      }
      /**
       * @return {?}
       */
      ngOnInit() {
          this.nzSelectService.activatedOption$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} option
           * @return {?}
           */
          option => {
              this.scrollIntoViewIfNeeded((/** @type {?} */ (option)));
          }));
          this.nzSelectService.check$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @return {?}
           */
          () => {
              this.cdr.markForCheck();
          }));
          this.ngZone.runOutsideAngular((/**
           * @return {?}
           */
          () => {
              /** @type {?} */
              const ul = this.dropdownUl.nativeElement;
              fromEvent(ul, 'scroll')
                  .pipe(takeUntil(this.destroy$))
                  .subscribe((/**
               * @param {?} e
               * @return {?}
               */
              e => {
                  e.preventDefault();
                  e.stopPropagation();
                  if (ul && ul.scrollTop > this.lastScrollTop && ul.scrollHeight < ul.clientHeight + ul.scrollTop + 10) {
                      this.lastScrollTop = ul.scrollTop;
                      this.ngZone.run((/**
                       * @return {?}
                       */
                      () => {
                          this.nzScrollToBottom.emit();
                      }));
                  }
              }));
          }));
      }
      /**
       * @return {?}
       */
      ngAfterViewInit() {
          this.listOfNzOptionLiComponent.changes
              .pipe(map((/**
           * @param {?} list
           * @return {?}
           */
          list => list.length)), pairwise(), filter((/**
           * @param {?} __0
           * @return {?}
           */
          ([before, after]) => after < before)), takeUntil(this.destroy$))
              .subscribe((/**
           * @return {?}
           */
          () => (this.lastScrollTop = 0)));
      }
      /**
       * @return {?}
       */
      ngOnDestroy() {
          this.destroy$.next();
          this.destroy$.complete();
      }
  }
  NzOptionContainerComponent.decorators = [
      { type: Component, args: [{
                  selector: '[nz-option-container]',
                  exportAs: 'nzOptionContainer',
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  encapsulation: ViewEncapsulation.None,
                  preserveWhitespaces: false,
                  template: "<ul #dropdownUl\n  class=\"ant-select-dropdown-menu ant-select-dropdown-menu-root ant-select-dropdown-menu-vertical\"\n  role=\"menu\"\n  tabindex=\"0\">\n  <li *ngIf=\"nzSelectService.isShowNotFound\"\n    nz-select-unselectable\n    class=\"ant-select-dropdown-menu-item ant-select-dropdown-menu-item-disabled\">\n    <nz-embed-empty [nzComponentName]=\"'select'\" [specificContent]=\"nzNotFoundContent\"></nz-embed-empty>\n  </li>\n  <li nz-option-li\n    *ngIf=\"nzSelectService.addedTagOption\"\n    [nzMenuItemSelectedIcon]=\"nzMenuItemSelectedIcon\"\n    [nzOption]=\"nzSelectService.addedTagOption\">\n  </li>\n  <ng-container *ngFor=\"let option of nzSelectService.listOfNzOptionComponent | nzFilterOption : nzSelectService.searchValue : nzSelectService.filterOption : nzSelectService.serverSearch; trackBy: trackValue\">\n    <li nz-option-li\n      *ngIf=\"!option.nzHide\"\n      [nzMenuItemSelectedIcon]=\"nzMenuItemSelectedIcon\"\n      [nzOption]=\"option\">\n    </li>\n  </ng-container>\n  <li class=\"ant-select-dropdown-menu-item-group\"\n    *ngFor=\"let group of nzSelectService.listOfNzOptionGroupComponent | nzFilterGroupOption : nzSelectService.searchValue : nzSelectService.filterOption :nzSelectService.serverSearch; trackBy: trackLabel\">\n    <div class=\"ant-select-dropdown-menu-item-group-title\"\n      [attr.title]=\"group.isLabelString ? group.nzLabel : ''\">\n      <ng-container *nzStringTemplateOutlet=\"group.nzLabel\"> {{group.nzLabel}} </ng-container>\n    </div>\n    <ul class=\"ant-select-dropdown-menu-item-group-list\">\n      <ng-container *ngFor=\"let option of group.listOfNzOptionComponent | nzFilterOption : nzSelectService.searchValue : nzSelectService.filterOption :nzSelectService.serverSearch; trackBy: trackValue\">\n        <li nz-option-li\n          *ngIf=\"!option.nzHide\"\n          [nzMenuItemSelectedIcon]=\"nzMenuItemSelectedIcon\"\n          [nzOption]=\"option\">\n        </li>\n      </ng-container>\n    </ul>\n  </li>\n  <li nz-option-li\n    *ngFor=\"let option of nzSelectService.listOfTagOption | nzFilterOption : nzSelectService.searchValue : nzSelectService.filterOption : nzSelectService.serverSearch; trackBy: trackValue \"\n    [nzMenuItemSelectedIcon]=\"nzMenuItemSelectedIcon\"\n    [nzOption]=\"option\">\n  </li>\n</ul>\n"
              }] }
  ];
  /** @nocollapse */
  NzOptionContainerComponent.ctorParameters = () => [
      { type: NzSelectService },
      { type: ChangeDetectorRef },
      { type: NgZone }
  ];
  NzOptionContainerComponent.propDecorators = {
      listOfNzOptionLiComponent: [{ type: ViewChildren, args: [NzOptionLiComponent,] }],
      dropdownUl: [{ type: ViewChild, args: ['dropdownUl', { static: true },] }],
      nzNotFoundContent: [{ type: Input }],
      nzMenuItemSelectedIcon: [{ type: Input }],
      nzScrollToBottom: [{ type: Output }]
  };
  if (false) {
      /**
       * @type {?}
       * @private
       */
      NzOptionContainerComponent.prototype.destroy$;
      /**
       * @type {?}
       * @private
       */
      NzOptionContainerComponent.prototype.lastScrollTop;
      /** @type {?} */
      NzOptionContainerComponent.prototype.listOfNzOptionLiComponent;
      /** @type {?} */
      NzOptionContainerComponent.prototype.dropdownUl;
      /** @type {?} */
      NzOptionContainerComponent.prototype.nzNotFoundContent;
      /** @type {?} */
      NzOptionContainerComponent.prototype.nzMenuItemSelectedIcon;
      /** @type {?} */
      NzOptionContainerComponent.prototype.nzScrollToBottom;
      /** @type {?} */
      NzOptionContainerComponent.prototype.nzSelectService;
      /**
       * @type {?}
       * @private
       */
      NzOptionContainerComponent.prototype.cdr;
      /**
       * @type {?}
       * @private
       */
      NzOptionContainerComponent.prototype.ngZone;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-select-top-control.component.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzSelectTopControlComponent {
      /**
       * @param {?} renderer
       * @param {?} nzSelectService
       * @param {?} cdr
       * @param {?=} noAnimation
       */
      constructor(renderer, nzSelectService, cdr, noAnimation) {
          this.renderer = renderer;
          this.nzSelectService = nzSelectService;
          this.cdr = cdr;
          this.noAnimation = noAnimation;
          this.isComposing = false;
          this.destroy$ = new Subject();
          this.nzShowSearch = false;
          this.nzOpen = false;
          this.nzAllowClear = false;
          this.nzShowArrow = true;
          this.nzLoading = false;
          this.nzTokenSeparators = [];
      }
      /**
       * @param {?} e
       * @return {?}
       */
      onClearSelection(e) {
          e.stopPropagation();
          this.nzSelectService.updateListOfSelectedValue([], true);
      }
      /**
       * @param {?} value
       * @return {?}
       */
      setInputValue(value) {
          /** fix clear value https://github.com/NG-ZORRO/ng-zorro-antd/issues/3825 **/
          if (this.inputDOM && !value) {
              this.inputDOM.value = value;
          }
          this.inputValue = value;
          this.updateWidth();
          this.nzSelectService.updateSearchValue(value);
          this.nzSelectService.tokenSeparate(this.inputValue, this.nzTokenSeparators);
      }
      /**
       * @return {?}
       */
      get mirrorDOM() {
          return this.mirrorElement && this.mirrorElement.nativeElement;
      }
      /**
       * @return {?}
       */
      get inputDOM() {
          return this.inputElement && this.inputElement.nativeElement;
      }
      /**
       * @return {?}
       */
      get placeHolderDisplay() {
          return this.inputValue || this.isComposing || this.nzSelectService.listOfSelectedValue.length ? 'none' : 'block';
      }
      /**
       * @return {?}
       */
      get selectedValueStyle() {
          /** @type {?} */
          let showSelectedValue = false;
          /** @type {?} */
          let opacity = 1;
          if (!this.nzShowSearch) {
              showSelectedValue = true;
          }
          else {
              if (this.nzOpen) {
                  showSelectedValue = !(this.inputValue || this.isComposing);
                  if (showSelectedValue) {
                      opacity = 0.4;
                  }
              }
              else {
                  showSelectedValue = true;
              }
          }
          return {
              display: showSelectedValue ? 'block' : 'none',
              opacity: `${opacity}`
          };
      }
      // tslint:disable-next-line:no-any
      /**
       * @param {?} _index
       * @param {?} option
       * @return {?}
       */
      trackValue(_index, option) {
          return option.nzValue;
      }
      /**
       * @return {?}
       */
      updateWidth() {
          if (this.mirrorDOM && this.inputDOM && this.inputDOM.value) {
              this.mirrorDOM.innerText = `${this.inputDOM.value}&nbsp;`;
              this.renderer.removeStyle(this.inputDOM, 'width');
              this.renderer.setStyle(this.inputDOM, 'width', `${this.mirrorDOM.clientWidth}px`);
          }
          else if (this.inputDOM) {
              this.renderer.removeStyle(this.inputDOM, 'width');
              this.mirrorDOM.innerText = '';
          }
      }
      /**
       * @param {?} option
       * @param {?} e
       * @return {?}
       */
      removeSelectedValue(option, e) {
          this.nzSelectService.removeValueFormSelected(option);
          e.stopPropagation();
      }
      /**
       * @return {?}
       */
      animationEnd() {
          this.nzSelectService.animationEvent$.next();
      }
      /**
       * @return {?}
       */
      ngOnInit() {
          this.nzSelectService.open$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} open
           * @return {?}
           */
          open => {
              if (this.inputElement && open) {
                  setTimeout((/**
                   * @return {?}
                   */
                  () => this.inputDOM.focus()));
              }
          }));
          this.nzSelectService.clearInput$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @return {?}
           */
          () => {
              this.setInputValue('');
          }));
          this.nzSelectService.check$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @return {?}
           */
          () => {
              this.cdr.markForCheck();
          }));
      }
      /**
       * @return {?}
       */
      ngOnDestroy() {
          this.destroy$.next();
          this.destroy$.complete();
      }
  }
  NzSelectTopControlComponent.decorators = [
      { type: Component, args: [{
                  selector: '[nz-select-top-control]',
                  exportAs: 'nzSelectTopControl',
                  preserveWhitespaces: false,
                  animations: [zoomMotion],
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  encapsulation: ViewEncapsulation.None,
                  template: "<ng-template #inputTemplate>\n  <input #inputElement\n    autocomplete=\"something-new\"\n    class=\"ant-select-search__field\"\n    (compositionstart)=\"isComposing = true\"\n    (compositionend)=\"isComposing = false\"\n    [ngModel]=\"inputValue\"\n    (ngModelChange)=\"setInputValue($event)\"\n    [disabled]=\"nzSelectService.disabled\">\n  <span #mirrorElement class=\"ant-select-search__field__mirror\"></span>\n</ng-template>\n<div class=\"ant-select-selection__rendered\">\n  <div *ngIf=\"nzPlaceHolder\"\n    nz-select-unselectable\n    [style.display]=\"placeHolderDisplay\"\n    class=\"ant-select-selection__placeholder\">{{ nzPlaceHolder }}</div>\n  <!--single mode-->\n  <ng-container *ngIf=\"nzSelectService.isSingleMode\">\n    <!--selected label-->\n    <div *ngIf=\"nzSelectService.listOfCachedSelectedOption.length && nzSelectService.listOfSelectedValue.length\"\n      class=\"ant-select-selection-selected-value\"\n      [attr.title]=\"nzSelectService.listOfCachedSelectedOption[0]?.nzLabel\"\n      [ngStyle]=\"selectedValueStyle\">\n      <ng-container *nzStringTemplateOutlet=\"nzCustomTemplate; context: { $implicit: nzSelectService.listOfCachedSelectedOption[0] }\">\n        <ng-container>{{ nzSelectService.listOfCachedSelectedOption[0]?.nzLabel }}</ng-container>\n      </ng-container>\n    </div>\n    <!--show search-->\n    <div *ngIf=\"nzShowSearch\"\n      class=\"ant-select-search ant-select-search--inline\" [style.display]=\"nzOpen ? 'block' : 'none'\">\n      <div class=\"ant-select-search__field__wrap\">\n        <ng-template [ngTemplateOutlet]=\"inputTemplate\"></ng-template>\n      </div>\n    </div>\n  </ng-container>\n  <!--multiple or tags mode-->\n  <ul *ngIf=\"nzSelectService.isMultipleOrTags\">\n    <ng-container *ngFor=\"let option of nzSelectService.listOfCachedSelectedOption | slice: 0 : nzMaxTagCount;trackBy:trackValue; let index = index\">\n      <li [@zoomMotion]\n        [@.disabled]=\"noAnimation?.nzNoAnimation\"\n        [nzNoAnimation]=\"noAnimation?.nzNoAnimation\"\n        [attr.title]=\"option.nzLabel\"\n        [class.ant-select-selection__choice__disabled]=\"option.nzDisabled\"\n        (@zoomMotion.done)=\"animationEnd()\"\n        class=\"ant-select-selection__choice\">\n        <ng-container *nzStringTemplateOutlet=\"nzCustomTemplate; context:{ $implicit: nzSelectService.listOfCachedSelectedOption[index] }\">\n          <div class=\"ant-select-selection__choice__content\">{{ option.nzLabel }}</div>\n        </ng-container>\n        <span *ngIf=\"!option.nzDisabled\"\n          class=\"ant-select-selection__choice__remove\"\n          (mousedown)=\"$event.preventDefault()\"\n          (click)=\"removeSelectedValue(option, $event)\">\n          <i nz-icon nzType=\"close\" class=\"ant-select-remove-icon\" *ngIf=\"!nzRemoveIcon; else nzRemoveIcon\"></i>\n        </span>\n      </li>\n    </ng-container>\n    <li *ngIf=\"nzSelectService.listOfCachedSelectedOption.length > nzMaxTagCount\"\n      [@zoomMotion]\n      [@.disabled]=\"noAnimation?.nzNoAnimation\"\n      [nzNoAnimation]=\"noAnimation?.nzNoAnimation\"\n      (@zoomMotion.done)=\"animationEnd()\"\n      class=\"ant-select-selection__choice\">\n      <div class=\"ant-select-selection__choice__content\">\n        <ng-container *ngIf=\"nzMaxTagPlaceholder\">\n          <ng-template\n            [ngTemplateOutlet]=\"nzMaxTagPlaceholder\"\n            [ngTemplateOutletContext]=\"{ $implicit: nzSelectService.listOfSelectedValue | slice: nzMaxTagCount}\">\n          </ng-template>\n        </ng-container>\n        <ng-container *ngIf=\"!nzMaxTagPlaceholder\">\n          + {{ nzSelectService.listOfCachedSelectedOption.length - nzMaxTagCount }} ...\n        </ng-container>\n      </div>\n    </li>\n    <li class=\"ant-select-search ant-select-search--inline\">\n      <ng-template [ngTemplateOutlet]=\"inputTemplate\"></ng-template>\n    </li>\n  </ul>\n</div>\n<span *ngIf=\"nzAllowClear && nzSelectService.listOfSelectedValue.length\"\n  class=\"ant-select-selection__clear\"\n  nz-select-unselectable\n  (mousedown)=\"$event.preventDefault()\"\n  (click)=\"onClearSelection($event)\">\n    <i nz-icon nzType=\"close-circle\" nzTheme=\"fill\" *ngIf=\"!nzClearIcon; else nzClearIcon\" class=\"ant-select-close-icon\"></i>\n  </span>\n<span class=\"ant-select-arrow\" nz-select-unselectable *ngIf=\"nzShowArrow\">\n  <i nz-icon nzType=\"loading\" *ngIf=\"nzLoading; else defaultArrow\"></i>\n  <ng-template #defaultArrow>\n    <i nz-icon nzType=\"down\" class=\"ant-select-arrow-icon\" *ngIf=\"!nzSuffixIcon; else nzSuffixIcon\"></i>\n  </ng-template>\n</span>"
              }] }
  ];
  /** @nocollapse */
  NzSelectTopControlComponent.ctorParameters = () => [
      { type: Renderer2 },
      { type: NzSelectService },
      { type: ChangeDetectorRef },
      { type: NzNoAnimationDirective, decorators: [{ type: Host }, { type: Optional }] }
  ];
  NzSelectTopControlComponent.propDecorators = {
      inputElement: [{ type: ViewChild, args: ['inputElement', { static: false },] }],
      mirrorElement: [{ type: ViewChild, args: ['mirrorElement', { static: false },] }],
      nzShowSearch: [{ type: Input }],
      nzPlaceHolder: [{ type: Input }],
      nzOpen: [{ type: Input }],
      nzMaxTagCount: [{ type: Input }],
      nzAllowClear: [{ type: Input }],
      nzShowArrow: [{ type: Input }],
      nzLoading: [{ type: Input }],
      nzCustomTemplate: [{ type: Input }],
      nzSuffixIcon: [{ type: Input }],
      nzClearIcon: [{ type: Input }],
      nzRemoveIcon: [{ type: Input }],
      nzMaxTagPlaceholder: [{ type: Input }],
      nzTokenSeparators: [{ type: Input }]
  };
  if (false) {
      /** @type {?} */
      NzSelectTopControlComponent.prototype.inputValue;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.isComposing;
      /**
       * @type {?}
       * @private
       */
      NzSelectTopControlComponent.prototype.destroy$;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.inputElement;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.mirrorElement;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzShowSearch;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzPlaceHolder;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzOpen;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzMaxTagCount;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzAllowClear;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzShowArrow;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzLoading;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzCustomTemplate;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzSuffixIcon;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzClearIcon;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzRemoveIcon;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzMaxTagPlaceholder;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzTokenSeparators;
      /**
       * @type {?}
       * @private
       */
      NzSelectTopControlComponent.prototype.renderer;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.nzSelectService;
      /**
       * @type {?}
       * @private
       */
      NzSelectTopControlComponent.prototype.cdr;
      /** @type {?} */
      NzSelectTopControlComponent.prototype.noAnimation;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-select.component.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzSelectComponent {
      /**
       * @param {?} renderer
       * @param {?} nzSelectService
       * @param {?} cdr
       * @param {?} platform
       * @param {?} elementRef
       * @param {?=} noAnimation
       */
      constructor(renderer, nzSelectService, cdr, platform, elementRef, noAnimation) {
          this.nzSelectService = nzSelectService;
          this.cdr = cdr;
          this.platform = platform;
          this.noAnimation = noAnimation;
          this.open = false;
          this.onChange = (/**
           * @return {?}
           */
          () => null);
          this.onTouched = (/**
           * @return {?}
           */
          () => null);
          this.dropDownPosition = 'bottom';
          this._disabled = false;
          this.isInit = false;
          this.destroy$ = new Subject();
          this.nzOnSearch = new EventEmitter();
          this.nzScrollToBottom = new EventEmitter();
          this.nzOpenChange = new EventEmitter();
          this.nzBlur = new EventEmitter();
          this.nzFocus = new EventEmitter();
          this.nzSize = 'default';
          this.nzDropdownMatchSelectWidth = true;
          this.nzAllowClear = false;
          this.nzShowSearch = false;
          this.nzLoading = false;
          this.nzAutoFocus = false;
          this.nzShowArrow = true;
          this.nzTokenSeparators = [];
          renderer.addClass(elementRef.nativeElement, 'ant-select');
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzAutoClearSearchValue(value) {
          this.nzSelectService.autoClearSearchValue = toBoolean(value);
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzMaxMultipleCount(value) {
          this.nzSelectService.maxMultipleCount = value;
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzServerSearch(value) {
          this.nzSelectService.serverSearch = toBoolean(value);
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzMode(value) {
          this.nzSelectService.mode = value;
          this.nzSelectService.check();
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzFilterOption(value) {
          this.nzSelectService.filterOption = value;
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set compareWith(value) {
          this.nzSelectService.compareWith = value;
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzOpen(value) {
          this.open = value;
          this.nzSelectService.setOpenState(value);
      }
      /**
       * @param {?} value
       * @return {?}
       */
      set nzDisabled(value) {
          this._disabled = toBoolean(value);
          this.nzSelectService.disabled = this._disabled;
          this.nzSelectService.check();
          if (this.nzDisabled && this.isInit) {
              this.closeDropDown();
          }
      }
      /**
       * @return {?}
       */
      get nzDisabled() {
          return this._disabled;
      }
      /**
       * @return {?}
       */
      get nzSelectTopControlDOM() {
          return this.nzSelectTopControlElement && this.nzSelectTopControlElement.nativeElement;
      }
      /**
       * @return {?}
       */
      updateAutoFocus() {
          if (this.nzSelectTopControlDOM && this.nzAutoFocus) {
              this.nzSelectTopControlDOM.focus();
          }
      }
      /**
       * @return {?}
       */
      focus() {
          if (this.nzSelectTopControlDOM) {
              this.nzSelectTopControlDOM.focus();
          }
      }
      /**
       * @return {?}
       */
      blur() {
          if (this.nzSelectTopControlDOM) {
              this.nzSelectTopControlDOM.blur();
          }
      }
      /**
       * @return {?}
       */
      onFocus() {
          this.nzFocus.emit();
      }
      /**
       * @return {?}
       */
      onBlur() {
          this.nzBlur.emit();
      }
      /**
       * @param {?} event
       * @return {?}
       */
      onKeyDown(event) {
          this.nzSelectService.onKeyDown(event);
      }
      /**
       * @return {?}
       */
      toggleDropDown() {
          if (!this.nzDisabled) {
              this.nzSelectService.setOpenState(!this.open);
          }
      }
      /**
       * @return {?}
       */
      closeDropDown() {
          this.nzSelectService.setOpenState(false);
      }
      /**
       * @param {?} position
       * @return {?}
       */
      onPositionChange(position) {
          this.dropDownPosition = position.connectionPair.originY;
      }
      /**
       * @return {?}
       */
      updateCdkConnectedOverlayStatus() {
          if (this.platform.isBrowser) {
              this.triggerWidth = this.cdkOverlayOrigin.elementRef.nativeElement.getBoundingClientRect().width;
          }
      }
      /**
       * @return {?}
       */
      updateCdkConnectedOverlayPositions() {
          setTimeout((/**
           * @return {?}
           */
          () => {
              if (this.cdkConnectedOverlay && this.cdkConnectedOverlay.overlayRef) {
                  this.cdkConnectedOverlay.overlayRef.updatePosition();
              }
          }));
      }
      /**
       * update ngModel -> update listOfSelectedValue *
       * @param {?} value
       * @return {?}
       */
      // tslint:disable-next-line:no-any
      writeValue(value) {
          this.value = value;
          /** @type {?} */
          let listValue = [];
          if (isNotNil(value)) {
              if (this.nzSelectService.isMultipleOrTags) {
                  listValue = value;
              }
              else {
                  listValue = [value];
              }
          }
          this.nzSelectService.updateListOfSelectedValue(listValue, false);
          this.cdr.markForCheck();
      }
      /**
       * @param {?} fn
       * @return {?}
       */
      registerOnChange(fn) {
          this.onChange = fn;
      }
      /**
       * @param {?} fn
       * @return {?}
       */
      registerOnTouched(fn) {
          this.onTouched = fn;
      }
      /**
       * @param {?} isDisabled
       * @return {?}
       */
      setDisabledState(isDisabled) {
          this.nzDisabled = isDisabled;
          this.cdr.markForCheck();
      }
      /**
       * @return {?}
       */
      ngOnInit() {
          this.nzSelectService.animationEvent$
              .pipe(takeUntil(this.destroy$))
              .subscribe((/**
           * @return {?}
           */
          () => this.updateCdkConnectedOverlayPositions()));
          this.nzSelectService.searchValue$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} data
           * @return {?}
           */
          data => {
              this.nzOnSearch.emit(data);
              this.updateCdkConnectedOverlayPositions();
          }));
          this.nzSelectService.modelChange$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} modelValue
           * @return {?}
           */
          modelValue => {
              if (this.value !== modelValue) {
                  this.value = modelValue;
                  this.onChange(this.value);
              }
          }));
          this.nzSelectService.open$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @param {?} value
           * @return {?}
           */
          value => {
              if (this.open !== value) {
                  this.nzOpenChange.emit(value);
              }
              if (value) {
                  this.focus();
                  this.updateCdkConnectedOverlayStatus();
              }
              else {
                  this.blur();
                  this.onTouched();
              }
              this.open = value;
              this.nzSelectService.clearInput();
          }));
          this.nzSelectService.check$.pipe(takeUntil(this.destroy$)).subscribe((/**
           * @return {?}
           */
          () => {
              this.cdr.markForCheck();
          }));
      }
      /**
       * @return {?}
       */
      ngAfterViewInit() {
          this.updateCdkConnectedOverlayStatus();
          this.updateAutoFocus();
          this.isInit = true;
      }
      /**
       * @return {?}
       */
      ngAfterContentInit() {
          this.listOfNzOptionGroupComponent.changes
              .pipe(startWith(true), flatMap((/**
           * @return {?}
           */
          () => merge(this.listOfNzOptionGroupComponent.changes, this.listOfNzOptionComponent.changes, ...this.listOfNzOptionComponent.map((/**
           * @param {?} option
           * @return {?}
           */
          option => option.changes)), ...this.listOfNzOptionGroupComponent.map((/**
           * @param {?} group
           * @return {?}
           */
          group => group.listOfNzOptionComponent ? group.listOfNzOptionComponent.changes : EMPTY))).pipe(startWith(true)))))
              .subscribe((/**
           * @return {?}
           */
          () => {
              this.nzSelectService.updateTemplateOption(this.listOfNzOptionComponent.toArray(), this.listOfNzOptionGroupComponent.toArray());
          }));
      }
      /**
       * @return {?}
       */
      ngOnDestroy() {
          this.destroy$.next();
          this.destroy$.complete();
      }
  }
  NzSelectComponent.decorators = [
      { type: Component, args: [{
                  selector: 'nz-select',
                  exportAs: 'nzSelect',
                  preserveWhitespaces: false,
                  providers: [
                      NzSelectService,
                      {
                          provide: NG_VALUE_ACCESSOR,
                          useExisting: forwardRef((/**
                           * @return {?}
                           */
                          () => NzSelectComponent)),
                          multi: true
                      }
                  ],
                  changeDetection: ChangeDetectionStrategy.OnPush,
                  encapsulation: ViewEncapsulation.None,
                  animations: [slideMotion],
                  template: "<div cdkOverlayOrigin\n  nz-select-top-control\n  tabindex=\"0\"\n  class=\"ant-select-selection\"\n  [nzOpen]=\"open\"\n  [@.disabled]=\"noAnimation?.nzNoAnimation\"\n  [nzNoAnimation]=\"noAnimation?.nzNoAnimation\"\n  [nzMaxTagPlaceholder]=\"nzMaxTagPlaceholder\"\n  [nzPlaceHolder]=\"nzPlaceHolder\"\n  [nzAllowClear]=\"nzAllowClear\"\n  [nzMaxTagCount]=\"nzMaxTagCount\"\n  [nzShowArrow]=\"nzShowArrow\"\n  [nzLoading]=\"nzLoading\"\n  [nzCustomTemplate]=\"nzCustomTemplate\"\n  [nzSuffixIcon]=\"nzSuffixIcon\"\n  [nzClearIcon]=\"nzClearIcon\"\n  [nzRemoveIcon]=\"nzRemoveIcon\"\n  [nzShowSearch]=\"nzShowSearch\"\n  [nzTokenSeparators]=\"nzTokenSeparators\"\n  [class.ant-select-selection--single]=\"nzSelectService.isSingleMode\"\n  [class.ant-select-selection--multiple]=\"nzSelectService.isMultipleOrTags\"\n  (focus)=\"onFocus()\"\n  (blur)=\"onBlur()\"\n  (keydown)=\"onKeyDown($event)\">\n</div>\n<ng-template\n  cdkConnectedOverlay\n  nzConnectedOverlay\n  [cdkConnectedOverlayHasBackdrop]=\"true\"\n  [cdkConnectedOverlayMinWidth]=\"nzDropdownMatchSelectWidth? null : triggerWidth\"\n  [cdkConnectedOverlayWidth]=\"nzDropdownMatchSelectWidth? triggerWidth : null\"\n  [cdkConnectedOverlayOrigin]=\"cdkOverlayOrigin\"\n  (backdropClick)=\"closeDropDown()\"\n  (detach)=\"closeDropDown();\"\n  (positionChange)=\"onPositionChange($event)\"\n  [cdkConnectedOverlayOpen]=\"open\">\n  <div\n    class=\"ant-select-dropdown\"\n    [class.ant-select-dropdown--single]=\"nzSelectService.isSingleMode\"\n    [class.ant-select-dropdown--multiple]=\"nzSelectService.isMultipleOrTags\"\n    [class.ant-select-dropdown-placement-bottomLeft]=\"dropDownPosition === 'bottom'\"\n    [class.ant-select-dropdown-placement-topLeft]=\"dropDownPosition === 'top'\"\n    [nzClassListAdd]=\"[nzDropdownClassName]\"\n    [@slideMotion]=\"dropDownPosition\"\n    [@.disabled]=\"noAnimation?.nzNoAnimation\"\n    [nzNoAnimation]=\"noAnimation?.nzNoAnimation\"\n    [ngStyle]=\"nzDropdownStyle\">\n    <div nz-option-container\n      style=\"overflow: auto;transform: translateZ(0px);\"\n      (keydown)=\"onKeyDown($event)\"\n      [nzMenuItemSelectedIcon]=\"nzMenuItemSelectedIcon\"\n      [nzNotFoundContent]=\"nzNotFoundContent\"\n      (nzScrollToBottom)=\"nzScrollToBottom.emit()\">\n    </div>\n    <ng-template [ngTemplateOutlet]=\"nzDropdownRender\"></ng-template>\n  </div>\n</ng-template>\n<!--can not use ViewChild since it will match sub options in option group -->\n<ng-template>\n  <ng-content></ng-content>\n</ng-template>",
                  host: {
                      '[class.ant-select-lg]': 'nzSize==="large"',
                      '[class.ant-select-sm]': 'nzSize==="small"',
                      '[class.ant-select-enabled]': '!nzDisabled',
                      '[class.ant-select-no-arrow]': '!nzShowArrow',
                      '[class.ant-select-disabled]': 'nzDisabled',
                      '[class.ant-select-allow-clear]': 'nzAllowClear',
                      '[class.ant-select-open]': 'open',
                      '(click)': 'toggleDropDown()'
                  },
                  styles: [`
        .ant-select-dropdown {
          top: 100%;
          left: 0;
          position: relative;
          width: 100%;
          margin-top: 4px;
          margin-bottom: 4px;
        }
      `]
              }] }
  ];
  /** @nocollapse */
  NzSelectComponent.ctorParameters = () => [
      { type: Renderer2 },
      { type: NzSelectService },
      { type: ChangeDetectorRef },
      { type: Platform },
      { type: ElementRef },
      { type: NzNoAnimationDirective, decorators: [{ type: Host }, { type: Optional }] }
  ];
  NzSelectComponent.propDecorators = {
      cdkOverlayOrigin: [{ type: ViewChild, args: [CdkOverlayOrigin, { static: false },] }],
      cdkConnectedOverlay: [{ type: ViewChild, args: [CdkConnectedOverlay, { static: false },] }],
      nzSelectTopControlComponent: [{ type: ViewChild, args: [NzSelectTopControlComponent, { static: true },] }],
      nzSelectTopControlElement: [{ type: ViewChild, args: [NzSelectTopControlComponent, { static: true, read: ElementRef },] }],
      listOfNzOptionComponent: [{ type: ContentChildren, args: [NzOptionComponent,] }],
      listOfNzOptionGroupComponent: [{ type: ContentChildren, args: [NzOptionGroupComponent,] }],
      nzOnSearch: [{ type: Output }],
      nzScrollToBottom: [{ type: Output }],
      nzOpenChange: [{ type: Output }],
      nzBlur: [{ type: Output }],
      nzFocus: [{ type: Output }],
      nzSize: [{ type: Input }],
      nzDropdownClassName: [{ type: Input }],
      nzDropdownMatchSelectWidth: [{ type: Input }],
      nzDropdownStyle: [{ type: Input }],
      nzNotFoundContent: [{ type: Input }],
      nzAllowClear: [{ type: Input }],
      nzShowSearch: [{ type: Input }],
      nzLoading: [{ type: Input }],
      nzAutoFocus: [{ type: Input }],
      nzPlaceHolder: [{ type: Input }],
      nzMaxTagCount: [{ type: Input }],
      nzDropdownRender: [{ type: Input }],
      nzCustomTemplate: [{ type: Input }],
      nzSuffixIcon: [{ type: Input }],
      nzClearIcon: [{ type: Input }],
      nzRemoveIcon: [{ type: Input }],
      nzMenuItemSelectedIcon: [{ type: Input }],
      nzShowArrow: [{ type: Input }],
      nzTokenSeparators: [{ type: Input }],
      nzMaxTagPlaceholder: [{ type: Input }],
      nzAutoClearSearchValue: [{ type: Input }],
      nzMaxMultipleCount: [{ type: Input }],
      nzServerSearch: [{ type: Input }],
      nzMode: [{ type: Input }],
      nzFilterOption: [{ type: Input }],
      compareWith: [{ type: Input }],
      nzOpen: [{ type: Input }],
      nzDisabled: [{ type: Input }]
  };
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzSelectComponent.prototype, "nzAllowClear", void 0);
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzSelectComponent.prototype, "nzShowSearch", void 0);
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzSelectComponent.prototype, "nzLoading", void 0);
  __decorate([
      InputBoolean(),
      __metadata("design:type", Object)
  ], NzSelectComponent.prototype, "nzAutoFocus", void 0);
  if (false) {
      /** @type {?} */
      NzSelectComponent.prototype.open;
      /** @type {?} */
      NzSelectComponent.prototype.value;
      /** @type {?} */
      NzSelectComponent.prototype.onChange;
      /** @type {?} */
      NzSelectComponent.prototype.onTouched;
      /** @type {?} */
      NzSelectComponent.prototype.dropDownPosition;
      /** @type {?} */
      NzSelectComponent.prototype.triggerWidth;
      /**
       * @type {?}
       * @private
       */
      NzSelectComponent.prototype._disabled;
      /**
       * @type {?}
       * @private
       */
      NzSelectComponent.prototype.isInit;
      /**
       * @type {?}
       * @private
       */
      NzSelectComponent.prototype.destroy$;
      /** @type {?} */
      NzSelectComponent.prototype.cdkOverlayOrigin;
      /** @type {?} */
      NzSelectComponent.prototype.cdkConnectedOverlay;
      /** @type {?} */
      NzSelectComponent.prototype.nzSelectTopControlComponent;
      /** @type {?} */
      NzSelectComponent.prototype.nzSelectTopControlElement;
      /**
       * should move to nz-option-container when https://github.com/angular/angular/issues/20810 resolved *
       * @type {?}
       */
      NzSelectComponent.prototype.listOfNzOptionComponent;
      /** @type {?} */
      NzSelectComponent.prototype.listOfNzOptionGroupComponent;
      /** @type {?} */
      NzSelectComponent.prototype.nzOnSearch;
      /** @type {?} */
      NzSelectComponent.prototype.nzScrollToBottom;
      /** @type {?} */
      NzSelectComponent.prototype.nzOpenChange;
      /** @type {?} */
      NzSelectComponent.prototype.nzBlur;
      /** @type {?} */
      NzSelectComponent.prototype.nzFocus;
      /** @type {?} */
      NzSelectComponent.prototype.nzSize;
      /** @type {?} */
      NzSelectComponent.prototype.nzDropdownClassName;
      /** @type {?} */
      NzSelectComponent.prototype.nzDropdownMatchSelectWidth;
      /** @type {?} */
      NzSelectComponent.prototype.nzDropdownStyle;
      /** @type {?} */
      NzSelectComponent.prototype.nzNotFoundContent;
      /** @type {?} */
      NzSelectComponent.prototype.nzAllowClear;
      /** @type {?} */
      NzSelectComponent.prototype.nzShowSearch;
      /** @type {?} */
      NzSelectComponent.prototype.nzLoading;
      /** @type {?} */
      NzSelectComponent.prototype.nzAutoFocus;
      /** @type {?} */
      NzSelectComponent.prototype.nzPlaceHolder;
      /** @type {?} */
      NzSelectComponent.prototype.nzMaxTagCount;
      /** @type {?} */
      NzSelectComponent.prototype.nzDropdownRender;
      /** @type {?} */
      NzSelectComponent.prototype.nzCustomTemplate;
      /** @type {?} */
      NzSelectComponent.prototype.nzSuffixIcon;
      /** @type {?} */
      NzSelectComponent.prototype.nzClearIcon;
      /** @type {?} */
      NzSelectComponent.prototype.nzRemoveIcon;
      /** @type {?} */
      NzSelectComponent.prototype.nzMenuItemSelectedIcon;
      /** @type {?} */
      NzSelectComponent.prototype.nzShowArrow;
      /** @type {?} */
      NzSelectComponent.prototype.nzTokenSeparators;
      /** @type {?} */
      NzSelectComponent.prototype.nzMaxTagPlaceholder;
      /** @type {?} */
      NzSelectComponent.prototype.nzSelectService;
      /**
       * @type {?}
       * @private
       */
      NzSelectComponent.prototype.cdr;
      /**
       * @type {?}
       * @private
       */
      NzSelectComponent.prototype.platform;
      /** @type {?} */
      NzSelectComponent.prototype.noAnimation;
  }
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-select-unselectable.directive.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzSelectUnselectableDirective {
  }
  NzSelectUnselectableDirective.decorators = [
      { type: Directive, args: [{
                  selector: '[nz-select-unselectable]',
                  exportAs: 'nzSelectUnselectable',
                  host: {
                      '[attr.unselectable]': '"unselectable"',
                      '[style.user-select]': '"none"'
                  }
              },] }
  ];
  
  /**
   * @fileoverview added by tsickle
   * Generated from: nz-select.module.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  class NzSelectModule {
  }
  NzSelectModule.decorators = [
      { type: NgModule, args: [{
                  imports: [
                      CommonModule,
                      NzI18nModule,
                      FormsModule,
                      PlatformModule,
                      OverlayModule,
                      NzIconModule,
                      NzAddOnModule,
                      NzEmptyModule,
                      NzOverlayModule,
                      NzNoAnimationModule
                  ],
                  declarations: [
                      NzFilterGroupOptionPipe,
                      NzFilterOptionPipe,
                      NzOptionComponent,
                      NzSelectComponent,
                      NzOptionContainerComponent,
                      NzOptionGroupComponent,
                      NzOptionLiComponent,
                      NzSelectTopControlComponent,
                      NzSelectUnselectableDirective
                  ],
                  exports: [
                      NzOptionComponent,
                      NzSelectComponent,
                      NzOptionContainerComponent,
                      NzOptionGroupComponent,
                      NzSelectTopControlComponent
                  ]
              },] }
  ];
  
  /**
   * @fileoverview added by tsickle
   * Generated from: public-api.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  
  /**
   * @fileoverview added by tsickle
   * Generated from: ng-zorro-antd-select.ts
   * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
   */
  
  export { NzFilterGroupOptionPipe, NzFilterOptionPipe, NzOptionComponent, NzOptionContainerComponent, NzOptionGroupComponent, NzOptionLiComponent, NzSelectComponent, NzSelectModule, NzSelectService, NzSelectTopControlComponent, NzSelectUnselectableDirective, defaultFilterOption };
  //# sourceMappingURL=ng-zorro-antd-select.js.map
  