@abp/ng.core 4.4.3 → 5.0.0-beta.3

package/fesm2015/abp-ng.core.js

@@ -1,30 +1,27 @@
 import * as i0 from '@angular/core';
-import { ChangeDetectorRef, Component, Injector, Input, InjectionToken, Injectable, Inject, Optional, SkipSelf, isDevMode, NgZone, Directive, ElementRef, EventEmitter, Output, TemplateRef, ViewContainerRef, IterableDiffers, Self, Renderer2, ComponentFactoryResolver, Pipe, NgModule, LOCALE_ID, APP_INITIALIZER, NgModuleFactory, Compiler, ApplicationRef, inject } from '@angular/core';
-import * as i1 from '@angular/router';
-import { PRIMARY_OUTLET, Router, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ActivatedRoute, RouterModule } from '@angular/router';
-import { registerLocaleData, CommonModule } from '@angular/common';
+import { ChangeDetectorRef, Component, Input, InjectionToken, Injectable, Inject, Optional, SkipSelf, isDevMode, Directive, EventEmitter, Output, Self, Injector, Pipe, NgModule, APP_INITIALIZER, LOCALE_ID, NgModuleFactory, Compiler, ComponentFactoryResolver, ApplicationRef, inject } from '@angular/core';
+import * as i1$1 from '@angular/router';
+import { PRIMARY_OUTLET, NavigationCancel, NavigationEnd, NavigationError, NavigationStart, ActivatedRoute, Router, RouterModule } from '@angular/router';
+import * as i5 from '@angular/common';
+import { registerLocaleData, DOCUMENT, CommonModule } from '@angular/common';
 import { BehaviorSubject, Subject, throwError, from, Subscription, fromEvent, of, timer, pipe, Observable, concat, ReplaySubject } from 'rxjs';
 import { map, distinctUntilChanged, filter, catchError, switchMap, take, mapTo, debounceTime, takeUntil, tap, finalize, retryWhen, delay, shareReplay } from 'rxjs/operators';
-import { __rest, __awaiter, __decorate } from 'tslib';
-import snq from 'snq';
+import { __rest, __awaiter } from 'tslib';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpClient, HttpClientModule, HttpClientXsrfModule, HTTP_INTERCEPTORS } from '@angular/common/http';
 import compare from 'just-compare';
-import * as i2 from '@angular/common/http';
-import { HttpClient, HttpHeaders, HttpClientModule, HttpClientXsrfModule, HTTP_INTERCEPTORS } from '@angular/common/http';
-import * as i4 from '@ngxs/store';
-import { Store, Action, Selector, State, NgxsModule, createSelector } from '@ngxs/store';
-import { FormGroupDirective, FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
-import * as i1$1 from 'angular-oauth2-oidc';
-import { OAuthService, OAuthStorage, OAuthErrorEvent, OAuthInfoEvent, OAuthModule } from 'angular-oauth2-oidc';
+import * as i1$2 from '@angular/forms';
+import { FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
+import * as i1$3 from 'angular-oauth2-oidc';
+import { OAuthStorage, OAuthService, OAuthErrorEvent, OAuthInfoEvent, OAuthModule } from 'angular-oauth2-oidc';
 import clone from 'just-clone';
 
 // Not an abstract class on purpose. Do not change!
-// tslint:disable-next-line: use-component-selector
 class AbstractNgModelComponent {
     constructor(injector) {
         this.injector = injector;
         this.valueFn = value => value;
         this.valueLimitFn = value => false;
-        // tslint:disable-next-line: deprecation
         this.cdRef = injector.get(ChangeDetectorRef);
     }
     set value(value) {
@@ -59,80 +56,22 @@ class AbstractNgModelComponent {
         this.disabled = isDisabled;
     }
 }
-AbstractNgModelComponent.decorators = [
-    { type: Component, args: [{ template: '' },] }
-];
-AbstractNgModelComponent.ctorParameters = () => [
-    { type: Injector }
-];
-AbstractNgModelComponent.propDecorators = {
-    disabled: [{ type: Input }],
-    readonly: [{ type: Input }],
-    valueFn: [{ type: Input }],
-    valueLimitFn: [{ type: Input }],
-    value: [{ type: Input }]
-};
-
-/**
- * @deprecated Use ConfigStateService. To be deleted in v5.0.
- */
-class GetAppConfiguration {
-}
-GetAppConfiguration.type = '[Config] Get App Configuration';
-/**
- * @deprecated Use EnvironmentService instead. To be deleted in v5.0.
- */
-class SetEnvironment {
-    constructor(environment) {
-        this.environment = environment;
-    }
-}
-SetEnvironment.type = '[Config] Set Environment';
-/**
- * @deprecated Use EnvironmentService instead. To be deleted in v5.0.
- */
-class PatchConfigState {
-    constructor(state) {
-        this.state = state;
-    }
-}
-PatchConfigState.type = '[Config] Set State';
-
-class StartLoader {
-    constructor(payload) {
-        this.payload = payload;
-    }
-}
-StartLoader.type = '[Loader] Start';
-class StopLoader {
-    constructor(payload) {
-        this.payload = payload;
-    }
-}
-StopLoader.type = '[Loader] Stop';
-
-class GetProfile {
-}
-GetProfile.type = '[Profile] Get';
-class UpdateProfile {
-    constructor(payload) {
-        this.payload = payload;
-    }
-}
-UpdateProfile.type = '[Profile] Update';
-class ChangePassword {
-    constructor(payload) {
-        this.payload = payload;
-    }
-}
-ChangePassword.type = '[Profile] Change Password';
-
-class RestOccurError {
-    constructor(payload) {
-        this.payload = payload;
-    }
-}
-RestOccurError.type = '[Rest] Error';
+AbstractNgModelComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbstractNgModelComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+AbstractNgModelComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.6", type: AbstractNgModelComponent, selector: "ng-component", inputs: { disabled: "disabled", readonly: "readonly", valueFn: "valueFn", valueLimitFn: "valueLimitFn", value: "value" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbstractNgModelComponent, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], valueFn: [{
+                type: Input
+            }], valueLimitFn: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
 
 const CORE_OPTIONS = new InjectionToken('CORE_OPTIONS');
 function coreOptionsFactory(_a) {
@@ -148,9 +87,10 @@ function getLocaleDirection(locale) {
 }
 function createLocalizer(localization) {
     return (resourceName, key, defaultValue) => {
+        var _a;
         if (resourceName === '_')
             return key;
-        const resource = snq(() => localization.values[resourceName]);
+        const resource = (_a = localization === null || localization === void 0 ? void 0 : localization.values) === null || _a === void 0 ? void 0 : _a[resourceName];
         if (!resource)
             return defaultValue;
         return resource[key] || defaultValue;
@@ -211,7 +151,6 @@ function interpolate(text, params) {
 }
 
 function noop() {
-    // tslint:disable-next-line: only-arrow-functions
     const fn = function () { };
     return fn;
 }
@@ -309,7 +248,6 @@ class InternalStore {
 }
 
 const mapToApiUrl = (key) => (apis) => (apis[key] || apis.default).url || apis.default.url;
-const ɵ0$1 = mapToApiUrl;
 class EnvironmentService {
     constructor() {
         this.store = new InternalStore({});
@@ -333,26 +271,53 @@ class EnvironmentService {
         this.store.set(environment);
     }
 }
-EnvironmentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnvironmentService_Factory() { return new EnvironmentService(); }, token: EnvironmentService, providedIn: "root" });
-EnvironmentService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
+EnvironmentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EnvironmentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class HttpErrorReporterService {
+    constructor() {
+        this._reporter$ = new Subject();
+        this._errors$ = new BehaviorSubject([]);
+        this.reportError = (error) => {
+            this._reporter$.next(error);
+            this._errors$.next([...this.errors, error]);
+        };
+    }
+    get reporter$() {
+        return this._reporter$.asObservable();
+    }
+    get errors$() {
+        return this._errors$.asObservable();
+    }
+    get errors() {
+        return this._errors$.value;
+    }
+}
+HttpErrorReporterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: HttpErrorReporterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+HttpErrorReporterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: HttpErrorReporterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: HttpErrorReporterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 class RestService {
-    constructor(options, http, environment, store) {
+    constructor(options, http, environment, httpErrorReporter) {
         this.options = options;
         this.http = http;
         this.environment = environment;
-        this.store = store;
+        this.httpErrorReporter = httpErrorReporter;
     }
     getApiFromStore(apiName) {
         return this.environment.getApiUrl(apiName);
     }
     handleError(err) {
-        this.store.dispatch(new RestOccurError(err));
+        this.httpErrorReporter.reportError(err);
         return throwError(err);
     }
-    // TODO: Deprecate service or improve interface in v5.0
     request(request, config, api) {
         config = config || {};
         api = api || this.getApiFromStore(config.apiName);
@@ -373,18 +338,17 @@ class RestService {
             .pipe(catchError(err => (skipHandleError ? throwError(err) : this.handleError(err))));
     }
 }
-RestService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RestService_Factory() { return new RestService(i0.ɵɵinject(CORE_OPTIONS), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(EnvironmentService), i0.ɵɵinject(i4.Store)); }, token: RestService, providedIn: "root" });
-RestService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-RestService.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [CORE_OPTIONS,] }] },
-    { type: HttpClient },
-    { type: EnvironmentService },
-    { type: Store }
-];
+RestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RestService, deps: [{ token: CORE_OPTIONS }, { token: i1.HttpClient }, { token: EnvironmentService }, { token: HttpErrorReporterService }], target: i0.ɵɵFactoryTarget.Injectable });
+RestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RestService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CORE_OPTIONS]
+                }] }, { type: i1.HttpClient }, { type: EnvironmentService }, { type: HttpErrorReporterService }]; } });
 
 class AbpApplicationConfigurationService {
     constructor(restService) {
@@ -398,15 +362,14 @@ class AbpApplicationConfigurationService {
         }, { apiName: this.apiName });
     }
 }
-AbpApplicationConfigurationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AbpApplicationConfigurationService_Factory() { return new AbpApplicationConfigurationService(i0.ɵɵinject(RestService)); }, token: AbpApplicationConfigurationService, providedIn: "root" });
-AbpApplicationConfigurationService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AbpApplicationConfigurationService.ctorParameters = () => [
-    { type: RestService }
-];
+AbpApplicationConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpApplicationConfigurationService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbpApplicationConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpApplicationConfigurationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpApplicationConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RestService }]; } });
 
 class ConfigStateService {
     constructor(abpConfigService) {
@@ -421,14 +384,7 @@ class ConfigStateService {
     initUpdateStream() {
         this.updateSubject
             .pipe(switchMap(() => this.abpConfigService.get()))
-            .subscribe(res => this.setState(res));
-    }
-    /**
-     * @deprecated do not use this method directly, instead call refreshAppState
-     * This method will be private in v5.0
-     */
-    setState(state) {
-        this.store.set(state);
+            .subscribe(res => this.store.set(res));
     }
     refreshAppState() {
         this.updateSubject.next();
@@ -520,15 +476,14 @@ class ConfigStateService {
         }));
     }
 }
