import {
  ConfigState,
  ChangePassword,
  StartLoader,
  StopLoader,
  GetProfile,
  UpdateProfile,
  ProfileState,
  RestOccurError,
  LazyLoadService,
  CoreModule,
} from '@abp/ng.core';
import {
  Component,
  EventEmitter,
  Renderer2,
  Input,
  Output,
  ViewChild,
  Injectable,
  ɵɵdefineInjectable,
  ɵɵinject,
  ElementRef,
  ChangeDetectorRef,
  ContentChild,
  ViewChildren,
  NgZone,
  ApplicationRef,
  ComponentFactoryResolver,
  RendererFactory2,
  Injector,
  INJECTOR,
  APP_INITIALIZER,
  NgModule,
} from '@angular/core';
import { MessageService } from 'primeng/components/common/messageservice';
import { ToastModule } from 'primeng/toast';
import { Subject, ReplaySubject, BehaviorSubject, fromEvent, interval, timer, Observable, forkJoin } from 'rxjs';
import { Router, NavigationStart, NavigationEnd, NavigationError } from '@angular/router';
import { Store, ofActionSuccessful, Actions, Select } from '@ngxs/store';
import { Validators, FormBuilder } from '@angular/forms';
import { comparePasswords, takeUntilDestroy, NgxValidateCoreModule } from '@ngx-validate/core';
import snq from 'snq';
import { finalize, takeUntil, debounceTime, filter, withLatestFrom, take } from 'rxjs/operators';
import { animation, style, animate, trigger, transition, useAnimation, keyframes, state } from '@angular/animations';
import { __decorate, __metadata } from 'tslib';
import { HttpErrorResponse } from '@angular/common/http';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class BreadcrumbComponent {
  /**
   * @param {?} router
   * @param {?} store
   */
  constructor(router, store) {
    this.router = router;
    this.store = store;
    this.segments = [];
    this.show = !!this.store.selectSnapshot(
      /**
       * @param {?} state
       * @return {?}
       */
      state => state.LeptonLayoutState,
    );
  }
  /**
   * @return {?}
   */
  ngOnInit() {
    /** @type {?} */
    const splittedUrl = this.router.url.split('/').filter(
      /**
       * @param {?} chunk
       * @return {?}
       */
      (chunk => chunk),
    );
    /** @type {?} */
    const currentUrl = this.store.selectSnapshot(ConfigState.getRoute(splittedUrl[0]));
    this.segments.push(currentUrl.name);
    if (splittedUrl.length > 1) {
      const [, ...arr] = splittedUrl;
      /** @type {?} */
      let childRoute = currentUrl;
      for (let i = 0; i < arr.length; i++) {
        /** @type {?} */
        const element = arr[i];
        childRoute = childRoute.children.find(
          /**
           * @param {?} child
           * @return {?}
           */
          child => child.path === element,
        );
        this.segments.push(childRoute.name);
      }
    }
  }
}
BreadcrumbComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-breadcrumb',
        template:
          '<ol *ngIf="show" class="breadcrumb">\n  <li class="breadcrumb-item">\n    <a routerLink="/"><i class="fa fa-home"></i> </a>\n  </li>\n  <li\n    *ngFor="let segment of segments; let last = last"\n    class="breadcrumb-item"\n    [class.active]="last"\n    aria-current="page"\n  >\n    {{ segment | abpLocalization }}\n  </li>\n</ol>\n',
      },
    ],
  },
];
/** @nocollapse */
BreadcrumbComponent.ctorParameters = () => [{ type: Router }, { type: Store }];
if (false) {
  /** @type {?} */
  BreadcrumbComponent.prototype.show;
  /** @type {?} */
  BreadcrumbComponent.prototype.segments;
  /**
   * @type {?}
   * @private
   */
  BreadcrumbComponent.prototype.router;
  /**
   * @type {?}
   * @private
   */
  BreadcrumbComponent.prototype.store;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ButtonComponent {
  /**
   * @param {?} renderer
   */
  constructor(renderer) {
    this.renderer = renderer;
    this.buttonClass = 'btn btn-primary';
    this.loading = false;
    this.disabled = false;
    // tslint:disable-next-line: no-output-native
    this.click = new EventEmitter();
    // tslint:disable-next-line: no-output-native
    this.focus = new EventEmitter();
    // tslint:disable-next-line: no-output-native
    this.blur = new EventEmitter();
    /**
     * @deprecated Use buttonType instead. To be deleted in v1
     */
    this.type = 'button';
  }
  /**
   * @return {?}
   */
  get icon() {
    return `${this.loading ? 'fa fa-spinner fa-spin' : this.iconClass || 'd-none'}`;
  }
  /**
   * @return {?}
   */
  ngOnInit() {
    if (this.attributes) {
      Object.keys(this.attributes).forEach(
        /**
         * @param {?} key
         * @return {?}
         */
        key => {
          this.renderer.setAttribute(this.buttonRef.nativeElement, key, this.attributes[key]);
        },
      );
    }
  }
}
ButtonComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-button',
        // tslint:disable-next-line: component-max-inline-declarations
        template: `
    <button
      #button
      [attr.type]="buttonType || type"
      [ngClass]="buttonClass"
      [disabled]="loading || disabled"
      (click)="click.emit($event)"
      (focus)="focus.emit($event)"
      (blur)="blur.emit($event)"
    >
      <i [ngClass]="icon" class="mr-1"></i><ng-content></ng-content>
    </button>
  `,
      },
    ],
  },
];
/** @nocollapse */
ButtonComponent.ctorParameters = () => [{ type: Renderer2 }];
ButtonComponent.propDecorators = {
  buttonClass: [{ type: Input }],
  buttonType: [{ type: Input }],
  iconClass: [{ type: Input }],
  loading: [{ type: Input }],
  disabled: [{ type: Input }],
  attributes: [{ type: Input }],
  click: [{ type: Output }],
  focus: [{ type: Output }],
  blur: [{ type: Output }],
  buttonRef: [{ type: ViewChild, args: ['button', { static: true }] }],
  type: [{ type: Input }],
};
if (false) {
  /** @type {?} */
  ButtonComponent.prototype.buttonClass;
  /** @type {?} */
  ButtonComponent.prototype.buttonType;
  /** @type {?} */
  ButtonComponent.prototype.iconClass;
  /** @type {?} */
  ButtonComponent.prototype.loading;
  /** @type {?} */
  ButtonComponent.prototype.disabled;
  /** @type {?} */
  ButtonComponent.prototype.attributes;
  /** @type {?} */
  ButtonComponent.prototype.click;
  /** @type {?} */
  ButtonComponent.prototype.focus;
  /** @type {?} */
  ButtonComponent.prototype.blur;
  /** @type {?} */
  ButtonComponent.prototype.buttonRef;
  /**
   * @deprecated Use buttonType instead. To be deleted in v1
   * @type {?}
   */
  ButtonComponent.prototype.type;
  /**
   * @type {?}
   * @private
   */
  ButtonComponent.prototype.renderer;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @abstract
 * @template T
 */
class AbstractToaster {
  /**
   * @param {?} messageService
   */
  constructor(messageService) {
    this.messageService = messageService;
    this.key = 'abpToast';
    this.sticky = false;
  }
  /**
   * @param {?} message
   * @param {?} title
   * @param {?=} options
   * @return {?}
   */
  info(message, title, options) {
    return this.show(message, title, 'info', options);
  }
  /**
   * @param {?} message
   * @param {?} title
   * @param {?=} options
   * @return {?}
   */
  success(message, title, options) {
    return this.show(message, title, 'success', options);
  }
  /**
   * @param {?} message
   * @param {?} title
   * @param {?=} options
   * @return {?}
   */
  warn(message, title, options) {
    return this.show(message, title, 'warn', options);
  }
  /**
   * @param {?} message
   * @param {?} title
   * @param {?=} options
   * @return {?}
   */
  error(message, title, options) {
    return this.show(message, title, 'error', options);
  }
  /**
   * @protected
   * @param {?} message
   * @param {?} title
   * @param {?} severity
   * @param {?=} options
   * @return {?}
   */
  show(message, title, severity, options) {
    this.messageService.clear(this.key);
    this.messageService.add(
      Object.assign(
        { severity, detail: message || '', summary: title || '' },
        options,
        { key: this.key },
        typeof (options || /** @type {?} */ ({})).sticky === 'undefined' && { sticky: this.sticky },
      ),
    );
    this.status$ = new Subject();
    return this.status$;
  }
  /**
   * @param {?=} status
   * @return {?}
   */
  clear(status) {
    this.messageService.clear(this.key);
    this.status$.next(status || 'dismiss' /* dismiss */);
    this.status$.complete();
  }
}
if (false) {
  /** @type {?} */
  AbstractToaster.prototype.status$;
  /** @type {?} */
  AbstractToaster.prototype.key;
  /** @type {?} */
  AbstractToaster.prototype.sticky;
  /**
   * @type {?}
   * @protected
   */
  AbstractToaster.prototype.messageService;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ToasterService extends AbstractToaster {
  /**
   * @param {?} messages
   * @return {?}
   */
  addAll(messages) {
    this.messageService.addAll(
      messages.map(
        /**
         * @param {?} message
         * @return {?}
         */
        message => Object.assign({ key: this.key }, message),
      ),
    );
  }
}
ToasterService.decorators = [{ type: Injectable, args: [{ providedIn: 'root' }] }];
/** @nocollapse */ ToasterService.ngInjectableDef = ɵɵdefineInjectable({
  factory: function ToasterService_Factory() {
    return new ToasterService(ɵɵinject(MessageService));
  },
  token: ToasterService,
  providedIn: 'root',
});

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
const { minLength, required } = Validators;
/** @type {?} */
const PASSWORD_FIELDS = ['newPassword', 'repeatNewPassword'];
class ChangePasswordComponent {
  /**
   * @param {?} fb
   * @param {?} store
   * @param {?} toasterService
   */
  constructor(fb, store, toasterService) {
    this.fb = fb;
    this.store = store;
    this.toasterService = toasterService;
    this.visibleChange = new EventEmitter();
    this.modalBusy = false;
    this.mapErrorsFn
    /**
     * @param {?} errors
     * @param {?} groupErrors
     * @param {?} control
     * @return {?}
     */ = (errors, groupErrors, control) => {
      if (PASSWORD_FIELDS.indexOf(control.name) < 0) return errors;
      return errors.concat(
        groupErrors.filter(
          /**
           * @param {?} __0
           * @return {?}
           */
          ({ key }) => key === 'passwordMismatch',
        ),
      );
    };
  }
  /**
   * @return {?}
   */
  get visible() {
    return this._visible;
  }
  /**
   * @param {?} value
   * @return {?}
   */
  set visible(value) {
    this._visible = value;
    this.visibleChange.emit(value);
  }
  /**
   * @return {?}
   */
  ngOnInit() {
    this.form = this.fb.group(
      {
        password: ['', required],
        newPassword: ['', required],
        repeatNewPassword: ['', required],
      },
      {
        validators: [comparePasswords(PASSWORD_FIELDS)],
      },
    );
  }
  /**
   * @return {?}
   */
  onSubmit() {
    if (this.form.invalid) return;
    this.modalBusy = true;
    this.store
      .dispatch(
        new ChangePassword({
          currentPassword: this.form.get('password').value,
          newPassword: this.form.get('newPassword').value,
        }),
      )
      .pipe(
        finalize(
          /**
           * @return {?}
           */
          () => {
            this.modalBusy = false;
          },
        ),
      )
      .subscribe({
        /**
         * @return {?}
         */
        next: () => {
          this.visible = false;
          this.form.reset();
        },
        /**
         * @param {?} err
         * @return {?}
         */
        error: err => {
          this.toasterService.error(
            snq(
              /**
               * @return {?}
               */
              () => err.error.error.message,
              'AbpAccount::DefaultErrorMessage',
            ),
            'Error',
            {
              life: 7000,
            },
          );
        },
      });
  }
  /**
   * @return {?}
   */
  openModal() {
    this.visible = true;
  }
  /**
   * @param {?} __0
   * @return {?}
   */
  ngOnChanges({ visible }) {
    if (!visible) return;
    if (visible.currentValue) {
      this.openModal();
    } else if (visible.currentValue === false && this.visible) {
      this.visible = false;
    }
  }
}
ChangePasswordComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-change-password',
        template:
          '<abp-modal [(visible)]="visible" [busy]="modalBusy">\n  <ng-template #abpHeader>\n    <h4>{{ \'AbpIdentity::ChangePassword\' | abpLocalization }}</h4>\n  </ng-template>\n  <ng-template #abpBody>\n    <form [formGroup]="form" (ngSubmit)="onSubmit()" [mapErrorsFn]="mapErrorsFn">\n      <div class="form-group">\n        <label for="current-password">{{ \'AbpIdentity::DisplayName:CurrentPassword\' | abpLocalization }}</label\n        ><span> * </span\n        ><input type="password" id="current-password" class="form-control" formControlName="password" autofocus />\n      </div>\n      <div class="form-group">\n        <label for="new-password">{{ \'AbpIdentity::DisplayName:NewPassword\' | abpLocalization }}</label\n        ><span> * </span><input type="password" id="new-password" class="form-control" formControlName="newPassword" />\n      </div>\n      <div class="form-group">\n        <label for="confirm-new-password">{{ \'AbpIdentity::DisplayName:NewPasswordConfirm\' | abpLocalization }}</label\n        ><span> * </span\n        ><input type="password" id="confirm-new-password" class="form-control" formControlName="repeatNewPassword" />\n      </div>\n    </form>\n  </ng-template>\n  <ng-template #abpFooter>\n    <button type="button" class="btn btn-secondary color-white" #abpClose>\n      {{ \'AbpIdentity::Cancel\' | abpLocalization }}\n    </button>\n    <abp-button iconClass="fa fa-check" buttonClass="btn btn-primary color-white" (click)="onSubmit()">{{\n      \'AbpIdentity::Save\' | abpLocalization\n    }}</abp-button>\n  </ng-template>\n</abp-modal>\n',
      },
    ],
  },
];
/** @nocollapse */
ChangePasswordComponent.ctorParameters = () => [{ type: FormBuilder }, { type: Store }, { type: ToasterService }];
ChangePasswordComponent.propDecorators = {
  visible: [{ type: Input }],
  visibleChange: [{ type: Output }],
  modalContent: [{ type: ViewChild, args: ['modalContent', { static: false }] }],
};
if (false) {
  /**
   * @type {?}
   * @protected
   */
  ChangePasswordComponent.prototype._visible;
  /** @type {?} */
  ChangePasswordComponent.prototype.visibleChange;
  /** @type {?} */
  ChangePasswordComponent.prototype.modalContent;
  /** @type {?} */
  ChangePasswordComponent.prototype.form;
  /** @type {?} */
  ChangePasswordComponent.prototype.modalBusy;
  /** @type {?} */
  ChangePasswordComponent.prototype.mapErrorsFn;
  /**
   * @type {?}
   * @private
   */
  ChangePasswordComponent.prototype.fb;
  /**
   * @type {?}
   * @private
   */
  ChangePasswordComponent.prototype.store;
  /**
   * @type {?}
   * @private
   */
  ChangePasswordComponent.prototype.toasterService;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} count
 * @return {?}
 */