-ConfigStateService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ConfigStateService_Factory() { return new ConfigStateService(i0.ɵɵinject(AbpApplicationConfigurationService)); }, token: ConfigStateService, providedIn: "root" });
-ConfigStateService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ConfigStateService.ctorParameters = () => [
-    { type: AbpApplicationConfigurationService }
-];
+ConfigStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ConfigStateService, deps: [{ token: AbpApplicationConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ConfigStateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ConfigStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: AbpApplicationConfigurationService }]; } });
 function splitKeys(keys) {
     if (typeof keys === 'string') {
         keys = keys.split('.');
@@ -599,15 +554,14 @@ class SessionStateService {
         document.documentElement.setAttribute('lang', language);
     }
 }
-SessionStateService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SessionStateService_Factory() { return new SessionStateService(i0.ɵɵinject(ConfigStateService)); }, token: SessionStateService, providedIn: "root" });
-SessionStateService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-SessionStateService.ctorParameters = () => [
-    { type: ConfigStateService }
-];
+SessionStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SessionStateService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SessionStateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SessionStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigStateService }]; } });
 
 class LocalizationService {
     constructor(sessionState, injector, otherInstance, configState) {
@@ -682,16 +636,16 @@ class LocalizationService {
         return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
     }
 }
-LocalizationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LocalizationService_Factory() { return new LocalizationService(i0.ɵɵinject(SessionStateService), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(LocalizationService, 12), i0.ɵɵinject(ConfigStateService)); }, token: LocalizationService, providedIn: "root" });
-LocalizationService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-LocalizationService.ctorParameters = () => [
-    { type: SessionStateService },
-    { type: Injector },
-    { type: LocalizationService, decorators: [{ type: Optional }, { type: SkipSelf }] },
-    { type: ConfigStateService }
-];
+LocalizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationService, deps: [{ token: SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+LocalizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: ConfigStateService }]; } });
 function getLocalization(state, key, ...interpolateParams) {
     if (!key)
         key = '';
@@ -796,14 +750,12 @@ class ReplaceableComponentsService {
         return this.replaceableComponents$.pipe(map(components => components.find(component => component.key === replaceableComponentKey)));
     }
 }
-ReplaceableComponentsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ReplaceableComponentsService_Factory() { return new ReplaceableComponentsService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.Router)); }, token: ReplaceableComponentsService, providedIn: "root" });
-ReplaceableComponentsService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-ReplaceableComponentsService.ctorParameters = () => [
-    { type: NgZone },
-    { type: Router }
-];
+ReplaceableComponentsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableComponentsService, deps: [{ token: i0.NgZone }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+ReplaceableComponentsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableComponentsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableComponentsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1$1.Router }]; } });
 
 const NavigationEvent = {
     Cancel: NavigationCancel,
@@ -831,13 +783,12 @@ class RouterEvents {
         return this.getNavigationEvents(...keys);
     }
 }
-RouterEvents.ɵprov = i0.ɵɵdefineInjectable({ factory: function RouterEvents_Factory() { return new RouterEvents(i0.ɵɵinject(i1.Router)); }, token: RouterEvents, providedIn: "root" });
-RouterEvents.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-RouterEvents.ctorParameters = () => [
-    { type: Router }
-];
+RouterEvents.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterEvents, deps: [{ token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterEvents.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterEvents, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterEvents, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1$1.Router }]; } });
 
 function pushValueTo(array) {
     return (element) => {
@@ -846,6 +797,7 @@ function pushValueTo(array) {
     };
 }
 
+/* eslint-disable @typescript-eslint/ban-types */
 class BaseTreeNode {
     constructor(props) {
         this.children = [];
@@ -944,20 +896,21 @@ class PermissionService {
         return this.mapToPolicies(this.configState.getAll());
     }
     mapToPolicies(applicationConfiguration) {
-        return snq(() => applicationConfiguration.auth.grantedPolicies, {});
+        var _a;
+        return ((_a = applicationConfiguration === null || applicationConfiguration === void 0 ? void 0 : applicationConfiguration.auth) === null || _a === void 0 ? void 0 : _a.grantedPolicies) || {};
     }
     getPolicy(key, grantedPolicies) {
-        return snq(() => grantedPolicies[key], false);
+        return grantedPolicies[key] || false;
     }
 }
-PermissionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PermissionService_Factory() { return new PermissionService(i0.ɵɵinject(ConfigStateService)); }, token: PermissionService, providedIn: "root" });
-PermissionService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-PermissionService.ctorParameters = () => [
-    { type: ConfigStateService }
-];
+PermissionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+PermissionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ConfigStateService }]; } });
 
+// eslint-disable-next-line @typescript-eslint/ban-types
 class AbstractTreeService {
     constructor() {
         this._flat$ = new BehaviorSubject([]);
@@ -1083,24 +1036,19 @@ class AbstractNavTreeService extends AbstractTreeService {
         this.subscription.unsubscribe();
     }
 }
-AbstractNavTreeService.decorators = [
-    { type: Injectable }
-];
-AbstractNavTreeService.ctorParameters = () => [
-    { type: Injector }
-];
+AbstractNavTreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbstractNavTreeService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractNavTreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbstractNavTreeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbstractNavTreeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 class RoutesService extends AbstractNavTreeService {
 }
-RoutesService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RoutesService_Factory() { return new RoutesService(i0.ɵɵinject(i0.INJECTOR)); }, token: RoutesService, providedIn: "root" });
-RoutesService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-class SettingTabsService extends AbstractNavTreeService {
-}
-SettingTabsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SettingTabsService_Factory() { return new SettingTabsService(i0.ɵɵinject(i0.INJECTOR)); }, token: SettingTabsService, providedIn: "root" });
-SettingTabsService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
+RoutesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RoutesService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+RoutesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RoutesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RoutesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 class SubscriptionService {
     constructor() {
@@ -1134,9 +1082,11 @@ class SubscriptionService {
         this.subscription = new Subscription();
     }
 }
-SubscriptionService.decorators = [
-    { type: Injectable }
-];
+SubscriptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SubscriptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SubscriptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SubscriptionService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SubscriptionService, decorators: [{
+            type: Injectable
+        }] });
 
 class DynamicLayoutComponent {
     constructor(injector, localizationService, replaceableComponents, subscription, routerEvents, dynamicLayoutComponent) {
@@ -1196,27 +1146,32 @@ class DynamicLayoutComponent {
         return this.replaceableComponents.get(key);
     }
 }
-DynamicLayoutComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'abp-dynamic-layout',
-                template: `
+DynamicLayoutComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: DynamicLayoutComponent, deps: [{ token: i0.Injector }, { token: LocalizationService }, { token: ReplaceableComponentsService }, { token: SubscriptionService }, { token: RouterEvents }, { token: DynamicLayoutComponent, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Component });
+DynamicLayoutComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.6", type: DynamicLayoutComponent, selector: "abp-dynamic-layout", providers: [SubscriptionService], ngImport: i0, template: `
+    <ng-container *ngTemplateOutlet="layout ? componentOutlet : routerOutlet"></ng-container>
+    <ng-template #routerOutlet><router-outlet></router-outlet></ng-template>
+    <ng-template #componentOutlet
+      ><ng-container *ngIf="isLayoutVisible" [ngComponentOutlet]="layout"></ng-container
+    ></ng-template>
+  `, isInline: true, directives: [{ type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i1$1.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate"], exportAs: ["outlet"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModuleFactory"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: DynamicLayoutComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'abp-dynamic-layout',
+                    template: `
     <ng-container *ngTemplateOutlet="layout ? componentOutlet : routerOutlet"></ng-container>
     <ng-template #routerOutlet><router-outlet></router-outlet></ng-template>
     <ng-template #componentOutlet
       ><ng-container *ngIf="isLayoutVisible" [ngComponentOutlet]="layout"></ng-container
     ></ng-template>
   `,
-                providers: [SubscriptionService]
-            },] }
-];
-DynamicLayoutComponent.ctorParameters = () => [
-    { type: Injector },
-    { type: LocalizationService },
-    { type: ReplaceableComponentsService },
-    { type: SubscriptionService },
-    { type: RouterEvents },
-    { type: DynamicLayoutComponent, decorators: [{ type: Optional }, { type: SkipSelf }] }
-];
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: LocalizationService }, { type: ReplaceableComponentsService }, { type: SubscriptionService }, { type: RouterEvents }, { type: DynamicLayoutComponent, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
 
 class ReplaceableRouteContainerComponent {
     constructor(route, replaceableComponents, subscription) {
@@ -1226,8 +1181,7 @@ class ReplaceableRouteContainerComponent {
     }
     ngOnInit() {
         this.defaultComponent = this.route.snapshot.data.replaceableComponent.defaultComponent;
-        this.componentKey = this.route.snapshot.data
-            .replaceableComponent.key;
+        this.componentKey = this.route.snapshot.data.replaceableComponent.key;
         const component$ = this.replaceableComponents
             .get$(this.componentKey)
             .pipe(distinctUntilChanged());
@@ -1236,31 +1190,32 @@ class ReplaceableRouteContainerComponent {
         });
     }
 }
-ReplaceableRouteContainerComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'abp-replaceable-route-container',
-                template: `
+ReplaceableRouteContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableRouteContainerComponent, deps: [{ token: i1$1.ActivatedRoute }, { token: ReplaceableComponentsService }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Component });
+ReplaceableRouteContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.6", type: ReplaceableRouteContainerComponent, selector: "abp-replaceable-route-container", providers: [SubscriptionService], ngImport: i0, template: `
+    <ng-container *ngComponentOutlet="externalComponent || defaultComponent"></ng-container>
+  `, isInline: true, directives: [{ type: i5.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModuleFactory"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableRouteContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'abp-replaceable-route-container',
+                    template: `
     <ng-container *ngComponentOutlet="externalComponent || defaultComponent"></ng-container>
   `,
-                providers: [SubscriptionService]
-            },] }
-];
-ReplaceableRouteContainerComponent.ctorParameters = () => [
-    { type: ActivatedRoute },
-    { type: ReplaceableComponentsService },
-    { type: SubscriptionService }
-];
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.ActivatedRoute }, { type: ReplaceableComponentsService }, { type: SubscriptionService }]; } });
 
 class RouterOutletComponent {
 }
-RouterOutletComponent.decorators = [
-    { type: Component, args: [{
-                selector: 'abp-router-outlet',
-                template: `
-    <router-outlet></router-outlet>
-  `
-            },] }
-];
+RouterOutletComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterOutletComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+RouterOutletComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.6", type: RouterOutletComponent, selector: "abp-router-outlet", ngImport: i0, template: ` <router-outlet></router-outlet> `, isInline: true, directives: [{ type: i1$1.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate"], exportAs: ["outlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterOutletComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'abp-router-outlet',
+                    template: ` <router-outlet></router-outlet> `,
+                }]
+        }] });
 
 // Different locales from .NET
 // Key is .NET locale, value is Angular locale
@@ -1608,18 +1563,18 @@ class AutofocusDirective {
         setTimeout(() => this.elRef.nativeElement.focus(), this.delay);
     }
 }
-AutofocusDirective.decorators = [
-    { type: Directive, args: [{
-                // tslint:disable-next-line: directive-selector
-                selector: '[autofocus]'
-            },] }
-];
-AutofocusDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-AutofocusDirective.propDecorators = {
-    delay: [{ type: Input, args: ['autofocus',] }]
-};
+AutofocusDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AutofocusDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+AutofocusDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: AutofocusDirective, selector: "[autofocus]", inputs: { delay: ["autofocus", "delay"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AutofocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[autofocus]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { delay: [{
+                type: Input,
+                args: ['autofocus']
+            }] } });
 
 class InputEventDebounceDirective {
     constructor(el, subscription) {
@@ -1635,21 +1590,21 @@ class InputEventDebounceDirective {
         });
     }
 }
-InputEventDebounceDirective.decorators = [
-    { type: Directive, args: [{
-                // tslint:disable-next-line: directive-selector
-                selector: '[input.debounce]',
-                providers: [SubscriptionService],
-            },] }
-];
-InputEventDebounceDirective.ctorParameters = () => [
-    { type: ElementRef },
-    { type: SubscriptionService }
-];
-InputEventDebounceDirective.propDecorators = {
-    debounce: [{ type: Input }],
-    debounceEvent: [{ type: Output, args: ['input.debounce',] }]
-};
+InputEventDebounceDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: InputEventDebounceDirective, deps: [{ token: i0.ElementRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive });
+InputEventDebounceDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: InputEventDebounceDirective, selector: "[input.debounce]", inputs: { debounce: "debounce" }, outputs: { debounceEvent: "input.debounce" }, providers: [SubscriptionService], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: InputEventDebounceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[input.debounce]',
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: SubscriptionService }]; }, propDecorators: { debounce: [{
+                type: Input
+            }], debounceEvent: [{
+                type: Output,
+                args: ['input.debounce']
+            }] } });
 
 class AbpForContext {
     constructor($implicit, index, count, list) {
@@ -1712,7 +1667,6 @@ class ForDirective {
     projectItems(items) {
         if (!items.length && this.emptyRef) {
             this.vcRef.clear();
-            // tslint:disable-next-line: no-unused-expression
             this.vcRef.createEmbeddedView(this.emptyRef).rootNodes;
             this.isShowEmptyRef = true;
             this.differ = null;
@@ -1735,7 +1689,7 @@ class ForDirective {
     }
     sortItems(items) {
         if (this.orderBy) {
-            items.sort((a, b) => (a[this.orderBy] > b[this.orderBy] ? 1 : a[this.orderBy] < b[this.orderBy] ? -1 : 0));
+            items.sort((a, b) => a[this.orderBy] > b[this.orderBy] ? 1 : a[this.orderBy] < b[this.orderBy] ? -1 : 0);
         }
         else {
             items.sort();
@@ -1746,7 +1700,9 @@ class ForDirective {
         if (!Array.isArray(items))
             return;
         const compareFn = this.compareFn;
-        if (typeof this.filterBy !== 'undefined' && typeof this.filterVal !== 'undefined' && this.filterVal !== '') {
+        if (typeof this.filterBy !== 'undefined' &&
+            typeof this.filterVal !== 'undefined' &&
+            this.filterVal !== '') {
             items = items.filter(item => compareFn(item[this.filterBy], this.filterVal));
         }
         switch (this.orderDir) {
@@ -1764,26 +1720,38 @@ class ForDirective {
         }
     }
 }
-ForDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[abpFor]',
-            },] }
-];
-ForDirective.ctorParameters = () => [
-    { type: TemplateRef },
-    { type: ViewContainerRef },
-    { type: IterableDiffers }
-];
-ForDirective.propDecorators = {
-    items: [{ type: Input, args: ['abpForOf',] }],
-    orderBy: [{ type: Input, args: ['abpForOrderBy',] }],
-    orderDir: [{ type: Input, args: ['abpForOrderDir',] }],
-    filterBy: [{ type: Input, args: ['abpForFilterBy',] }],
-    filterVal: [{ type: Input, args: ['abpForFilterVal',] }],
-    trackBy: [{ type: Input, args: ['abpForTrackBy',] }],
-    compareBy: [{ type: Input, args: ['abpForCompareBy',] }],
-    emptyRef: [{ type: Input, args: ['abpForEmptyRef',] }]
-};
+ForDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ForDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Directive });
+ForDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: ForDirective, selector: "[abpFor]", inputs: { items: ["abpForOf", "items"], orderBy: ["abpForOrderBy", "orderBy"], orderDir: ["abpForOrderDir", "orderDir"], filterBy: ["abpForFilterBy", "filterBy"], filterVal: ["abpForFilterVal", "filterVal"], trackBy: ["abpForTrackBy", "trackBy"], compareBy: ["abpForCompareBy", "compareBy"], emptyRef: ["abpForEmptyRef", "emptyRef"] }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ForDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[abpFor]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.IterableDiffers }]; }, propDecorators: { items: [{
+                type: Input,
+                args: ['abpForOf']
+            }], orderBy: [{
+                type: Input,
+                args: ['abpForOrderBy']
+            }], orderDir: [{
+                type: Input,
+                args: ['abpForOrderDir']
+            }], filterBy: [{
+                type: Input,
+                args: ['abpForFilterBy']
+            }], filterVal: [{
+                type: Input,
+                args: ['abpForFilterVal']
+            }], trackBy: [{
+                type: Input,
+                args: ['abpForTrackBy']
+            }], compareBy: [{
+                type: Input,
+                args: ['abpForCompareBy']
+            }], emptyRef: [{
+                type: Input,
+                args: ['abpForEmptyRef']
+            }] } });
 
 class FormSubmitDirective {
     constructor(formGroupDirective, host, cdRef, subscription) {
@@ -1815,24 +1783,24 @@ class FormSubmitDirective {
         this.cdRef.detectChanges();
     }
 }
-FormSubmitDirective.decorators = [
-    { type: Directive, args: [{
-                // tslint:disable-next-line: directive-selector
-                selector: 'form[ngSubmit][formGroup]',
-                providers: [SubscriptionService],
-            },] }
-];
-FormSubmitDirective.ctorParameters = () => [
-    { type: FormGroupDirective, decorators: [{ type: Self }] },
-    { type: ElementRef },
-    { type: ChangeDetectorRef },
-    { type: SubscriptionService }
-];
-FormSubmitDirective.propDecorators = {
-    debounce: [{ type: Input }],
-    notValidateOnSubmit: [{ type: Input }],
-    ngSubmit: [{ type: Output }]
-};
+FormSubmitDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: FormSubmitDirective, deps: [{ token: i1$2.FormGroupDirective, self: true }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive });
+FormSubmitDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: FormSubmitDirective, selector: "form[ngSubmit][formGroup]", inputs: { debounce: "debounce", notValidateOnSubmit: "notValidateOnSubmit" }, outputs: { ngSubmit: "ngSubmit" }, providers: [SubscriptionService], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: FormSubmitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'form[ngSubmit][formGroup]',
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.FormGroupDirective, decorators: [{
+                    type: Self
+                }] }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: SubscriptionService }]; }, propDecorators: { debounce: [{
+                type: Input
+            }], notValidateOnSubmit: [{
+                type: Input
+            }], ngSubmit: [{
+                type: Output
+            }] } });
 function setDirty(controls) {
     if (Array.isArray(controls)) {
         controls.forEach(group => {
@@ -1855,15 +1823,15 @@ class InitDirective {
         this.init.emit(this.elRef);
     }
 }
-InitDirective.decorators = [
-    { type: Directive, args: [{ selector: '[abpInit]' },] }
-];
-InitDirective.ctorParameters = () => [
-    { type: ElementRef }
-];
-InitDirective.propDecorators = {
-    init: [{ type: Output, args: ['abpInit',] }]
-};
+InitDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: InitDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+InitDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: InitDirective, selector: "[abpInit]", outputs: { init: "abpInit" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: InitDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[abpInit]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { init: [{
+                type: Output,
+                args: ['abpInit']
+            }] } });
 
 class PermissionDirective {
     constructor(elRef, renderer, templateRef, vcRef, permissionService, cdRef) {
@@ -1882,26 +1850,12 @@ class PermissionDirective {
             .getGrantedPolicy$(this.condition)
             .pipe(distinctUntilChanged())
             .subscribe(isGranted => {
-            if (this.templateRef)
-                this.initStructural(isGranted);
-            else
-                this.initAttribute(isGranted);
+            this.vcRef.clear();
+            if (isGranted)
+                this.vcRef.createEmbeddedView(this.templateRef);
             this.cdRef.detectChanges();
         });
     }
-    initStructural(isGranted) {
-        this.vcRef.clear();
-        if (isGranted)
-            this.vcRef.createEmbeddedView(this.templateRef);
-    }
-    /**
-     * @deprecated Will be deleted in v5.0
-     */
-    initAttribute(isGranted) {
-        if (!isGranted) {
-            this.renderer.removeChild(this.elRef.nativeElement.parentElement, this.elRef.nativeElement);
-        }
-    }
     ngOnDestroy() {
         if (this.subscription)
             this.subscription.unsubscribe();
@@ -1910,22 +1864,19 @@ class PermissionDirective {
         this.check();
     }
 }
-PermissionDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[abpPermission]',
-            },] }
-];
-PermissionDirective.ctorParameters = () => [
-    { type: ElementRef },
-    { type: Renderer2 },
-    { type: TemplateRef, decorators: [{ type: Optional }] },
-    { type: ViewContainerRef },
-    { type: PermissionService },
-    { type: ChangeDetectorRef }
-];
-PermissionDirective.propDecorators = {
-    condition: [{ type: Input, args: ['abpPermission',] }]
-};
+PermissionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.TemplateRef, optional: true }, { token: i0.ViewContainerRef }, { token: PermissionService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+PermissionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: PermissionDirective, selector: "[abpPermission]", inputs: { condition: ["abpPermission", "condition"] }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[abpPermission]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ViewContainerRef }, { type: PermissionService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { condition: [{
+                type: Input,
+                args: ['abpPermission']
+            }] } });
 
 class ReplaceableTemplateDirective {
     constructor(injector, templateRef, cfRes, vcRef, replaceableComponents, subscription) {
@@ -1935,7 +1886,10 @@ class ReplaceableTemplateDirective {
         this.vcRef = vcRef;
         this.replaceableComponents = replaceableComponents;
         this.subscription = subscription;
-        this.providedData = { inputs: {}, outputs: {} };
+        this.providedData = {
+            inputs: {},
+            outputs: {},
+        };
         this.context = {};
         this.defaultComponentSubscriptions = {};
         this.initialized = false;
@@ -1972,7 +1926,8 @@ class ReplaceableTemplateDirective {
         });
     }
     ngOnChanges(changes) {
-        if (snq(() => changes.data.currentValue.inputs) && this.defaultComponentRef) {
+        var _a, _b;
+        if (((_b = (_a = changes === null || changes === void 0 ? void 0 : changes.data) === null || _a === void 0 ? void 0 : _a.currentValue) === null || _b === void 0 ? void 0 : _b.inputs) && this.defaultComponentRef) {
             this.setDefaultComponentInputs();
         }
     }
@@ -1981,7 +1936,7 @@ class ReplaceableTemplateDirective {
             return;
         if (this.data.inputs) {
             for (const key in this.data.inputs) {
-                if (this.data.inputs.hasOwnProperty(key)) {
+                if (Object.prototype.hasOwnProperty.call(this.data.inputs, key)) {
                     if (!compare(this.defaultComponentRef[key], this.data.inputs[key].value)) {
                         this.defaultComponentRef[key] = this.data.inputs[key].value;
                     }
@@ -1990,7 +1945,7 @@ class ReplaceableTemplateDirective {
         }
         if (this.data.outputs) {
             for (const key in this.data.outputs) {
-                if (this.data.outputs.hasOwnProperty(key)) {
+                if (Object.prototype.hasOwnProperty.call(this.data.outputs, key)) {
                     if (!this.defaultComponentSubscriptions[key]) {
                         this.defaultComponentSubscriptions[key] = this.defaultComponentRef[key].subscribe(value => {
                             this.data.outputs[key](value);
@@ -2019,20 +1974,18 @@ class ReplaceableTemplateDirective {
         this.defaultComponentRef = null;
     }
 }
-ReplaceableTemplateDirective.decorators = [
-    { type: Directive, args: [{ selector: '[abpReplaceableTemplate]', providers: [SubscriptionService] },] }
-];
-ReplaceableTemplateDirective.ctorParameters = () => [
-    { type: Injector },
-    { type: TemplateRef },
-    { type: ComponentFactoryResolver },
-    { type: ViewContainerRef },
-    { type: ReplaceableComponentsService },
-    { type: SubscriptionService }
-];
-ReplaceableTemplateDirective.propDecorators = {
-    data: [{ type: Input, args: ['abpReplaceableTemplate',] }]
-};
+ReplaceableTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableTemplateDirective, deps: [{ token: i0.Injector }, { token: i0.TemplateRef }, { token: i0.ComponentFactoryResolver }, { token: i0.ViewContainerRef }, { token: ReplaceableComponentsService }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive });
+ReplaceableTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: ReplaceableTemplateDirective, selector: "[abpReplaceableTemplate]", inputs: { data: ["abpReplaceableTemplate", "data"] }, providers: [SubscriptionService], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ReplaceableTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[abpReplaceableTemplate]',
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i0.TemplateRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: ReplaceableComponentsService }, { type: SubscriptionService }]; }, propDecorators: { data: [{
+                type: Input,
+                args: ['abpReplaceableTemplate']
+            }] } });
 
 class StopPropagationDirective {
     constructor(el, subscription) {
@@ -2047,79 +2000,19 @@ class StopPropagationDirective {
         });
     }
 }
-StopPropagationDirective.decorators = [
-    { type: Directive, args: [{
-                // tslint:disable-next-line: directive-selector
-                selector: '[click.stop]',
-                providers: [SubscriptionService],
-            },] }
-];
-StopPropagationDirective.ctorParameters = () => [
-    { type: ElementRef },
-    { type: SubscriptionService }
-];
-StopPropagationDirective.propDecorators = {
-    stopPropEvent: [{ type: Output, args: ['click.stop',] }]
-};
-
-/**
- *
- * @deprecated To be deleted in v5.0
- */
-class VisibilityDirective {
-    constructor(elRef, renderer) {
-        this.elRef = elRef;
-        this.renderer = renderer;
-        this.completed$ = new Subject();
-    }
-    ngAfterViewInit() {
-        if (!this.focusedElement && this.elRef) {
-            this.focusedElement = this.elRef.nativeElement;
-        }
-        let observer;
-        observer = new MutationObserver(mutations => {
-            mutations.forEach(mutation => {
-                if (!mutation.target)
-                    return;
-                const htmlNodes = snq(() => Array.from(mutation.target.childNodes).filter(node => node instanceof HTMLElement), []);
-                if (!htmlNodes.length) {
-                    this.removeFromDOM();
-                }
-            });
-        });
-        observer.observe(this.focusedElement, {
-            childList: true,
-        });
-        setTimeout(() => {
-            const htmlNodes = snq(() => Array.from(this.focusedElement.childNodes).filter(node => node instanceof HTMLElement), []);
-            if (!htmlNodes.length)
-                this.removeFromDOM();
-        }, 0);
-        this.completed$.subscribe(() => observer.disconnect());
-    }
-    disconnect() {
-        this.completed$.next();
-        this.completed$.complete();
-    }
-    removeFromDOM() {
-        if (!this.elRef.nativeElement)
-            return;
-        this.renderer.removeChild(this.elRef.nativeElement.parentElement, this.elRef.nativeElement);
-        this.disconnect();
-    }
-}
-VisibilityDirective.decorators = [
-    { type: Directive, args: [{
-                selector: '[abpVisibility]',
-            },] }
-];
-VisibilityDirective.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Optional }] },
-    { type: Renderer2 }
-];
-VisibilityDirective.propDecorators = {
-    focusedElement: [{ type: Input, args: ['abpVisibility',] }]
-};
+StopPropagationDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: StopPropagationDirective, deps: [{ token: i0.ElementRef }, { token: SubscriptionService }], target: i0.ɵɵFactoryTarget.Directive });
+StopPropagationDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.6", type: StopPropagationDirective, selector: "[click.stop]", outputs: { stopPropEvent: "click.stop" }, providers: [SubscriptionService], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: StopPropagationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[click.stop]',
+                    providers: [SubscriptionService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: SubscriptionService }]; }, propDecorators: { stopPropEvent: [{
+                type: Output,
+                args: ['click.stop']
+            }] } });
 
 class OAuthConfigurationHandler {
     constructor(oAuthService, environmentService, options) {
@@ -2137,17 +2030,17 @@ class OAuthConfigurationHandler {
         });
     }
 }
-OAuthConfigurationHandler.ɵprov = i0.ɵɵdefineInjectable({ factory: function OAuthConfigurationHandler_Factory() { return new OAuthConfigurationHandler(i0.ɵɵinject(i1$1.OAuthService), i0.ɵɵinject(EnvironmentService), i0.ɵɵinject(CORE_OPTIONS)); }, token: OAuthConfigurationHandler, providedIn: "root" });
-OAuthConfigurationHandler.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-OAuthConfigurationHandler.ctorParameters = () => [
-    { type: OAuthService },
-    { type: EnvironmentService },
-    { type: undefined, decorators: [{ type: Inject, args: [CORE_OPTIONS,] }] }
-];
+OAuthConfigurationHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: OAuthConfigurationHandler, deps: [{ token: i1$3.OAuthService }, { token: EnvironmentService }, { token: CORE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
+OAuthConfigurationHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: OAuthConfigurationHandler, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: OAuthConfigurationHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$3.OAuthService }, { type: EnvironmentService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CORE_OPTIONS]
+                }] }]; } });
 
 class RoutesHandler {
     constructor(routes, router) {
@@ -2169,16 +2062,16 @@ class RoutesHandler {
         });
     }
 }
-RoutesHandler.ɵprov = i0.ɵɵdefineInjectable({ factory: function RoutesHandler_Factory() { return new RoutesHandler(i0.ɵɵinject(RoutesService), i0.ɵɵinject(i1.Router, 8)); }, token: RoutesHandler, providedIn: "root" });
-RoutesHandler.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-RoutesHandler.ctorParameters = () => [
-    { type: RoutesService },
-    { type: Router, decorators: [{ type: Optional }] }
-];
+RoutesHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RoutesHandler, deps: [{ token: RoutesService }, { token: i1$1.Router, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+RoutesHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RoutesHandler, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RoutesHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RoutesService }, { type: i1$1.Router, decorators: [{
+                    type: Optional
+                }] }]; } });
 function flatRoutes(routes, parent) {
     if (!routes)
         return [];
@@ -2266,15 +2159,14 @@ class HttpWaitService {
         return endpoint === request.endpoint && method === request.method;
     }
 }
-HttpWaitService.ɵprov = i0.ɵɵdefineInjectable({ factory: function HttpWaitService_Factory() { return new HttpWaitService(i0.ɵɵinject(i0.INJECTOR)); }, token: HttpWaitService, providedIn: "root" });
-HttpWaitService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-HttpWaitService.ctorParameters = () => [
-    { type: Injector }
-];
+HttpWaitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: HttpWaitService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpWaitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: HttpWaitService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: HttpWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
 const TENANT_KEY = new InjectionToken('TENANT_KEY');
 
@@ -2310,18 +2202,17 @@ class ApiInterceptor {
         return headers;
     }
 }
-ApiInterceptor.ɵprov = i0.ɵɵdefineInjectable({ factory: function ApiInterceptor_Factory() { return new ApiInterceptor(i0.ɵɵinject(i1$1.OAuthService), i0.ɵɵinject(SessionStateService), i0.ɵɵinject(HttpWaitService), i0.ɵɵinject(TENANT_KEY)); }, token: ApiInterceptor, providedIn: "root" });
-ApiInterceptor.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ApiInterceptor.ctorParameters = () => [
-    { type: OAuthService },
-    { type: SessionStateService },
-    { type: HttpWaitService },
-    { type: String, decorators: [{ type: Inject, args: [TENANT_KEY,] }] }
-];
+ApiInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ApiInterceptor, deps: [{ token: i1$3.OAuthService }, { token: SessionStateService }, { token: HttpWaitService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ApiInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ApiInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$3.OAuthService }, { type: SessionStateService }, { type: HttpWaitService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
+                }] }]; } });
 
 class LocalizationPipe {
     constructor(localization) {
@@ -2331,24 +2222,30 @@ class LocalizationPipe {
         return this.localization.instant(value, ...interpolateParams.reduce((acc, val) => (Array.isArray(val) ? [...acc, ...val] : [...acc, val]), []));
     }
 }
-LocalizationPipe.decorators = [
-    { type: Injectable },
-    { type: Pipe, args: [{
-                name: 'abpLocalization',
-            },] }
-];
-LocalizationPipe.ctorParameters = () => [
-    { type: LocalizationService }
-];
+LocalizationPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+LocalizationPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationPipe, name: "abpLocalization" });
+LocalizationPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationPipe });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationPipe, decorators: [{
+            type: Injectable
+        }, {
+            type: Pipe,
+            args: [{
+                    name: 'abpLocalization',
+                }]
+        }], ctorParameters: function () { return [{ type: LocalizationService }]; } });
 
 class LocalizationModule {
 }
-LocalizationModule.decorators = [
-    { type: NgModule, args: [{
-                exports: [LocalizationPipe],
-                declarations: [LocalizationPipe],
-            },] }
-];
+LocalizationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LocalizationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationModule, declarations: [LocalizationPipe], exports: [LocalizationPipe] });
+LocalizationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [LocalizationPipe],
+                    declarations: [LocalizationPipe],
+                }]
+        }] });
 
 class SortPipe {
     transform(value, sortOrder = 'asc', sortKey) {
@@ -2385,12 +2282,39 @@ class SortPipe {
         return sortOrder === 'asc' ? sorted : sorted.reverse();
     }
 }
-SortPipe.decorators = [
-    { type: Injectable },
-    { type: Pipe, args: [{
-                name: 'abpSort',
-            },] }
-];
+SortPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SortPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+SortPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SortPipe, name: "abpSort" });
+SortPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SortPipe });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: SortPipe, decorators: [{
+            type: Injectable
+        }, {
+            type: Pipe,
+            args: [{
+                    name: 'abpSort',
+                }]
+        }] });
+
+const COOKIE_LANGUAGE_KEY = new InjectionToken('COOKIE_LANGUAGE_KEY', {
+    factory: () => '.AspNetCore.Culture',
+});
+
+function setLanguageToCookie(injector) {
+    return () => {
+        const sessionState = injector.get(SessionStateService);
+        const document = injector.get(DOCUMENT);
+        const cookieLanguageKey = injector.get(COOKIE_LANGUAGE_KEY);
+        sessionState.getLanguage$().subscribe(language => {
+            const cookieValue = encodeURIComponent(`c=${language}|uic=${language}`);
+            document.cookie = `${cookieLanguageKey}=${cookieValue}`;
+        });
+    };
+}
+const CookieLanguageProvider = {
+    provide: APP_INITIALIZER,
+    useFactory: setLanguageToCookie,
+    deps: [Injector],
+    multi: true,
+};
 
 class LocaleId extends String {
     constructor(localizationService) {
@@ -2411,96 +2335,6 @@ const LocaleProvider = {
     deps: [LocalizationService],
 };
 
-class ProfileService {
-    constructor(rest) {
-        this.rest = rest;
-        this.apiName = 'AbpIdentity';
-    }
-    get() {
-        const request = {
-            method: 'GET',
-            url: '/api/identity/my-profile',
-        };
-        return this.rest.request(request, { apiName: this.apiName });
-    }
-    update(body) {
-        const request = {
-            method: 'PUT',
-            url: '/api/identity/my-profile',
-            body,
-        };
-        return this.rest.request(request, {
-            apiName: this.apiName,
-        });
-    }
-    changePassword(body, skipHandleError = false) {
-        const request = {
-            method: 'POST',
-            url: '/api/identity/my-profile/change-password',
-            body,
-        };
-        return this.rest.request(request, {
-            skipHandleError,
-            apiName: this.apiName,
-        });
-    }
-}
-ProfileService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ProfileService_Factory() { return new ProfileService(i0.ɵɵinject(RestService)); }, token: ProfileService, providedIn: "root" });
-ProfileService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ProfileService.ctorParameters = () => [
-    { type: RestService }
-];
-
-let ProfileState = class ProfileState {
-    constructor(profileService) {
-        this.profileService = profileService;
-    }
-    static getProfile({ profile }) {
-        return profile;
-    }
-    getProfile({ patchState }) {
-        return this.profileService.get().pipe(tap(profile => patchState({
-            profile,
-        })));
-    }
-    updateProfile({ patchState }, { payload }) {
-        return this.profileService.update(payload).pipe(tap(profile => patchState({
-            profile,
-        })));
-    }
-    changePassword(_, { payload }) {
-        return this.profileService.changePassword(payload, true);
-    }
-};
-ProfileState.decorators = [
-    { type: Injectable }
-];
-ProfileState.ctorParameters = () => [
-    { type: ProfileService }
-];
-__decorate([
-    Action(GetProfile)
-], ProfileState.prototype, "getProfile", null);
-__decorate([
-    Action(UpdateProfile)
-], ProfileState.prototype, "updateProfile", null);
-__decorate([
-    Action(ChangePassword)
-], ProfileState.prototype, "changePassword", null);
-__decorate([
-    Selector()
-], ProfileState, "getProfile", null);
-ProfileState = __decorate([
-    State({
-        name: 'ProfileState',
-        defaults: {},
-    })
-], ProfileState);
-
 const cookieKey = 'rememberMe';
 const storageKey = 'passwordFlow';
 function pipeToLogin(params, injector) {
@@ -2542,8 +2376,11 @@ const oAuthStorage = localStorage;
 class AuthFlowStrategy {
     constructor(injector) {
         this.injector = injector;
-        this.catchError = err => this.store.dispatch(new RestOccurError(err));
-        this.store = injector.get(Store);
+        this.catchError = err => {
+            this.httpErrorReporter.reportError(err);
+            return of(null);
+        };
+        this.httpErrorReporter = injector.get(HttpErrorReporterService);
         this.environment = injector.get(EnvironmentService);
         this.configState = injector.get(ConfigStateService);
         this.oAuthService = injector.get(OAuthService);
@@ -2750,12 +2587,6 @@ class AuthService {
     logout(queryParams) {
         return this.strategy.logout(queryParams);
     }
-    /**
-     * @deprecated Use navigateToLogin method instead. To be deleted in v5.0
-     */
-    initLogin() {
-        this.strategy.navigateToLogin();
-    }
     navigateToLogin(queryParams) {
         this.strategy.navigateToLogin(queryParams);
     }
@@ -2763,15 +2594,14 @@ class AuthService {
         return this.strategy.login(params);
     }
 }
-AuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(i0.ɵɵinject(i0.INJECTOR)); }, token: AuthService, providedIn: "root" });
-AuthService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AuthService.ctorParameters = () => [
-    { type: Injector }
-];
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AuthService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
 const APP_INIT_ERROR_HANDLERS = new InjectionToken('APP_INIT_ERROR_HANDLERS');
 
@@ -2782,10 +2612,13 @@ function getRemoteEnv(injector, environment) {
     if (!url)
         return Promise.resolve();
     const http = injector.get(HttpClient);
-    const store = injector.get(Store);
+    const httpErrorReporter = injector.get(HttpErrorReporterService);
     return http
         .request(method, url, { headers })
-        .pipe(catchError(err => store.dispatch(new RestOccurError(err))), // TODO: Condiser get handle function from a provider
+        .pipe(catchError(err => {
+        httpErrorReporter.reportError(err);
+        return of(null);
+    }), // TODO: Consider get handle function from a provider
     tap(env => environmentService.setState(mergeEnvironments(environment, env, remoteEnv))))
         .toPromise();
 }
@@ -2818,15 +2651,14 @@ class AbpTenantService {
         }, { apiName: this.apiName });
     }
 }
-AbpTenantService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AbpTenantService_Factory() { return new AbpTenantService(i0.ɵɵinject(RestService)); }, token: AbpTenantService, providedIn: "root" });
-AbpTenantService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AbpTenantService.ctorParameters = () => [
-    { type: RestService }
-];
+AbpTenantService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpTenantService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbpTenantService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpTenantService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpTenantService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RestService }]; } });
 
 class MultiTenancyService {
     constructor(restService, sessionState, tenantService, configStateService, tenantKey) {
@@ -2843,22 +2675,6 @@ class MultiTenancyService {
             return this.configStateService.refreshAppState().pipe(map(_ => tenant));
         };
     }
-    /**
-     * @deprecated Use AbpTenantService.findTenantByName method instead. To be deleted in v5.0.
-     */
-    findTenantByName(name, headers) {
-        return this.restService.request({
-            url: `/api/abp/multi-tenancy/tenants/by-name/${name}`,
-            method: 'GET',
-            headers,
-        }, { apiName: this.apiName });
-    }
-    /**
-     * @deprecated Use AbpTenantService.findTenantById method instead. To be deleted in v5.0.
-     */
-    findTenantById(id, headers) {
-        return this.restService.request({ url: `/api/abp/multi-tenancy/tenants/by-id/${id}`, method: 'GET', headers }, { apiName: this.apiName });
-    }
     setTenantByName(tenantName) {
         return this.tenantService
             .findTenantByName(tenantName, { [this.tenantKey]: '' })
@@ -2870,17 +2686,15 @@ class MultiTenancyService {
             .pipe(switchMap(this.setTenantToState));
     }
 }
-MultiTenancyService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MultiTenancyService_Factory() { return new MultiTenancyService(i0.ɵɵinject(RestService), i0.ɵɵinject(SessionStateService), i0.ɵɵinject(AbpTenantService), i0.ɵɵinject(ConfigStateService), i0.ɵɵinject(TENANT_KEY)); }, token: MultiTenancyService, providedIn: "root" });
-MultiTenancyService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-MultiTenancyService.ctorParameters = () => [
-    { type: RestService },
-    { type: SessionStateService },
-    { type: AbpTenantService },
-    { type: ConfigStateService },
-    { type: String, decorators: [{ type: Inject, args: [TENANT_KEY,] }] }
-];
+MultiTenancyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: MultiTenancyService, deps: [{ token: RestService }, { token: SessionStateService }, { token: AbpTenantService }, { token: ConfigStateService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable });
+MultiTenancyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: MultiTenancyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: MultiTenancyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: RestService }, { type: SessionStateService }, { type: AbpTenantService }, { type: ConfigStateService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
+                }] }]; } });
 
 const tenancyPlaceholder = '{0}';
 function getCurrentTenancyName(appBaseUrl) {
@@ -3020,84 +2834,146 @@ function storageFactory() {
  */
 class BaseCoreModule {
 }
-BaseCoreModule.decorators = [
-    { type: NgModule, args: [{
-                exports: [
-                    CommonModule,
-                    HttpClientModule,
-                    FormsModule,
-                    ReactiveFormsModule,
-                    RouterModule,
-                    LocalizationModule,
-                    AbstractNgModelComponent,
-                    AutofocusDirective,
-                    DynamicLayoutComponent,
-                    ForDirective,
-                    FormSubmitDirective,
-                    InitDirective,
-                    InputEventDebounceDirective,
-                    PermissionDirective,
-                    ReplaceableRouteContainerComponent,
-                    ReplaceableTemplateDirective,
-                    RouterOutletComponent,
-                    SortPipe,
-                    StopPropagationDirective,
-                    VisibilityDirective,
-                ],
-                imports: [
-                    OAuthModule,
-                    CommonModule,
-                    HttpClientModule,
-                    FormsModule,
-                    ReactiveFormsModule,
-                    RouterModule,
-                    LocalizationModule,
-                ],
-                declarations: [
-                    AbstractNgModelComponent,
-                    AutofocusDirective,
-                    DynamicLayoutComponent,
-                    ForDirective,
-                    FormSubmitDirective,
-                    InitDirective,
-                    InputEventDebounceDirective,
-                    PermissionDirective,
-                    ReplaceableRouteContainerComponent,
-                    ReplaceableTemplateDirective,
-                    RouterOutletComponent,
-                    SortPipe,
-                    StopPropagationDirective,
-                    VisibilityDirective,
-                ],
-                providers: [LocalizationPipe],
-                entryComponents: [
-                    RouterOutletComponent,
-                    DynamicLayoutComponent,
-                    ReplaceableRouteContainerComponent,
-                ],
-            },] }
-];
+BaseCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: BaseCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BaseCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: BaseCoreModule, declarations: [AbstractNgModelComponent,
+        AutofocusDirective,
+        DynamicLayoutComponent,
+        ForDirective,
+        FormSubmitDirective,
+        InitDirective,
+        InputEventDebounceDirective,
+        PermissionDirective,
+        ReplaceableRouteContainerComponent,
+        ReplaceableTemplateDirective,
+        RouterOutletComponent,
+        SortPipe,
+        StopPropagationDirective], imports: [OAuthModule,
+        CommonModule,
+        HttpClientModule,
+        FormsModule,
+        ReactiveFormsModule,
+        RouterModule,
+        LocalizationModule], exports: [CommonModule,
+        HttpClientModule,
+        FormsModule,
+        ReactiveFormsModule,
+        RouterModule,
+        LocalizationModule,
+        AbstractNgModelComponent,
+        AutofocusDirective,
+        DynamicLayoutComponent,
+        ForDirective,
+        FormSubmitDirective,
+        InitDirective,
+        InputEventDebounceDirective,
+        PermissionDirective,
+        ReplaceableRouteContainerComponent,
+        ReplaceableTemplateDirective,
+        RouterOutletComponent,
+        SortPipe,
+        StopPropagationDirective] });
+BaseCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: BaseCoreModule, providers: [LocalizationPipe], imports: [[
+            OAuthModule,
+            CommonModule,
+            HttpClientModule,
+            FormsModule,
+            ReactiveFormsModule,
+            RouterModule,
+            LocalizationModule,
+        ], CommonModule,
+        HttpClientModule,
+        FormsModule,
+        ReactiveFormsModule,
+        RouterModule,
+        LocalizationModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: BaseCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        CommonModule,
+                        HttpClientModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        RouterModule,
+                        LocalizationModule,
+                        AbstractNgModelComponent,
+                        AutofocusDirective,
+                        DynamicLayoutComponent,
+                        ForDirective,
+                        FormSubmitDirective,
+                        InitDirective,
+                        InputEventDebounceDirective,
+                        PermissionDirective,
+                        ReplaceableRouteContainerComponent,
+                        ReplaceableTemplateDirective,
+                        RouterOutletComponent,
+                        SortPipe,
+                        StopPropagationDirective,
+                    ],
+                    imports: [
+                        OAuthModule,
+                        CommonModule,
+                        HttpClientModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        RouterModule,
+                        LocalizationModule,
+                    ],
+                    declarations: [
+                        AbstractNgModelComponent,
+                        AutofocusDirective,
+                        DynamicLayoutComponent,
+                        ForDirective,
+                        FormSubmitDirective,
+                        InitDirective,
+                        InputEventDebounceDirective,
+                        PermissionDirective,
+                        ReplaceableRouteContainerComponent,
+                        ReplaceableTemplateDirective,
+                        RouterOutletComponent,
+                        SortPipe,
+                        StopPropagationDirective,
+                    ],
+                    providers: [LocalizationPipe],
+                    entryComponents: [
+                        RouterOutletComponent,
+                        DynamicLayoutComponent,
+                        ReplaceableRouteContainerComponent,
+                    ],
+                }]
+        }] });
 /**
  * RootCoreModule is the module that will be used at root level
  * and it introduces imports useful at root level (e.g. NGXS)
  */
 class RootCoreModule {
 }
-RootCoreModule.decorators = [
-    { type: NgModule, args: [{
-                exports: [BaseCoreModule, LocalizationModule],
-                imports: [
-                    BaseCoreModule,
-                    LocalizationModule,
-                    NgxsModule.forFeature([ProfileState]),
-                    OAuthModule.forRoot(),
-                    HttpClientXsrfModule.withOptions({
-                        cookieName: 'XSRF-TOKEN',
-                        headerName: 'RequestVerificationToken',
-                    }),
-                ],
-            },] }
-];
+RootCoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RootCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RootCoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RootCoreModule, imports: [BaseCoreModule, LocalizationModule, i1$3.OAuthModule, i1.HttpClientXsrfModule], exports: [BaseCoreModule, LocalizationModule] });
+RootCoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RootCoreModule, imports: [[
+            BaseCoreModule,
+            LocalizationModule,
+            OAuthModule.forRoot(),
+            HttpClientXsrfModule.withOptions({
+                cookieName: 'XSRF-TOKEN',
+                headerName: 'RequestVerificationToken',
+            }),
+        ], BaseCoreModule, LocalizationModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RootCoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [BaseCoreModule, LocalizationModule],
+                    imports: [
+                        BaseCoreModule,
+                        LocalizationModule,
+                        OAuthModule.forRoot(),
+                        HttpClientXsrfModule.withOptions({
+                            cookieName: 'XSRF-TOKEN',
+                            headerName: 'RequestVerificationToken',
+                        }),
+                    ],
+                }]
+        }] });
 /**
  * CoreModule is the module that is publicly available
  */
@@ -3107,6 +2983,7 @@ class CoreModule {
             ngModule: RootCoreModule,
             providers: [
                 LocaleProvider,
+                CookieLanguageProvider,
                 {
                     provide: 'CORE_OPTIONS',
                     useValue: options,
@@ -3157,12 +3034,16 @@ class CoreModule {
         };
     }
 }
-CoreModule.decorators = [
-    { type: NgModule, args: [{
-                exports: [BaseCoreModule],
-                imports: [BaseCoreModule],
-            },] }
-];
+CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: CoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: CoreModule, imports: [BaseCoreModule], exports: [BaseCoreModule] });
+CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: CoreModule, imports: [[BaseCoreModule], BaseCoreModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [BaseCoreModule],
+                    imports: [BaseCoreModule],
+                }]
+        }] });
 function ngxsStoragePluginSerialize(data) {
     return data;
 }
@@ -3181,23 +3062,21 @@ class AuthGuard {
         return false;
     }
 }
-AuthGuard.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthGuard_Factory() { return new AuthGuard(i0.ɵɵinject(i1$1.OAuthService), i0.ɵɵinject(AuthService)); }, token: AuthGuard, providedIn: "root" });
-AuthGuard.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AuthGuard.ctorParameters = () => [
-    { type: OAuthService },
-    { type: AuthService }
-];
+AuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AuthGuard, deps: [{ token: i1$3.OAuthService }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AuthGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$3.OAuthService }, { type: AuthService }]; } });
 
 class PermissionGuard {
-    constructor(router, routesService, store, permissionService) {
+    constructor(router, routesService, permissionService, httpErrorReporter) {
         this.router = router;
         this.routesService = routesService;
-        this.store = store;
         this.permissionService = permissionService;
+        this.httpErrorReporter = httpErrorReporter;
     }
     canActivate(route, state) {
         let { requiredPolicy } = route.data || {};
@@ -3209,28 +3088,24 @@ class PermissionGuard {
             return of(true);
         return this.permissionService.getGrantedPolicy$(requiredPolicy).pipe(tap(access => {
             if (!access) {
-                this.store.dispatch(new RestOccurError({ status: 403 }));
+                this.httpErrorReporter.reportError({ status: 403 });
             }
         }));
     }
 }
-PermissionGuard.ɵprov = i0.ɵɵdefineInjectable({ factory: function PermissionGuard_Factory() { return new PermissionGuard(i0.ɵɵinject(i1.Router), i0.ɵɵinject(RoutesService), i0.ɵɵinject(i4.Store), i0.ɵɵinject(PermissionService)); }, token: PermissionGuard, providedIn: "root" });
-PermissionGuard.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-PermissionGuard.ctorParameters = () => [
-    { type: Router },
-    { type: RoutesService },
-    { type: Store },
-    { type: PermissionService }
-];
+PermissionGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionGuard, deps: [{ token: i1$1.Router }, { token: RoutesService }, { token: PermissionService }, { token: HttpErrorReporterService }], target: i0.ɵɵFactoryTarget.Injectable });
+PermissionGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: PermissionGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: RoutesService }, { type: PermissionService }, { type: HttpErrorReporterService }]; } });
 
 class ListResultDto {
     constructor(initialValues = {}) {
         for (const key in initialValues) {
-            if (initialValues.hasOwnProperty(key)) {
+            if (Object.prototype.hasOwnProperty.call(initialValues, key)) {
                 this[key] = initialValues[key];
             }
         }
@@ -3245,7 +3120,8 @@ class LimitedResultRequestDto {
     constructor(initialValues = {}) {
         this.maxResultCount = 10;
         for (const key in initialValues) {
-            if (initialValues.hasOwnProperty(key) && initialValues[key] !== undefined) {
+            if (Object.prototype.hasOwnProperty.call(initialValues, key) &&
+                initialValues[key] !== undefined) {
                 this[key] = initialValues[key];
             }
         }
@@ -3264,7 +3140,7 @@ class PagedAndSortedResultRequestDto extends PagedResultRequestDto {
 class EntityDto {
     constructor(initialValues = {}) {
         for (const key in initialValues) {
-            if (initialValues.hasOwnProperty(key)) {
+            if (Object.prototype.hasOwnProperty.call(initialValues, key)) {
                 this[key] = initialValues[key];
             }
         }
@@ -3303,7 +3179,7 @@ class FullAuditedEntityWithUserDto extends FullAuditedEntityDto {
 class ExtensibleObject {
     constructor(initialValues = {}) {
         for (const key in initialValues) {
-            if (initialValues.hasOwnProperty(key)) {
+            if (Object.prototype.hasOwnProperty.call(initialValues, key)) {
                 this[key] = initialValues[key];
             }
         }
@@ -3345,30 +3221,33 @@ class ExtensibleFullAuditedEntityWithUserDto extends ExtensibleFullAuditedEntity
     }
 }
 
-/**
- * @deprecated Use AbpApplicationConfigurationService instead. To be deleted in v5.0.
- */
-class ApplicationConfigurationService {
-    constructor(rest) {
-        this.rest = rest;
-    }
-    getConfiguration() {
-        const request = {
+class AbpApiDefinitionService {
+    constructor(restService) {
+        this.restService = restService;
+        this.apiName = 'abp';
+        this.getByModel = (model) => this.restService.request({
             method: 'GET',
-            url: '/api/abp/application-configuration',
-        };
-        return this.rest.request(request, {});
-    }
-}
-ApplicationConfigurationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ApplicationConfigurationService_Factory() { return new ApplicationConfigurationService(i0.ɵɵinject(RestService)); }, token: ApplicationConfigurationService, providedIn: "root" });
-ApplicationConfigurationService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ApplicationConfigurationService.ctorParameters = () => [
-    { type: RestService }
-];
+            url: '/api/abp/api-definition',
+            params: { includeTypes: model.includeTypes },
+        }, { apiName: this.apiName });
+    }
+}
+AbpApiDefinitionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpApiDefinitionService, deps: [{ token: RestService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbpApiDefinitionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpApiDefinitionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: AbpApiDefinitionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RestService }]; } });
+
+/* eslint-disable @typescript-eslint/ban-types */
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+/* eslint-disable @typescript-eslint/ban-types */
 
 class ContentProjectionService {
     constructor(injector) {
@@ -3378,13 +3257,12 @@ class ContentProjectionService {
         return projectionStrategy.injectContent(injector);
     }
 }
-ContentProjectionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContentProjectionService_Factory() { return new ContentProjectionService(i0.ɵɵinject(i0.INJECTOR)); }, token: ContentProjectionService, providedIn: "root" });
-ContentProjectionService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-ContentProjectionService.ctorParameters = () => [
-    { type: Injector }
-];
+ContentProjectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ContentProjectionService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ContentProjectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ContentProjectionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ContentProjectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
 function getShortDateFormat(configStateService) {
     const dateTimeFormat = configStateService.getDeep('localization.currentCulture.dateTimeFormat');
@@ -3436,7 +3314,6 @@ function downloadBlob(blob, filename) {
 }
 
 function isNumber(value) {
-    /* tslint:disable-next-line:triple-equals */
     return value == Number(value);
 }
 
@@ -3451,7 +3328,6 @@ function mapEnumToOptions(_enum) {
     return options;
 }
 
-// tslint:disable: no-bitwise
 function uuid(a) {
     return a
         ? (a ^ ((Math.random() * 16) >> (a / 4))).toString(16)
@@ -3561,7 +3437,6 @@ function fromLazyLoad(element, domStrategy = DOM_STRATEGY.AppendToHead(), crossO
     });
 }
 function createErrorHandler(observer, element) {
-    /* tslint:disable-next-line:only-arrow-functions */
     return function (event) {
         clearCallbacks(element);
         element.parentNode.removeChild(element);
@@ -3577,30 +3452,6 @@ function clearCallbacks(element) {
     element.onsuspend = null;
 }
 
-// tslint:disable: max-line-length
-function isFunction(value) {
-    return typeof value === 'function';
-}
-/**
- * @deprecated no longer working, please use SubscriptionService (https://docs.abp.io/en/abp/latest/UI/Angular/Subscription-Service) instead.
- */
-const takeUntilDestroy = (componentInstance, destroyMethodName = 'ngOnDestroy') => (source) => {
-    const originalDestroy = componentInstance[destroyMethodName];
-    if (isFunction(originalDestroy) === false) {
-        throw new Error(`${componentInstance.constructor.name} is using untilDestroyed but doesn't implement ${destroyMethodName}`);
-    }
-    if (!componentInstance['__takeUntilDestroy']) {
-        componentInstance['__takeUntilDestroy'] = new Subject();
-        componentInstance[destroyMethodName] = function () {
-            // tslint:disable-next-line: no-unused-expression
-            isFunction(originalDestroy) && originalDestroy.apply(this, arguments);
-            componentInstance['__takeUntilDestroy'].next(true);
-            componentInstance['__takeUntilDestroy'].complete();
-        };
-    }
-    return source.pipe(takeUntil(componentInstance['__takeUntilDestroy']));
-};
-
 class DomInsertionService {
     constructor() {
         this.inserted = new Set();
@@ -3623,10 +3474,12 @@ class DomInsertionService {
         return this.inserted.has(hash);
     }
 }
-DomInsertionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DomInsertionService_Factory() { return new DomInsertionService(); }, token: DomInsertionService, providedIn: "root" });
-DomInsertionService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
+DomInsertionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: DomInsertionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DomInsertionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: DomInsertionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: DomInsertionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 class ResourceWaitService {
     constructor() {
@@ -3655,12 +3508,14 @@ class ResourceWaitService {
         this.store.patch({ resources });
     }
 }
-ResourceWaitService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ResourceWaitService_Factory() { return new ResourceWaitService(); }, token: ResourceWaitService, providedIn: "root" });
-ResourceWaitService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
+ResourceWaitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ResourceWaitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResourceWaitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ResourceWaitService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ResourceWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 class LazyLoadService {
     constructor(resourceWaitService) {
@@ -3685,15 +3540,14 @@ class LazyLoadService {
         return true;
     }
 }
-LazyLoadService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LazyLoadService_Factory() { return new LazyLoadService(i0.ɵɵinject(ResourceWaitService)); }, token: LazyLoadService, providedIn: "root" });
-LazyLoadService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-LazyLoadService.ctorParameters = () => [
-    { type: ResourceWaitService }
-];
+LazyLoadService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LazyLoadService, deps: [{ token: ResourceWaitService }], target: i0.ɵɵFactoryTarget.Injectable });
+LazyLoadService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LazyLoadService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: LazyLoadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: ResourceWaitService }]; } });
 
 const LIST_QUERY_DEBOUNCE_TIME = new InjectionToken('LIST_QUERY_DEBOUNCE_TIME');
 