function getRandomBackgroundColor(count) {
  /** @type {?} */
  const colors = [];
  for (let i = 0; i < count; i++) {
    /** @type {?} */
    const r = ((i + 5) * (i + 5) * 474) % 255;
    /** @type {?} */
    const g = ((i + 5) * (i + 5) * 1600) % 255;
    /** @type {?} */
    const b = ((i + 5) * (i + 5) * 84065) % 255;
    colors.push('rgba(' + r + ', ' + g + ', ' + b + ', 0.7)');
  }
  return colors;
}
/** @type {?} */
const chartJsLoaded$ = new ReplaySubject(1);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ChartComponent {
  /**
   * @param {?} el
   * @param {?} cdRef
   */
  constructor(el, cdRef) {
    this.el = el;
    this.cdRef = cdRef;
    this.options = {};
    this.plugins = [];
    this.responsive = true;
    // tslint:disable-next-line: no-output-on-prefix
    this.onDataSelect = new EventEmitter();
    this.initialized = new BehaviorSubject(this);
    this.onCanvasClick
    /**
     * @param {?} event
     * @return {?}
     */ = event => {
      if (this.chart) {
        /** @type {?} */
        const element = this.chart.getElementAtEvent(event);
        /** @type {?} */
        const dataset = this.chart.getDatasetAtEvent(event);
        if (element && element[0] && dataset) {
          this.onDataSelect.emit({
            originalEvent: event,
            element: element[0],
            dataset,
          });
        }
      }
    };
    this.initChart
    /**
     * @return {?}
     */ = () => {
      /** @type {?} */
      const opts = this.options || {};
      opts.responsive = this.responsive;
      // allows chart to resize in responsive mode
      if (opts.responsive && (this.height || this.width)) {
        opts.maintainAspectRatio = false;
      }
      this.chart = new Chart(this.el.nativeElement.children[0].children[0], {
        type: this.type,
        data: this.data,
        options: this.options,
        plugins: this.plugins,
      });
      this.cdRef.detectChanges();
    };
    this.generateLegend
    /**
     * @return {?}
     */ = () => {
      if (this.chart) {
        return this.chart.generateLegend();
      }
    };
    this.refresh
    /**
     * @return {?}
     */ = () => {
      if (this.chart) {
        this.chart.update();
        this.cdRef.detectChanges();
      }
    };
    this.reinit
    /**
     * @return {?}
     */ = () => {
      if (this.chart) {
        this.chart.destroy();
        this.initChart();
      }
    };
  }
  /**
   * @return {?}
   */
  get data() {
    return this._data;
  }
  /**
   * @param {?} val
   * @return {?}
   */
  set data(val) {
    this._data = val;
    this.reinit();
  }
  /**
   * @return {?}
   */
  get canvas() {
    return this.el.nativeElement.children[0].children[0];
  }
  /**
   * @return {?}
   */
  get base64Image() {
    return this.chart.toBase64Image();
  }
  /**
   * @return {?}
   */
  ngAfterViewInit() {
    chartJsLoaded$.subscribe(
      /**
       * @return {?}
       */
      () => {
        try {
          // tslint:disable-next-line: no-unused-expression
          Chart;
        } catch (error) {
          console.error(`Chart is not found. Import the Chart from app.module like shown below:
        import('chart.js');
        `);
          return;
        }
        this.initChart();
        this._initialized = true;
      },
    );
  }
  /**
   * @return {?}
   */
  ngOnDestroy() {
    if (this.chart) {
      this.chart.destroy();
      this._initialized = false;
      this.chart = null;
    }
  }
}
ChartComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-chart',
        template:
          '<div\n  style="position:relative"\n  [style.width]="responsive && !width ? null : width"\n  [style.height]="responsive && !height ? null : height"\n>\n  <canvas\n    [attr.width]="responsive && !width ? null : width"\n    [attr.height]="responsive && !height ? null : height"\n    (click)="onCanvasClick($event)"\n  ></canvas>\n</div>\n',
      },
    ],
  },
];
/** @nocollapse */
ChartComponent.ctorParameters = () => [{ type: ElementRef }, { type: ChangeDetectorRef }];
ChartComponent.propDecorators = {
  type: [{ type: Input }],
  options: [{ type: Input }],
  plugins: [{ type: Input }],
  width: [{ type: Input }],
  height: [{ type: Input }],
  responsive: [{ type: Input }],
  onDataSelect: [{ type: Output }],
  initialized: [{ type: Output }],
  data: [{ type: Input }],
};
if (false) {
  /** @type {?} */
  ChartComponent.prototype.type;
  /** @type {?} */
  ChartComponent.prototype.options;
  /** @type {?} */
  ChartComponent.prototype.plugins;
  /** @type {?} */
  ChartComponent.prototype.width;
  /** @type {?} */
  ChartComponent.prototype.height;
  /** @type {?} */
  ChartComponent.prototype.responsive;
  /** @type {?} */
  ChartComponent.prototype.onDataSelect;
  /** @type {?} */
  ChartComponent.prototype.initialized;
  /**
   * @type {?}
   * @private
   */
  ChartComponent.prototype._initialized;
  /** @type {?} */
  ChartComponent.prototype._data;
  /** @type {?} */
  ChartComponent.prototype.chart;
  /** @type {?} */
  ChartComponent.prototype.onCanvasClick;
  /** @type {?} */
  ChartComponent.prototype.initChart;
  /** @type {?} */
  ChartComponent.prototype.generateLegend;
  /** @type {?} */
  ChartComponent.prototype.refresh;
  /** @type {?} */
  ChartComponent.prototype.reinit;
  /** @type {?} */
  ChartComponent.prototype.el;
  /**
   * @type {?}
   * @private
   */
  ChartComponent.prototype.cdRef;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ConfirmationService extends AbstractToaster {
  /**
   * @param {?} messageService
   */
  constructor(messageService) {
    super(messageService);
    this.messageService = messageService;
    this.key = 'abpConfirmation';
    this.sticky = true;
    this.destroy$ = new Subject();
  }
  /**
   * @param {?} message
   * @param {?} title
   * @param {?} severity
   * @param {?=} options
   * @return {?}
   */
  show(message, title, severity, options) {
    this.listenToEscape();
    return super.show(message, title, severity, options);
  }
  /**
   * @param {?=} status
   * @return {?}
   */
  clear(status) {
    super.clear(status);
    this.destroy$.next();
  }
  /**
   * @return {?}
   */
  listenToEscape() {
    fromEvent(document, 'keyup')
      .pipe(
        takeUntil(this.destroy$),
        debounceTime(150),
        filter(
          /**
           * @param {?} key
           * @return {?}
           */
          key => key && key.code === 'Escape',
        ),
      )
      .subscribe(
        /**
         * @param {?} _
         * @return {?}
         */
        _ => {
          this.clear();
        },
      );
  }
}
ConfirmationService.decorators = [{ type: Injectable, args: [{ providedIn: 'root' }] }];
/** @nocollapse */
ConfirmationService.ctorParameters = () => [{ type: MessageService }];
/** @nocollapse */ ConfirmationService.ngInjectableDef = ɵɵdefineInjectable({
  factory: function ConfirmationService_Factory() {
    return new ConfirmationService(ɵɵinject(MessageService));
  },
  token: ConfirmationService,
  providedIn: 'root',
});
if (false) {
  /** @type {?} */
  ConfirmationService.prototype.key;
  /** @type {?} */
  ConfirmationService.prototype.sticky;
  /** @type {?} */
  ConfirmationService.prototype.destroy$;
  /**
   * @type {?}
   * @protected
   */
  ConfirmationService.prototype.messageService;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ConfirmationComponent {
  /**
   * @param {?} confirmationService
   */
  constructor(confirmationService) {
    this.confirmationService = confirmationService;
    this.confirm = 'confirm' /* confirm */;
    this.reject = 'reject' /* reject */;
    this.dismiss = 'dismiss' /* dismiss */;
  }
  /**
   * @param {?} status
   * @return {?}
   */
  close(status) {
    this.confirmationService.clear(status);
  }
}
ConfirmationComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-confirmation',
        // tslint:disable-next-line: component-max-inline-declarations
        template: `
    <p-toast
      position="center"
      key="abpConfirmation"
      (onClose)="close(dismiss)"
      [modal]="true"
      [baseZIndex]="1000"
      styleClass="abp-confirm"
    >
      <ng-template let-message pTemplate="message">
        <i class="fa fa-exclamation-circle abp-confirm-icon"></i>
        <div *ngIf="message.summary" class="abp-confirm-summary">
          {{ message.summary | abpLocalization: message.titleLocalizationParams }}
        </div>
        <div class="abp-confirm-body">
          {{ message.detail | abpLocalization: message.messageLocalizationParams }}
        </div>

        <div class="abp-confirm-footer justify-content-center">
          <button
            *ngIf="!message.hideCancelBtn"
            id="cancel"
            type="button"
            class="btn btn-sm btn-primary"
            (click)="close(reject)"
          >
            {{ message.cancelCopy || 'AbpIdentity::Cancel' | abpLocalization }}
          </button>
          <button
            *ngIf="!message.hideYesBtn"
            id="confirm"
            type="button"
            class="btn btn-sm btn-primary"
            (click)="close(confirm)"
            autofocus
          >
            <span>{{ message.yesCopy || 'AbpIdentity::Yes' | abpLocalization }}</span>
          </button>
        </div>
      </ng-template>
    </p-toast>
  `,
      },
    ],
  },
];
/** @nocollapse */
ConfirmationComponent.ctorParameters = () => [{ type: ConfirmationService }];
if (false) {
  /** @type {?} */
  ConfirmationComponent.prototype.confirm;
  /** @type {?} */
  ConfirmationComponent.prototype.reject;
  /** @type {?} */
  ConfirmationComponent.prototype.dismiss;
  /**
   * @type {?}
   * @private
   */
  ConfirmationComponent.prototype.confirmationService;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ErrorComponent {
  constructor() {
    this.title = 'Oops!';
    this.details = 'Sorry, an error has occured.';
  }
  /**
   * @return {?}
   */
  destroy() {
    this.renderer.removeChild(this.host, this.elementRef.nativeElement);
  }
}
ErrorComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-error',
        template:
          '<div class="error">\n  <button id="abp-close-button mr-3" type="button" class="close" (click)="destroy()">\n    <span aria-hidden="true">&times;</span>\n  </button>\n  <div class="row centered">\n    <div class="col-md-12">\n      <div class="error-template">\n        <h1>\n          {{ title | abpLocalization }}\n        </h1>\n        <div class="error-details">\n          {{ details | abpLocalization }}\n        </div>\n        <div class="error-actions">\n          <a (click)="destroy()" routerLink="/" class="btn btn-primary btn-md mt-2"\n            ><span class="glyphicon glyphicon-home"></span>\n            {{ { key: \'::Menu:Home\', defaultValue: \'Home\' } | abpLocalization }}\n          </a>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n',
        styles: [
          '.error{position:fixed;top:0;background-color:#fff;width:100vw;height:100vh;z-index:999999}.centered{position:fixed;top:50%;left:50%;transform:translate(-50%,-50%)}',
        ],
      },
    ],
  },
];
if (false) {
  /** @type {?} */
  ErrorComponent.prototype.title;
  /** @type {?} */
  ErrorComponent.prototype.details;
  /** @type {?} */
  ErrorComponent.prototype.renderer;
  /** @type {?} */
  ErrorComponent.prototype.elementRef;
  /** @type {?} */
  ErrorComponent.prototype.host;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class LoaderBarComponent {
  /**
   * @param {?} actions
   * @param {?} router
   * @param {?} cdRef
   */
  constructor(actions, router, cdRef) {
    this.actions = actions;
    this.router = router;
    this.cdRef = cdRef;
    this.containerClass = 'abp-loader-bar';
    this.color = '#77b6ff';
    this.isLoading = false;
    this.progressLevel = 0;
    this.filter
    /**
     * @param {?} action
     * @return {?}
     */ = action => action.payload.url.indexOf('openid-configuration') < 0;
    actions
      .pipe(
        ofActionSuccessful(StartLoader, StopLoader),
        filter(this.filter),
        takeUntilDestroy(this),
      )
      .subscribe(
        /**
         * @param {?} action
         * @return {?}
         */
        action => {
          if (action instanceof StartLoader) this.startLoading();
          else this.stopLoading();
        },
      );
    router.events
      .pipe(
        filter(
          /**
           * @param {?} event
           * @return {?}
           */
          event =>
            event instanceof NavigationStart || event instanceof NavigationEnd || event instanceof NavigationError,
        ),
        takeUntilDestroy(this),
      )
      .subscribe(
        /**
         * @param {?} event
         * @return {?}
         */
        event => {
          if (event instanceof NavigationStart) this.startLoading();
          else this.stopLoading();
        },
      );
  }
  /**
   * @return {?}
   */
  get boxShadow() {
    return `0 0 10px rgba(${this.color}, 0.5)`;
  }
  /**
   * @return {?}
   */
  ngOnDestroy() {
    this.interval.unsubscribe();
  }
  /**
   * @return {?}
   */
  startLoading() {
    if (this.isLoading || this.progressLevel !== 0) return;
    this.isLoading = true;
    this.interval = interval(350).subscribe(
      /**
       * @return {?}
       */
      () => {
        if (this.progressLevel < 75) {
          this.progressLevel += Math.random() * 10;
        } else if (this.progressLevel < 90) {
          this.progressLevel += 0.4;
        } else if (this.progressLevel < 100) {
          this.progressLevel += 0.1;
        } else {
          this.interval.unsubscribe();
        }
        this.cdRef.detectChanges();
      },
    );
  }
  /**
   * @return {?}
   */
  stopLoading() {
    this.interval.unsubscribe();
    this.progressLevel = 100;
    this.isLoading = false;
    if (this.timer && !this.timer.closed) return;
    this.timer = timer(820).subscribe(
      /**
       * @return {?}
       */
      () => {
        this.progressLevel = 0;
        this.cdRef.detectChanges();
      },
    );
  }
}
LoaderBarComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-loader-bar',
        template: `
    <div id="abp-loader-bar" [ngClass]="containerClass" [class.is-loading]="isLoading">
      <div
        class="abp-progress"
        [style.width.vw]="progressLevel"
        [ngStyle]="{
          'background-color': color,
          'box-shadow': boxShadow
        }"
      ></div>
    </div>
  `,
        styles: [
          '.abp-loader-bar{left:0;opacity:0;position:fixed;top:0;transition:opacity .4s linear .4s;z-index:99999}.abp-loader-bar.is-loading{opacity:1;transition:none}.abp-loader-bar .abp-progress{height:3px;left:0;position:fixed;top:0;transition:width .4s}',
        ],
      },
    ],
  },
];
/** @nocollapse */
LoaderBarComponent.ctorParameters = () => [{ type: Actions }, { type: Router }, { type: ChangeDetectorRef }];
LoaderBarComponent.propDecorators = {
  containerClass: [{ type: Input }],
  color: [{ type: Input }],
  isLoading: [{ type: Input }],
  filter: [{ type: Input }],
};
if (false) {
  /** @type {?} */
  LoaderBarComponent.prototype.containerClass;
  /** @type {?} */
  LoaderBarComponent.prototype.color;
  /** @type {?} */
  LoaderBarComponent.prototype.isLoading;
  /** @type {?} */
  LoaderBarComponent.prototype.progressLevel;
  /** @type {?} */
  LoaderBarComponent.prototype.interval;
  /** @type {?} */
  LoaderBarComponent.prototype.timer;
  /** @type {?} */
  LoaderBarComponent.prototype.filter;
  /**
   * @type {?}
   * @private
   */
  LoaderBarComponent.prototype.actions;
  /**
   * @type {?}
   * @private
   */
  LoaderBarComponent.prototype.router;
  /**
   * @type {?}
   * @private
   */
  LoaderBarComponent.prototype.cdRef;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const fadeIn = animation([style({ opacity: '0' }), animate('{{ time}} {{ easing }}', style({ opacity: '1' }))], {
  params: { time: '350ms', easing: 'ease' },
});
/** @type {?} */
const fadeOut = animation([style({ opacity: '1' }), animate('{{ time}} {{ easing }}', style({ opacity: '0' }))], {
  params: { time: '350ms', easing: 'ease' },
});
/** @type {?} */
const fadeInDown = animation(
  [
    style({ opacity: '0', transform: '{{ transform }} translateY(-20px)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateY(0)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeInUp = animation(
  [
    style({ opacity: '0', transform: '{{ transform }} translateY(20px)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateY(0)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeInLeft = animation(
  [
    style({ opacity: '0', transform: '{{ transform }} translateX(20px)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateX(0)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeInRight = animation(
  [
    style({ opacity: '0', transform: '{{ transform }} translateX(-20px)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '1', transform: '{{ transform }} translateX(0)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeOutDown = animation(
  [
    style({ opacity: '1', transform: '{{ transform }} translateY(0)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateY(20px)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeOutUp = animation(
  [
    style({ opacity: '1', transform: '{{ transform }} translateY(0)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateY(-20px)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeOutLeft = animation(
  [
    style({ opacity: '1', transform: '{{ transform }} translateX(0)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateX(20px)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);
/** @type {?} */
const fadeOutRight = animation(
  [
    style({ opacity: '1', transform: '{{ transform }} translateX(0)' }),
    animate('{{ time }} {{ easing }}', style({ opacity: '0', transform: '{{ transform }} translateX(-20px)' })),
  ],
  { params: { time: '350ms', easing: 'ease', transform: '' } },
);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const fadeAnimation = trigger('fade', [
  transition(':enter', useAnimation(fadeIn)),
  transition(':leave', useAnimation(fadeOut)),
]);
/** @type {?} */
const dialogAnimation = trigger('dialog', [
  transition(':enter', useAnimation(fadeInDown)),
  transition(':leave', useAnimation(fadeOut)),
]);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ModalComponent {
  /**
   * @param {?} renderer
   * @param {?} confirmationService
   */
  constructor(renderer, confirmationService) {
    this.renderer = renderer;
    this.confirmationService = confirmationService;
    this.centered = false;
    this.modalClass = '';
    this.size = 'lg';
    this.visibleChange = new EventEmitter();
    this.init = new EventEmitter();
    this.appear = new EventEmitter();
    this.disappear = new EventEmitter();
    this._visible = false;
    this._busy = false;
    this.isModalOpen = false;
    this.isConfirmationOpen = false;
    this.destroy$ = new Subject();
  }
  /**
   * @return {?}
   */
  get visible() {
    return this._visible;
  }
  /**
   * @param {?} value
   * @return {?}
   */
  set visible(value) {
    if (typeof value !== 'boolean') return;
    this.isModalOpen = value;
    this._visible = value;
    this.visibleChange.emit(value);
    if (value) {
      setTimeout(
        /**
         * @return {?}
         */
        () => this.listen(),
        0,
      );
      this.renderer.addClass(document.body, 'modal-open');
      this.appear.emit();
    } else {
      this.renderer.removeClass(document.body, 'modal-open');
      this.disappear.emit();
    }
  }
  /**
   * @return {?}
   */
  get busy() {
    return this._busy;
  }
  /**
   * @param {?} value
   * @return {?}
   */
  set busy(value) {
    if (this.abpSubmit && this.abpSubmit instanceof ButtonComponent) {
      this.abpSubmit.loading = value;
    }
    this._busy = value;
  }
  /**
   * @return {?}
   */
  ngOnDestroy() {
    this.destroy$.next();
  }
  /**
   * @return {?}
   */
  close() {
    if (this.busy) return;
    /** @type {?} */
    const nodes = getFlatNodes(
      /** @type {?} */ (this.modalContent.nativeElement.querySelector('#abp-modal-body')).childNodes,
    );
    if (hasNgDirty(nodes)) {
      if (this.isConfirmationOpen) return;
      this.isConfirmationOpen = true;
      this.confirmationService
        .warn('AbpAccount::AreYouSureYouWantToCancelEditingWarningMessage', 'AbpAccount::AreYouSure')
        .subscribe(
          /**
           * @param {?} status
           * @return {?}
           */
          status => {
            this.isConfirmationOpen = false;
            if (status === 'confirm' /* confirm */) {
              this.visible = false;
            }
          },
        );
    } else {
      this.visible = false;
    }
  }
  /**
   * @return {?}
   */
  listen() {
    fromEvent(document, 'keyup')
      .pipe(
        takeUntil(this.destroy$),
        debounceTime(150),
        filter(
          /**
           * @param {?} key
           * @return {?}
           */
          key => key && key.code === 'Escape',
        ),
      )
      .subscribe(
        /**
         * @param {?} _
         * @return {?}
         */
        _ => {
          this.close();
        },
      );
    setTimeout(
      /**
       * @return {?}
       */
      () => {
        if (!this.abpClose) return;
        fromEvent(this.abpClose.nativeElement, 'click')
          .pipe(
            takeUntil(this.destroy$),
            filter(
              /**
               * @return {?}
               */
              () => !!this.modalContent,
            ),
          )
          .subscribe(
            /**
             * @return {?}
             */
            () => this.close(),
          );
      },
      0,
    );
    this.init.emit();
  }
}
ModalComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-modal',
        template:
          '<ng-container *ngIf="visible">\n  <div class="modal show {{ modalClass }}" tabindex="-1" role="dialog">\n    <div class="modal-backdrop" [@fade]="isModalOpen" (click)="close()"></div>\n    <div\n      id="abp-modal-dialog"\n      class="modal-dialog modal-{{ size }}"\n      role="document"\n      [@dialog]="isModalOpen"\n      #abpModalContent\n    >\n      <div id="abp-modal-content" class="modal-content">\n        <div id="abp-modal-header" class="modal-header">\n          <ng-container *ngTemplateOutlet="abpHeader"></ng-container>\n          \u200B\n          <button id="abp-modal-close-button" type="button" class="close" aria-label="Close" (click)="close()">\n            <span aria-hidden="true">&times;</span>\n          </button>\n        </div>\n        <div id="abp-modal-body" class="modal-body">\n          <ng-container *ngTemplateOutlet="abpBody"></ng-container>\n        </div>\n        <div id="abp-modal-footer" class="modal-footer">\n          <ng-container *ngTemplateOutlet="abpFooter"></ng-container>\n        </div>\n      </div>\n    </div>\n    <ng-content></ng-content>\n  </div>\n</ng-container>\n',
        animations: [fadeAnimation, dialogAnimation],
      },
    ],
  },
];
/** @nocollapse */
ModalComponent.ctorParameters = () => [{ type: Renderer2 }, { type: ConfirmationService }];
ModalComponent.propDecorators = {
  visible: [{ type: Input }],
  busy: [{ type: Input }],
  centered: [{ type: Input }],
  modalClass: [{ type: Input }],
  size: [{ type: Input }],
  abpSubmit: [{ type: ContentChild, args: [ButtonComponent, { static: false, read: ButtonComponent }] }],
  abpHeader: [{ type: ContentChild, args: ['abpHeader', { static: false }] }],
  abpBody: [{ type: ContentChild, args: ['abpBody', { static: false }] }],
  abpFooter: [{ type: ContentChild, args: ['abpFooter', { static: false }] }],
  abpClose: [{ type: ContentChild, args: ['abpClose', { static: false, read: ElementRef }] }],
  modalContent: [{ type: ViewChild, args: ['abpModalContent', { static: false }] }],
  abpButtons: [{ type: ViewChildren, args: ['abp-button'] }],
  visibleChange: [{ type: Output }],
  init: [{ type: Output }],
  appear: [{ type: Output }],
  disappear: [{ type: Output }],
};
if (false) {
  /** @type {?} */
  ModalComponent.prototype.centered;
  /** @type {?} */
  ModalComponent.prototype.modalClass;
  /** @type {?} */
  ModalComponent.prototype.size;
  /** @type {?} */
  ModalComponent.prototype.abpSubmit;
  /** @type {?} */
  ModalComponent.prototype.abpHeader;
  /** @type {?} */
  ModalComponent.prototype.abpBody;
  /** @type {?} */
  ModalComponent.prototype.abpFooter;
  /** @type {?} */
  ModalComponent.prototype.abpClose;
  /** @type {?} */
  ModalComponent.prototype.modalContent;
  /** @type {?} */
  ModalComponent.prototype.abpButtons;
  /** @type {?} */
  ModalComponent.prototype.visibleChange;
  /** @type {?} */
  ModalComponent.prototype.init;
  /** @type {?} */
  ModalComponent.prototype.appear;
  /** @type {?} */
  ModalComponent.prototype.disappear;
  /** @type {?} */
  ModalComponent.prototype._visible;
  /** @type {?} */
  ModalComponent.prototype._busy;
  /** @type {?} */
  ModalComponent.prototype.isModalOpen;
  /** @type {?} */
  ModalComponent.prototype.isConfirmationOpen;
  /** @type {?} */
  ModalComponent.prototype.destroy$;
  /**
   * @type {?}
   * @private
   */
  ModalComponent.prototype.renderer;
  /**
   * @type {?}
   * @private
   */
  ModalComponent.prototype.confirmationService;
}
/**
 * @param {?} nodes
 * @return {?}
 */
function getFlatNodes(nodes) {
  return Array.from(nodes).reduce(
    /**
     * @param {?} acc
     * @param {?} val
     * @return {?}
     */
    (acc, val) => [...acc, ...(val.childNodes && val.childNodes.length ? getFlatNodes(val.childNodes) : [val])],
    [],
  );
}
/**
 * @param {?} nodes
 * @return {?}
 */
function hasNgDirty(nodes) {
  return (
    nodes.findIndex(
      /**
       * @param {?} node
       * @return {?}
       */
      node => (node.className || '').indexOf('ng-dirty') > -1,
    ) > -1
  );
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
const { maxLength, required: required$1, email } = Validators;
class ProfileComponent {
  /**
   * @param {?} fb
   * @param {?} store
   */
  constructor(fb, store) {
    this.fb = fb;
    this.store = store;
    this.visibleChange = new EventEmitter();
    this.modalBusy = false;
  }
  /**
   * @return {?}
   */
  get visible() {
    return this._visible;
  }
  /**
   * @param {?} value
   * @return {?}
   */
  set visible(value) {
    this._visible = value;
    this.visibleChange.emit(value);
  }
  /**
   * @return {?}
   */
  buildForm() {
    this.store
      .dispatch(new GetProfile())
      .pipe(
        withLatestFrom(this.profile$),
        take(1),
      )
      .subscribe(
        /**
         * @param {?} __0
         * @return {?}
         */
        ([, profile]) => {
          this.form = this.fb.group({
            userName: [profile.userName, [required$1, maxLength(256)]],
            email: [profile.email, [required$1, email, maxLength(256)]],
            name: [profile.name || '', [maxLength(64)]],
            surname: [profile.surname || '', [maxLength(64)]],
            phoneNumber: [profile.phoneNumber || '', [maxLength(16)]],
          });
        },
      );
  }
  /**
   * @return {?}
   */
  submit() {
    if (this.form.invalid) return;
    this.modalBusy = true;
    this.store.dispatch(new UpdateProfile(this.form.value)).subscribe(
      /**
       * @return {?}
       */
      () => {
        this.modalBusy = false;
        this.visible = false;
        this.form.reset();
      },
    );
  }
  /**
   * @return {?}
   */
  openModal() {
    this.buildForm();
    this.visible = true;
  }
  /**
   * @param {?} __0
   * @return {?}
   */
  ngOnChanges({ visible }) {
    if (!visible) return;
    if (visible.currentValue) {
      this.openModal();
    } else if (visible.currentValue === false && this.visible) {
      this.visible = false;
    }
  }
}
ProfileComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-profile',
        template:
          '<abp-modal [(visible)]="visible" [busy]="modalBusy">\n  <ng-template #abpHeader>\n    <h4>{{ \'AbpIdentity::PersonalInfo\' | abpLocalization }}</h4>\n  </ng-template>\n  <ng-template #abpBody>\n    <form novalidate *ngIf="form" [formGroup]="form" (ngSubmit)="submit()">\n      <div class="form-group">\n        <label for="username">{{ \'AbpIdentity::DisplayName:UserName\' | abpLocalization }}</label\n        ><span> * </span><input type="text" id="username" class="form-control" formControlName="userName" autofocus />\n      </div>\n      <div class="row">\n        <div class="col col-md-6">\n          <div class="form-group">\n            <label for="name">{{ \'AbpIdentity::DisplayName:Name\' | abpLocalization }}</label\n            ><input type="text" id="name" class="form-control" formControlName="name" />\n          </div>\n        </div>\n        <div class="col col-md-6">\n          <div class="form-group">\n            <label for="surname">{{ \'AbpIdentity::DisplayName:Surname\' | abpLocalization }}</label\n            ><input type="text" id="surname" class="form-control" formControlName="surname" />\n          </div>\n        </div>\n      </div>\n      <div class="form-group">\n        <label for="email-address">{{ \'AbpIdentity::DisplayName:Email\' | abpLocalization }}</label\n        ><span> * </span><input type="text" id="email-address" class="form-control" formControlName="email" />\n      </div>\n      <div class="form-group">\n        <label for="phone-number">{{ \'AbpIdentity::DisplayName:PhoneNumber\' | abpLocalization }}</label\n        ><input type="text" id="phone-number" class="form-control" formControlName="phoneNumber" />\n      </div>\n    </form>\n  </ng-template>\n  <ng-template #abpFooter>\n    <button #abpClose type="button" class="btn btn-secondary color-white">\n      {{ \'AbpIdentity::Cancel\' | abpLocalization }}\n    </button>\n    <abp-button iconClass="fa fa-check" buttonClass="btn btn-primary color-white" (click)="submit()">{{ \'AbpIdentity::Save\' | abpLocalization }}</abp-button>\n  </ng-template>\n</abp-modal>\n',
      },
    ],
  },
];
/** @nocollapse */
ProfileComponent.ctorParameters = () => [{ type: FormBuilder }, { type: Store }];
ProfileComponent.propDecorators = {
  visible: [{ type: Input }],
  visibleChange: [{ type: Output }],
};
__decorate(
  [Select(ProfileState.getProfile), __metadata('design:type', Observable)],
  ProfileComponent.prototype,
  'profile$',
  void 0,
);
if (false) {
  /**
   * @type {?}
   * @protected
   */
  ProfileComponent.prototype._visible;
  /** @type {?} */
  ProfileComponent.prototype.visibleChange;
  /** @type {?} */
  ProfileComponent.prototype.profile$;
  /** @type {?} */
  ProfileComponent.prototype.form;
  /** @type {?} */
  ProfileComponent.prototype.modalBusy;
  /**
   * @type {?}
   * @private
   */
  ProfileComponent.prototype.fb;
  /**
   * @type {?}
   * @private
   */
  ProfileComponent.prototype.store;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class ToastComponent {}
ToastComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-toast',
        // tslint:disable-next-line: component-max-inline-declarations
        template: `
    <p-toast position="bottom-right" key="abpToast" styleClass="abp-toast" [baseZIndex]="1000">
      <ng-template let-message pTemplate="message">
        <span
          class="ui-toast-icon pi"
          [ngClass]="{
            'pi-info-circle': message.severity == 'info',
            'pi-exclamation-triangle': message.severity == 'warn',
            'pi-times': message.severity == 'error',
            'pi-check': message.severity == 'success'
          }"
        ></span>
        <div class="ui-toast-message-text-content">
          <div class="ui-toast-summary">{{ message.summary | abpLocalization: message.titleLocalizationParams }}</div>
          <div class="ui-toast-detail">{{ message.detail | abpLocalization: message.messageLocalizationParams }}</div>
        </div>
      </ng-template>
    </p-toast>
  `,
      },
    ],
  },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class SortOrderIconComponent {
  constructor() {
    this.selectedKeyChange = new EventEmitter();
    this.orderChange = new EventEmitter();
  }
  /**
   * @param {?} value
   * @return {?}
   */
  set selectedKey(value) {
    this._selectedKey = value;
    this.selectedKeyChange.emit(value);
  }
  /**
   * @return {?}
   */
  get selectedKey() {
    return this._selectedKey;
  }
  /**
   * @param {?} value
   * @return {?}
   */
  set order(value) {
    this._order = value;
    this.orderChange.emit(value);
  }
  /**
   * @return {?}
   */
  get order() {
    return this._order;
  }
  /**
   * @return {?}
   */
  get icon() {
    if (!this.selectedKey) return 'fa-sort';
    if (this.selectedKey === this.key) return `fa-sort-${this.order}`;
    else return '';
  }
  /**
   * @param {?} key
   * @return {?}
   */
  sort(key) {
    this.selectedKey = key;
    switch (this.order) {
      case '':
        this.order = 'asc';
        break;
      case 'asc':
        this.order = 'desc';
        this.orderChange.emit('desc');
        break;
      case 'desc':
        this.order = '';
        this.selectedKey = '';
        break;
    }
  }
}
SortOrderIconComponent.decorators = [
  {
    type: Component,
    args: [
      {
        selector: 'abp-sort-order-icon',
        template: '<span class="float-right {{ iconClass }}">\n  <i class="fa {{ icon }}"></i>\n</span>\n',
      },
    ],
  },
];
SortOrderIconComponent.propDecorators = {
  selectedKey: [{ type: Input }],
  selectedKeyChange: [{ type: Output }],
  key: [{ type: Input }],
  order: [{ type: Input }],
  orderChange: [{ type: Output }],
  iconClass: [{ type: Input }],
};
if (false) {
  /**
   * @type {?}
   * @private
   */
  SortOrderIconComponent.prototype._order;
  /**
   * @type {?}
   * @private
   */
  SortOrderIconComponent.prototype._selectedKey;
  /** @type {?} */
  SortOrderIconComponent.prototype.selectedKeyChange;
  /** @type {?} */
  SortOrderIconComponent.prototype.key;
  /** @type {?} */
  SortOrderIconComponent.prototype.orderChange;
  /** @type {?} */
  SortOrderIconComponent.prototype.iconClass;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var styles = `
.is-invalid .form-control {
  border-color: #dc3545;
  border-style: solid !important;
}

.is-invalid .invalid-feedback,
.is-invalid + * .invalid-feedback {
  display: block;
}

.data-tables-filter {
  text-align: right;
}

.pointer {
  cursor: pointer;
}

.navbar .dropdown-submenu a::after {
  transform: rotate(-90deg);
  position: absolute;
  right: 16px;
  top: 18px;
}

.navbar .dropdown-menu {
  min-width: 215px;
}

.ui-table-scrollable-body::-webkit-scrollbar {
  height: 5px !important;
}

.ui-table-scrollable-body::-webkit-scrollbar-track {
  background: #ddd;
}

.ui-table-scrollable-body::-webkit-scrollbar-thumb {
  background: #8a8686;
}

.modal.show {
  display: block !important;
}

.modal-backdrop {
  position: absolute !important;
  top: 0 !important;
  left: 0 !important;
  width: 100% !important;
  height: 100% !important;
  background-color: rgba(0, 0, 0, 0.6) !important;
  z-index: 1040 !important;
}

.modal-dialog {
  z-index: 1050 !important;
}

.abp-ellipsis-inline {
  display: inline-block;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}

.abp-ellipsis {
  overflow: hidden !important;
  text-overflow: ellipsis;
  white-space: nowrap;
}

.abp-toast .ui-toast-message {
  box-sizing: border-box !important;
  border: 2px solid transparent !important;
  border-radius: 4px !important;
  background-color: #f4f4f7 !important;
  color: #1b1d29 !important;
}

.abp-toast .ui-toast-message-content {
  padding: 10px !important;
}

.abp-toast .ui-toast-message-content .ui-toast-icon {
  top: 0 !important;
  left: 0 !important;
  padding: 10px !important;
}

.abp-toast .ui-toast-summary {
  margin: 0 !important;
  font-weight: 700 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-error {
  border-color: #ba1659 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-error .ui-toast-message-content .ui-toast-icon {
  color: #ba1659 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-warning {
  border-color: #ed5d98 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-warning .ui-toast-message-content .ui-toast-icon {
  color: #ed5d98 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-success {
  border-color: #1c9174 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-success .ui-toast-message-content .ui-toast-icon {
  color: #1c9174 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-info {
  border-color: #fccb31 !important;
}

.abp-toast .ui-toast-message.ui-toast-message-info .ui-toast-message-content .ui-toast-icon {
  color: #fccb31 !important;
}

.abp-confirm .ui-toast-message {
  box-sizing: border-box !important;
  padding: 0px !important;
  border:0 none !important;
  border-radius: 4px !important;
  background-color: #fff !important;
  color: rgba(0, 0, 0, .65) !important;
  font-family: "Poppins", sans-serif;
  text-align: center !important;
}

.abp-confirm .ui-toast-message-content {
  padding: 0px !important;
}

.abp-confirm .abp-confirm-icon {
  margin: 32px 50px 5px !important;
  color: #f8bb86 !important;
  font-size: 52px !important;
}

.abp-confirm .ui-toast-close-icon {
  display: none !important;
}

.abp-confirm .abp-confirm-summary {
  display: block !important;
  margin-bottom: 13px !important;
  padding: 13px 16px 0px !important;
  font-weight: 600 !important;
  font-size: 18px !important;
}

.abp-confirm .abp-confirm-body {
  display: inline-block !important;
  padding: 0px 10px !important;
}

.abp-confirm .abp-confirm-footer {
  display: block !important;
  margin-top: 30px !important;
  padding: 16px !important;
  background-color: #f4f4f7 !important;
  text-align: right !important;
}

.abp-confirm .abp-confirm-footer .btn {
  margin-left: 10px !important;
}

.ui-widget-overlay {
  z-index: 1000;
}

.color-white {
  color: #FFF !important;
}

/* <animations */

.fade-in-top {
  animation: fadeInTop 0.2s ease-in-out;
}

.fade-out-top {
  animation: fadeOutTop 0.2s ease-in-out;
}

.abp-collapsed {
  -moz-transition: margin ease-in-out 0.5s;
  -ms-transition: margin ease-in-out 0.5s;
  -o-transition: margin ease-in-out 0.5s;
  -webkit-transition: margin ease-in-out 0.5s;
  transition: margin ease-in-out 0.5s;
  margin-top: -100%;
}

.abp-collapsed.expanded {
  margin-top: 0 !important;
}

@keyframes fadeInTop {
  from {
    transform: translateY(-5px);
    opacity: 0;
  }

  to {
    transform: translateY(0px);
    opacity: 1;
  }
}

@keyframes fadeOutTop {
  to {
    transform: translateY(-5px);
    opacity: 0;
  }
}

/* </animations */

`;

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const DEFAULT_ERROR_MESSAGES = {
  defaultError: {
    title: 'An error has occurred!',
    details: 'Error detail not sent by server.',
  },
  defaultError401: {
    title: 'You are not authenticated!',
    details: 'You should be authenticated (sign in) in order to perform this operation.',
  },
  defaultError403: {
    title: 'You are not authorized!',
    details: 'You are not allowed to perform this operation.',
  },
  defaultError404: {
    title: 'Resource not found!',
    details: 'The resource requested could not found on the server.',
  },
  defaultError500: {
    title: '500',
    details: { key: 'AbpAccount::InternalServerErrorMessage', defaultValue: 'Error detail not sent by server.' },
  },
  defaultErrorUnknown: {
    title: 'Unknown Error',
    details: { key: 'AbpAccount::InternalServerErrorMessage', defaultValue: 'Error detail not sent by server.' },
  },
};
class ErrorHandler {
  /**
   * @param {?} actions
   * @param {?} router
   * @param {?} ngZone
   * @param {?} store
   * @param {?} confirmationService
   * @param {?} appRef
   * @param {?} cfRes
   * @param {?} rendererFactory
   * @param {?} injector
   */
  constructor(actions, router, ngZone, store, confirmationService, appRef, cfRes, rendererFactory, injector) {
    this.actions = actions;
    this.router = router;
    this.ngZone = ngZone;
    this.store = store;
    this.confirmationService = confirmationService;
    this.appRef = appRef;
    this.cfRes = cfRes;
    this.rendererFactory = rendererFactory;
    this.injector = injector;
    actions.pipe(ofActionSuccessful(RestOccurError)).subscribe(
      /**
       * @param {?} res
       * @return {?}
       */
      res => {
        const { payload: err = /** @type {?} */ ({}) } = res;
        /** @type {?} */
        const body = snq(
          /**
           * @return {?}
           */
          (() => /** @type {?} */ (err).error.error),
          DEFAULT_ERROR_MESSAGES.defaultError.title,
        );
        if (err instanceof HttpErrorResponse && err.headers.get('_AbpErrorFormat')) {
          /** @type {?} */
          const confirmation$ = this.showError(null, null, body);
          if (err.status === 401) {
            confirmation$.subscribe(
              /**
               * @return {?}
               */
              () => {
                this.navigateToLogin();
              },
            );
          }
        } else {
          switch (/** @type {?} */ (err).status) {
            case 401:
              this.showError(
                DEFAULT_ERROR_MESSAGES.defaultError401.details,
                DEFAULT_ERROR_MESSAGES.defaultError401.title,
              ).subscribe(
                /**
                 * @return {?}
                 */
                () => this.navigateToLogin(),
              );
              break;
            case 403:
              this.createErrorComponent({
                title: DEFAULT_ERROR_MESSAGES.defaultError403.title,
                details: DEFAULT_ERROR_MESSAGES.defaultError403.details,
              });
              break;
            case 404:
              this.showError(
                DEFAULT_ERROR_MESSAGES.defaultError404.details,
                DEFAULT_ERROR_MESSAGES.defaultError404.title,
              );
              break;
            case 500:
              this.createErrorComponent({
                title: DEFAULT_ERROR_MESSAGES.defaultError500.title,
                details: DEFAULT_ERROR_MESSAGES.defaultError500.details,
              });
              break;
            case 0:
              if (/** @type {?} */ (err).statusText === 'Unknown Error') {
                this.createErrorComponent({
                  title: DEFAULT_ERROR_MESSAGES.defaultErrorUnknown.title,
                  details: DEFAULT_ERROR_MESSAGES.defaultErrorUnknown.details,
                });
              }
              break;
            default:
              this.showError(DEFAULT_ERROR_MESSAGES.defaultError.details, DEFAULT_ERROR_MESSAGES.defaultError.title);
              break;
          }
        }
      },
    );
  }
  /**
   * @private
   * @param {?=} message
   * @param {?=} title
   * @param {?=} body
   * @return {?}
   */
  showError(message, title, body) {
    if (body) {
      if (body.details) {
        message = body.details;
        title = body.message;
      } else {
        message = body.message || DEFAULT_ERROR_MESSAGES.defaultError.title;
      }
    }
    return this.confirmationService.error(message, title, {
      hideCancelBtn: true,
      yesCopy: 'OK',
    });
  }
  /**
   * @private
   * @return {?}
   */
  navigateToLogin() {
    this.ngZone.run(
      /**
       * @return {?}
       */
      () => {
        this.router.navigate(['/account/login'], {
          state: { redirectUrl: this.router.url },
        });
      },
    );
  }
  /**
   * @param {?} instance
   * @return {?}
   */
  createErrorComponent(instance) {
    /** @type {?} */
    const renderer = this.rendererFactory.createRenderer(null, null);
    /** @type {?} */
    const host = renderer.selectRootElement(document.body, true);
    /** @type {?} */
    const componentRef = this.cfRes.resolveComponentFactory(ErrorComponent).create(this.injector);
    for (const key in componentRef.instance) {
      if (componentRef.instance.hasOwnProperty(key)) {
        componentRef.instance[key] = instance[key];
      }
    }
    this.appRef.attachView(componentRef.hostView);
    renderer.appendChild(host, /** @type {?} */ (componentRef.hostView).rootNodes[0]);
    componentRef.instance.renderer = renderer;
    componentRef.instance.elementRef = componentRef.location;
    componentRef.instance.host = host;
  }
}
ErrorHandler.decorators = [{ type: Injectable, args: [{ providedIn: 'root' }] }];
/** @nocollapse */
ErrorHandler.ctorParameters = () => [
  { type: Actions },
  { type: Router },
  { type: NgZone },
  { type: Store },
  { type: ConfirmationService },
  { type: ApplicationRef },
  { type: ComponentFactoryResolver },
  { type: RendererFactory2 },
  { type: Injector },
];
/** @nocollapse */ ErrorHandler.ngInjectableDef = ɵɵdefineInjectable({
  factory: function ErrorHandler_Factory() {
    return new ErrorHandler(
      ɵɵinject(Actions),
      ɵɵinject(Router),
      ɵɵinject(NgZone),
      ɵɵinject(Store),
      ɵɵinject(ConfirmationService),
      ɵɵinject(ApplicationRef),
      ɵɵinject(ComponentFactoryResolver),
      ɵɵinject(RendererFactory2),
      ɵɵinject(INJECTOR),
    );
  },
  token: ErrorHandler,
  providedIn: 'root',
});
if (false) {
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.actions;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.router;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.ngZone;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.store;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.confirmationService;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.appRef;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.cfRes;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.rendererFactory;
  /**
   * @type {?}
   * @private
   */
  ErrorHandler.prototype.injector;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class TableEmptyMessageComponent {
  constructor() {
    this.colspan = 2;
    this.localizationResource = 'AbpAccount';
    this.localizationProp = 'NoDataAvailableInDatatable';
  }
  /**
   * @return {?}
   */
  get emptyMessage() {
    return this.message || `${this.localizationResource}::${this.localizationProp}`;
  }
}
TableEmptyMessageComponent.decorators = [
  {
    type: Component,
    args: [
      {
        // tslint:disable-next-line: component-selector
        selector: '[abp-table-empty-message]',
        template: `
    <td class="text-center" [attr.colspan]="colspan">
      {{ emptyMessage | abpLocalization }}
    </td>
  `,
      },
    ],
  },
];
TableEmptyMessageComponent.propDecorators = {
  colspan: [{ type: Input }],
  message: [{ type: Input }],
  localizationResource: [{ type: Input }],
  localizationProp: [{ type: Input }],
};
if (false) {
  /** @type {?} */
  TableEmptyMessageComponent.prototype.colspan;
  /** @type {?} */
  TableEmptyMessageComponent.prototype.message;
  /** @type {?} */
  TableEmptyMessageComponent.prototype.localizationResource;
  /** @type {?} */
  TableEmptyMessageComponent.prototype.localizationProp;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} injector
 * @return {?}
 */
function appendScript(injector) {
  /** @type {?} */
  const fn
  /**
   * @return {?}
   */ = (() => {
    import('chart.js').then(
      /**
       * @return {?}
       */
      () => chartJsLoaded$.next(true),
    );
    /** @type {?} */
    const lazyLoadService = injector.get(LazyLoadService);
    return forkJoin(
      lazyLoadService.load(
        null,
        'style',
        styles,
        'head',
        'afterbegin',
      ) /* lazyLoadService.load(null, 'script', scripts) */,
    ).toPromise();
  });
  return fn;
}
class ThemeSharedModule {
  /**
   * @return {?}
   */
  static forRoot() {
    return {
      ngModule: ThemeSharedModule,
      providers: [
        {
          provide: APP_INITIALIZER,
          multi: true,
          deps: [Injector, ErrorHandler],
          useFactory: appendScript,
        },
        { provide: MessageService, useClass: MessageService },
      ],
    };
  }
}
ThemeSharedModule.decorators = [
  {
    type: NgModule,
    args: [
      {
        imports: [CoreModule, ToastModule, NgxValidateCoreModule],
        declarations: [
          BreadcrumbComponent,
          ButtonComponent,
          ChangePasswordComponent,
          ChartComponent,
          ConfirmationComponent,
          ErrorComponent,
          LoaderBarComponent,
          ModalComponent,
          ProfileComponent,
          TableEmptyMessageComponent,
          ToastComponent,
          SortOrderIconComponent,
        ],
        exports: [
          BreadcrumbComponent,
          ButtonComponent,
          ChangePasswordComponent,
          ChartComponent,
          ConfirmationComponent,
          LoaderBarComponent,
          ModalComponent,
          ProfileComponent,
          TableEmptyMessageComponent,
          ToastComponent,
          SortOrderIconComponent,
        ],
        entryComponents: [ErrorComponent],
      },
    ],
  },
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const bounceIn = animation(
  [
    style({ opacity: '0', display: '{{ display }}' }),
    animate(
      '{{ time}} {{ easing }}',
      keyframes([
        style({ opacity: '0', transform: '{{ transform }} scale(0.0)', offset: 0 }),
        style({ opacity: '0', transform: '{{ transform }} scale(0.8)', offset: 0.5 }),
        style({ opacity: '1', transform: '{{ transform }} scale(1.0)', offset: 1 }),
      ]),
    ),
  ],
  {
    params: {
      time: '350ms',
      easing: 'cubic-bezier(.7,.31,.72,1.47)',
      display: 'block',
      transform: 'translate(-50%, -50%)',
    },
  },
);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const collapseY = animation(
  [
    style({ height: '*', overflow: 'hidden', 'box-sizing': 'border-box' }),
    animate('{{ time }} {{ easing }}', style({ height: '0', padding: '0px' })),
  ],
  { params: { time: '350ms', easing: 'ease' } },
);
/** @type {?} */
const collapseYWithMargin = animation(
  [style({ 'margin-top': '0' }), animate('{{ time }} {{ easing }}', style({ 'margin-top': '-100%' }))],
  {
    params: { time: '500ms', easing: 'ease' },
  },
);
/** @type {?} */
const collapseX = animation(
  [
    style({ width: '*', overflow: 'hidden', 'box-sizing': 'border-box' }),
    animate('{{ time }} {{ easing }}', style({ width: '0', padding: '0px' })),
  ],
  { params: { time: '350ms', easing: 'ease' } },
);
/** @type {?} */
const expandY = animation(
  [
    style({ height: '0', overflow: 'hidden', 'box-sizing': 'border-box' }),
    animate('{{ time }} {{ easing }}', style({ height: '*', padding: '*' })),
  ],
  { params: { time: '350ms', easing: 'ease' } },
);
/** @type {?} */
const expandYWithMargin = animation(
  [style({ 'margin-top': '-100%' }), animate('{{ time }} {{ easing }}', style({ 'margin-top': '0' }))],
  {
    params: { time: '500ms', easing: 'ease' },
  },
);
/** @type {?} */
const expandX = animation(
  [
    style({ width: '0', overflow: 'hidden', 'box-sizing': 'border-box' }),
    animate('{{ time }} {{ easing }}', style({ width: '*', padding: '*' })),
  ],
  { params: { time: '350ms', easing: 'ease' } },
);
/** @type {?} */
const collapse = trigger('collapse', [
  state('collapsed', style({ height: '0', overflow: 'hidden' })),
  state('expanded', style({ height: '*', overflow: 'hidden' })),
  transition('expanded => collapsed', useAnimation(collapseY)),
  transition('collapsed => expanded', useAnimation(expandY)),
]);
/** @type {?} */
const collapseWithMargin = trigger('collapseWithMargin', [
  state('collapsed', style({ 'margin-top': '-100%' })),
  state('expanded', style({ 'margin-top': '0' })),
  transition('expanded => collapsed', useAnimation(collapseYWithMargin), {
    params: { time: '400ms', easing: 'linear' },
  }),
  transition('collapsed => expanded', useAnimation(expandYWithMargin)),
]);
/** @type {?} */
const collapseLinearWithMargin = trigger('collapseLinearWithMargin', [
  state('collapsed', style({ 'margin-top': '-100%' })),
  state('expanded', style({ 'margin-top': '0' })),
  transition(
    'expanded => collapsed',
    useAnimation(collapseYWithMargin, { params: { time: '200ms', easing: 'linear' } }),
  ),
  transition('collapsed => expanded', useAnimation(expandYWithMargin, { params: { time: '250ms', easing: 'linear' } })),
]);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const slideFromBottom = trigger('slideFromBottom', [
  transition('* <=> *', [
    style({ 'margin-top': '20px', opacity: '0' }),
    animate('0.2s ease-out', style({ opacity: '1', 'margin-top': '0px' })),
  ]),
]);

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var Confirmation;
(function(Confirmation) {
  /**
   * @record
   */
  function Options() {}
  Confirmation.Options = Options;
  if (false) {
    /** @type {?|undefined} */
    Options.prototype.hideCancelBtn;
    /** @type {?|undefined} */
    Options.prototype.hideYesBtn;
    /** @type {?|undefined} */
    Options.prototype.cancelCopy;
    /** @type {?|undefined} */
    Options.prototype.yesCopy;
  }
})(Confirmation || (Confirmation = {}));

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @record
 */
function SettingTab() {}
if (false) {
  /** @type {?} */
  SettingTab.prototype.component;
  /** @type {?} */
  SettingTab.prototype.name;
  /** @type {?} */
  SettingTab.prototype.order;
  /** @type {?|undefined} */
  SettingTab.prototype.requiredPolicy;
}
/** @type {?} */
const SETTING_TABS = /** @type {?} */ ([]);
/**
 * @param {?} tab
 * @return {?}
 */
function addSettingTab(tab) {
  if (!Array.isArray(tab)) {
    tab = [tab];
  }
  SETTING_TABS.push(...tab);
}
/**
 * @return {?}
 */
function getSettingTabs() {
  return SETTING_TABS;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var Statistics;
(function(Statistics) {
  /**
   * @record
   */
  function Response() {}
  Statistics.Response = Response;
  if (false) {
    /** @type {?} */
    Response.prototype.data;
  }
  /**
   * @record
   */
  function Data() {}
  Statistics.Data = Data;
  /**
   * @record
   */
  function Filter() {}
  Statistics.Filter = Filter;
  if (false) {
    /** @type {?} */
    Filter.prototype.startDate;
    /** @type {?} */
    Filter.prototype.endDate;
  }
})(Statistics || (Statistics = {}));

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var Toaster;
(function(Toaster) {
  /**
   * @record
   */
  function Options() {}
  Toaster.Options = Options;
  if (false) {
    /** @type {?|undefined} */
    Options.prototype.id;
    /** @type {?|undefined} */
    Options.prototype.closable;
    /** @type {?|undefined} */
    Options.prototype.life;
    /** @type {?|undefined} */
    Options.prototype.sticky;
    /** @type {?|undefined} */
    Options.prototype.data;
    /** @type {?|undefined} */
    Options.prototype.messageLocalizationParams;
    /** @type {?|undefined} */
    Options.prototype.titleLocalizationParams;
  }
})(Toaster || (Toaster = {}));

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

export {
  BreadcrumbComponent,
  ButtonComponent,
  ChangePasswordComponent,
  ChartComponent,
  ConfirmationComponent,
  ConfirmationService,
  LoaderBarComponent,
  ModalComponent,
  ProfileComponent,
  SortOrderIconComponent,
  TableEmptyMessageComponent,
  ThemeSharedModule,
  ToastComponent,
  Toaster,
  ToasterService,
  addSettingTab,
  appendScript,
  bounceIn,
  chartJsLoaded$,
  collapse,
  collapseLinearWithMargin,
  collapseWithMargin,
  collapseX,
  collapseY,
  collapseYWithMargin,
  dialogAnimation,
  expandX,
  expandY,
  expandYWithMargin,
  fadeAnimation,
  fadeIn,
  fadeInDown,
  fadeInLeft,
  fadeInRight,
  fadeInUp,
  fadeOut,
  fadeOutDown,
  fadeOutLeft,
  fadeOutRight,
  fadeOutUp,
  getRandomBackgroundColor,
  getSettingTabs,
  slideFromBottom,
  BreadcrumbComponent as ɵa,
  ButtonComponent as ɵb,
  ChangePasswordComponent as ɵc,
  ToasterService as ɵd,
  AbstractToaster as ɵe,
  ChartComponent as ɵf,
  ConfirmationComponent as ɵg,
  ConfirmationService as ɵh,
  ErrorComponent as ɵi,
  LoaderBarComponent as ɵj,
  ModalComponent as ɵk,
  fadeAnimation as ɵl,
  dialogAnimation as ɵm,
  fadeIn as ɵn,
  fadeOut as ɵo,
  fadeInDown as ɵp,
  ProfileComponent as ɵq,
  TableEmptyMessageComponent as ɵr,
  ToastComponent as ɵs,
  SortOrderIconComponent as ɵt,
  ErrorHandler as ɵu,
};
//# sourceMappingURL=abp-ng.theme.shared.js.map