@@ -3789,256 +3643,11 @@ class ListService {
         });
     }
 }
-ListService.decorators = [
-    { type: Injectable }
-];
-ListService.ctorParameters = () => [
-    { type: Injector }
-];
-
-var ConfigState_1;
-/**
- * @deprecated Use ConfigStateService instead. To be deleted in v5.0.
- */
-let ConfigState = ConfigState_1 = class ConfigState {
-    constructor(store, environmentService, configState) {
-        this.store = store;
-        this.environmentService = environmentService;
-        this.configState = configState;
-        this.syncConfigState();
-        this.syncEnvironment();
-    }
-    static getAll(state) {
-        return state;
-    }
-    static getApplicationInfo(state) {
-        return state.environment.application || {};
-    }
-    static getEnvironment(state) {
-        return state.environment;
-    }
-    static getOne(key) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            return state[key];
-        });
-        return selector;
-    }
-    static getDeep(keys) {
-        if (typeof keys === 'string') {
-            keys = keys.split('.');
-        }
-        if (!Array.isArray(keys)) {
-            throw new Error('The argument must be a dot string or an string array.');
-        }
-        const selector = createSelector([ConfigState_1], (state) => {
-            return keys.reduce((acc, val) => {
-                if (acc) {
-                    return acc[val];
-                }
-                return undefined;
-            }, state);
-        });
-        return selector;
-    }
-    static getApiUrl(key) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            return (state.environment.apis[key || 'default'] || state.environment.apis.default).url;
-        });
-        return selector;
-    }
-    static getFeature(key) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            return snq(() => state.features.values[key]);
-        });
-        return selector;
-    }
-    static getSetting(key) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            return snq(() => state.setting.values[key]);
-        });
-        return selector;
-    }
-    static getSettings(keyword) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            const settings = snq(() => state.setting.values, {});
-            if (!keyword)
-                return settings;
-            const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
-            return keysFound.reduce((acc, key) => {
-                acc[key] = settings[key];
-                return acc;
-            }, {});
-        });
-        return selector;
-    }
-    /**
-     * @deprecated use PermissionService's getGrantedPolicyStream or getGrantedPolicy methods.
-     */
-    static getGrantedPolicy(key) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            if (!key)
-                return true;
-            const getPolicy = (k) => snq(() => state.auth.grantedPolicies[k], false);
-            const orRegexp = /\|\|/g;
-            const andRegexp = /&&/g;
-            // TODO: Allow combination of ANDs & ORs
-            if (orRegexp.test(key)) {
-                const keys = key.split('||').filter(Boolean);
-                if (keys.length < 2)
-                    return false;
-                return keys.some(k => getPolicy(k.trim()));
-            }
-            else if (andRegexp.test(key)) {
-                const keys = key.split('&&').filter(Boolean);
-                if (keys.length < 2)
-                    return false;
-                return keys.every(k => getPolicy(k.trim()));
-            }
-            return getPolicy(key);
-        });
-        return selector;
-    }
-    static getLocalizationResource(resourceName) {
-        const selector = createSelector([ConfigState_1], (state) => {
-            return state.localization.values[resourceName];
-        });
-        return selector;
-    }
-    static getLocalization(key, ...interpolateParams) {
-        if (!key)
-            key = '';
-        let defaultValue;
-        if (typeof key !== 'string') {
-            defaultValue = key.defaultValue;
-            key = key.key;
-        }
-        const keys = key.split('::');
-        const selector = createSelector([ConfigState_1], (state) => {
-            const warn = (message) => {
-                if (!state.environment.production)
-                    console.warn(message);
-            };
-            if (keys.length < 2) {
-                warn('The localization source separator (::) not found.');
-                return defaultValue || key;
-            }
-            if (!state.localization)
-                return defaultValue || keys[1];
-            const sourceName = keys[0] ||
-                snq(() => state.environment.localization.defaultResourceName) ||
-                state.localization.defaultResourceName;
-            const sourceKey = keys[1];
-            if (sourceName === '_') {
-                return defaultValue || sourceKey;
-            }
-            if (!sourceName) {
-                warn('Localization source name is not specified and the defaultResourceName was not defined!');
-                return defaultValue || sourceKey;
-            }
-            const source = state.localization.values[sourceName];
-            if (!source) {
-                warn('Could not find localization source: ' + sourceName);
-                return defaultValue || sourceKey;
-            }
-            let localization = source[sourceKey];
-            if (typeof localization === 'undefined') {
-                return defaultValue || sourceKey;
-            }
-            interpolateParams = interpolateParams.filter(params => params != null);
-            if (localization)
-                localization = interpolate(localization, interpolateParams);
-            if (typeof localization !== 'string')
-                localization = '';
-            return localization || defaultValue || key;
-        });
-        return selector;
-    }
-    syncConfigState() {
-        this.configState
-            .createOnUpdateStream(state => state)
-            .pipe(distinctUntilChanged(compare))
-            .subscribe(config => this.store.dispatch(new PatchConfigState(config)));
-    }
-    syncEnvironment() {
-        this.environmentService
-            .createOnUpdateStream(state => state)
-            .pipe(distinctUntilChanged(compare))
-            .subscribe(env => this.store.dispatch(new PatchConfigState({ environment: env })));
-    }
-    addData({ patchState, dispatch }) {
-        const apiName = 'default';
-        const api = this.store.selectSnapshot(ConfigState_1.getApiUrl(apiName));
-        return this.configState.refreshAppState().pipe(catchError((err) => {
-            dispatch(new RestOccurError(err));
-            return throwError(err);
-        }));
-    }
-    setEnvironment(_, { environment }) {
-        return this.environmentService.setState(environment);
-    }
-    setConfig({ patchState, getState }, { state }) {
-        patchState(Object.assign(Object.assign({}, getState()), state));
-    }
-};
-ConfigState.decorators = [
-    { type: Injectable }
-];
-ConfigState.ctorParameters = () => [
-    { type: Store },
-    { type: EnvironmentService },
-    { type: ConfigStateService }
-];
-__decorate([
-    Action(GetAppConfiguration)
-], ConfigState.prototype, "addData", null);
-__decorate([
-    Action(SetEnvironment)
-], ConfigState.prototype, "setEnvironment", null);
-__decorate([
-    Action(PatchConfigState)
-], ConfigState.prototype, "setConfig", null);
-__decorate([
-    Selector()
-], ConfigState, "getAll", null);
-__decorate([
-    Selector()
-], ConfigState, "getApplicationInfo", null);
-__decorate([
-    Selector()
-], ConfigState, "getEnvironment", null);
-ConfigState = ConfigState_1 = __decorate([
-    State({
-        name: 'ConfigState',
-        defaults: {},
-    })
-], ConfigState);
-
-class ProfileStateService {
-    constructor(store) {
-        this.store = store;
-    }
-    getProfile() {
-        return this.store.selectSnapshot(ProfileState.getProfile);
-    }
-    dispatchGetProfile() {
-        return this.store.dispatch(new GetProfile());
-    }
-    dispatchUpdateProfile(...args) {
-        return this.store.dispatch(new UpdateProfile(...args));
-    }
-    dispatchChangePassword(...args) {
-        return this.store.dispatch(new ChangePassword(...args));
-    }
-}
-ProfileStateService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ProfileStateService_Factory() { return new ProfileStateService(i0.ɵɵinject(i4.Store)); }, token: ProfileStateService, providedIn: "root" });
-ProfileStateService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-ProfileStateService.ctorParameters = () => [
-    { type: Store }
-];
+ListService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ListService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ListService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ListService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: ListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
 class RouterWaitService {
     constructor(routerEvents, injector) {
@@ -4073,31 +3682,33 @@ class RouterWaitService {
         this.store.patch({ loading });
     }
 }
-RouterWaitService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RouterWaitService_Factory() { return new RouterWaitService(i0.ɵɵinject(RouterEvents), i0.ɵɵinject(i0.INJECTOR)); }, token: RouterWaitService, providedIn: "root" });
-RouterWaitService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-RouterWaitService.ctorParameters = () => [
-    { type: RouterEvents },
-    { type: Injector }
-];
+RouterWaitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterWaitService, deps: [{ token: RouterEvents }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterWaitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterWaitService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: RouterWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: RouterEvents }, { type: i0.Injector }]; } });
 
 const trackBy = (key) => (_, item) => item[key];
-const trackByDeep = (...keys) => (_, item) => keys.reduce((acc, key) => acc[key], item);
+const trackByDeep = (
+// eslint-disable-next-line @typescript-eslint/ban-types
+...keys) => (_, item) => keys.reduce((acc, key) => acc[key], item);
 class TrackByService {
     constructor() {
         this.by = trackBy;
         this.byDeep = trackByDeep;
     }
 }
-TrackByService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TrackByService_Factory() { return new TrackByService(); }, token: TrackByService, providedIn: "root" });
-TrackByService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
+TrackByService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: TrackByService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TrackByService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: TrackByService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.6", ngImport: i0, type: TrackByService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
 class ContainerStrategy {
     constructor(containerRef) {
@@ -4166,13 +3777,17 @@ const CONTENT_SECURITY_STRATEGY = {
 };
 
 class ContentStrategy {
-    constructor(content, domStrategy = DOM_STRATEGY.AppendToHead(), contentSecurityStrategy = CONTENT_SECURITY_STRATEGY.None()) {
+    constructor(content, domStrategy = DOM_STRATEGY.AppendToHead(), contentSecurityStrategy = CONTENT_SECURITY_STRATEGY.None(), options = {}) {
         this.content = content;
         this.domStrategy = domStrategy;
         this.contentSecurityStrategy = contentSecurityStrategy;
+        this.options = options;
     }
     insertElement() {
         const element = this.createElement();
+        if (this.options && Object.keys(this.options).length > 0) {
+            Object.keys(this.options).forEach(key => (element[key] = this.options[key]));
+        }
         this.contentSecurityStrategy.applyCSP(element);
         this.domStrategy.insertElement(element);
         return element;
@@ -4193,17 +3808,17 @@ class ScriptContentStrategy extends ContentStrategy {
     }
 }
 const CONTENT_STRATEGY = {
-    AppendScriptToBody(content) {
-        return new ScriptContentStrategy(content, DOM_STRATEGY.AppendToBody());
+    AppendScriptToBody(content, options) {
+        return new ScriptContentStrategy(content, DOM_STRATEGY.AppendToBody(), undefined, options);
     },
-    AppendScriptToHead(content) {
-        return new ScriptContentStrategy(content, DOM_STRATEGY.AppendToHead());
+    AppendScriptToHead(content, options) {
+        return new ScriptContentStrategy(content, DOM_STRATEGY.AppendToHead(), undefined, options);
     },
-    AppendStyleToHead(content) {
-        return new StyleContentStrategy(content, DOM_STRATEGY.AppendToHead());
+    AppendStyleToHead(content, options) {
+        return new StyleContentStrategy(content, DOM_STRATEGY.AppendToHead(), undefined, options);
     },
-    PrependStyleToHead(content) {
-        return new StyleContentStrategy(content, DOM_STRATEGY.PrependToHead());
+    PrependStyleToHead(content, options) {
+        return new StyleContentStrategy(content, DOM_STRATEGY.PrependToHead(), undefined, options);
     },
 };
 
@@ -4211,7 +3826,6 @@ class ContextStrategy {
     constructor(context) {
         this.context = context;
     }
-    /* tslint:disable-next-line:no-unused-variable */
     setContext(componentRef) {
         return this.context;
     }
@@ -4413,7 +4027,6 @@ function isValidCreditCard(value) {
     let multiplier = 1;
     for (let i = value.length; i > 0; i--) {
         const digit = Number(value[i - 1]) * multiplier;
-        /* tslint:disable-next-line:no-bitwise */
         checksum += (digit % 10) + ~~(digit / 10);
         multiplier = (multiplier * 2) % 3;
     }
@@ -4479,10 +4092,9 @@ function isValidUrl(value) {
     return false;
 }
 
-const ɵ0 = () => Validators.email;
 const AbpValidators = {
     creditCard: validateCreditCard,
-    emailAddress: ɵ0,
+    emailAddress: () => Validators.email,
     minAge: validateMinAge,
     range: validateRange,
     required: validateRequired,
@@ -4490,38 +4102,11 @@ const AbpValidators = {
     url: validateUrl,
 };
 
-class AbpApiDefinitionService {
-    constructor(restService) {
-        this.restService = restService;
-        this.apiName = 'abp';
-        this.getByModel = (model) => this.restService.request({
-            method: 'GET',
-            url: '/api/abp/api-definition',
-            params: { includeTypes: model.includeTypes },
-        }, { apiName: this.apiName });
-    }
-}
-AbpApiDefinitionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AbpApiDefinitionService_Factory() { return new AbpApiDefinitionService(i0.ɵɵinject(RestService)); }, token: AbpApiDefinitionService, providedIn: "root" });
-AbpApiDefinitionService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AbpApiDefinitionService.ctorParameters = () => [
-    { type: RestService }
-];
-
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null
-});
-
-/*
- * Public API Surface of core
- */
+// export * from './lib/handlers';
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { APP_INIT_ERROR_HANDLERS, AbpApiDefinitionService, AbpApplicationConfigurationService, AbpTenantService, AbpValidators, AbstractNavTreeService, AbstractNgModelComponent, AbstractTreeService, ApiInterceptor, ApplicationConfigurationService, AuditedEntityDto, AuditedEntityWithUserDto, AuthGuard, AuthService, AutofocusDirective, BaseCoreModule, BaseTreeNode, CONTAINER_STRATEGY, CONTENT_SECURITY_STRATEGY, CONTENT_STRATEGY, CONTEXT_STRATEGY, CORE_OPTIONS, CROSS_ORIGIN_STRATEGY, ChangePassword, ClearContainerStrategy, ComponentContextStrategy, ComponentProjectionStrategy, ConfigState, ConfigStateService, ContainerStrategy, ContentProjectionService, ContentSecurityStrategy, ContentStrategy, ContextStrategy, CoreModule, CreationAuditedEntityDto, CreationAuditedEntityWithUserDto, CrossOriginStrategy, DOM_STRATEGY, DomInsertionService, DomStrategy, DynamicLayoutComponent, EntityDto, EnvironmentService, ExtensibleAuditedEntityDto, ExtensibleAuditedEntityWithUserDto, ExtensibleCreationAuditedEntityDto, ExtensibleCreationAuditedEntityWithUserDto, ExtensibleEntityDto, ExtensibleFullAuditedEntityDto, ExtensibleFullAuditedEntityWithUserDto, ExtensibleObject, ForDirective, FormSubmitDirective, FullAuditedEntityDto, FullAuditedEntityWithUserDto, GetAppConfiguration, GetProfile, HttpWaitService, InitDirective, InputEventDebounceDirective, InsertIntoContainerStrategy, InternalStore, LIST_QUERY_DEBOUNCE_TIME, LOADER_DELAY, LOADING_STRATEGY, LazyLoadService, LazyModuleFactory, LimitedResultRequestDto, ListResultDto, ListService, LoadingStrategy, LocalizationModule, LocalizationPipe, LocalizationService, LooseContentSecurityStrategy, MultiTenancyService, NAVIGATE_TO_MANAGE_PROFILE, NavigationEvent, NoContentSecurityStrategy, NoContextStrategy, NoCrossOriginStrategy, index as ObjectExtending, PROJECTION_STRATEGY, PagedAndSortedResultRequestDto, PagedResultDto, PagedResultRequestDto, PermissionDirective, PermissionGuard, PermissionService, ProfileService, ProfileState, ProfileStateService, ProjectionStrategy, ReplaceableComponentsService, ReplaceableRouteContainerComponent, ReplaceableTemplateDirective, ResourceWaitService, RestOccurError, RestService, RootComponentProjectionStrategy, RootCoreModule, RouterEvents, RouterOutletComponent, RouterWaitService, RoutesService, ScriptContentStrategy, ScriptLoadingStrategy, SessionStateService, SetEnvironment, SettingTabsService, SortPipe, StartLoader, StopLoader, StopPropagationDirective, StyleContentStrategy, StyleLoadingStrategy, SubscriptionService, TENANT_KEY, TemplateContextStrategy, TemplateProjectionStrategy, TrackByService, UpdateProfile, VisibilityDirective, WebHttpUrlEncodingCodec, checkAccessToken, coreOptionsFactory, createLocalizationPipeKeyGenerator, createLocalizer, createLocalizerWithFallback, createMapFromList, createTokenParser, createTreeFromList, createTreeNodeFilterCreator, deepMerge, differentLocales, downloadBlob, exists, featuresFactory, findRoute, fromLazyLoad, generateHash, generatePassword, getInitialData, getLocaleDirection, getPathName, getRemoteEnv, getRoutePath, getShortDateFormat, getShortDateShortTimeFormat, getShortTimeFormat, interpolate, isArray, isNode, isNullOrUndefined, isNumber, isObject, isObjectAndNotArray, isObjectAndNotArrayNotNode, isUndefinedOrEmptyString, localeInitializer, mapEnumToOptions, ngxsStoragePluginSerialize, noop, parseTenantFromUrl, pipeToLogin, pushValueTo, reloadRoute, removeRememberMe, setRememberMe, setTokenResponseToStorage, storageFactory, takeUntilDestroy, trackBy, trackByDeep, uuid, validateCreditCard, validateMinAge, validateRange, validateRequired, validateStringLength, validateUrl, oAuthStorage as ɵa, LocalizationPipe as ɵb, SortPipe as ɵba, StopPropagationDirective as ɵbb, VisibilityDirective as ɵbc, ProfileState as ɵbd, ProfileService as ɵbe, GetProfile as ɵbf, UpdateProfile as ɵbg, ChangePassword as ɵbh, LocaleId as ɵbj, LocaleProvider as ɵbk, ApiInterceptor as ɵbl, TENANT_KEY as ɵbm, HttpWaitService as ɵbn, OAuthConfigurationHandler as ɵbo, noop as ɵbp, getInitialData as ɵbq, localeInitializer as ɵbr, RoutesHandler as ɵbs, AbstractTreeService as ɵbt, AbstractNavTreeService as ɵbu, RoutesService as ɵbv, LocalizationService as ɵc, SessionStateService as ɵd, ConfigStateService as ɵe, AbpApplicationConfigurationService as ɵf, RestService as ɵg, CORE_OPTIONS as ɵh, coreOptionsFactory as ɵi, EnvironmentService as ɵk, AbstractNgModelComponent as ɵl, AutofocusDirective as ɵm, DynamicLayoutComponent as ɵn, SubscriptionService as ɵo, ReplaceableComponentsService as ɵp, RouterEvents as ɵq, ForDirective as ɵr, FormSubmitDirective as ɵs, InitDirective as ɵt, InputEventDebounceDirective as ɵu, PermissionDirective as ɵv, PermissionService as ɵw, ReplaceableRouteContainerComponent as ɵx, ReplaceableTemplateDirective as ɵy, RouterOutletComponent as ɵz };
+export { APP_INIT_ERROR_HANDLERS, AbpApiDefinitionService, AbpApplicationConfigurationService, AbpTenantService, AbpValidators, AbstractNavTreeService, AbstractNgModelComponent, AbstractTreeService, ApiInterceptor, AuditedEntityDto, AuditedEntityWithUserDto, AuthGuard, AuthService, AutofocusDirective, BaseCoreModule, BaseTreeNode, CONTAINER_STRATEGY, CONTENT_SECURITY_STRATEGY, CONTENT_STRATEGY, CONTEXT_STRATEGY, COOKIE_LANGUAGE_KEY, CORE_OPTIONS, CROSS_ORIGIN_STRATEGY, ClearContainerStrategy, ComponentContextStrategy, ComponentProjectionStrategy, ConfigStateService, ContainerStrategy, ContentProjectionService, ContentSecurityStrategy, ContentStrategy, ContextStrategy, CoreModule, CreationAuditedEntityDto, CreationAuditedEntityWithUserDto, CrossOriginStrategy, DOM_STRATEGY, DomInsertionService, DomStrategy, DynamicLayoutComponent, EntityDto, EnvironmentService, ExtensibleAuditedEntityDto, ExtensibleAuditedEntityWithUserDto, ExtensibleCreationAuditedEntityDto, ExtensibleCreationAuditedEntityWithUserDto, ExtensibleEntityDto, ExtensibleFullAuditedEntityDto, ExtensibleFullAuditedEntityWithUserDto, ExtensibleObject, ForDirective, FormSubmitDirective, FullAuditedEntityDto, FullAuditedEntityWithUserDto, HttpErrorReporterService, HttpWaitService, InitDirective, InputEventDebounceDirective, InsertIntoContainerStrategy, InternalStore, LIST_QUERY_DEBOUNCE_TIME, LOADER_DELAY, LOADING_STRATEGY, LazyLoadService, LazyModuleFactory, LimitedResultRequestDto, ListResultDto, ListService, LoadingStrategy, LocalizationModule, LocalizationPipe, LocalizationService, LooseContentSecurityStrategy, MultiTenancyService, NAVIGATE_TO_MANAGE_PROFILE, NavigationEvent, NoContentSecurityStrategy, NoContextStrategy, NoCrossOriginStrategy, index as ObjectExtending, PROJECTION_STRATEGY, PagedAndSortedResultRequestDto, PagedResultDto, PagedResultRequestDto, PermissionDirective, PermissionGuard, PermissionService, ProjectionStrategy, ReplaceableComponentsService, ReplaceableRouteContainerComponent, ReplaceableTemplateDirective, ResourceWaitService, RestService, RootComponentProjectionStrategy, RootCoreModule, RouterEvents, RouterOutletComponent, RouterWaitService, RoutesService, ScriptContentStrategy, ScriptLoadingStrategy, SessionStateService, SortPipe, StopPropagationDirective, StyleContentStrategy, StyleLoadingStrategy, SubscriptionService, TENANT_KEY, TemplateContextStrategy, TemplateProjectionStrategy, TrackByService, WebHttpUrlEncodingCodec, checkAccessToken, coreOptionsFactory, createLocalizationPipeKeyGenerator, createLocalizer, createLocalizerWithFallback, createMapFromList, createTokenParser, createTreeFromList, createTreeNodeFilterCreator, deepMerge, differentLocales, downloadBlob, exists, featuresFactory, findRoute, fromLazyLoad, generateHash, generatePassword, getInitialData, getLocaleDirection, getPathName, getRemoteEnv, getRoutePath, getShortDateFormat, getShortDateShortTimeFormat, getShortTimeFormat, interpolate, isArray, isNode, isNullOrUndefined, isNumber, isObject, isObjectAndNotArray, isObjectAndNotArrayNotNode, isUndefinedOrEmptyString, localeInitializer, mapEnumToOptions, ngxsStoragePluginSerialize, noop, parseTenantFromUrl, pipeToLogin, pushValueTo, reloadRoute, removeRememberMe, setRememberMe, setTokenResponseToStorage, storageFactory, trackBy, trackByDeep, uuid, validateCreditCard, validateMinAge, validateRange, validateRequired, validateStringLength, validateUrl };
 //# sourceMappingURL=abp-ng.core.js.map