@eui/core 13.0.0-beta.14 → 13.0.0-beta.18

package/fesm2020/eui-core.mjs

@@ -0,0 +1,4592 @@
+import * as i1 from '@eui/base';
+import { LogLevel, ConsoleAppender, Logger, LoggerMock, mergeAll, getI18nLoaderConfig, EuiLazyService, getI18nServiceConfigFromBase, getI18nState, getLastAddedModule, getBrowserDefaultLanguage, UxEuLanguages, getActiveLang, initialAppState, initialUserState, initialNotificationsState, initialI18nState, initialLocaleState, xhr, getApiQueue, getApiQueueItem, EuiService, getUserRights, getUserState, UxPublishErrorFeedbackEvent, UxClearErrorFeedbackEvent, getLocaleServiceConfigFromBase, getLocaleState, transformToUxHttpResponse } from '@eui/base';
+export * from '@eui/base';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Injector, NgModule, Optional, APP_INITIALIZER, EventEmitter, PLATFORM_ID, SkipSelf, ErrorHandler, LOCALE_ID } from '@angular/core';
+import * as i1$2 from '@angular/common/http';
+import { HttpClientModule, HttpErrorResponse, HttpResponse, HttpHeaders, HttpEventType } from '@angular/common/http';
+import * as extendProxy from 'extend';
+import { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';
+import { MomentDateAdapter } from '@angular/material-moment-adapter';
+import { LOCATION_INITIALIZED, DOCUMENT, isPlatformBrowser, getLocaleId, registerLocaleData } from '@angular/common';
+import * as i1$1 from '@ngrx/store';
+import { createSelector } from '@ngrx/store';
+import { throwError, forkJoin, of, BehaviorSubject, defer, merge, fromEvent, Observable, Subject, from } from 'rxjs';
+import { debounceTime, distinctUntilChanged, map, catchError, switchMap, tap, filter, take, mapTo, mergeMap, concatMap, takeUntil } from 'rxjs/operators';
+import { __decorate, __metadata } from 'tslib';
+import * as i2 from '@ngx-translate/core';
+import { TranslateLoader } from '@ngx-translate/core';
+import * as i1$3 from '@ngrx/effects';
+import { ofType, Effect } from '@ngrx/effects';
+import * as i2$1 from '@angular/router';
+import { NavigationEnd } from '@angular/router';
+import isEqual from 'lodash-es/isEqual';
+import get from 'lodash-es/get';
+import { By } from '@angular/platform-browser';
+import { FormGroup, FormArray } from '@angular/forms';
+import { DomPortalOutlet, ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import * as lf from 'localforage';
+
+/** default log configuration */
+const DEFAULT_LOG_CONFIG = {
+    baseLoggerName: 'root',
+    logLevel: LogLevel.ERROR,
+    logAppenders: {
+        type: ConsoleAppender,
+        prefixFormat: '[{level}]',
+    },
+};
+const DEFAULT_I18N_SERVICE_CONFIG = {
+    languages: ['en'],
+    defaultLanguage: 'en',
+};
+const DEFAULT_I18N_LOADER_CONFIG = {};
+const DEFAULT_LOCALE_SERVICE_CONFIG = {
+    id: 'en',
+    available: ['en'],
+    registered: ['en'],
+    bindWithTranslate: false,
+    affectGlobalLocale: false
+};
+const DEFAULT_HTTP_ERROR_HANDLER_CONFIG = {
+    routes: [],
+};
+const DEFAULT_GLOBAL_CONFIG = {
+    showConnectionStatus: true,
+    i18n: {
+        i18nService: {
+            ...DEFAULT_I18N_SERVICE_CONFIG,
+        },
+        i18nLoader: {
+            ...DEFAULT_I18N_LOADER_CONFIG,
+        },
+    },
+    locale: {
+        ...DEFAULT_LOCALE_SERVICE_CONFIG
+    },
+    user: {
+        defaultUserPreferences: {
+            locale: {
+                ...DEFAULT_LOCALE_SERVICE_CONFIG
+            }
+        }
+    }
+};
+const DEFAULT_EUI_APP_CONFIG = {
+    global: {
+        ...DEFAULT_GLOBAL_CONFIG,
+    },
+};
+const DEFAULT_EUI_ENV_CONFIG = {
+    envAppHandlersConfig: {},
+};
+const DEFAULT_EUI_CONFIG = {
+    appConfig: {
+        ...DEFAULT_EUI_APP_CONFIG,
+    },
+    environment: {
+        ...DEFAULT_EUI_ENV_CONFIG,
+    },
+};
+
+const extend$1 = extendProxy.default || extendProxy;
+const EUI_CONFIG_TOKEN = new InjectionToken('EuiConfig');
+const MODULE_NAME_TOKEN = new InjectionToken('moduleName');
+const MODULE_CONFIG_TOKEN = new InjectionToken('moduleConfig');
+const CONFIG_TOKEN = new InjectionToken('finalConfigToken');
+const GLOBAL_CONFIG_TOKEN = new InjectionToken('globalConfig');
+const BASE_NAME_TOKEN = new InjectionToken('baseName');
+const ROOT_LOG_CONFIG_TOKEN = new InjectionToken('logConfig');
+const SHOW_CONNECTION_STATUS_TOKEN = new InjectionToken('SHOW_CONNECTION_STATUS');
+const HTTP_ERROR_HANDLER_CONFIG_TOKEN = new InjectionToken('HTTP_ERROR_HANDLER_CONFIG');
+function getGlobalConfig(appConfig) {
+    return Object.assign(DEFAULT_EUI_CONFIG.appConfig.global, appConfig && appConfig.global);
+}
+function getShowConnectionStatus(globalConfig) {
+    return Object.assign({}, DEFAULT_EUI_CONFIG.appConfig.global.showConnectionStatus, globalConfig && globalConfig.showConnectionStatus);
+}
+function getModuleConfig(appConfig, moduleName) {
+    return Object.assign({}, appConfig && appConfig.modules && appConfig.modules[moduleName]);
+}
+function getHttpErrorHandlingConfig(appConfig) {
+    return Object.assign({}, appConfig && appConfig.httpErrorHandler);
+}
+function getRootLogConfig(appConfig) {
+    return Object.assign({}, appConfig && appConfig.log);
+}
+function prepareEuiAppConfigToken(euiConfig) {
+    const environment = euiConfig && euiConfig.environment;
+    const merge = environment.envDynamicConfig
+        && environment.envDynamicConfig.merge && Array.isArray(environment.envDynamicConfig.merge)
+        ? environment.envDynamicConfig.merge : [];
+    const isDeepMerge = environment.envDynamicConfig
+        && environment.envDynamicConfig.deepMerge
+        ? environment.envDynamicConfig.deepMerge : false;
+    const envAppJsonConfig = environment && environment.loadedEnvDynamicConfig;
+    const initialAppConfig = euiConfig && euiConfig.appConfig;
+    const envAppHandlersConfig = environment && environment.envAppHandlersConfig;
+    const envHandlersMergedAppConfig = mergeAppHandlerConfigToAppConfig(initialAppConfig, envAppHandlersConfig);
+    const finalConfig = mergeAppJsonConfigToAppConfig(envHandlersMergedAppConfig, envAppJsonConfig, merge, isDeepMerge);
+    return finalConfig;
+}
+function mergeAppHandlerConfigToAppConfig(euiAppConfig, envAppHandler) {
+    return Object.assign({}, euiAppConfig, envAppHandler);
+}
+function mergeAppJsonConfigToAppConfig(euiAppConfig, envAppJsonConfig, merge, isDeepMerge) {
+    const deepMerged = {};
+    if (merge && merge.length > 0) {
+        merge.forEach((key) => {
+            if (envAppJsonConfig[key] && typeof envAppJsonConfig[key] === 'object'
+                && euiAppConfig[key] && typeof euiAppConfig[key] === 'object') {
+                if (isDeepMerge) {
+                    deepMerged[key] = {};
+                    extend$1(true, deepMerged[key], euiAppConfig[key], envAppJsonConfig[key]);
+                }
+                else {
+                    envAppJsonConfig[key] = {
+                        ...euiAppConfig[key],
+                        ...envAppJsonConfig[key],
+                    };
+                }
+            }
+        });
+    }
+    return Object.assign({}, euiAppConfig, envAppJsonConfig, deepMerged);
+}
+
+const BASE_LOGGER_NAME_TOKEN = new InjectionToken('BASE_LOGGER_NAME');
+const LOG_LEVEL_TOKEN = new InjectionToken('LOG_LEVEL');
+const LOG_APPENDERS_TOKEN = new InjectionToken('LOG_APPENDERS');
+/**
+ * Log service, responsible for getting or creating loggers. It itself acts as a base logger
+ */
+class LogService extends Logger {
+    constructor(name, level, appenders) {
+        super(name, level, appenders);
+        this.name = name;
+        this.level = level;
+        this.appenders = appenders;
+        /** the list of persistent loggers */
+        this.loggers = {};
+    }
+    /**
+     * Gets a logger by name. If the logger does not exist, it is created
+     * @param loggerName logger name
+     * @param persist optional parameter. Set it to true if you want to reuse the logger. By default, it is set to false
+     * @returns the logger
+     */
+    getLogger(loggerName, persist = false) {
+        // create the logger, if necessary
+        const logger = persist && this.loggers[loggerName] || new Logger(loggerName, this.level, this.appenders);
+        // if the logger is persistent, add it to the list of persistent loggers
+        if (persist) {
+            this.loggers[loggerName] = logger;
+        }
+        return logger;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ LogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogService, deps: [{ token: BASE_LOGGER_NAME_TOKEN }, { token: LOG_LEVEL_TOKEN }, { token: LOG_APPENDERS_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BASE_LOGGER_NAME_TOKEN]
+                }] }, { type: i1.LogLevel, decorators: [{
+                    type: Inject,
+                    args: [LOG_LEVEL_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOG_APPENDERS_TOKEN]
+                }] }]; } });
+
+const LOG_INSTANCES = {};
+/**
+ * Helper function to check if the log config is defined.
+ * Does not check only for empty object, because the config can have  other (non-log) parameters
+ * @params config log configuration
+ * @returns true/false
+ */
+function isLogConfigDefined(config) {
+    return config && ('baseLoggerName' in config || 'logLevel' in config || 'logAppenders' in config);
+}
+/**
+ * Helper function to provide a list of log appenders from a log configuration
+ * @params config log configuration
+ * @returns an array of log appenders
+ */
+function getLogAppendersConfig(config = DEFAULT_LOG_CONFIG, injector = null) {
+    config = Object.assign({}, DEFAULT_LOG_CONFIG, config);
+    config.logAppenders = config.logAppenders || [];
+    config.logAppenders = Array.isArray(config.logAppenders) ? config.logAppenders : [config.logAppenders];
+    return config.logAppenders.map(logAppender => {
+        const appenderType = typeof logAppender === 'object' ? logAppender.type : logAppender;
+        const appenderParams = typeof logAppender === 'object' ? logAppender : undefined;
+        return new appenderType(appenderParams, injector);
+    });
+}
+/**
+ * Helper function to provide an instance of LogService from a configuration
+ * @params config log configuration
+ * @returns an instance of log service
+ */
+function logServiceFactory(config = DEFAULT_LOG_CONFIG, injector = null) {
+    // add the default values to config
+    config = Object.assign({}, DEFAULT_LOG_CONFIG, config);
+    // extract parameters from config
+    const logLevel = config.logLevel;
+    const logAppenders = getLogAppendersConfig(config, injector);
+    // return an instance of LogService
+    return new LogService(config.baseLoggerName, logLevel, logAppenders);
+}
+function euiLogServiceFactory(injector, rootBaseLoggerName, rootConfig, childBaseLoggerName = null, childConfig = {}) {
+    // determine if the configuration is for non-root modules
+    const forChild = isLogConfigDefined(childConfig);
+    const baseLoggerName = forChild ? childBaseLoggerName : rootBaseLoggerName;
+    // create the proper configuration
+    const config = Object.assign({ baseLoggerName: baseLoggerName }, forChild ? Object.assign({}, rootConfig, childConfig) : rootConfig);
+    // re-use the log service or create a new instance
+    const logService = LOG_INSTANCES[baseLoggerName] || logServiceFactory(config, injector);
+    LOG_INSTANCES[baseLoggerName] = logService;
+    return logService;
+}
+
+class LogServiceMock extends LoggerMock {
+    getLogger() {
+        return new LoggerMock();
+    }
+}
+
+const LOG_MODULE_CONFIG_TOKEN = new InjectionToken('LOG_CONFIG');
+/**
+ * Log Module
+ */
+class LogModule {
+    /** method called in your root module to provide the LogService */
+    static forRoot(config = DEFAULT_LOG_CONFIG) {
+        return {
+            ngModule: LogModule,
+            providers: [
+                { provide: LOG_MODULE_CONFIG_TOKEN, useValue: config },
+                { provide: LogService, useFactory: logServiceFactory, deps: [LOG_MODULE_CONFIG_TOKEN, Injector] },
+            ],
+        };
+    }
+    /** method called in your other (non root, lazy loaded) modules to import a different instance of LogService */
+    static forChild(config = DEFAULT_LOG_CONFIG) {
+        return {
+            ngModule: LogModule,
+            providers: [
+                { provide: LOG_MODULE_CONFIG_TOKEN, useValue: config },
+                { provide: LogService, useFactory: logServiceFactory, deps: [LOG_MODULE_CONFIG_TOKEN, Injector] },
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ LogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ LogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogModule });
+/** @nocollapse */ /** @nocollapse */ LogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LogModule, decorators: [{
+            type: NgModule
+        }] });
+
+var CoreAppActionTypes;
+(function (CoreAppActionTypes) {
+    CoreAppActionTypes["INIT_STORE"] = "[App] Init store";
+    CoreAppActionTypes["UPDATE_APP_VERSION"] = "[App] Update version";
+    CoreAppActionTypes["UPDATE_APP_CONNECTION"] = "[App] Update connection";
+    CoreAppActionTypes["ADD_APP_LOADED_CONFIG_MODULES"] = "[App] Update app loaded config modules";
+    CoreAppActionTypes["UPDATE_APP_STATUS"] = "[App] Update status";
+    CoreAppActionTypes["UPDATE_CURRENT_MODULE"] = "[App] Update current module";
+    CoreAppActionTypes["ACTIVATED_ROUTE"] = "[App] Activated route";
+    CoreAppActionTypes["ADD_API_QUEUE_ITEM"] = "[App] Add API queue item";
+    CoreAppActionTypes["REMOVE_API_QUEUE_ITEM"] = "[App] Remove API queue item";
+    CoreAppActionTypes["EMPTY_API_QUEUE"] = "[App] empty API queue";
+})(CoreAppActionTypes || (CoreAppActionTypes = {}));
+class InitStoreAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.INIT_STORE;
+    }
+}
+class UpdateAppVersionAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.UPDATE_APP_VERSION;
+    }
+}
+class UpdateAppConnectionAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.UPDATE_APP_CONNECTION;
+    }
+}
+class AddAppLoadedConfigModulesAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.ADD_APP_LOADED_CONFIG_MODULES;
+    }
+}
+class UpdateAppStatusAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.UPDATE_APP_STATUS;
+    }
+}
+class UpdateCurrentModuleAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.UPDATE_CURRENT_MODULE;
+    }
+}
+class ActivatedRouteAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.ACTIVATED_ROUTE;
+    }
+}
+class AddApiQueueItemAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.ADD_API_QUEUE_ITEM;
+    }
+}
+class RemoveApiQueueItemAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.REMOVE_API_QUEUE_ITEM;
+    }
+}
+class EmptyApiQueueAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreAppActionTypes.EMPTY_API_QUEUE;
+    }
+}
+
+var BrowserStorageType;
+(function (BrowserStorageType) {
+    BrowserStorageType[BrowserStorageType["local"] = 0] = "local";
+    BrowserStorageType[BrowserStorageType["session"] = 1] = "session";
+})(BrowserStorageType || (BrowserStorageType = {}));
+// todo should stay here but all the store directory should be moved upper level
+class StoreService {
+    constructor(store, logService) {
+        this.store = store;
+        this.logService = logService;
+        /**
+         * autoSave handlers to call before saving in local Storage
+         */
+        this._autoSaveHandlers = {};
+        /** storage instance e.g. localStorage, sessionStorage */
+        this._storage = localStorage;
+    }
+    // use init with just version info, to update to user state, UserService.updateState
+    // initializeStore(version?: string, userDetails?: BaseUserDetails) {
+    //     this.dispatch(new InitStoreAction({ version, userDetails }));
+    // }
+    init(version, storageType) {
+        this.dispatch(new InitStoreAction({ version }));
+        this._storage = storageType === BrowserStorageType.session ? sessionStorage : localStorage;
+    }
+    addAutoSaveHandler(stateSlice, handler) {
+        if (!this.store) {
+            if (this.logService) {
+                this.logService.warn('StoreService.addAutoSaveHandler() not available without NGRX');
+            }
+            return;
+        }
+        this._autoSaveHandlers[stateSlice] = handler;
+    }
+    handleAutoSave() {
+        if (!this.store) {
+            return;
+        }
+        this.store
+            .pipe(debounceTime(1000), distinctUntilChanged())
+            .subscribe(state => {
+            this.saveState(state);
+        });
+    }
+    /**
+     * Proxy to NGRX store.dispatch()
+     * that allows to intercept if the store is present
+     */
+    dispatch(action) {
+        if (this.store) {
+            return this.store.dispatch(action);
+        }
+    }
+    /**
+     * Proxy to NGRX store.select()
+     * that allows to intercept if the store is present
+     */
+    select(key) {
+        if (!this.store) {
+            return throwError(new Error('NGRX Store not configured'));
+        }
+        return this.store.select(key);
+    }
+    /**
+     * filters and save the state with the Browser storage
+     * @param state type of CoreState
+     */
+    saveState(state) {
+        let stateToSave = {
+            app: state.app,
+        };
+        if (state.user) {
+            const { userId, preferences } = state.user;
+            stateToSave.user = { userId, preferences };
+        }
+        Object.keys(this._autoSaveHandlers).forEach((sliceState) => {
+            const handler = this._autoSaveHandlers[sliceState];
+            stateToSave = Object.assign(stateToSave, { [sliceState]: handler(state[sliceState]) });
+        });
+        try {
+            const serializedState = JSON.stringify(stateToSave);
+            this._storage.setItem('state', serializedState);
+        }
+        catch (err) {
+            // Ignore write errors.
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ StoreService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: StoreService, deps: [{ token: i1$1.Store, optional: true }, { token: LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ StoreService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: StoreService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: StoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.Store, decorators: [{
+                    type: Optional
+                }] }, { type: LogService, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+function euiInitApp(injector) {
+    return () => {
+        return new Promise((resolve) => {
+            const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve(null));
+            locationInitialized.then(() => {
+                const appConfig = injector.get(CONFIG_TOKEN);
+                // necessary config parameters
+                const appVersion = appConfig && appConfig.versions && appConfig.versions.app;
+                const storageType = appConfig && appConfig.saveStateStorage;
+                const storeService = injector.get(StoreService);
+                storeService.init(appVersion, storageType);
+                storeService.handleAutoSave();
+                resolve(null);
+            });
+        });
+    };
+}
+
+function getCoreProviders() {
+    return [
+        // core config
+        ...getDependencyProviders(),
+        { provide: BASE_NAME_TOKEN, useValue: 'eui-core' },
+        // app config
+        { provide: CONFIG_TOKEN, useFactory: prepareEuiAppConfigToken, deps: [EUI_CONFIG_TOKEN] },
+        // global config
+        { provide: GLOBAL_CONFIG_TOKEN, useFactory: getGlobalConfig, deps: [CONFIG_TOKEN] },
+        { provide: ROOT_LOG_CONFIG_TOKEN, useFactory: getRootLogConfig, deps: [CONFIG_TOKEN] },
+        { provide: SHOW_CONNECTION_STATUS_TOKEN, useFactory: getShowConnectionStatus, deps: [GLOBAL_CONFIG_TOKEN] },
+        { provide: LogService, useFactory: euiLogServiceFactory, deps: [Injector, BASE_NAME_TOKEN, ROOT_LOG_CONFIG_TOKEN] },
+        { provide: HTTP_ERROR_HANDLER_CONFIG_TOKEN, useFactory: getHttpErrorHandlingConfig, deps: [CONFIG_TOKEN] },
+        { provide: APP_INITIALIZER, useFactory: euiInitApp, multi: true, deps: [Injector] },
+    ];
+}
+function getDependencyProviders() {
+    return [
+        { provide: DateAdapter, useClass: MomentDateAdapter, deps: [MAT_DATE_LOCALE] },
+    ];
+}
+function getCoreChildProviders(moduleName) {
+    return [
+        // module config
+        { provide: MODULE_NAME_TOKEN, useValue: moduleName },
+        { provide: MODULE_CONFIG_TOKEN, useFactory: getModuleConfig, deps: [CONFIG_TOKEN, MODULE_NAME_TOKEN] },
+        // log config
+        {
+            provide: LogService,
+            useFactory: euiLogServiceFactory,
+            deps: [Injector, BASE_NAME_TOKEN, ROOT_LOG_CONFIG_TOKEN, MODULE_NAME_TOKEN, MODULE_CONFIG_TOKEN],
+        },
+    ];
+}
+
+var CoreI18nActionTypes;
+(function (CoreI18nActionTypes) {
+    CoreI18nActionTypes["UPDATE_I18N_STATE"] = "[I18n] Update I18n State";
+})(CoreI18nActionTypes || (CoreI18nActionTypes = {}));
+class UpdateI18nStateAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreI18nActionTypes.UPDATE_I18N_STATE;
+    }
+}
+
+var CoreUserActionTypes;
+(function (CoreUserActionTypes) {
+    CoreUserActionTypes["UPDATE_USER_STATE"] = "[User] Update User state";
+    CoreUserActionTypes["UPDATE_USER_DETAILS"] = "[User] Update details";
+    CoreUserActionTypes["UPDATE_USER_PREFERENCES"] = "[User] Update preferences";
+    CoreUserActionTypes["UPDATE_USER_RIGHTS"] = "[User] Update rights";
+    CoreUserActionTypes["UPDATE_USER_DASHBOARD"] = "[User] Update dashboard";
+})(CoreUserActionTypes || (CoreUserActionTypes = {}));
+class UpdateUserStateAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreUserActionTypes.UPDATE_USER_STATE;
+    }
+}
+class UpdateUserDetailsAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreUserActionTypes.UPDATE_USER_DETAILS;
+    }
+}
+class UpdateUserPreferencesAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreUserActionTypes.UPDATE_USER_PREFERENCES;
+    }
+}
+class UpdateUserRightsAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreUserActionTypes.UPDATE_USER_RIGHTS;
+    }
+}
+class UpdateUserDashboardAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreUserActionTypes.UPDATE_USER_DASHBOARD;
+    }
+}
+
+var CoreNotificationsActionTypes;
+(function (CoreNotificationsActionTypes) {
+    CoreNotificationsActionTypes["UPDATE_NOTIFICATIONS_LIST"] = "[Notif] Update list";
+})(CoreNotificationsActionTypes || (CoreNotificationsActionTypes = {}));
+class UpdateNotificationsListAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreNotificationsActionTypes.UPDATE_NOTIFICATIONS_LIST;
+    }
+}
+
+var CoreLocaleActionTypes;
+(function (CoreLocaleActionTypes) {
+    CoreLocaleActionTypes["UPDATE_LOCALE_STATE"] = "[Locale] Update Locale State";
+})(CoreLocaleActionTypes || (CoreLocaleActionTypes = {}));
+class UpdateLocaleStateAction {
+    constructor(payload) {
+        this.payload = payload;
+        this.type = CoreLocaleActionTypes.UPDATE_LOCALE_STATE;
+    }
+}
+
+class I18nResourceImpl {
+    /**
+     * Resource constructor
+     * @param prefix the prefix of the resource
+     * @param suffix the suffix of the resource, optional parameter
+     * @param compileTranslations compiler function, optional parameter
+     */
+    constructor(prefix, suffix = '', compileTranslationsFn = (translations) => {
+        return translations;
+    }) {
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.compileTranslationsFn = compileTranslationsFn;
+    }
+    /**
+     * Translations pre-processor
+     * @param translations the object to be pre-processed
+     * @param lang the translations language
+     * @returns the pre-processed translations
+     */
+    compileTranslations(translations, lang) {
+        return this.compileTranslationsFn(translations, lang);
+    }
+    /**
+     * Indicates whether other object is equal-to this one.
+     * @param obj the reference object with which to compare
+     * @returns true if this object is the same as obj, false otherwise
+     */
+    equals(obj) {
+        return this.prefix === obj.prefix && this.suffix === obj.suffix;
+    }
+    /**
+     * The path to the resource
+     * @param lang the resource language
+     * @returns the path
+     */
+    getPath(lang) {
+        return `${this.prefix}${lang}${this.suffix}`;
+    }
+}
+
+class I18nLoader {
+    constructor(http, logService, euiAppConfig) {
+        this.http = http;
+        this.logService = logService;
+        this.euiAppConfig = euiAppConfig;
+        this.resources = [];
+        // create the resources from the config object
+        const i18nConfig = this.euiAppConfig.global && this.euiAppConfig.global.i18n;
+        const i18nLoaderConfig = i18nConfig && i18nConfig.i18nLoader;
+        this.resources.push(...this.createResources(i18nLoaderConfig));
+    }
+    /**
+     * Gets the translations from the server
+     * @param lang
+     * @returns Observable<any>
+     */
+    getTranslation(lang) {
+        return this.loadResources(this.resources, lang).pipe(map((loadedResources) => {
+            return loadedResources.translations;
+        }));
+    }
+    /**
+     * Adds resources
+     * @param config loader configuration
+     * @returns Observable<any> | false
+     */
+    addResources(config) {
+        // create the resources
+        let resources = this.createResources(config);
+        // filter the resources first, to avoid duplicates
+        resources = resources.filter(resource => !this.resources.some(res => res.equals(resource)));
+        // add the new resources to the list of existing resources
+        this.resources.push(...resources);
+        // return the filtered resources
+        return resources;
+    }
+    /**
+     * Removes resources from the loader instance
+     */
+    removeResources(removedResources) {
+        this.resources = this.resources.filter(res => !removedResources.some((removedResource) => removedResource.equals(res)));
+    }
+    /**
+     * Loads an array of resources, by language
+     * @param resources the definition of the resources
+     * @param lang the resource language to load
+     * @returns Observable<any>
+     */
+    loadResources(resources, lang) {
+        // if there are resources to load
+        if (Array.isArray(resources) && resources.length > 0) {
+            // load all the resources in an array of Observable
+            const requests = resources.map(resource => this.loadResource(resource, lang));
+            // group all the observables with forkJoin and deep merge them
+            return forkJoin(requests).pipe(map(response => {
+                const successResp = [];
+                const errResp = [];
+                response.forEach((item) => {
+                    if (item.isError) {
+                        errResp.push({ resource: item.resource, error: item.error });
+                    }
+                    else {
+                        successResp.push(item);
+                    }
+                });
+                if (successResp.length === response.length) {
+                    return { hasError: false, translations: mergeAll(successResp) };
+                }
+                else {
+                    return { hasError: true, translations: mergeAll(successResp), errors: errResp };
+                }
+            }));
+        }
+        else {
+            // no resources to load
+            return of({ hasError: false, translations: {} });
+        }
+    }
+    /**
+     * Create resources from a config file
+     * @param config loader configuration
+     * @returns I18nResourceImpl[] resources
+     */
+    createResources(config) {
+        // use the default config as a reference base
+        config = getI18nLoaderConfig(config);
+        const resources = [];
+        // extract the i18n folders from config
+        const i18nFolders = Array.isArray(config.i18nFolders) ?
+            config.i18nFolders : (config.i18nFolders ? [config.i18nFolders] : []);
+        if (i18nFolders) {
+            // add the i18n folders to resources
+            resources.push(...i18nFolders.map(folder => new I18nResourceImpl(`assets/${folder}/`, '.json')));
+        }
+        // extract the i18n services from config
+        const i18nServices = Array.isArray(config.i18nServices) ?
+            config.i18nServices : (config.i18nServices ? [config.i18nServices] : []);
+        if (i18nServices) {
+            // add the i18n services to resources
+            resources.push(...i18nServices.map(service => new I18nResourceImpl(service)));
+        }
+        // extract the i18n resources from config
+        const i18nResources = Array.isArray(config.i18nResources) ?
+            config.i18nResources : (config.i18nResources ? [config.i18nResources] : []);
+        if (i18nResources) {
+            // add the i18n resources to resources
+            resources.push(...i18nResources.map(resource => new I18nResourceImpl(resource.prefix, resource.suffix, this.getResourceCompileFunction(resource.compileTranslations))));
+        }
+        return resources;
+    }
+    /**
+     * Loads a resource, by language
+     * @param resource the definition of the resource
+     * @param lang the resource language to load
+     * @returns Observable<any>
+     */
+    loadResource(resource, lang) {
+        // the path to the resource
+        const path = resource.getPath(lang);
+        // load the translations from the path
+        return this.http.get(path)
+            .pipe(
+        // preprocess the translations using the resource compiler
+        map((translations) => resource.compileTranslations(translations, lang)), map((translations) => {
+            // resource loaded properly, send a info message
+            if (this.logService) {
+                this.logService.info(`I18n resource loaded from path ${path}`);
+            }
+            // return the translations
+            return translations;
+        }), catchError((err) => {
+            // resource not loaded properly, send a warning message
+            if (this.logService) {
+                this.logService.warn(`I18n resource NOT loaded from path ${path}`, err);
+            }
+            const resourceError = { error: `I18n resource NOT loaded from path ${path}`, resource, isError: true };
+            return of(resourceError);
+        }));
+    }
+    getResourceCompileFunction(id) {
+        const customHandlers = this.euiAppConfig.customHandler;
+        if (customHandlers && typeof customHandlers[id] === 'function') {
+            return customHandlers[id];
+        }
+        return undefined;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ I18nLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nLoader, deps: [{ token: i1$2.HttpClient }, { token: LogService, optional: true }, { token: CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ I18nLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nLoader });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$2.HttpClient }, { type: LogService, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CONFIG_TOKEN]
+                }] }]; } });
+const translateConfig = {
+    loader: {
+        provide: TranslateLoader,
+        useClass: I18nLoader,
+    },
+};
+
+class I18nService extends EuiLazyService {
+    constructor(baseGlobalConfig, translateService, logService, store, document) {
+        super({ activeLang: 'en' });
+        this.baseGlobalConfig = baseGlobalConfig;
+        this.translateService = translateService;
+        this.logService = logService;
+        this.store = store;
+        this.document = document;
+        this.config = getI18nServiceConfigFromBase(this.baseGlobalConfig);
+        this.onModuleLoad = new BehaviorSubject({ ready: false, name: null });
+    }
+    getState(keyOrMapFn) {
+        return this.store.select(getI18nState);
+    }
+    updateState(langState) {
+        this.updateHTMLDOMLang(langState.activeLang);
+        this.store.dispatch(new UpdateI18nStateAction(langState));
+    }
+    init(langState) {
+        const initLang = langState && langState.activeLang ? langState.activeLang : this.preparedDefaultLanguage();
+        const initState = {
+            ...langState,
+            activeLang: initLang,
+        };
+        if (typeof initLang === 'string') {
+            super.initEuiService(this.store);
+            this.updateState(initState);
+            return this.setup(initLang);
+        }
+        return of({ success: false, error: 'Initial active lang should be string' });
+    }
+    /**
+     * A pipe function that could serve as a wrapper of another observable
+     * e.g. ngx-translate i18n.onReady('my_module').pipe(switchMap(()=>translate.get('eui.KEY')));
+     * WARNING: onReady will emit only once for a loaded Module, going to another and then going back will not result
+     * into another emission.
+     * @param moduleName the name of the module that has been given through the eUI globalConfig. In case non provided
+     * fetch module name from the state.
+     */
+    onReady(moduleName) {
+        return this.onModuleLoad.pipe(switchMap((evt) => moduleName ? of(evt) :
+            this.store.select(getLastAddedModule).pipe(tap(m => moduleName = m), map(() => evt))), 
+        // emit only if event emitted matches the module name and is ready
+        filter((evt) => evt.ready === true && evt.name === moduleName), 
+        // make sure that observable completes
+        take(1));
+    }
+    lazyLoad(config) {
+        const moduleId = Math.floor((Math.random() * 100000) + 1).toLocaleString();
+        return this.addResources(config, moduleId);
+    }
+    lazyLoadInit(moduleConfig, moduleName) {
+        const i18nLoaderConfig = moduleConfig;
+        // add resources
+        return this.addResources(i18nLoaderConfig, moduleName);
+    }
+    /**
+     * Add resources based of a config loader
+     * @param config I18nLoaderConfig
+     * @return Promise<EuiServiceStatus> an EuiServiceStatus when translation has fully loaded
+     */
+    addResources(config, moduleName) {
+        // emit that module is loading
+        this.onModuleLoad.next({ ready: false, name: moduleName });
+        const loader = this.translateService.currentLoader;
+        if (loader instanceof I18nLoader) {
+            const langSubscription = [];
+            const i18nLoader = loader;
+            // add the resources to the loader
+            const resources = i18nLoader.addResources(config);
+            // manually load the resources for the CURRENT language and add them to the translate service
+            langSubscription.push(i18nLoader.loadResources(resources, this.translateService.currentLang)
+                .pipe(take(1), tap((loadedResources) => {
+                // add the new set of translations to the current language
+                this.translateService.setTranslation(this.translateService.currentLang, loadedResources.translations, true);
+                if (loadedResources.hasError) {
+                    i18nLoader.removeResources(loadedResources.errors.map(err => err.resource));
+                }
+            })));
+            // if the current language is different than the DEFAULT language
+            if (this.translateService.currentLang !== this.translateService.defaultLang) {
+                // manually load the resources for the default language and add them to the translate service
+                langSubscription.push(i18nLoader.loadResources(resources, this.translateService.defaultLang)
+                    .pipe(take(1), tap((loadedResources) => {
+                    this.translateService.setTranslation(this.translateService.defaultLang, loadedResources.translations, true);
+                    if (loadedResources.hasError) {
+                        i18nLoader.removeResources(loadedResources.errors.map(err => err.resource));
+                    }
+                })));
+            }
+            return forkJoin(langSubscription).pipe(map((loadedResourcesArr) => {
+                return !loadedResourcesArr[0].hasError ?
+                    { success: true } :
+                    { success: false, error: loadedResourcesArr[0].errors };
+            }), tap(() => {
+                // emit status of module loading progress
+                this.onModuleLoad.next({ ready: true, name: moduleName });
+            }), catchError(error => {
+                // emit status of module loading progress
+                this.onModuleLoad.next({ ready: true, name: moduleName, error: error });
+                return of({ success: false, error: error });
+            }));
+        }
+        else {
+            return of({ success: false, error: 'currentLoader is not an I18nLoader.' });
+        }
+    }
+    /**
+     * Prepares the default language
+     */
+    preparedDefaultLanguage() {
+        const browserPref = getBrowserDefaultLanguage();
+        // If user has browser preferred lang, and that language is part of the languages array
+        if (browserPref && this.config.languages && UxEuLanguages.getLanguageCodes(this.config.languages).includes(browserPref)) {
+            return browserPref;
+        }
+        return this.config.defaultLanguage;
+    }
+    /**
+     * @param default_language if given default language to override default language coming from the
+     * configuration token.
+     */
+    setup(initLanguage) {
+        // use the default config as a reference base
+        this.config = Object.assign({}, DEFAULT_I18N_SERVICE_CONFIG, this.config);
+        // configure the translate config service
+        if (this.config.languages) {
+            this.translateService.addLangs(UxEuLanguages.getLanguageCodes(this.config.languages));
+            if (this.logService) {
+                this.logService.info(`I18n accepted languages set to ${UxEuLanguages.getLanguageCodes(this.config.languages)}`);
+            }
+        }
+        // set the current language, causing to load translations
+        return this.translateService
+            .use(initLanguage)
+            .pipe(tap(() => {
+            this.bindActiveLangStateToTranslateService();
+            this.bindTranslateServiceLangChangeToState();
+            if (this.config.defaultLanguage) {
+                this.setDefaultLanguage(this.config.defaultLanguage);
+            }
+        }), map(() => {
+            return { success: true };
+        }), catchError((error) => {
+            return of({ success: false, error: error });
+        }));
+    }
+    bindActiveLangStateToTranslateService() {
+        this.store.select(getActiveLang).subscribe((lang) => {
+            if (lang !== null && (this.translateService.currentLang !== lang)) {
+                this.use(lang);
+            }
+        });
+    }
+    bindTranslateServiceLangChangeToState() {
+        this.translateService.onLangChange.subscribe((event) => {
+            if (this.stateInstance.activeLang !== event.lang) {
+                this.updateState({ activeLang: event.lang });
+            }
+            if (this.logService) {
+                this.logService.info(`I18n current language set to ${event.lang}`);
+            }
+        });
+    }
+    setDefaultLanguage(defaultLanguage) {
+        // removed, current language is already calculated in init, setup function fill use it directly, not default
+        // this.translateService.currentLang = default_language || this.config.defaultLanguage;
+        this.translateService.setDefaultLang(defaultLanguage);
+        if (this.logService) {
+            this.logService.info(`I18n default language set to ${defaultLanguage}`);
+        }
+    }
+    /**
+     * change the currently used language
+     * @param lang is the language code based on the convention you used e.g. (en or en-EN)
+     * @returns Observable that returns an object contain the object translation for given language after language
+     * fully loaded.
+     */
+    use(lang) {
+        return this.translateService.use(lang);
+    }
+    /**
+     * updates the HTML element lang attribute
+     * @private
+     */
+    updateHTMLDOMLang(lang) {
+        this.document.documentElement.lang = lang;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ I18nService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nService, deps: [{ token: GLOBAL_CONFIG_TOKEN }, { token: i2.TranslateService }, { token: LogService, optional: true }, { token: StoreService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ I18nService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GLOBAL_CONFIG_TOKEN]
+                }] }, { type: i2.TranslateService }, { type: LogService, decorators: [{
+                    type: Optional
+                }] }, { type: StoreService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+
+class I18nServiceMock extends I18nService {
+    constructor() {
+        super(null, null, null, null, null);
+        this.DEFAULT_LANGUAGE = 'en';
+    }
+    get onLangChange() {
+        return new EventEmitter();
+    }
+    addResources() {
+        return of({ success: true });
+    }
+    get currentLanguage() {
+        return this.DEFAULT_LANGUAGE;
+    }
+    getState() {
+        return of({ activeLang: this.DEFAULT_LANGUAGE });
+    }
+    updateState(i18nState) {
+        this.DEFAULT_LANGUAGE = i18nState.activeLang || 'en';
+    }
+    init(i18nState) {
+        this.DEFAULT_LANGUAGE = i18nState.activeLang || 'en';
+        return of({ success: true });
+    }
+    lazyLoadInit() {
+        return of({ success: true });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ I18nServiceMock.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nServiceMock, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ I18nServiceMock.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nServiceMock });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: I18nServiceMock, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+const initialState = {
+    appName: '',
+    appShortName: '',
+    appSubTitle: '',
+    userInfos: null,
+    userSubInfos: null,
+    impersonatedUserInfos: null,
+    isSidebarOpen: false,
+    isSidebarHover: false,
+    isSidebarActive: false,
+    isSidebarInnerActive: false,
+    isSidebarStateCloseWithIcons: false,
+    hasSidebar: false,
+    hasHeader: false,
+    hasHeaderLogo: false,
+    hasHeaderEnvironment: false,
+    environmentValue: '',
+    isSidebarHidden: false,
+    hasToolbar: false,
+    windowWidth: 0,
+    windowHeight: 0,
+    mainContentHeight: 0,
+    pageHeaderHeight: 0,
+    wrapperClasses: '',
+    breakpoint: '',
+    breakpoints: {
+        isMobile: false,
+        isTablet: false,
+        isLtDesktop: false,
+        isDesktop: false,
+        isXL: false,
+        isXXL: false,
+    },
+    menuLinks: [],
+    sidebarLinks: [],
+    combinedLinks: [],
+    isBlockDocumentActive: false,
+    deviceInfo: null,
+    activeLanguage: 'en',
+    languages: UxEuLanguages.getLanguages(),
+    appMetadata: null,
+    hasModalActive: false,
+    isDimmerActive: false,
+};
+// TODO: this service needs to be transferred in the respective component
+class UxAppShellService {
+    constructor(config, http, platformId, router, storeService, i18nService) {
+        this.config = config;
+        this.http = http;
+        this.platformId = platformId;
+        this.router = router;
+        this.storeService = storeService;
+        this.i18nService = i18nService;
+        this.growlMessages = [];
+        this.isGrowlSticky = false;
+        this.growlLife = 3000;
+        this.growlPosition = 'bottom-right';
+        this.growlCallback = null;
+        this.activeModals = [];
+        this.openModalId = new BehaviorSubject('');
+        this.cssVars = [];
+        let stateWithConfig = initialState;
+        const languages = config?.i18n?.i18nService?.languages || initialState.languages;
+        const defaultLanguage = config?.i18n?.i18nService?.defaultLanguage || initialState.activeLanguage;
+        stateWithConfig = {
+            ...stateWithConfig, ...{
+                languages: languages,
+                activeLanguage: defaultLanguage,
+            },
+        };
+        this._state$ = new BehaviorSubject(stateWithConfig);
+        this._breakpoint$ = new BehaviorSubject('');
+        this._breakpoints$ = new BehaviorSubject({});
+        this.bindActiveLanguageToAppShellState();
+        if (isPlatformBrowser(this.platformId)) {
+            router.events
+                .subscribe((event) => {
+                if (event instanceof NavigationEnd) {
+                    window.scrollTo(0, 0);
+                }
+            });
+        }
+    }
+    // -------------------
+    get state$() {
+        return this._state$.asObservable();
+    }
+    // -------------------
+    // exposed observables
+    get breakpoint$() {
+        return this._breakpoint$.asObservable();
+    }
+    get breakpoints$() {
+        return this._breakpoints$.asObservable();
+    }
+    // ----------------
+    // state operations
+    // ----------------
+    get state() {
+        return this._state$.getValue();
+    }
+    get isSidebarOpen() {
+        return this.state.isSidebarOpen;
+    }
+    // Edit mode
+    get isDimmerActive() {
+        return this.state.isDimmerActive;
+    }
+    // ----------------------------
+    // public setters and functions
+    // ----------------------------
+    set isSidebarOpen(isOpen) {
+        this.setState({
+            ...this.state,
+            isSidebarOpen: isOpen,
+        });
+    }
+    set isSidebarHover(isHover) {
+        this.setState({
+            ...this.state,
+            isSidebarHover: isHover,
+        });
+    }
+    get isSidebarHover() {
+        return this.state.isSidebarHover;
+    }
+    set isSidebarActive(isActive) {
+        this.setState({
+            ...this.state,
+            isSidebarActive: isActive,
+        });
+    }
+    set isSidebarInnerActive(isOpen) {
+        this.setState({
+            ...this.state,
+            isSidebarInnerActive: isOpen,
+        });
+    }
+    set sidebarLinks(links) {
+        this.setState({
+            ...this.state,
+            sidebarLinks: links,
+        });
+    }
+    set menuLinks(links) {
+        this.setState({
+            ...this.state,
+            menuLinks: links,
+        });
+    }
+    set isBlockDocumentActive(isActive) {
+        this.setState({
+            ...this.state,
+            isBlockDocumentActive: isActive,
+        });
+    }
+    // Edit mode
+    set isDimmerActive(isActive) {
+        this.setState({
+            ...this.state,
+            isDimmerActive: isActive,
+        });
+    }
+    setState(nextState, updateI18 = true) {
+        let breakpoint, breakpoints, wrapperClasses;
+        let combinedLinks;
+        const state = this.state;
+        // check if window width has been updated from previous state
+        if (this.state.windowWidth !== nextState.windowWidth) {
+            breakpoint = this.getBreakpoint(nextState.windowWidth);
+            breakpoints = this.getBreakpoints(breakpoint);
+            this._breakpoint$.next(breakpoint);
+            this._breakpoints$.next(breakpoints);
+            // if not propagate the old ones without doing any calculations
+        }
+        else {
+            breakpoint = state.breakpoint;
+            breakpoints = state.breakpoints;
+        }
+        // finally get the wrapper classes when both the state and breakpoint are known
+        wrapperClasses = this.getWrapperClasses(nextState, breakpoint);
+        // check if the menuLinks or sidebarLinks have changed from previous state
+        if (this.state.menuLinks !== nextState.menuLinks || this.state.sidebarLinks !== nextState.sidebarLinks) {
+            combinedLinks = [...nextState.menuLinks, ...nextState.sidebarLinks];
+        }
+        else {
+            combinedLinks = this.state.combinedLinks;
+        }
+        const stateBeforeUpdate = { ...this.state };
+        // we put it all together with the calculated properties
+        this._state$.next({
+            ...nextState,
+            wrapperClasses,
+            breakpoint,
+            breakpoints,
+            combinedLinks,
+        });
+        // update the Store Language
+        if (updateI18 && nextState.activeLanguage !== stateBeforeUpdate.activeLanguage) {
+            this.i18nService.updateState({ activeLang: nextState.activeLanguage });
+        }
+    }
+    /**
+     * Emits a slice from the state whether that changes
+     * @param key can be 'key' or 'key.sub.sub'
+     */
+    getState(key) {
+        return defer(() => {
+            // check if key exists
+            return key ? this.state$.pipe(map((state) => get(state, key)), filter((state) => state), distinctUntilChanged((x, y) => isEqual(x, y))) : this.state$;
+        });
+    }
+    sidebarToggle() {
+        this.isSidebarOpen = !this.state.isSidebarOpen;
+    }
+    // Edit mode
+    dimmerActiveToggle() {
+        const isActive = this.isDimmerActive;
+        this.setState({
+            ...this.state,
+            isDimmerActive: !isActive,
+        });
+        this.activateEditModeCssVars(!isActive);
+    }
+    setDimmerActiveState(activeState) {
+        this.setState({
+            ...this.state,
+            isDimmerActive: activeState,
+        });
+        this.activateEditModeCssVars(activeState);
+    }
+    activateEditModeCssVars(isActive) {
+        if (isActive) {
+            this._setCssVarValue('--eui-docpage-navigation-z-index', 'inherit'); // Reset doc-page-navigation-column z-index
+            this._setCssVarValue('--eui-z-index-sidebar', 'inherit'); // Reset eui-app-sidebar z-index
+            this._setCssVarValue('--eui-z-index-root', 'inherit'); // Reset eui-app-main-content z-index
+        }
+        else {
+            this._setCssVarValue('--eui-docpage-navigation-z-index', '2'); // Restore doc-page-navigation-column z-index
+            this._setCssVarValue('--eui-z-index-sidebar', '1044'); // Restore eui-app-sidebar z-index
+            this._setCssVarValue('--eui-z-index-root', '1'); // Restore eui-app-main-content z-index
+        }
+    }
+    // --------------
+    // public methods
+    // --------------
+    fetchAppMetadata(metadataFilePath = 'assets/app-metadata.json') {
+        this.getJson(metadataFilePath)
+            .then((data) => {
+            this.setState({
+                ...this.state,
+                appMetadata: data,
+            });
+        });
+    }
+    activateSidebar() {
+        this.setState({
+            ...this.state,
+            hasSidebar: true,
+        });
+        if (!this.state.isSidebarHidden) {
+            this.activateSidebarCssVars();
+        }
+    }
+    activateSidebarHeader() {
+        this.activateSidebarHeaderCssVars();
+    }
+    activateSidebarFooter() {
+        this.activateSidebarFooterCssVars();
+    }
+    activateHeader() {
+        this.setState({
+            ...this.state,
+            hasHeader: true,
+        });
+        this.activateHeaderCssVars();
+    }
+    activateToolbar() {
+        this.setState({
+            ...this.state,
+            hasToolbar: true,
+        });
+        this.activateToolbarCssVars();
+    }
+    fetchCssVars() {
+        const cssVarNames = [
+            '--eui-app-header-height-default',
+            '--eui-app-header-height-active',
+            '--eui-app-header-height-shrink',
+            '--eui-app-toolbar-height-default',
+            '--eui-app-toolbar-height-active',
+            '--eui-app-sidebar-width-default',
+            '--eui-app-sidebar-width-active',
+            '--eui-app-sidebar-width-close-default',
+            '--eui-app-sidebar-width-close-active',
+            '--eui-app-sidebar-header-height-default',
+            '--eui-app-sidebar-header-height-active',
+            '--eui-app-sidebar-footer-height-default',
+            '--eui-app-sidebar-footer-height-active',
+        ];
+        this.cssVars = cssVarNames.map((v) => {
+            return { key: v, value: this.getCssVarValue(v) };
+        });
+    }
+    initCssVars() {
+        this.setCssVar('--eui-app-header-height-default', '--eui-app-header-height');
+        this.setCssVar('--eui-app-toolbar-height-default', '--eui-app-toolbar-height');
+        this.setCssVar('--eui-app-sidebar-width-default', '--eui-app-sidebar-width');
+        this.setCssVar('--eui-app-sidebar-width-close-default', '--eui-app-sidebar-width-close');
+        this.setCssVar('--eui-app-sidebar-header-height-default', '--eui-app-sidebar-header-height');
+        this.setCssVar('--eui-app-sidebar-footer-height-default', '--eui-app-sidebar-footer-height');
+    }
+    activateHeaderCssVars() {
+        this.setCssVar('--eui-app-header-height-active', '--eui-app-header-height');
+    }
+    activateToolbarCssVars() {
+        this.setCssVar('--eui-app-toolbar-height-active', '--eui-app-toolbar-height');
+    }
+    activateFooterCssVars() {
+        this.setCssVar('--eui-app-footer-height-active', '--eui-app-footer-height');
+    }
+    setHeaderShrinkCssVar(active) {
+        if (active) {
+            this.setCssVar('--eui-app-header-height-shrink', '--eui-app-header-height');
+        }
+        else {
+            this.setCssVar('--eui-app-header-height-active', '--eui-app-header-height');
+        }
+    }
+    activateSidebarCssVars() {
+        this.setCssVar('--eui-app-sidebar-width-active', '--eui-app-sidebar-width');
+        this.setCssVar('--eui-app-sidebar-width-close-active', '--eui-app-sidebar-width-close');
+    }
+    activateSidebarHeaderCssVars() {
+        this.setCssVar('--eui-app-sidebar-header-height-active', '--eui-app-sidebar-header-height');
+    }
+    activateSidebarFooterCssVars() {
+        this.setCssVar('--eui-app-sidebar-footer-height-active', '--eui-app-sidebar-footer-height');
+    }
+    /**
+     * displays a growl UxMessage item, isSticky
+     */
+    growl(msg, isSticky, isMultiple, life, position, callback) {
+        if (msg.severity !== 'info' && msg.severity !== 'warning' && msg.severity !== 'success' && msg.severity !== 'danger') {
+            throw new Error('UxAppShellService.growl() ERROR : message severity must be either : success, warning, info, danger');
+        }
+        else {
+            if (isMultiple === undefined || !isMultiple) {
+                this.growlMessages = [];
+            }
+            this.growlMessages = this.growlMessages.concat(msg);
+            msg.life = life;
+            msg.sticky = isSticky;
+            if (life === undefined || isNaN(life)) {
+                if (msg.severity === 'danger') {
+                    isSticky = true;
+                }
+                else {
+                    this.growlLife = 3000;
+                }
+            }
+            else {
+                this.growlLife = life;
+            }
+            if (isSticky) {
+                this.isGrowlSticky = isSticky;
+            }
+            else {
+                this.isGrowlSticky = false;
+            }
+            if (position) {
+                this.growlPosition = position;
+            }
+            if (callback) {
+                this.growlCallback = callback;
+            }
+            else {
+                this.growlCallback = () => {
+                };
+            }
+        }
+    }
+    clearGrowl() {
+        this.growlMessages = [];
+    }
+    growlSuccess(msg, position) {
+        this.growl({ severity: 'success', summary: 'SUCCESS', detail: msg }, false, false, undefined, position);
+    }
+    growlError(msg, position) {
+        this.growl({ severity: 'danger', summary: 'ERROR', detail: msg }, false, false, undefined, position);
+    }
+    // date helpers
+    growlWarning(msg, position) {
+        this.growl({ severity: 'warning', summary: 'WARNING', detail: msg }, false, false, undefined, position);
+    }
+    growlInfo(msg, position) {
+        this.growl({ severity: 'info', summary: 'INFO', detail: msg }, false, false, undefined, position);
+    }
+    openModal(modalId) {
+        document.body.classList.add('modal-open');
+        if (!modalId) {
+            modalId = 'single_modal';
+        }
+        this.activeModals.push({
+            id: modalId,
+            isOpen: true,
+        });
+        setTimeout(() => {
+            const el = document.getElementById(modalId + '-close-button');
+            if (el) {
+                el.focus();
+            }
+        }, 100);
+    }
+    openMessageBox(messageBoxId) {
+        if (!messageBoxId) {
+            messageBoxId = 'messagebox_modal';
+        }
+        this.openModal(messageBoxId);
+    }
+    closeMessageBox(messageBoxId) {
+        if (!messageBoxId) {
+            messageBoxId = 'messagebox_modal';
+        }
+        this.closeModal(messageBoxId);
+    }
+    isModalOpen(modalId) {
+        if (!modalId) {
+            modalId = 'single_modal';
+        }
+        if (this.activeModals.length) {
+            let modalIndex = this.findModalIndex(modalId);
+            if (modalIndex !== -1) {
+                return this.activeModals[modalIndex].isOpen;
+            }
+        }
+        return false;
+    }
+    // Positions helpers
+    closeModal(modalId) {
+        if (!modalId) {
+            modalId = 'single_modal';
+        }
+        /**
+         * Make sure we find the modal before splicing the activeModals array
+         */
+        const index = this.findModalIndex(modalId);
+        if (index >= 0) {
+            this.activeModals.splice(index, 1);
+        }
+        if (this.activeModals && this.activeModals.length <= 0) {
+            document.body.classList.remove('modal-open');
+        }
+        else {
+            // If there is still another (parent) modal dialog open, ensure it is focused upon to be able to close is with the ESC key:
+            const lastModalId = this.activeModals[this.activeModals.length - 1].id;
+            if (lastModalId) {
+                setTimeout(() => {
+                    const el = document.getElementById(lastModalId + '-close-button');
+                    if (el) {
+                        el.focus();
+                    }
+                }, 100);
+            }
+        }
+    }
+    findModalIndex(modalId) {
+        let index = -1;
+        if (this.activeModals.length) {
+            for (let i = 0; i < this.activeModals.length; i++) {
+                if (this.activeModals[i].id === modalId) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+        return index;
+    }
+    // ---------------
+    // private getters
+    // ---------------
+    getCssVarValue(inputProperty) {
+        return getComputedStyle(document.documentElement).getPropertyValue(inputProperty);
+    }
+    setCssVar(inputProperty, outputProperty) {
+        const cssVarValue = this.cssVars.filter(v => v.key === inputProperty)[0].value;
+        this._setCssVarValue(outputProperty, cssVarValue);
+        // console.log(inputProperty, outputProperty, cssVarValue);
+    }
+    _setCssVarValue(varName, varValue) {
+        document.documentElement.style.setProperty(varName, varValue);
+    }
+    getWrapperClasses(state, breakpoint) {
+        let classes = [];
+        classes.push(breakpoint);
+        if (state.isSidebarOpen && (state.isSidebarActive || state.isSidebarInnerActive)) {
+            classes.push('sidebar-state-open');
+        }
+        if (!state.isSidebarOpen && (state.isSidebarActive || state.isSidebarInnerActive)) {
+            classes.push('sidebar-state-close');
+        }
+        if (state.isSidebarActive) {
+            classes.push('sidebar-active');
+        }
+        if (state.isSidebarInnerActive) {
+            classes.push('sidebar-inner-active');
+        }
+        if (state.isSidebarStateCloseWithIcons) {
+            classes.push('sidebar-state-close-with-icons');
+        }
+        // NEW APP-SHELL props
+        if (state.isSidebarHidden) {
+            classes.push('sidebar--hidden');
+        }
+        if (state.isSidebarOpen) {
+            classes.push('sidebar--open');
+        }
+        else {
+            classes.push('sidebar--close');
+        }
+        if (state.isSidebarHover) {
+            classes.push('sidebar--hover');
+        }
+        if (state.deviceInfo && state.deviceInfo.isFF) {
+            classes.push('ff');
+        }
+        if (state.deviceInfo && state.deviceInfo.isIE) {
+            classes.push('ie');
+        }
+        if (state.deviceInfo && state.deviceInfo.isIE11) {
+            classes.push('ie11');
+        }
+        if (state.deviceInfo && state.deviceInfo.isChrome) {
+            classes.push('chrome');
+        }
+        return classes.join(' ');
+    }
+    getBreakpoint(windowWidth) {
+        let bkp = '';
+        switch (true) {
+            case (windowWidth >= 0 && windowWidth < 576):
+                bkp = 'xs';
+                break;
+            case (windowWidth >= 576 && windowWidth < 768):
+                bkp = 'sm';
+                break;
+            case (windowWidth >= 768 && windowWidth < 992):
+                bkp = 'md';
+                break;
+            case (windowWidth >= 992 && windowWidth < 1200):
+                bkp = 'lg';
+                break;
+            case (windowWidth >= 1200 && windowWidth < 1400):
+                bkp = 'xl';
+                break;
+            case (windowWidth >= 1400):
+                bkp = 'xxl';
+                break;
+        }
+        return bkp;
+    }
+    getBreakpoints(bkp) {
+        return {
+            isMobile: (bkp === 'xs' || bkp === 'sm'),
+            isTablet: bkp === 'md',
+            isLtDesktop: (bkp === 'xs' || bkp === 'sm' || bkp === 'md'),
+            isDesktop: bkp === 'lg',
+            isXL: bkp === 'xl',
+            isXXL: bkp === 'xxl',
+        };
+    }
+    getJson(url) {
+        return this.http
+            .get(url)
+            .toPromise()
+            .then(this.extractData)
+            .catch(this.handleError);
+    }
+    extractData(res) {
+        const body = res;
+        return body || {};
+    }
+    handleError(error) {
+        console.error('An error occurred', error);
+        return Promise.reject(error.message || error);
+    }
+    bindActiveLanguageToAppShellState() {
+        this.storeService.select(getActiveLang).subscribe((activeLang) => {
+            if (activeLang !== this.state.activeLanguage) {
+                this.setState({
+                    ...this.state,
+                    activeLanguage: activeLang,
+                }, false);
+            }
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UxAppShellService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxAppShellService, deps: [{ token: GLOBAL_CONFIG_TOKEN, optional: true }, { token: i1$2.HttpClient }, { token: PLATFORM_ID }, { token: i2$1.Router }, { token: StoreService }, { token: I18nService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UxAppShellService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxAppShellService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxAppShellService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [GLOBAL_CONFIG_TOKEN]
+                }] }, { type: i1$2.HttpClient }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i2$1.Router }, { type: StoreService }, { type: I18nService, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+class CoreAppEffects {
+    constructor(actions, showConnectionStatus, translateService, asService) {
+        this.actions = actions;
+        this.showConnectionStatus = showConnectionStatus;
+        this.translateService = translateService;
+        this.asService = asService;
+        this.getAppConnectionInformation = merge(fromEvent(window, 'online').pipe(mapTo(true)), fromEvent(window, 'offline').pipe(mapTo(false))).pipe(map(connected => new UpdateAppConnectionAction(connected)));
+        this.activatedRoute = this.actions
+            .pipe(ofType(CoreAppActionTypes.ACTIVATED_ROUTE), map((action) => action.payload), mergeMap(route => {
+            // extract the module name, if defined
+            const module = route.snapshot.data['module'] || 'undefined';
+            return [
+                new UpdateCurrentModuleAction(module),
+            ];
+        }));
+        this.updateAppConnection = this.actions
+            .pipe(ofType(CoreAppActionTypes.UPDATE_APP_CONNECTION), map((action) => action.payload), tap(connected => {
+            // if the user needs to be informed about the connection status
+            if (this.showConnectionStatus) {
+                if (connected) {
+                    this.translateService.get('eui.CONNECTED').subscribe((translation) => {
+                        this.asService.growl({ severity: 'success', summary: 'MESSAGE', detail: translation }, true, false);
+                    });
+                }
+                else {
+                    this.translateService.get('eui.NOTCONNECTED').subscribe((translation) => {
+                        this.asService.growl({ severity: 'danger', summary: 'ERROR', detail: translation }, true, false);
+                    });
+                }
+            }
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CoreAppEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreAppEffects, deps: [{ token: i1$3.Actions }, { token: SHOW_CONNECTION_STATUS_TOKEN }, { token: i2.TranslateService }, { token: UxAppShellService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CoreAppEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreAppEffects });
+__decorate([
+    Effect(),
+    __metadata("design:type", Observable)
+], CoreAppEffects.prototype, "getAppConnectionInformation", void 0);
+__decorate([
+    Effect(),
+    __metadata("design:type", Observable)
+], CoreAppEffects.prototype, "activatedRoute", void 0);
+__decorate([
+    Effect({ dispatch: false }),
+    __metadata("design:type", Object)
+], CoreAppEffects.prototype, "updateAppConnection", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreAppEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$3.Actions }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SHOW_CONNECTION_STATUS_TOKEN]
+                }] }, { type: i2.TranslateService }, { type: UxAppShellService }]; }, propDecorators: { getAppConnectionInformation: [], activatedRoute: [], updateAppConnection: [] } });
+
+const CoreModuleEffects = [CoreAppEffects];
+
+const updateAppVersion = (state, action) => ({ ...state, version: action.payload });
+const updateAppConnection = (state, action) => ({ ...state, connected: action.payload });
+const AddAppLoadedConfigModules = (state, action) => ({
+    ...state,
+    loadedConfigModules: {
+        lastAddedModule: action.payload.moduleName,
+        modulesConfig: {
+            ...state.loadedConfigModules.modulesConfig,
+            [action.payload.moduleName]: {
+                ...action.payload.moduleConfig,
+            },
+        },
+    },
+});
+const updateAppStatus = (state, action) => ({ ...state, status: action.payload });
+const updateCurrentModule = (state, action) => {
+    return Object.assign({}, state, { currentModule: action.payload });
+};
+const addApiQueueItem = (state, action) => {
+    // apply the timestamp to the queue item
+    const apiQueueItem = Object.assign({}, action.payload.item, { timestamp: new Date().getTime() });
+    // update the queue
+    const apiQueue = Object.assign({}, state.apiQueue, { [action.payload.id]: apiQueueItem });
+    return Object.assign({}, state, { apiQueue });
+};
+const removeApiQueueItem = (state, action) => {
+    // remove the specified id from the list of item ids and recreate the apiQueue from the remaining ids
+    const apiQueue = Object.keys(state.apiQueue).filter(id => id !== action.payload).reduce((queue, key) => {
+        queue[key] = state.apiQueue[key];
+        return queue;
+    }, {});
+    return Object.assign({}, state, { apiQueue });
+};
+const emptyApiQueue = (state, action) => {
+    // remove all items in the Api Queue
+    return Object.assign({}, state, { apiQueue: {} });
+};
+const actionToReducerMap$4 = {
+    [CoreAppActionTypes.UPDATE_APP_VERSION]: updateAppVersion,
+    [CoreAppActionTypes.UPDATE_APP_CONNECTION]: updateAppConnection,
+    [CoreAppActionTypes.ADD_APP_LOADED_CONFIG_MODULES]: AddAppLoadedConfigModules,
+    [CoreAppActionTypes.UPDATE_APP_STATUS]: updateAppStatus,
+    [CoreAppActionTypes.UPDATE_CURRENT_MODULE]: updateCurrentModule,
+    [CoreAppActionTypes.ADD_API_QUEUE_ITEM]: addApiQueueItem,
+    [CoreAppActionTypes.REMOVE_API_QUEUE_ITEM]: removeApiQueueItem,
+    [CoreAppActionTypes.EMPTY_API_QUEUE]: emptyApiQueue,
+};
+const coreAppReducers = (state = initialAppState, action) => {
+    if (actionToReducerMap$4[action.type]) {
+        return actionToReducerMap$4[action.type](state, action);
+    }
+    // if the action type is not in the map, call the base reducers method
+    return state;
+};
+
+const updateUser = (state, action) => {
+    let fullName = action.payload.fullName;
+    if (!fullName) {
+        fullName = `${action.payload.firstName || ''} ${action.payload.lastName || ''}`.trim();
+    }
+    return Object.assign({}, state, action.payload, { fullName });
+};
+const updateUserDetails = (state, action) => {
+    let fullName = action.payload.fullName;
+    if (!fullName) {
+        fullName = `${action.payload.firstName || ''} ${action.payload.lastName || ''}`.trim();
+    }
+    // todo should be checked if state.details is really there
+    const details = Object.assign({}, state.details, action.payload, { fullName });
+    return Object.assign({}, state, details);
+};
+const updateUserPreferences = (state, action) => {
+    const preferences = Object.assign({}, state.preferences, action.payload);
+    return Object.assign({}, state, { preferences });
+};
+const updateUserRights = (state, action) => Object.assign({}, state, { rights: [...action.payload] });
+const updateUserDashboard = (state, action) => {
+    // apply the dashboard to preferences
+    const preferences = Object.assign({}, state.preferences, { dashboard: action.payload });
+    // update the state
+    return { ...state, preferences };
+};
+const actionToReducerMap$3 = {
+    [CoreUserActionTypes.UPDATE_USER_DETAILS]: updateUserDetails,
+    [CoreUserActionTypes.UPDATE_USER_PREFERENCES]: updateUserPreferences,
+    [CoreUserActionTypes.UPDATE_USER_STATE]: updateUser,
+    [CoreUserActionTypes.UPDATE_USER_RIGHTS]: updateUserRights,
+    [CoreUserActionTypes.UPDATE_USER_DASHBOARD]: updateUserDashboard,
+};
+const coreUserReducers = (state = initialUserState, action) => {
+    if (actionToReducerMap$3[action.type]) {
+        return actionToReducerMap$3[action.type](state, action);
+    }
+    return state;
+};
+
+const updateNotificationsList = (state, action) => {
+    return Object.assign({}, state, { list: [...action.payload] });
+};
+const actionToReducerMap$2 = {
+    [CoreNotificationsActionTypes.UPDATE_NOTIFICATIONS_LIST]: updateNotificationsList,
+};
+const coreNotificationsReducers = (state = initialNotificationsState, action) => {
+    if (actionToReducerMap$2[action.type]) {
+        return actionToReducerMap$2[action.type](state, action);
+    }
+    return state;
+};
+
+const updateI18nState = (state, action) => {
+    return {
+        ...state,
+        ...action.payload,
+    };
+};
+const actionToReducerMap$1 = {
+    [CoreI18nActionTypes.UPDATE_I18N_STATE]: updateI18nState,
+};
+const corI18nReducers = (state = initialI18nState, action) => {
+    if (actionToReducerMap$1[action.type]) {
+        return actionToReducerMap$1[action.type](state, action);
+    }
+    return state;
+};
+
+const updateLocaleState = (state, action) => {
+    return {
+        ...state,
+        ...action.payload,
+    };
+};
+const actionToReducerMap = {
+    [CoreLocaleActionTypes.UPDATE_LOCALE_STATE]: updateLocaleState,
+};
+const coreLocaleReducers = (state = initialLocaleState, action) => {
+    if (actionToReducerMap[action.type]) {
+        return actionToReducerMap[action.type](state, action);
+    }
+    return state;
+};
+
+const coreReducers = Object.assign({}, {
+    app: coreAppReducers,
+    user: coreUserReducers,
+    notifications: coreNotificationsReducers,
+    i18n: corI18nReducers,
+    locale: coreLocaleReducers,
+});
+
+const extend = extendProxy.default || extendProxy;
+/**
+ * Utility meta-reducer to load the state from the local storage
+ * @param reducer the action reducer
+ */
+function localStorageSync(reducer) {
+    return cb(reducer, localStorage);
+}
+/**
+ * Utility meta-reducer to load the state from the session storage
+ * @param reducer the action reducer
+ */
+function sessionStorageSync(reducer) {
+    return cb(reducer, sessionStorage);
+}
+// Keys that are allowed to be synced with NgRx state from BrowserStorage
+const disallowedKeys = ['loadedConfigModules', 'connect', 'currentModule', 'status', 'apiQueue'];
+/**
+ * filters the AppState by removing those keys from the state and return a new state Object
+ * @param app the AppState
+ */
+const filterAppState = (app) => {
+    // in case app is undefined or null it should return empty object
+    if (!app) {
+        return {};
+    }
+    return Object.keys(app)
+        // select keys that are present in the allowed list
+        .filter(key => !disallowedKeys.includes(key))
+        // build a new object with only the allowed properties
+        .reduce((obj, key) => {
+        obj[key] = app[key];
+        return obj;
+    }, {});
+};
+/**
+ *
+ * @param storageType
+ */
+const loadState = (storage = localStorage) => {
+    try {
+        // by default falls back to localStorage
+        const serializedState = storage.getItem('state');
+        if (serializedState === null) {
+            return undefined;
+        }
+        // deserialize state
+        let state = JSON.parse(serializedState);
+        // filter AppState and replace
+        state = { ...state, app: filterAppState(state?.app) };
+        return state;
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+const cb = (reducer, storage) => {
+    return function (state, action) {
+        if (action.type === CoreAppActionTypes.INIT_STORE) {
+            // This action must be dispatched from an app initializer
+            // We load the state from a storage and compare the version and userId with the provided ones.
+            // If they are the same, we merge the local state into the initial state.
+            // If there is a mismatch, we don't merge the local state, but update only the initial state.
+            // load the state from the localStorage
+            const localState = loadState(storage);
+            // extract the details about user and app version from the action payload
+            const payload = action.payload;
+            const payloadVersion = payload?.version;
+            if (localState) {
+                // TODO: Why all these checks here? What is the purpose of this code?
+                // extract the details about user and app version from the storage state
+                const localVersion = localState?.app?.version;
+                // const localUserId = localState.user && localState.user.userId;
+                const isVersionOK = (!localVersion || !payloadVersion || localVersion === payloadVersion);
+                // const isUserIdOK = (localUserId === payloadUserId);
+                // update the entire state with deep merge of states, if the version and user are the same
+                if (isVersionOK) {
+                    state = extend(true, {}, state, localState);
+                }
+            }
+            // update the app version, if defined
+            if (payloadVersion) {
+                state = { ...state, app: { ...state?.app, version: payloadVersion } };
+            }
+        }
+        return reducer(state, action);
+    };
+};
+
+class StoreServiceMock extends StoreService {
+    constructor() {
+        super(null, null);
+    }
+    init() {
+    }
+    addAutoSaveHandler() {
+    }
+    handleAutoSave() {
+    }
+    dispatch() {
+    }
+    select() {
+        return of({});
+    }
+}
+/** @nocollapse */ /** @nocollapse */ StoreServiceMock.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: StoreServiceMock, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ StoreServiceMock.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: StoreServiceMock });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: StoreServiceMock, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+const CORE_ROOT_GUARD = new InjectionToken('Internal Theme ForRoot Guard');
+class CoreModule {
+    constructor(guard, parentModule, injector) {
+        // if there is a parentModule, a new instance is created in a lazy loaded module
+        if (parentModule) {
+            // extract the i18n service and the i18n loader config
+            // todo, this thing should be achieved by store, and localization service dependency should be removed
+            const storeService = injector.get(StoreService);
+            const moduleName = injector.get(MODULE_NAME_TOKEN);
+            const moduleConfig = injector.get(MODULE_CONFIG_TOKEN);
+            storeService.dispatch(new AddAppLoadedConfigModulesAction({ moduleName, moduleConfig }));
+        }
+    }
+    /**
+     * No more providing config from forRoot, you have to use EUI_CONFIG_TOKEN to pass config via providers.
+     */
+    static forRoot() {
+        return {
+            ngModule: CoreModule,
+            providers: [
+                {
+                    provide: EuiCoreRootGuardClass,
+                    useFactory: euiCoreRootGuardClass,
+                    deps: [],
+                },
+                {
+                    provide: CORE_ROOT_GUARD,
+                    useFactory: createEuiCoreRootGuard,
+                    deps: [[EuiCoreRootGuardClass, new Optional(), new SkipSelf()]],
+                },
+                ...getCoreProviders(),
+            ],
+        };
+    }
+    static forChild(moduleName) {
+        return {
+            ngModule: CoreModule,
+            providers: getCoreChildProviders(moduleName),
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreModule, deps: [{ token: CORE_ROOT_GUARD, optional: true }, { token: CoreModule, optional: true, skipSelf: true }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreModule, imports: [HttpClientModule] });
+/** @nocollapse */ /** @nocollapse */ CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreModule, imports: [[
+            HttpClientModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        HttpClientModule,
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CORE_ROOT_GUARD]
+                }] }, { type: CoreModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i0.Injector }]; } });
+function createEuiCoreRootGuard(core) {
+    if (core) {
+        throw new TypeError(`CoreModule.forRoot() called twice. Feature modules should use ThemeModule.forChild() instead.`);
+    }
+    return 'guarded';
+}
+class EuiCoreRootGuardClass {
+    constructor() {
+    }
+}
+function euiCoreRootGuardClass() {
+    return new EuiCoreRootGuardClass();
+}
+
+/**
+ * Function to be used before the AppModule is bootstrapped. It is currently used to load dynamic configurations.
+ * It needs to be added in your application main.ts file.
+ * @param envConfig the current environment configuration
+ * @returns the updated environment configuration, as a promise
+ */
+async function preInitApp(envConfig) {
+    const envDynamicConfig = envConfig && envConfig.envDynamicConfig;
+    if (envDynamicConfig) {
+        // load the local configuration file, if defined
+        const euiAppJsonConfig = await loadEuiDynamicEnvironmentConfig(envDynamicConfig.uri, envDynamicConfig.configTimeout || 2000);
+        envConfig.loadedEnvDynamicConfig = euiAppJsonConfig;
+        return envConfig;
+    }
+    return envConfig;
+}
+/**
+ * Function to load asynchronously a dynamic configuration (from a local path or a web service)
+ * @param url the path to the configuration
+ * @param timeout possible timeout
+ * @returns EuiAppJsonConfig promise
+ */
+async function loadEuiDynamicEnvironmentConfig(url, timeout) {
+    // if the url is specified
+    if (url) {
+        // fetch the config
+        try {
+            return await xhr({
+                url: url,
+                timeout: timeout,
+            });
+        }
+        catch (error) {
+            // send a warning to the console
+            console.warn('Dynamic configuration cannot be loaded from url', url, error);
+        }
+    }
+    // the dynamic config is not loaded
+    return null;
+}
+
+const errorCodes = {
+    ERR_GENERIC: 'ERR_GENERIC',
+};
+const messages = {
+    ERR_GENERIC: 'An error occured',
+};
+class ErrorSubClass {
+    constructor(code, msg, args) {
+        if (!msg && code && code in messages) {
+            if (typeof messages[code] === 'function') {
+                msg = messages[code](...args.messageParams);
+            }
+            else {
+                msg = messages[code];
+            }
+        }
+        this.name = 'ErrorSubClass';
+        this.message = msg;
+        this.code = code;
+        this.stack = (new Error(msg)).stack;
+        if (args) {
+            Object.keys(args).forEach((k) => {
+                if (k !== 'messageParams') {
+                    this[k] = args[k];
+                }
+            });
+        }
+    }
+}
+// This replaces the "extends" on the Class
+// ErrorSubClass.prototype = <any>Object.create(Error.prototype);
+class EuiError extends ErrorSubClass {
+    constructor(code = errorCodes.ERR_GENERIC, msg, args) {
+        super(code, msg, args);
+        this.name = 'EuiError';
+    }
+}
+
+class GlobalErrorHandler extends ErrorHandler {
+    constructor(logService) {
+        super();
+        this.logService = logService;
+    }
+    handleError(error) {
+        // log error
+        this.logService.error(error.message || error.toString());
+        // throw error;
+        super.handleError(error);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ GlobalErrorHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: GlobalErrorHandler, deps: [{ token: LogService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ GlobalErrorHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: GlobalErrorHandler, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: GlobalErrorHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: LogService }]; } });
+
+class HttpErrorHandlerInterceptor {
+    constructor(config = DEFAULT_HTTP_ERROR_HANDLER_CONFIG, injector, router) {
+        this.config = config;
+        this.injector = injector;
+        this.router = router;
+    }
+    intercept(req, next) {
+        return next.handle(req)
+            .pipe(tap(() => {
+        }, (error) => {
+            // in case of http error
+            if (error instanceof HttpErrorResponse) {
+                const routeConfig = this.getRouteConfig(error);
+                const rule = routeConfig && (routeConfig[error.status] || routeConfig.default);
+                if (typeof rule === 'string') {
+                    // perform a redirect
+                    this.router.navigate([rule]);
+                }
+                else if (typeof rule === 'function') {
+                    // callback function
+                    rule.call(null, error, this.injector);
+                }
+            }
+        }));
+    }
+    /**
+     * Search in the configuration for the first matching route
+     * @param error http error response
+     * @returns HttpErrorRouteConfig or null
+     */
+    getRouteConfig(error) {
+        // filter the routes
+        const routes = this.config.routes.filter((route) => {
+            const regex = new RegExp('^' + route.path.split('*').join('.*') + '$');
+            return regex.test(error.url) && (typeof route[error.status] !== 'undefined' || typeof route.default !== 'undefined');
+        });
+        // return the first matching route, if any
+        return routes.length > 0 ? routes[0] : null;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ HttpErrorHandlerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: HttpErrorHandlerInterceptor, deps: [{ token: HTTP_ERROR_HANDLER_CONFIG_TOKEN }, { token: i0.Injector }, { token: i2$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ HttpErrorHandlerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: HttpErrorHandlerInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: HttpErrorHandlerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HTTP_ERROR_HANDLER_CONFIG_TOKEN]
+                }] }, { type: i0.Injector }, { type: i2$1.Router }]; } });
+
+function AlertHttpErrorCallbackFn(error) {
+    alert(error.statusText);
+}
+function ConsoleHttpErrorCallbackFn(error) {
+    console.error('HttpError', error);
+}
+function LogHttpErrorCallbackFn(error, injector) {
+    const logService = injector.get(LogService);
+    logService.error('HttpError', error);
+}
+function GrowlHttpErrorCallbackFn(error, injector) {
+    const asService = injector.get(UxAppShellService);
+    asService.growlError(error.statusText);
+}
+
+class ApiQueueService {
+    constructor(store, http, logService) {
+        this.store = store;
+        this.http = http;
+        this.logService = logService;
+    }
+    /**
+     * Adds an item in the queue by dispatching an action to the store.
+     * @param id - The id of the item inside the queue.
+     * WARNING if matches any other queue item id will overwrite it.
+     * @param item - an item for Queue
+     */
+    addQueueItem(id, item) {
+        const allowedMethods = ['post', 'put', 'get'];
+        if (allowedMethods.indexOf(item.method) < 0) {
+            throw new Error(`[ApiQueue] method "${item.method}" is not allowed`);
+        }
+        this.store.dispatch(new AddApiQueueItemAction({ id, item }));
+    }
+    /**
+     * Subscribes to the store to retrieve queue and then converts the queue object to an array of items.
+     * @return An Observable of array of all items inside the current queue (ApiQueueItem[])
+     */
+    getQueue() {
+        return this.store.select(getApiQueue)
+            .pipe(take(1), map((queue) => {
+            const queueArray = queue && Object.values(queue);
+            if (!queueArray || queueArray.length < 1) {
+                this.logService.warn('No items in the queue exist.');
+            }
+            return queueArray;
+        }));
+    }
+    /**
+     * Subscribes to the store to retrieve an item from the queue.
+     * @param id - id of the item inside the queue
+     * @return An Observable of ApiQueueItem type
+     */
+    getQueueItem(id) {
+        return this.store.select(getApiQueueItem(id))
+            .pipe(take(1), map((queue) => {
+            if (!queue) {
+                this.logService.warn(`Queue item with id "${id}" does not exist`);
+                return null;
+            }
+            return queue;
+        }));
+    }
+    /**
+     * Removes a given item from the queue.
+     * @param id - id of the item inside the queue
+     */
+    removeQueueItem(id) {
+        this.store.dispatch(new RemoveApiQueueItemAction(id));
+    }
+    /**
+     * Removes all items placed in the queue.
+     */
+    removeAllQueueItem() {
+        this.store.dispatch(new EmptyApiQueueAction(null));
+    }
+    /**
+     * Process an item from the queue.
+     * @param id - id of the item inside the queue
+     * @return An Observable of type any
+     */
+    processQueueItem(id) {
+        return this.store.select(getApiQueueItem(id))
+            .pipe(take(1), switchMap((queue) => {
+            if (!queue) {
+                this.logService.warn(`Queue item with id "${id}" does not exist`);
+                // tslint:disable-next-line:deprecation
+                return of(null);
+            }
+            return this.buildHttpRequest(id, queue);
+        }));
+    }
+    /**
+     * Process all the items inside the queue.
+     * @param [continueOnError=true] - in case of an item request fails continue with the rest in queue
+     * @return An Observable with an array which contains all responses from all items in queue.
+     */
+    processAllQueueItems(continueOnError = true) {
+        return this.store.select(getApiQueue)
+            .pipe(map((queue) => Object.entries(queue)
+            .map(([key, value]) => this.buildHttpRequest(key, value).pipe(catchError((error) => {
+            this.logService.error(`Queue Item with id ${key} failed.`, error.message, error.stack);
+            if (!continueOnError) {
+                throw error;
+            }
+            // tslint:disable-next-line:deprecation
+            return of(error);
+        })))), switchMap((obsQueue) => forkJoin(Array.from(obsQueue))));
+    }
+    /**
+     * Process all items in queue after it order them based on their timestamp. Beware that order
+     * matter in execution of Http Request in queue. When a request completes only then next will begin. Emission
+     * or Http response follows order.
+     * @param [ascending=true] - sets the order of queue items based on timestamp
+     */
+    processAllQueueItemsSequential(ascending = true) {
+        return this.store.select(getApiQueue).pipe(concatMap((queue) => Object.entries(queue)
+            .sort((a, b) => ascending ? this.sortOnTimestamp(a, b) : this.sortOnTimestamp(b, a))
+            .map(([id, item]) => this.buildHttpRequest(id, item))));
+    }
+    /**
+     * Short dates ascending based on input
+     * @param a - Date one
+     * @param b - Date two
+     *
+     * @beta
+     */
+    sortOnTimestamp(a, b) {
+        return +new Date(a[1].timestamp) - +new Date(b[1].timestamp);
+    }
+    /**
+     * build and HttpRequest Observable based on the given queue.
+     * After successful request completion removes the item from the queue.
+     * @param id - id of the item inside the queue
+     * @param item - the item of the queue that matches the id.
+     * @return An Observable of HttpClient Request
+     */
+    buildHttpRequest(id, item) {
+        return this.http[item.method.toLowerCase()](item.uri, item.payload)
+            .pipe(tap(() => this.removeQueueItem(id)));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ ApiQueueService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ApiQueueService, deps: [{ token: StoreService }, { token: i1$2.HttpClient }, { token: LogService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ ApiQueueService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ApiQueueService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: ApiQueueService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: StoreService }, { type: i1$2.HttpClient }, { type: LogService }]; } });
+
+class ApiQueueServiceMock extends ApiQueueService {
+    constructor() {
+        super(null, null, null);
+    }
+    getQueue() {
+        // tslint:disable-next-line:deprecation
+        return of([]);
+    }
+    getQueueItem(id) {
+        // tslint:disable-next-line:deprecation
+        return of(null);
+    }
+    removeAllQueueItem() { }
+    processAllQueueItems() {
+        // tslint:disable-next-line:deprecation
+        return of({});
+    }
+    addQueueItem() { }
+    removeQueueItem() { }
+    processQueueItem() {
+        // tslint:disable-next-line:deprecation
+        return of({});
+    }
+}
+
+const diffDays = (dateStart, dateEnd) => {
+    return Math.round((dateEnd.getTime() - dateStart.getTime()) / 1000 / 60 / 60 / 24);
+};
+const diffDaysFromToday = (date) => {
+    return diffDays(new Date(), date);
+};
+
+/**
+ * Provides read-only equivalent of jQuery's position function:
+ * http://api.jquery.com/position/
+ */
+const position = (nativeEl) => {
+    let elBCR = offset(nativeEl);
+    let offsetParentBCR = { top: 0, left: 0 };
+    let offsetParentEl = parentOffsetEl(nativeEl);
+    if (offsetParentEl !== document) {
+        offsetParentBCR = offset(offsetParentEl);
+        offsetParentBCR.top += offsetParentEl.clientTop - offsetParentEl.scrollTop;
+        offsetParentBCR.left += offsetParentEl.clientLeft - offsetParentEl.scrollLeft;
+    }
+    let boundingClientRect = nativeEl.getBoundingClientRect();
+    return {
+        width: boundingClientRect.width || nativeEl.offsetWidth,
+        height: boundingClientRect.height || nativeEl.offsetHeight,
+        top: elBCR.top - offsetParentBCR.top,
+        left: elBCR.left - offsetParentBCR.left
+    };
+};
+/**
+ * Provides read-only equivalent of jQuery's offset function:
+ * http://api.jquery.com/offset/
+ */
+const offset = (nativeEl) => {
+    let boundingClientRect = nativeEl.getBoundingClientRect();
+    return {
+        width: boundingClientRect.width || nativeEl.offsetWidth,
+        height: boundingClientRect.height || nativeEl.offsetHeight,
+        top: boundingClientRect.top + (window.pageYOffset || document.documentElement.scrollTop),
+        left: boundingClientRect.left + (window.pageXOffset || document.documentElement.scrollLeft)
+    };
+};
+// PRIVATE FUNCTIONS
+const getStyle = (nativeEl, cssProp) => {
+    // IE
+    if (nativeEl.currentStyle) {
+        return nativeEl.currentStyle[cssProp];
+    }
+    if (window.getComputedStyle) {
+        return window.getComputedStyle(nativeEl)[cssProp];
+    }
+    // finally try and get inline style
+    return nativeEl.style[cssProp];
+};
+/**
+ * Checks if a given element is statically positioned
+ */
+const isStaticPositioned = (nativeEl) => {
+    return (getStyle(nativeEl, 'position') || 'static') === 'static';
+};
+/**
+ * returns the closest, non-statically positioned parentOffset of a given element
+ * @param nativeEl
+ */
+const parentOffsetEl = (nativeEl) => {
+    let offsetParent = nativeEl.offsetParent || document;
+    while (offsetParent && offsetParent !== document &&
+        isStaticPositioned(offsetParent)) {
+        offsetParent = offsetParent.offsetParent;
+    }
+    return offsetParent || document;
+};
+const getViewElement = (fixture, componentClass, klass) => {
+    let de, el, domElement;
+    de = fixture.debugElement.query(By.css(componentClass));
+    if (de) {
+        el = de.nativeElement;
+        if (el && klass) {
+            domElement = el.querySelectorAll(klass);
+            if (domElement.length <= 1) {
+                domElement = el.querySelector(klass);
+            }
+        }
+    }
+    return { de, el, domElement };
+};
+const closestMatchingParent = (target, className) => {
+    let element = target;
+    while (element && element.nodeType === Node.ELEMENT_NODE) {
+        if (element.classList.contains(className)) {
+            return element;
+        }
+        element = element.parentElement;
+    }
+    return null;
+};
+
+const consumeEvent = (event) => {
+    if (event) {
+        event.preventDefault();
+        event.stopPropagation();
+        event.cancelBubble = true;
+    }
+    return false;
+};
+
+const forOwn = (object, iteratee) => {
+    object = Object(object);
+    Object.keys(object).forEach((key) => iteratee(object[key], key, object));
+};
+const markFormGroupTouched = (FormControls) => {
+    const markFormGroupTouchedRecursive = (controls) => {
+        forOwn(controls, (c, controlKey) => {
+            if (c instanceof FormGroup || c instanceof FormArray) {
+                markFormGroupTouchedRecursive(c.controls);
+            }
+            else {
+                c.markAsTouched();
+                c.updateValueAndValidity();
+            }
+        });
+    };
+    markFormGroupTouchedRecursive(FormControls);
+};
+const markControlsTouched = (group) => {
+    Object.keys(group.controls).forEach((key) => {
+        const abstractControl = group.controls[key];
+        if (abstractControl instanceof FormGroup || abstractControl instanceof FormArray) {
+            markControlsTouched(abstractControl);
+        }
+        else {
+            abstractControl.markAsTouched();
+        }
+    });
+};
+const validateEmail = (c) => {
+    /* tslint:disable */
+    let EMAIL_REGEXP = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+    /* tslint:enable */
+    return EMAIL_REGEXP.test(c.value) ? null : {
+        validateEmail: {
+            valid: false
+        }
+    };
+};
+
+/**
+ * returns a random string with radix=36
+ */
+const uniqueId = () => {
+    return Math.random().toString(36).substr(2, 9);
+};
+/**
+ * Its job is to parse number and format it based on given input.
+ * @param value can be a number or a string number
+ * @param fractionSize size of fraction of a number e.g. 1000.88 fraction is 2 (88)  default is 2
+ * @param inDecimalSeparator separator for decimal part of the number default is ','
+ * @param inThousandSeparator separator for the whole part of the number default is ''
+ */
+const formatNumber = (value, fractionSize = 2, inDecimalSeparator = ',', inThousandSeparator = '') => {
+    if (inDecimalSeparator || inThousandSeparator) {
+        console.warn('The inDecimalSeparator and inThousandSeparator are deprecated. They will be a ' +
+            'BREAKING CHANGE for eUI 9 and be replaced by localization strategy.');
+    }
+    let decimalSeparator = '';
+    let thousandsSeparator = '';
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        // get all non characters
+        let nonChars = value.match(/[^0-9]+/g) || [];
+        // get all unique chars
+        let uniqueChars = nonChars
+            .reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());
+        // get separators
+        let separators = Array.from(uniqueChars.keys());
+        // sense where decimal separator and where thousand separator is
+        if (separators.length > 1) {
+            // left detected separator will be thousand and second will be decimal
+            thousandsSeparator = separators[0];
+            decimalSeparator = separators[1];
+        }
+        else if (separators.length > 0) {
+            // in case there is only one separator you don't know exactly who this separator is.
+            // in case there are more than two occurrences means we have a thousand otherwise we'll
+            // agree by conventions that is decimal
+            if (nonChars.length > 1) {
+                return value
+                    .split(separators[0])
+                    .join('')
+                    .replace(/\B(?=(\d{3})+(?!\d))/g, inThousandSeparator);
+            }
+            else {
+                return value.replace(separators[0], inDecimalSeparator)
+                    .replace(/\B(?=(\d{3})+(?!\d))/g, inThousandSeparator);
+            }
+        }
+        else {
+            // in case there are no separators then only format based on thousand one
+            return value.replace(/\B(?=(\d{3})+(?!\d))/g, inThousandSeparator);
+        }
+        // do the replacement of separators and parseInt
+        // Beware! Always replace thousand separator first and then decimal
+        value = value.split(thousandsSeparator).join('')
+            .replace(decimalSeparator, '.');
+    }
+    decimalSeparator = inDecimalSeparator;
+    thousandsSeparator = inThousandSeparator;
+    const maxFraction = '0'.repeat(fractionSize);
+    let [integer, fraction = maxFraction] = (value || '0').toString().split('.');
+    fraction = fractionSize > 0 ? (fraction + maxFraction).substring(0, fractionSize) : '';
+    // this rule makes sense only in number in case fraction is all zero
+    fraction = (typeof value === 'number' && fraction === maxFraction) ? '' : decimalSeparator + fraction;
+    return integer.replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSeparator) + fraction;
+};
+
+const handleError = (error) => {
+    let errMsg = (error.message) ? error.message :
+        error.status ? `${error.status} - ${error.statusText}` : 'Server error';
+    // console.error(errMsg);
+    return throwError(errMsg);
+};
+
+/**
+ * check if a value is null or undefined. If it's not both returns true otherwise false
+ * @param value
+ */
+function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+
+class EuiPermissionService extends EuiService {
+    constructor(log, store) {
+        super([]);
+        this.log = log;
+        this.store = store;
+        if (log) {
+            this.logger = log.getLogger('core.PermissionService');
+        }
+    }
+    /**
+     * initialize the service by providing a state
+     * @param rights
+     */
+    init(rights) {
+        super.initEuiService();
+        if (Array.isArray(rights)) {
+            this.updateState(rights);
+            return of({ success: true });
+        }
+        if (this.logger) {
+            this.logger.error('Init object should be instance of BaseUserState');
+        }
+        return of({ success: false, error: 'Init object should be instance of BaseUserState' });
+    }
+    get userRights() {
+        return this.stateInstance;
+    }
+    /**
+     * get the user's Rights from the state
+     */
+    getState() {
+        return this.store.select(getUserRights);
+    }
+    /**
+     * update the state with the given user's rights
+     * @param rights
+     */
+    updateState(rights) {
+        this.store.dispatch(new UpdateUserRightsAction(rights || []));
+    }
+    /**
+     * accepts a string of right and or a permission. In string first comes the right and or followed by permission in
+     * a dot separated way e.g. 'RIGHT.PERMISSION' or 'RIGHT'. The string can contain more that 2 separated fields.
+     * In that case the last field should be the permission and all the others a Right. e.g. 'RIGHT1.RIGHT2.PERMISSION'
+     * The last part is useful where you want a user to have multiple rights and the permission of the last right.
+     * @param rightsAndPermission
+     */
+    checkAttributePermission(rightsAndPermission) {
+        const permProps = rightsAndPermission.split('.');
+        const rightId = permProps[0];
+        const hasRight = this.checkRight(rightId);
+        if (hasRight) {
+            if (permProps.length === 2) {
+                // in case of 'RIGHT.PERMISSION'
+                const permission = permProps[1];
+                return this.checkPermission(rightId, permission);
+            }
+            else if (permProps.length > 2) {
+                // in case of 'RIGHT1.RIGHT2.....PERMISSION' string call recursively
+                return this.checkAttributePermission(rightsAndPermission.slice(rightId.length + 1));
+            }
+        }
+        return hasRight;
+    }
+    /**
+     * check if a user has the right.
+     * @param rightId the id of Right
+     */
+    checkRight(rightId) {
+        return this.userRights.some(right => right && right.id === rightId);
+    }
+    /**
+     * check if a user has that right and that right has the permission given.
+     * @param rightId the right of the user
+     * @param permission the permission of the right
+     */
+    checkPermission(rightId, permission) {
+        // the user has to have that right and that right has to have the given permission
+        return this.userRights.some(right => right &&
+            right.id === rightId &&
+            right.permissions &&
+            right.permissions.includes(permission));
+    }
+    /**
+     * checks whether a user have all rights passed as an argument
+     * @param rights an array of UxUserRight
+     */
+    haveAllRights(rights) {
+        if (!isDefined(rights)) {
+            throw Error(`The rights should be an array but instead it's not defined!`);
+        }
+        return rights.every((right) => this.userRights.find((uRight) => uRight.id === right.id));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EuiPermissionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EuiPermissionService, deps: [{ token: LogService, optional: true }, { token: StoreService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ EuiPermissionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EuiPermissionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EuiPermissionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: LogService, decorators: [{
+                    type: Optional
+                }] }, { type: StoreService }]; } });
+
+class UxDynamicMenuService {
+    // TODO: it should be moved euiservice, or it should be static
+    // TODO: can we moved that service inside the module of the component that's using it?
+    constructor(uxPermission, store) {
+        this.uxPermission = uxPermission;
+        this.store = store;
+        this.menuLinks = [];
+        this.store.select(getUserState).subscribe((user) => {
+            if (user.menuLinks) {
+                this.menuLinks = user.menuLinks;
+            }
+        });
+    }
+    getMenuLinks() {
+        return this.menuLinks;
+    }
+    filterUxLinksWithRights(links) {
+        return links.filter((link) => {
+            if (link.hasChildren) {
+                link.children = this.filterUxLinksWithRights(link.children);
+            }
+            // First check if the user is denied access:
+            if (link.deniedRightId) {
+                if (this.uxPermission.checkRight(link.deniedRightId)) {
+                    return false;
+                }
+            }
+            if (link.deniedRightIds) {
+                for (const deniedRightId of link.deniedRightIds) {
+                    if (this.uxPermission.checkRight(deniedRightId)) {
+                        return false;
+                    }
+                }
+            }
+            // Then check if the user needs to be allowed access explicitly:
+            if (link.allowedRightId) {
+                return this.uxPermission.checkRight(link.allowedRightId);
+            }
+            if (link.allowedRightIds) {
+                for (const allowedRightId of link.allowedRightIds) {
+                    if (this.uxPermission.checkRight(allowedRightId)) {
+                        return true;
+                    }
+                }
+                // User doesn't have one of the allowed rights. Deny access:
+                return false;
+            }
+            // Access to the menu item is not denied, therefore allow it:
+            return true;
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UxDynamicMenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxDynamicMenuService, deps: [{ token: EuiPermissionService }, { token: StoreService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UxDynamicMenuService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxDynamicMenuService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxDynamicMenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: EuiPermissionService }, { type: StoreService }]; } });
+
+function withUxErrorManager(errorManager) {
+    return function (source$) {
+        return new Observable(observer => {
+            const wrapper = {
+                next: value => {
+                    errorManager.clearError();
+                    observer.next(value);
+                },
+                error: (err) => {
+                    errorManager.publishError(err);
+                },
+            };
+            return source$.subscribe(wrapper);
+        });
+    };
+}
+
+class UxErrorFeedbackService {
+    constructor(asService, translateService) {
+        this.asService = asService;
+        this.translateService = translateService;
+        this.errors = new Subject();
+    }
+    /**
+     *  Publishes errors to targeted components
+     */
+    publishError(err, instanceId, groupId, accumulate) {
+        if (instanceId) {
+            this.errors.next(new UxPublishErrorFeedbackEvent(err.uxHttpErrorOutput, instanceId, groupId, accumulate));
+        }
+        else {
+            this.errors.next(new UxPublishErrorFeedbackEvent(err.uxHttpErrorOutput, undefined, groupId, accumulate));
+        }
+    }
+    /**
+     *  Growl errors
+     */
+    growlError(err) {
+        const feedBacks = err.uxHttpErrorOutput.getFeedBacks();
+        const isGrowlSticky = false;
+        const isGrowlMultiple = true;
+        const growlLife = 10000;
+        const position = 'bottom-right';
+        feedBacks.forEach((feedback) => this.translateService.get(feedback.msgId).pipe(take(1)).subscribe((translate) => {
+            this.asService.growl({
+                severity: feedback.severity || 'danger',
+                summary: 'ERROR',
+                detail: translate,
+            }, isGrowlSticky, isGrowlMultiple, growlLife, position);
+        }));
+    }
+    clearError(id, groupId) {
+        this.errors.next(new UxClearErrorFeedbackEvent(id, groupId));
+    }
+    createLocalErrorManager() {
+        return new UxErrorManager(this);
+    }
+    createGlobalErrorManager() {
+        return new UxErrorManager(this, true);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UxErrorFeedbackService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxErrorFeedbackService, deps: [{ token: UxAppShellService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UxErrorFeedbackService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxErrorFeedbackService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxErrorFeedbackService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: UxAppShellService }, { type: i2.TranslateService }]; } });
+class UxErrorManager {
+    constructor(uxErrorFeedbackService, isGlobal) {
+        this.uxErrorFeedbackService = uxErrorFeedbackService;
+        this.isGlobal = isGlobal;
+        this.httpErrorOperator = withUxErrorManager(this);
+        this.id = Math.random().toString();
+    }
+    publishError(err, groupId, accumulate) {
+        if (!this.isGlobal) {
+            this.uxErrorFeedbackService.publishError(err, this.id, groupId, accumulate);
+        }
+        else {
+            this.uxErrorFeedbackService.publishError(err, undefined, groupId, accumulate);
+        }
+    }
+    clearError(groupId) {
+        if (!this.isGlobal) {
+            this.uxErrorFeedbackService.clearError(this.id, groupId);
+        }
+        else {
+            this.uxErrorFeedbackService.clearError(undefined, groupId);
+        }
+    }
+    growlError(err) {
+        this.uxErrorFeedbackService.growlError(err);
+    }
+    errors() {
+        if (!this.isGlobal) {
+            return this.uxErrorFeedbackService.errors.pipe(filter((evt) => evt.id === this.id));
+        }
+        else {
+            return this.uxErrorFeedbackService.errors.pipe(filter((evt) => !evt.id));
+        }
+    }
+}
+
+const DYNAMIC_COMPONENT_CONFIG = new InjectionToken('DYNAMIC_COMPONENT_CONFIG');
+class UxDynamicComponentService {
+    constructor(componentFactoryResolver, injector, appRef) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.injector = injector;
+        this.appRef = appRef;
+    }
+    /**
+     * Adds a component to portal host dynamically
+     * @param component The component to be injected
+     * @param el The element reference for the component to be injected
+     * @param config The data to be passed (config) for the DYNAMIC_COMPONENT_CONFIG token
+     */
+    add(component, el, config) {
+        // Create a portalHost from a DOM element
+        this.portalHost = new DomPortalOutlet(el ? el.nativeElement : document.body, this.componentFactoryResolver, this.appRef, this.injector);
+        // Locate the component factory for the ComponentToIncludeDynamicallyComponent
+        this.portal = new ComponentPortal(component, null, config ? this.createInjector(config) : null);
+        // Attach portal to host
+        this.portalComponentInstance = this.portalHost.attach(this.portal);
+        if (config) {
+            Object.assign(config, {
+                portalHostRef: this.portalHost,
+                portalRef: this.portal,
+                portalComponentInstanceRef: this.portalComponentInstance,
+            });
+        }
+        return {
+            portalHost: this.portalHost,
+            portal: this.portal,
+            portalComponentInstance: this.portalComponentInstance
+        };
+    }
+    /**
+     * detaches a portalHost
+     * @param portalHostRef reference of portal host to be detached
+     */
+    remove(portalHostRef) {
+        portalHostRef.detach();
+        this.portalHost = null;
+        this.portal = null;
+        this.portalComponentInstance = null;
+    }
+    /**
+     * creates an  Custom injector to be used when providing custom injection tokens to components inside a portal
+     * @param data to be used by DYNAMIC_COMPONENT_CONFIG token
+     */
+    createInjector(data) {
+        const injectorTokens = new WeakMap();
+        injectorTokens.set(DYNAMIC_COMPONENT_CONFIG, data);
+        return new PortalInjector(this.injector, injectorTokens);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UxDynamicComponentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxDynamicComponentService, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UxDynamicComponentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxDynamicComponentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxDynamicComponentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ApplicationRef }]; } });
+
+const UX_COUNTRIES = {
+    AF: 'Afghanistan',
+    AX: 'Aland Islands',
+    AL: 'Albania',
+    DZ: 'Algeria',
+    AS: 'American Samoa',
+    AD: 'Andorra',
+    AO: 'Angola',
+    AI: 'Anguilla',
+    AQ: 'Antarctica',
+    AG: 'Antigua and Barbuda',
+    AR: 'Argentina',
+    AM: 'Armenia',
+    AW: 'Aruba',
+    AU: 'Australia',
+    AT: 'Austria',
+    AZ: 'Azerbaijan',
+    BS: 'Bahamas',
+    BH: 'Bahrain',
+    BD: 'Bangladesh',
+    BB: 'Barbados',
+    BY: 'Belarus',
+    BE: 'Belgium',
+    BZ: 'Belize',
+    BJ: 'Benin',
+    BM: 'Bermuda',
+    BT: 'Bhutan',
+    BO: 'Bolivia',
+    BA: 'Bosnia and Herzegovina',
+    BW: 'Botswana',
+    BV: 'Bouvet Island',
+    BR: 'Brazil',
+    VG: 'British Virgin Islands',
+    IO: 'British Indian Ocean Territory',
+    BN: 'Brunei Darussalam',
+    BG: 'Bulgaria',
+    BF: 'Burkina Faso',
+    BI: 'Burundi',
+    KH: 'Cambodia',
+    CM: 'Cameroon',
+    CA: 'Canada',
+    CV: 'Cape Verde',
+    KY: 'Cayman Islands',
+    CF: 'Central African Republic',
+    TD: 'Chad',
+    CL: 'Chile',
+    CN: 'China',
+    HK: 'Hong Kong',
+    MO: 'Macao',
+    CX: 'Christmas Island',
+    CC: 'Cocos (Keeling) Islands',
+    CO: 'Colombia',
+    KM: 'Comoros',
+    CG: 'Congo (Brazzaville)',
+    CD: 'Congo, (Kinshasa)',
+    CK: 'Cook Islands',
+    CR: 'Costa Rica',
+    CI: 'Côte d\'Ivoire',
+    HR: 'Croatia',
+    CU: 'Cuba',
+    CY: 'Cyprus',
+    CZ: 'Czech Republic',
+    DK: 'Denmark',
+    DJ: 'Djibouti',
+    DM: 'Dominica',
+    DO: 'Dominican Republic',
+    EC: 'Ecuador',
+    EG: 'Egypt',
+    SV: 'El Salvador',
+    GQ: 'Equatorial Guinea',
+    ER: 'Eritrea',
+    EE: 'Estonia',
+    ET: 'Ethiopia',
+    FK: 'Falkland Islands (Malvinas)',
+    FO: 'Faroe Islands',
+    FJ: 'Fiji',
+    FI: 'Finland',
+    FR: 'France',
+    GF: 'French Guiana',
+    PF: 'French Polynesia',
+    TF: 'French Southern Territories',
+    GA: 'Gabon',
+    GM: 'Gambia',
+    GE: 'Georgia',
+    DE: 'Germany',
+    GH: 'Ghana',
+    GI: 'Gibraltar',
+    GR: 'Greece',
+    GL: 'Greenland',
+    GD: 'Grenada',
+    GP: 'Guadeloupe',
+    GU: 'Guam',
+    GT: 'Guatemala',
+    GG: 'Guernsey',
+    GN: 'Guinea',
+    GW: 'Guinea-Bissau',
+    GY: 'Guyana',
+    HT: 'Haiti',
+    HM: 'Heard and Mcdonald Islands',
+    VA: 'Vatican City State',
+    HN: 'Honduras',
+    HU: 'Hungary',
+    IS: 'Iceland',
+    IN: 'India',
+    ID: 'Indonesia',
+    IR: 'Iran',
+    IQ: 'Iraq',
+    IE: 'Ireland',
+    IM: 'Isle of Man',
+    IL: 'Israel',
+    IT: 'Italy',
+    JM: 'Jamaica',
+    JP: 'Japan',
+    JE: 'Jersey',
+    JO: 'Jordan',
+    KZ: 'Kazakhstan',
+    KE: 'Kenya',
+    KI: 'Kiribati',
+    KP: 'Korea (North)',
+    KR: 'Korea (South)',
+    KW: 'Kuwait',
+    KG: 'Kyrgyzstan',
+    LA: 'Lao PDR',
+    LV: 'Latvia',
+    LB: 'Lebanon',
+    LS: 'Lesotho',
+    LR: 'Liberia',
+    LY: 'Libya',
+    LI: 'Liechtenstein',
+    LT: 'Lithuania',
+    LU: 'Luxembourg',
+    MK: 'Macedonia',
+    MG: 'Madagascar',
+    MW: 'Malawi',
+    MY: 'Malaysia',
+    MV: 'Maldives',
+    ML: 'Mali',
+    MT: 'Malta',
+    MH: 'Marshall Islands',
+    MQ: 'Martinique',
+    MR: 'Mauritania',
+    MU: 'Mauritius',
+    YT: 'Mayotte',
+    MX: 'Mexico',
+    FM: 'Micronesia',
+    MD: 'Moldova',
+    MC: 'Monaco',
+    MN: 'Mongolia',
+    ME: 'Montenegro',
+    MS: 'Montserrat',
+    MA: 'Morocco',
+    MZ: 'Mozambique',
+    MM: 'Myanmar',
+    NA: 'Namibia',
+    NR: 'Nauru',
+    NP: 'Nepal',
+    NL: 'Netherlands',
+    AN: 'Netherlands Antilles',
+    NC: 'New Caledonia',
+    NZ: 'New Zealand',
+    NI: 'Nicaragua',
+    NE: 'Niger',
+    NG: 'Nigeria',
+    NU: 'Niue',
+    NF: 'Norfolk Island',
+    MP: 'Northern Mariana Islands',
+    NO: 'Norway',
+    OM: 'Oman',
+    PK: 'Pakistan',
+    PW: 'Palau',
+    PS: 'Palestinian Territory',
+    PA: 'Panama',
+    PG: 'Papua New Guinea',
+    PY: 'Paraguay',
+    PE: 'Peru',
+    PH: 'Philippines',
+    PN: 'Pitcairn',
+    PL: 'Poland',
+    PT: 'Portugal',
+    PR: 'Puerto Rico',
+    QA: 'Qatar',
+    RE: 'Réunion',
+    RO: 'Romania',
+    RU: 'Russian Federation',
+    RW: 'Rwanda',
+    BL: 'Saint-Barthélemy',
+    SH: 'Saint Helena',
+    KN: 'Saint Kitts and Nevis',
+    LC: 'Saint Lucia',
+    MF: 'Saint-Martin (French part)',
+    PM: 'Saint Pierre and Miquelon',
+    VC: 'Saint Vincent and Grenadines',
+    WS: 'Samoa',
+    SM: 'San Marino',
+    ST: 'Sao Tome and Principe',
+    SA: 'Saudi Arabia',
+    SN: 'Senegal',
+    RS: 'Serbia',
+    SC: 'Seychelles',
+    SL: 'Sierra Leone',
+    SG: 'Singapore',
+    SK: 'Slovakia',
+    SI: 'Slovenia',
+    SB: 'Solomon Islands',
+    SO: 'Somalia',
+    ZA: 'South Africa',
+    GS: 'South Georgia and the South Sandwich Islands',
+    SS: 'South Sudan',
+    ES: 'Spain',
+    LK: 'Sri Lanka',
+    SD: 'Sudan',
+    SR: 'Suriname',
+    SJ: 'Svalbard and Jan Mayen Islands',
+    SZ: 'Swaziland',
+    SE: 'Sweden',
+    CH: 'Switzerland',
+    SY: 'Syria',
+    TW: 'Taiwan',
+    TJ: 'Tajikistan',
+    TZ: 'Tanzania',
+    TH: 'Thailand',
+    TL: 'Timor-Leste',
+    TG: 'Togo',
+    TK: 'Tokelau',
+    TO: 'Tonga',
+    TT: 'Trinidad and Tobago',
+    TN: 'Tunisia',
+    TR: 'Turkey',
+    TM: 'Turkmenistan',
+    TC: 'Turks and Caicos Islands',
+    TV: 'Tuvalu',
+    UG: 'Uganda',
+    UA: 'Ukraine',
+    AE: 'United Arab Emirates',
+    GB: 'United Kingdom (GB)',
+    US: 'United States of America (USA)',
+    UM: 'US Minor Outlying Islands',
+    UY: 'Uruguay',
+    UZ: 'Uzbekistan',
+    VU: 'Vanuatu',
+    VE: 'Venezuela',
+    VN: 'Viet Nam',
+    VI: 'Virgin Islands, US',
+    WF: 'Wallis and Futuna Islands',
+    EH: 'Western Sahara',
+    YE: 'Yemen',
+    ZM: 'Zambia',
+    ZW: 'Zimbabwe'
+};
+const UX_TIMEZONES = [
+    { name: 'Europe/Andorra', desc: 'Andorra - Andorra (GMT+02:00)' },
+    { name: 'Asia/Dubai', desc: 'United Arab Emirates - Dubai (GMT+04:00)' },
+    { name: 'Asia/Kabul', desc: 'Afghanistan - Kabul (GMT+04:30)' },
+    { name: 'America/Antigua', desc: 'Antigua and Barbuda - Antigua (GMT-04:00)' },
+    { name: 'America/Anguilla', desc: 'Anguilla - Anguilla (GMT-04:00)' },
+    { name: 'Europe/Tirane', desc: 'Albania - Tirane (GMT+02:00)' },
+    { name: 'Asia/Yerevan', desc: 'Armenia - Yerevan (GMT+04:00)' },
+    { name: 'Africa/Luanda', desc: 'Angola - Luanda (GMT+01:00)' },
+    { name: 'Antarctica/McMurdo', desc: 'Antarctica - McMurdo (GMT+12:00)' },
+    { name: 'Antarctica/Rothera', desc: 'Antarctica - Rothera (GMT-03:00)' },
+    { name: 'Antarctica/Palmer', desc: 'Antarctica - Palmer (GMT-03:00)' },
+    { name: 'Antarctica/Mawson', desc: 'Antarctica - Mawson (GMT+05:00)' },
+    { name: 'Antarctica/Davis', desc: 'Antarctica - Davis (GMT+07:00)' },
+    { name: 'Antarctica/Casey', desc: 'Antarctica - Casey (GMT+08:00)' },
+    { name: 'Antarctica/Vostok', desc: 'Antarctica - Vostok (GMT+06:00)' },
+    { name: 'Antarctica/DumontDUrville', desc: 'Antarctica - DumontDUrville (GMT+10:00)' },
+    { name: 'Antarctica/Syowa', desc: 'Antarctica - Syowa (GMT+03:00)' },
+    { name: 'Antarctica/Troll', desc: 'Antarctica - Troll (GMT+02:00)' },
+    { name: 'America/Argentina/Buenos_Aires', desc: 'Argentina - Buenos Aires (GMT-03:00)' },
+    { name: 'America/Argentina/Cordoba', desc: 'Argentina - Cordoba (GMT-03:00)' },
+    { name: 'America/Argentina/Salta', desc: 'Argentina - Salta (GMT-03:00)' },
+    { name: 'America/Argentina/Jujuy', desc: 'Argentina - Jujuy (GMT-03:00)' },
+    { name: 'America/Argentina/Tucuman', desc: 'Argentina - Tucuman (GMT-03:00)' },
+    { name: 'America/Argentina/Catamarca', desc: 'Argentina - Catamarca (GMT-03:00)' },
+    { name: 'America/Argentina/La_Rioja', desc: 'Argentina - La Rioja (GMT-03:00)' },
+    { name: 'America/Argentina/San_Juan', desc: 'Argentina - San Juan (GMT-03:00)' },
+    { name: 'America/Argentina/Mendoza', desc: 'Argentina - Mendoza (GMT-03:00)' },
+    { name: 'America/Argentina/San_Luis', desc: 'Argentina - San Luis (GMT-03:00)' },
+    { name: 'America/Argentina/Rio_Gallegos', desc: 'Argentina - Rio Gallegos (GMT-03:00)' },
+    { name: 'America/Argentina/Ushuaia', desc: 'Argentina - Ushuaia (GMT-03:00)' },
+    { name: 'Pacific/Pago_Pago', desc: 'American Samoa - Pago Pago (GMT-11:00)' },
+    { name: 'Pacific/Samoa', desc: 'American Samoa - Samoa (GMT-11:00)' },
+    { name: 'Europe/Vienna', desc: 'Austria - Vienna (GMT+02:00)' },
+    { name: 'Australia/Lord_Howe', desc: 'Australia - Lord Howe (GMT+10:30)' },
+    { name: 'Antarctica/Macquarie', desc: 'Australia - Macquarie (GMT+11:00)' },
+    { name: 'Australia/Hobart', desc: 'Australia - Hobart (GMT+10:00)' },
+    { name: 'Australia/Currie', desc: 'Australia - Currie (GMT+10:00)' },
+    { name: 'Australia/Melbourne', desc: 'Australia - Melbourne (GMT+10:00)' },
+    { name: 'Australia/Sydney', desc: 'Australia - Sydney (GMT+10:00)' },
+    { name: 'Australia/Broken_Hill', desc: 'Australia - Broken Hill (GMT+09:30)' },
+    { name: 'Australia/Brisbane', desc: 'Australia - Brisbane (GMT+10:00)' },
+    { name: 'Australia/Lindeman', desc: 'Australia - Lindeman (GMT+10:00)' },
+    { name: 'Australia/Adelaide', desc: 'Australia - Adelaide (GMT+09:30)' },
+    { name: 'Australia/Darwin', desc: 'Australia - Darwin (GMT+09:30)' },
+    { name: 'Australia/Perth', desc: 'Australia - Perth (GMT+08:00)' },
+    { name: 'Australia/Eucla', desc: 'Australia - Eucla (GMT+08:45)' },
+    { name: 'Australia/Canberra', desc: 'Australia - Canberra (GMT+10:00)' },
+    { name: 'Australia/Queensland', desc: 'Australia - Queensland (GMT+10:00)' },
+    { name: 'Australia/Tasmania', desc: 'Australia - Tasmania (GMT+10:00)' },
+    { name: 'Australia/Victoria', desc: 'Australia - Victoria (GMT+10:00)' },
+    { name: 'America/Aruba', desc: 'Aruba - Aruba (GMT-04:00)' },
+    { name: 'Europe/Mariehamn', desc: 'Aland Islands - Mariehamn (GMT+03:00)' },
+    { name: 'Asia/Baku', desc: 'Azerbaijan - Baku (GMT+04:00)' },
+    { name: 'Europe/Sarajevo', desc: 'Bosnia and Herzegovina - Sarajevo (GMT+02:00)' },
+    { name: 'America/Barbados', desc: 'Barbados - Barbados (GMT-04:00)' },
+    { name: 'Asia/Dhaka', desc: 'Bangladesh - Dhaka (GMT+06:00)' },
+    { name: 'Europe/Brussels', desc: 'Belgium - Brussels (GMT+02:00)' },
+    { name: 'Africa/Ouagadougou', desc: 'Burkina Faso - Ouagadougou (GMT+00:00)' },
+    { name: 'Europe/Sofia', desc: 'Bulgaria - Sofia (GMT+03:00)' },
+    { name: 'Asia/Bahrain', desc: 'Bahrain - Bahrain (GMT+03:00)' },
+    { name: 'Africa/Bujumbura', desc: 'Burundi - Bujumbura (GMT+02:00)' },
+    { name: 'Africa/Porto-Novo', desc: 'Benin - Porto-Novo (GMT+01:00)' },
+    { name: 'America/St_Barthelemy', desc: 'Saint-Barthélemy - St Barthelemy (GMT-04:00)' },
+    { name: 'Atlantic/Bermuda', desc: 'Bermuda - Bermuda (GMT-03:00)' },
+    { name: 'Asia/Brunei', desc: 'Brunei Darussalam - Brunei (GMT+08:00)' },
+    { name: 'America/La_Paz', desc: 'Bolivia - La Paz (GMT-04:00)' },
+    { name: 'America/Kralendijk', desc: 'BQ - Kralendijk (GMT-04:00)' },
+    { name: 'America/Noronha', desc: 'Brazil - Noronha (GMT-02:00)' },
+    { name: 'America/Belem', desc: 'Brazil - Belem (GMT-03:00)' },
+    { name: 'America/Fortaleza', desc: 'Brazil - Fortaleza (GMT-03:00)' },
+    { name: 'America/Recife', desc: 'Brazil - Recife (GMT-03:00)' },
+    { name: 'America/Araguaina', desc: 'Brazil - Araguaina (GMT-03:00)' },
+    { name: 'America/Maceio', desc: 'Brazil - Maceio (GMT-03:00)' },
+    { name: 'America/Bahia', desc: 'Brazil - Bahia (GMT-03:00)' },
+    { name: 'America/Sao_Paulo', desc: 'Brazil - Sao Paulo (GMT-03:00)' },
+    { name: 'America/Campo_Grande', desc: 'Brazil - Campo Grande (GMT-04:00)' },
+    { name: 'America/Cuiaba', desc: 'Brazil - Cuiaba (GMT-04:00)' },
+    { name: 'America/Santarem', desc: 'Brazil - Santarem (GMT-03:00)' },
+    { name: 'America/Porto_Velho', desc: 'Brazil - Porto Velho (GMT-04:00)' },
+    { name: 'America/Boa_Vista', desc: 'Brazil - Boa Vista (GMT-04:00)' },
+    { name: 'America/Manaus', desc: 'Brazil - Manaus (GMT-04:00)' },
+    { name: 'America/Eirunepe', desc: 'Brazil - Eirunepe (GMT-05:00)' },
+    { name: 'America/Rio_Branco', desc: 'Brazil - Rio Branco (GMT-05:00)' },
+    { name: 'America/Nassau', desc: 'Bahamas - Nassau (GMT-04:00)' },
+    { name: 'Asia/Thimphu', desc: 'Bhutan - Thimphu (GMT+06:00)' },
+    { name: 'Africa/Gaborone', desc: 'Botswana - Gaborone (GMT+02:00)' },
+    { name: 'Europe/Minsk', desc: 'Belarus - Minsk (GMT+03:00)' },
+    { name: 'America/Belize', desc: 'Belize - Belize (GMT-06:00)' },
+    { name: 'America/St_Johns', desc: 'Canada - St Johns (GMT-02:30)' },
+    { name: 'America/Halifax', desc: 'Canada - Halifax (GMT-03:00)' },
+    { name: 'America/Glace_Bay', desc: 'Canada - Glace Bay (GMT-03:00)' },
+    { name: 'America/Moncton', desc: 'Canada - Moncton (GMT-03:00)' },
+    { name: 'America/Goose_Bay', desc: 'Canada - Goose Bay (GMT-03:00)' },
+    { name: 'America/Blanc-Sablon', desc: 'Canada - Blanc-Sablon (GMT-04:00)' },
+    { name: 'America/Toronto', desc: 'Canada - Toronto (GMT-04:00)' },
+    { name: 'America/Nipigon', desc: 'Canada - Nipigon (GMT-04:00)' },
+    { name: 'America/Thunder_Bay', desc: 'Canada - Thunder Bay (GMT-04:00)' },
+    { name: 'America/Iqaluit', desc: 'Canada - Iqaluit (GMT-04:00)' },
+    { name: 'America/Pangnirtung', desc: 'Canada - Pangnirtung (GMT-04:00)' },
+    { name: 'America/Resolute', desc: 'Canada - Resolute (GMT-05:00)' },
+    { name: 'America/Atikokan', desc: 'Canada - Atikokan (GMT-05:00)' },
+    { name: 'America/Rankin_Inlet', desc: 'Canada - Rankin Inlet (GMT-05:00)' },
+    { name: 'America/Winnipeg', desc: 'Canada - Winnipeg (GMT-05:00)' },
+    { name: 'America/Rainy_River', desc: 'Canada - Rainy River (GMT-05:00)' },
+    { name: 'America/Regina', desc: 'Canada - Regina (GMT-06:00)' },
+    { name: 'America/Swift_Current', desc: 'Canada - Swift Current (GMT-06:00)' },
+    { name: 'America/Edmonton', desc: 'Canada - Edmonton (GMT-06:00)' },
+    { name: 'America/Cambridge_Bay', desc: 'Canada - Cambridge Bay (GMT-06:00)' },
+    { name: 'America/Yellowknife', desc: 'Canada - Yellowknife (GMT-06:00)' },
+    { name: 'America/Inuvik', desc: 'Canada - Inuvik (GMT-06:00)' },
+    { name: 'America/Creston', desc: 'Canada - Creston (GMT-07:00)' },
+    { name: 'America/Dawson_Creek', desc: 'Canada - Dawson Creek (GMT-07:00)' },
+    { name: 'America/Vancouver', desc: 'Canada - Vancouver (GMT-07:00)' },
+    { name: 'America/Whitehorse', desc: 'Canada - Whitehorse (GMT-07:00)' },
+    { name: 'America/Dawson', desc: 'Canada - Dawson (GMT-07:00)' },
+    { name: 'America/Montreal', desc: 'Canada - Montreal (GMT-04:00)' },
+    { name: 'Canada/Atlantic', desc: 'Canada - Atlantic (GMT-03:00)' },
+    { name: 'Canada/Central', desc: 'Canada - Central (GMT-05:00)' },
+    { name: 'Canada/Eastern', desc: 'Canada - Eastern (GMT-04:00)' },
+    { name: 'Canada/Mountain', desc: 'Canada - Mountain (GMT-06:00)' },
+    { name: 'Canada/Newfoundland', desc: 'Canada - Newfoundland (GMT-02:30)' },
+    { name: 'Canada/Pacific', desc: 'Canada - Pacific (GMT-07:00)' },
+    { name: 'Canada/Saskatchewan', desc: 'Canada - Saskatchewan (GMT-06:00)' },
+    { name: 'Canada/Yukon', desc: 'Canada - Yukon (GMT-07:00)' },
+    { name: 'Indian/Cocos', desc: 'Cocos (Keeling) Islands - Cocos (GMT+06:30)' },
+    { name: 'Africa/Kinshasa', desc: 'Congo, (Kinshasa) - Kinshasa (GMT+01:00)' },
+    { name: 'Africa/Lubumbashi', desc: 'Congo, (Kinshasa) - Lubumbashi (GMT+02:00)' },
+    { name: 'Africa/Bangui', desc: 'Central African Republic - Bangui (GMT+01:00)' },
+    { name: 'Africa/Brazzaville', desc: 'Congo (Brazzaville) - Brazzaville (GMT+01:00)' },
+    { name: 'Europe/Zurich', desc: 'Switzerland - Zurich (GMT+02:00)' },
+    { name: 'Africa/Abidjan', desc: 'Côte d\'Ivoire - Abidjan (GMT+00:00)' },
+    { name: 'Pacific/Rarotonga', desc: 'Cook Islands - Rarotonga (GMT-10:00)' },
+    { name: 'America/Santiago', desc: 'Chile - Santiago (GMT-04:00)' },
+    { name: 'Pacific/Easter', desc: 'Chile - Easter (GMT-06:00)' },
+    { name: 'Chile/Continental', desc: 'Chile - Continental (GMT-04:00)' },
+    { name: 'Chile/EasterIsland', desc: 'Chile - EasterIsland (GMT-06:00)' },
+    { name: 'Africa/Douala', desc: 'Cameroon - Douala (GMT+01:00)' },
+    { name: 'Asia/Shanghai', desc: 'China - Shanghai (GMT+08:00)' },
+    { name: 'Asia/Harbin', desc: 'China - Harbin (GMT+08:00)' },
+    { name: 'Asia/Chongqing', desc: 'China - Chongqing (GMT+08:00)' },
+    { name: 'Asia/Urumqi', desc: 'China - Urumqi (GMT+06:00)' },
+    { name: 'Asia/Kashgar', desc: 'China - Kashgar (GMT+06:00)' },
+    { name: 'America/Bogota', desc: 'Colombia - Bogota (GMT-05:00)' },
+    { name: 'America/Costa_Rica', desc: 'Costa Rica - Costa Rica (GMT-06:00)' },
+    { name: 'America/Havana', desc: 'Cuba - Havana (GMT-04:00)' },
+    { name: 'Atlantic/Cape_Verde', desc: 'Cape Verde - Cape Verde (GMT-01:00)' },
+    { name: 'America/Curacao', desc: 'CW - Curacao (GMT-04:00)' },
+    { name: 'Indian/Christmas', desc: 'Christmas Island - Christmas (GMT+07:00)' },
+    { name: 'Asia/Nicosia', desc: 'Cyprus - Nicosia (GMT+03:00)' },
+    { name: 'Europe/Prague', desc: 'Czech Republic - Prague (GMT+02:00)' },
+    { name: 'Europe/Berlin', desc: 'Germany - Berlin (GMT+02:00)' },
+    { name: 'Africa/Djibouti', desc: 'Djibouti - Djibouti (GMT+03:00)' },
+    { name: 'Europe/Copenhagen', desc: 'Denmark - Copenhagen (GMT+02:00)' },
+    { name: 'America/Dominica', desc: 'Dominica - Dominica (GMT-04:00)' },
+    { name: 'America/Santo_Domingo', desc: 'Dominican Republic - Santo Domingo (GMT-04:00)' },
+    { name: 'Africa/Algiers', desc: 'Algeria - Algiers (GMT+01:00)' },
+    { name: 'America/Guayaquil', desc: 'Ecuador - Guayaquil (GMT-05:00)' },
+    { name: 'Pacific/Galapagos', desc: 'Ecuador - Galapagos (GMT-06:00)' },
+    { name: 'Europe/Tallinn', desc: 'Estonia - Tallinn (GMT+03:00)' },
+    { name: 'Egypt', desc: 'Egypt - Egypt (GMT+02:00)' },
+    { name: 'Africa/El_Aaiun', desc: 'Western Sahara - El Aaiun (GMT+00:00)' },
+    { name: 'Africa/Asmara', desc: 'Eritrea - Asmara (GMT+03:00)' },
+    { name: 'Europe/Madrid', desc: 'Spain - Madrid (GMT+02:00)' },
+    { name: 'Africa/Ceuta', desc: 'Spain - Ceuta (GMT+02:00)' },
+    { name: 'Atlantic/Canary', desc: 'Spain - Canary (GMT+01:00)' },
+    { name: 'Africa/Addis_Ababa', desc: 'Ethiopia - Addis Ababa (GMT+03:00)' },
+    { name: 'Europe/Helsinki', desc: 'Finland - Helsinki (GMT+03:00)' },
+    { name: 'Pacific/Fiji', desc: 'Fiji - Fiji (GMT+12:00)' },
+    { name: 'Atlantic/Stanley', desc: 'Falkland Islands (Malvinas) - Stanley (GMT-03:00)' },
+    { name: 'Pacific/Chuuk', desc: 'Micronesia - Chuuk (GMT+10:00)' },
+    { name: 'Pacific/Pohnpei', desc: 'Micronesia - Pohnpei (GMT+11:00)' },
+    { name: 'Pacific/Kosrae', desc: 'Micronesia - Kosrae (GMT+11:00)' },
+    { name: 'Atlantic/Faroe', desc: 'Faroe Islands - Faroe (GMT+01:00)' },
+    { name: 'Europe/Paris', desc: 'France - Paris (GMT+02:00)' },
+    { name: 'Africa/Libreville', desc: 'Gabon - Libreville (GMT+01:00)' },
+    { name: 'Europe/London', desc: 'United Kingdom (GB) - London (GMT+01:00)' },
+    { name: 'America/Grenada', desc: 'Grenada - Grenada (GMT-04:00)' },
+    { name: 'Asia/Tbilisi', desc: 'Georgia - Tbilisi (GMT+04:00)' },
+    { name: 'America/Cayenne', desc: 'French Guiana - Cayenne (GMT-03:00)' },
+    { name: 'Europe/Guernsey', desc: 'Guernsey - Guernsey (GMT+01:00)' },
+    { name: 'Africa/Accra', desc: 'Ghana - Accra (GMT+00:00)' },
+    { name: 'Europe/Gibraltar', desc: 'Gibraltar - Gibraltar (GMT+02:00)' },
+    { name: 'America/Godthab', desc: 'Greenland - Godthab (GMT-02:00)' },
+    { name: 'America/Danmarkshavn', desc: 'Greenland - Danmarkshavn (GMT+00:00)' },
+    { name: 'America/Scoresbysund', desc: 'Greenland - Scoresbysund (GMT+00:00)' },
+    { name: 'America/Thule', desc: 'Greenland - Thule (GMT-03:00)' },
+    { name: 'Africa/Banjul', desc: 'Gambia - Banjul (GMT+00:00)' },
+    { name: 'Africa/Conakry', desc: 'Guinea - Conakry (GMT+00:00)' },
+    { name: 'America/Guadeloupe', desc: 'Guadeloupe - Guadeloupe (GMT-04:00)' },
+    { name: 'Africa/Malabo', desc: 'Equatorial Guinea - Malabo (GMT+01:00)' },
+    { name: 'Europe/Athens', desc: 'Greece - Athens (GMT+03:00)' },
+    { name: 'Atlantic/South_Georgia', desc: 'South Georgia and the South Sandwich Islands - South Georgia (GMT-02:00)' },
+    { name: 'America/Guatemala', desc: 'Guatemala - Guatemala (GMT-06:00)' },
+    { name: 'Pacific/Guam', desc: 'Guam - Guam (GMT+10:00)' },
+    { name: 'Africa/Bissau', desc: 'Guinea-Bissau - Bissau (GMT+00:00)' },
+    { name: 'America/Guyana', desc: 'Guyana - Guyana (GMT-04:00)' },
+    { name: 'Asia/Hong_Kong', desc: 'Hong Kong - Hong Kong (GMT+08:00)' },
+    { name: 'America/Tegucigalpa', desc: 'Honduras - Tegucigalpa (GMT-06:00)' },
+    { name: 'Europe/Zagreb', desc: 'Croatia - Zagreb (GMT+02:00)' },
+    { name: 'America/Port-au-Prince', desc: 'Haiti - Port-au-Prince (GMT-04:00)' },
+    { name: 'Europe/Budapest', desc: 'Hungary - Budapest (GMT+02:00)' },
+    { name: 'Asia/Jakarta', desc: 'Indonesia - Jakarta (GMT+07:00)' },
+    { name: 'Asia/Pontianak', desc: 'Indonesia - Pontianak (GMT+07:00)' },
+    { name: 'Asia/Makassar', desc: 'Indonesia - Makassar (GMT+08:00)' },
+    { name: 'Asia/Jayapura', desc: 'Indonesia - Jayapura (GMT+09:00)' },
+    { name: 'Europe/Dublin', desc: 'Ireland - Dublin (GMT+01:00)' },
+    { name: 'Asia/Jerusalem', desc: 'Israel - Jerusalem (GMT+03:00)' },
+    { name: 'Europe/Isle_of_Man', desc: 'Isle of Man - Isle of_Man (GMT+01:00)' },
+    { name: 'Asia/Kolkata', desc: 'India - Kolkata (GMT+05:30)' },
+    { name: 'Indian/Chagos', desc: 'British Indian Ocean Territory - Chagos (GMT+06:00)' },
+    { name: 'Asia/Baghdad', desc: 'Iraq - Baghdad (GMT+03:00)' },
+    { name: 'Asia/Tehran', desc: 'Iran - Tehran (GMT+04:30)' },
+    { name: 'Atlantic/Reykjavik', desc: 'Iceland - Reykjavik (GMT+00:00)' },
+    { name: 'Europe/Rome', desc: 'Italy - Rome (GMT+02:00)' },
+    { name: 'Europe/Jersey', desc: 'Jersey - Jersey (GMT+01:00)' },
+    { name: 'America/Jamaica', desc: 'Jamaica - Jamaica (GMT-05:00)' },
+    { name: 'Asia/Amman', desc: 'Jordan - Amman (GMT+03:00)' },
+    { name: 'Asia/Tokyo', desc: 'Japan - Tokyo (GMT+09:00)' },
+    { name: 'Africa/Nairobi', desc: 'Kenya - Nairobi (GMT+03:00)' },
+    { name: 'Asia/Bishkek', desc: 'Kyrgyzstan - Bishkek (GMT+06:00)' },
+    { name: 'Asia/Phnom_Penh', desc: 'Cambodia - Phnom Penh (GMT+07:00)' },
+    { name: 'Pacific/Tarawa', desc: 'Kiribati - Tarawa (GMT+12:00)' },
+    { name: 'Pacific/Enderbury', desc: 'Kiribati - Enderbury (GMT+13:00)' },
+    { name: 'Pacific/Kiritimati', desc: 'Kiribati - Kiritimati (GMT+14:00)' },
+    { name: 'Indian/Comoro', desc: 'Comoros - Comoro (GMT+03:00)' },
+    { name: 'America/St_Kitts', desc: 'Saint Kitts and Nevis - St Kitts (GMT-04:00)' },
+    { name: 'Asia/Pyongyang', desc: 'Korea (North) - Pyongyang (GMT+09:00)' },
+    { name: 'Asia/Seoul', desc: 'Korea (South) - Seoul (GMT+09:00)' },
+    { name: 'Asia/Kuwait', desc: 'Kuwait - Kuwait (GMT+03:00)' },
+    { name: 'America/Cayman', desc: 'Cayman Islands - Cayman (GMT-05:00)' },
+    { name: 'Asia/Almaty', desc: 'Kazakhstan - Almaty (GMT+06:00)' },
+    { name: 'Asia/Qyzylorda', desc: 'Kazakhstan - Qyzylorda (GMT+06:00)' },
+    { name: 'Asia/Aqtobe', desc: 'Kazakhstan - Aqtobe (GMT+05:00)' },
+    { name: 'Asia/Aqtau', desc: 'Kazakhstan - Aqtau (GMT+05:00)' },
+    { name: 'Asia/Oral', desc: 'Kazakhstan - Oral (GMT+05:00)' },
+    { name: 'Asia/Vientiane', desc: 'Lao PDR - Vientiane (GMT+07:00)' },
+    { name: 'Asia/Beirut', desc: 'Lebanon - Beirut (GMT+03:00)' },
+    { name: 'America/St_Lucia', desc: 'Saint Lucia - St Lucia (GMT-04:00)' },
+    { name: 'Europe/Vaduz', desc: 'Liechtenstein - Vaduz (GMT+02:00)' },
+    { name: 'Asia/Colombo', desc: 'Sri Lanka - Colombo (GMT+05:30)' },
+    { name: 'Africa/Monrovia', desc: 'Liberia - Monrovia (GMT+00:00)' },
+    { name: 'Africa/Maseru', desc: 'Lesotho - Maseru (GMT+02:00)' },
+    { name: 'Europe/Vilnius', desc: 'Lithuania - Vilnius (GMT+03:00)' },
+    { name: 'Europe/Luxembourg', desc: 'Luxembourg - Luxembourg (GMT+02:00)' },
+    { name: 'Europe/Riga', desc: 'Latvia - Riga (GMT+03:00)' },
+    { name: 'Africa/Tripoli', desc: 'Libya - Tripoli (GMT+02:00)' },
+    { name: 'Africa/Casablanca', desc: 'Morocco - Casablanca (GMT+00:00)' },
+    { name: 'Europe/Monaco', desc: 'Monaco - Monaco (GMT+02:00)' },
+    { name: 'Europe/Chisinau', desc: 'Moldova - Chisinau (GMT+03:00)' },
+    { name: 'Europe/Podgorica', desc: 'Montenegro - Podgorica (GMT+02:00)' },
+    { name: 'America/Marigot', desc: 'Saint-Martin (French part) - Marigot (GMT-04:00)' },
+    { name: 'Indian/Antananarivo', desc: 'Madagascar - Antananarivo (GMT+03:00)' },
+    { name: 'Pacific/Majuro', desc: 'Marshall Islands - Majuro (GMT+12:00)' },
+    { name: 'Pacific/Kwajalein', desc: 'Marshall Islands - Kwajalein (GMT+12:00)' },
+    { name: 'Europe/Skopje', desc: 'Macedonia - Skopje (GMT+02:00)' },
+    { name: 'Africa/Bamako', desc: 'Mali - Bamako (GMT+00:00)' },
+    { name: 'Asia/Rangoon', desc: 'Myanmar - Rangoon (GMT+06:30)' },
+    { name: 'Asia/Ulaanbaatar', desc: 'Mongolia - Ulaanbaatar (GMT+08:00)' },
+    { name: 'Asia/Hovd', desc: 'Mongolia - Hovd (GMT+07:00)' },
+    { name: 'Asia/Choibalsan', desc: 'Mongolia - Choibalsan (GMT+08:00)' },
+    { name: 'Asia/Macau', desc: 'Macao - Macau (GMT+08:00)' },
+    { name: 'Pacific/Saipan', desc: 'Northern Mariana Islands - Saipan (GMT+10:00)' },
+    { name: 'America/Martinique', desc: 'Martinique - Martinique (GMT-04:00)' },
+    { name: 'Africa/Nouakchott', desc: 'Mauritania - Nouakchott (GMT+00:00)' },
+    { name: 'America/Montserrat', desc: 'Montserrat - Montserrat (GMT-04:00)' },
+    { name: 'Europe/Malta', desc: 'Malta - Malta (GMT+02:00)' },
+    { name: 'Indian/Mauritius', desc: 'Mauritius - Mauritius (GMT+04:00)' },
+    { name: 'Indian/Maldives', desc: 'Maldives - Maldives (GMT+05:00)' },
+    { name: 'Africa/Blantyre', desc: 'Malawi - Blantyre (GMT+02:00)' },
+    { name: 'America/Mexico_City', desc: 'Mexico - Mexico City (GMT-05:00)' },
+    { name: 'America/Cancun', desc: 'Mexico - Cancun (GMT-05:00)' },
+    { name: 'America/Merida', desc: 'Mexico - Merida (GMT-05:00)' },
+    { name: 'America/Monterrey', desc: 'Mexico - Monterrey (GMT-05:00)' },
+    { name: 'America/Matamoros', desc: 'Mexico - Matamoros (GMT-05:00)' },
+    { name: 'America/Mazatlan', desc: 'Mexico - Mazatlan (GMT-06:00)' },
+    { name: 'America/Chihuahua', desc: 'Mexico - Chihuahua (GMT-06:00)' },
+    { name: 'America/Ojinaga', desc: 'Mexico - Ojinaga (GMT-06:00)' },
+    { name: 'America/Hermosillo', desc: 'Mexico - Hermosillo (GMT-07:00)' },
+    { name: 'America/Tijuana', desc: 'Mexico - Tijuana (GMT-07:00)' },
+    { name: 'America/Santa_Isabel', desc: 'Mexico - Santa Isabel (GMT-07:00)' },
+    { name: 'America/Bahia_Banderas', desc: 'Mexico - Bahia Banderas (GMT-05:00)' },
+    { name: 'Asia/Kuala_Lumpur', desc: 'Malaysia - Kuala Lumpur (GMT+08:00)' },
+    { name: 'Asia/Kuching', desc: 'Malaysia - Kuching (GMT+08:00)' },
+    { name: 'Africa/Maputo', desc: 'Mozambique - Maputo (GMT+02:00)' },
+    { name: 'Africa/Windhoek', desc: 'Namibia - Windhoek (GMT+02:00)' },
+    { name: 'Pacific/Noumea', desc: 'New Caledonia - Noumea (GMT+11:00)' },
+    { name: 'Africa/Niamey', desc: 'Niger - Niamey (GMT+01:00)' },
+    { name: 'Pacific/Norfolk', desc: 'Norfolk Island - Norfolk (GMT+11:00)' },
+    { name: 'Africa/Lagos', desc: 'Nigeria - Lagos (GMT+01:00)' },
+    { name: 'America/Managua', desc: 'Nicaragua - Managua (GMT-06:00)' },
+    { name: 'Europe/Amsterdam', desc: 'Netherlands - Amsterdam (GMT+02:00)' },
+    { name: 'Europe/Oslo', desc: 'Norway - Oslo (GMT+02:00)' },
+    { name: 'Asia/Kathmandu', desc: 'Nepal - Kathmandu (GMT+05:45)' },
+    { name: 'Pacific/Nauru', desc: 'Nauru - Nauru (GMT+12:00)' },
+    { name: 'Pacific/Niue', desc: 'Niue - Niue (GMT-11:00)' },
+    { name: 'Pacific/Auckland', desc: 'New Zealand - Auckland (GMT+12:00)' },
+    { name: 'Pacific/Chatham', desc: 'New Zealand - Chatham (GMT+12:45)' },
+    { name: 'Asia/Muscat', desc: 'Oman - Muscat (GMT+04:00)' },
+    { name: 'America/Panama', desc: 'Panama - Panama (GMT-05:00)' },
+    { name: 'America/Lima', desc: 'Peru - Lima (GMT-05:00)' },
+    { name: 'Pacific/Tahiti', desc: 'French Polynesia - Tahiti (GMT-10:00)' },
+    { name: 'Pacific/Marquesas', desc: 'French Polynesia - Marquesas (GMT-09:30)' },
+    { name: 'Pacific/Gambier', desc: 'French Polynesia - Gambier (GMT-09:00)' },
+    { name: 'Pacific/Port_Moresby', desc: 'Papua New Guinea - Port Moresby (GMT+10:00)' },
+    { name: 'Asia/Manila', desc: 'Philippines - Manila (GMT+08:00)' },
+    { name: 'Asia/Karachi', desc: 'Pakistan - Karachi (GMT+05:00)' },
+    { name: 'Europe/Warsaw', desc: 'Poland - Warsaw (GMT+02:00)' },
+    { name: 'Poland', desc: 'Poland - Poland (GMT+02:00)' },
+    { name: 'America/Miquelon', desc: 'Saint Pierre and Miquelon - Miquelon (GMT-02:00)' },
+    { name: 'Pacific/Pitcairn', desc: 'Pitcairn - Pitcairn (GMT-08:00)' },
+    { name: 'America/Puerto_Rico', desc: 'Puerto Rico - Puerto Rico (GMT-04:00)' },
+    { name: 'Asia/Gaza', desc: 'Palestinian Territory - Gaza (GMT+03:00)' },
+    { name: 'Asia/Hebron', desc: 'Palestinian Territory - Hebron (GMT+03:00)' },
+    { name: 'Europe/Lisbon', desc: 'Portugal - Lisbon (GMT+01:00)' },
+    { name: 'Atlantic/Madeira', desc: 'Portugal - Madeira (GMT+01:00)' },
+    { name: 'Atlantic/Azores', desc: 'Portugal - Azores (GMT+00:00)' },
+    { name: 'Pacific/Palau', desc: 'Palau - Palau (GMT+09:00)' },
+    { name: 'America/Asuncion', desc: 'Paraguay - Asuncion (GMT-04:00)' },
+    { name: 'Asia/Qatar', desc: 'Qatar - Qatar (GMT+03:00)' },
+    { name: 'Indian/Reunion', desc: 'Réunion - Reunion (GMT+04:00)' },
+    { name: 'Europe/Bucharest', desc: 'Romania - Bucharest (GMT+03:00)' },
+    { name: 'Europe/Belgrade', desc: 'Serbia - Belgrade (GMT+02:00)' },
+    { name: 'Europe/Kaliningrad', desc: 'Russian Federation - Kaliningrad (GMT+02:00)' },
+    { name: 'Europe/Moscow', desc: 'Russian Federation - Moscow (GMT+03:00)' },
+    { name: 'Europe/Volgograd', desc: 'Russian Federation - Volgograd (GMT+03:00)' },
+    { name: 'Europe/Samara', desc: 'Russian Federation - Samara (GMT+04:00)' },
+    { name: 'Europe/Simferopol', desc: 'Russian Federation - Simferopol (GMT+03:00)' },
+    { name: 'Asia/Yekaterinburg', desc: 'Russian Federation - Yekaterinburg (GMT+05:00)' },
+    { name: 'Asia/Omsk', desc: 'Russian Federation - Omsk (GMT+06:00)' },
+    { name: 'Asia/Novosibirsk', desc: 'Russian Federation - Novosibirsk (GMT+07:00)' },
+    { name: 'Asia/Novokuznetsk', desc: 'Russian Federation - Novokuznetsk (GMT+07:00)' },
+    { name: 'Asia/Krasnoyarsk', desc: 'Russian Federation - Krasnoyarsk (GMT+07:00)' },
+    { name: 'Asia/Irkutsk', desc: 'Russian Federation - Irkutsk (GMT+08:00)' },
+    { name: 'Asia/Yakutsk', desc: 'Russian Federation - Yakutsk (GMT+09:00)' },
+    { name: 'Asia/Khandyga', desc: 'Russian Federation - Khandyga (GMT+09:00)' },
+    { name: 'Asia/Vladivostok', desc: 'Russian Federation - Vladivostok (GMT+10:00)' },
+    { name: 'Asia/Sakhalin', desc: 'Russian Federation - Sakhalin (GMT+11:00)' },
+    { name: 'Asia/Ust-Nera', desc: 'Russian Federation - Ust-Nera (GMT+10:00)' },
+    { name: 'Asia/Magadan', desc: 'Russian Federation - Magadan (GMT+11:00)' },
+    { name: 'Asia/Kamchatka', desc: 'Russian Federation - Kamchatka (GMT+12:00)' },
+    { name: 'Asia/Anadyr', desc: 'Russian Federation - Anadyr (GMT+12:00)' },
+    { name: 'Africa/Kigali', desc: 'Rwanda - Kigali (GMT+02:00)' },
+    { name: 'Asia/Riyadh', desc: 'Saudi Arabia - Riyadh (GMT+03:00)' },
+    { name: 'Pacific/Guadalcanal', desc: 'Solomon Islands - Guadalcanal (GMT+11:00)' },
+    { name: 'Indian/Mahe', desc: 'Seychelles - Mahe (GMT+04:00)' },
+    { name: 'Africa/Khartoum', desc: 'Sudan - Khartoum (GMT+02:00)' },
+    { name: 'Europe/Stockholm', desc: 'Sweden - Stockholm (GMT+02:00)' },
+    { name: 'Asia/Singapore', desc: 'Singapore - Singapore (GMT+08:00)' },
+    { name: 'Atlantic/St_Helena', desc: 'Saint Helena - St Helena (GMT+00:00)' },
+    { name: 'Europe/Ljubljana', desc: 'Slovenia - Ljubljana (GMT+02:00)' },
+    { name: 'Arctic/Longyearbyen', desc: 'Svalbard and Jan Mayen Islands - Longyearbyen (GMT+02:00)' },
+    { name: 'Europe/Bratislava', desc: 'Slovakia - Bratislava (GMT+02:00)' },
+    { name: 'Africa/Freetown', desc: 'Sierra Leone - Freetown (GMT+00:00)' },
+    { name: 'Europe/San_Marino', desc: 'San Marino - San Marino (GMT+02:00)' },
+    { name: 'Africa/Dakar', desc: 'Senegal - Dakar (GMT+00:00)' },
+    { name: 'Africa/Mogadishu', desc: 'Somalia - Mogadishu (GMT+03:00)' },
+    { name: 'America/Paramaribo', desc: 'Suriname - Paramaribo (GMT-03:00)' },
+    { name: 'Africa/Juba', desc: 'South Sudan - Juba (GMT+03:00)' },
+    { name: 'Africa/Sao_Tome', desc: 'Sao Tome and Principe - Sao Tome (GMT+01:00)' },
+    { name: 'America/El_Salvador', desc: 'El Salvador - El Salvador (GMT-06:00)' },
+    { name: 'America/Lower_Princes', desc: 'SX - Lower Princes (GMT-04:00)' },
+    { name: 'Asia/Damascus', desc: 'Syria - Damascus (GMT+03:00)' },
+    { name: 'Africa/Mbabane', desc: 'Swaziland - Mbabane (GMT+02:00)' },
+    { name: 'America/Grand_Turk', desc: 'Turks and Caicos Islands - Grand Turk (GMT-04:00)' },
+    { name: 'Africa/Ndjamena', desc: 'Chad - Ndjamena (GMT+01:00)' },
+    { name: 'Indian/Kerguelen', desc: 'French Southern Territories - Kerguelen (GMT+05:00)' },
+    { name: 'Africa/Lome', desc: 'Togo - Lome (GMT+00:00)' },
+    { name: 'Asia/Bangkok', desc: 'Thailand - Bangkok (GMT+07:00)' },
+    { name: 'Asia/Dushanbe', desc: 'Tajikistan - Dushanbe (GMT+05:00)' },
+    { name: 'Pacific/Fakaofo', desc: 'Tokelau - Fakaofo (GMT+13:00)' },
+    { name: 'Asia/Dili', desc: 'Timor-Leste - Dili (GMT+09:00)' },
+    { name: 'Asia/Ashgabat', desc: 'Turkmenistan - Ashgabat (GMT+05:00)' },
+    { name: 'Africa/Tunis', desc: 'Tunisia - Tunis (GMT+01:00)' },
+    { name: 'Pacific/Tongatapu', desc: 'Tonga - Tongatapu (GMT+13:00)' },
+    { name: 'Europe/Istanbul', desc: 'Turkey - Istanbul (GMT+03:00)' },
+    { name: 'America/Port_of_Spain', desc: 'Trinidad and Tobago - Port of_Spain (GMT-04:00)' },
+    { name: 'Pacific/Funafuti', desc: 'Tuvalu - Funafuti (GMT+12:00)' },
+    { name: 'Asia/Taipei', desc: 'Taiwan - Taipei (GMT+08:00)' },
+    { name: 'Africa/Dar_es_Salaam', desc: 'Tanzania - Dar es_Salaam (GMT+03:00)' },
+    { name: 'Europe/Kiev', desc: 'Ukraine - Kiev (GMT+03:00)' },
+    { name: 'Europe/Uzhgorod', desc: 'Ukraine - Uzhgorod (GMT+03:00)' },
+    { name: 'Europe/Zaporozhye', desc: 'Ukraine - Zaporozhye (GMT+03:00)' },
+    { name: 'Africa/Kampala', desc: 'Uganda - Kampala (GMT+03:00)' },
+    { name: 'Pacific/Johnston', desc: 'US Minor Outlying Islands - Johnston (GMT-10:00)' },
+    { name: 'Pacific/Midway', desc: 'US Minor Outlying Islands - Midway (GMT-11:00)' },
+    { name: 'Pacific/Wake', desc: 'US Minor Outlying Islands - Wake (GMT+12:00)' },
+    { name: 'America/New_York', desc: 'United States of America (USA) - New York (GMT-04:00)' },
+    { name: 'America/Detroit', desc: 'United States of America (USA) - Detroit (GMT-04:00)' },
+    { name: 'America/Kentucky/Louisville', desc: 'United States of America (USA) - Louisville (GMT-04:00)' },
+    { name: 'America/Kentucky/Monticello', desc: 'United States of America (USA) - Monticello (GMT-04:00)' },
+    { name: 'America/Indiana/Indianapolis', desc: 'United States of America (USA) - Indianapolis (GMT-04:00)' },
+    { name: 'America/Indiana/Vincennes', desc: 'United States of America (USA) - Vincennes (GMT-04:00)' },
+    { name: 'America/Indiana/Winamac', desc: 'United States of America (USA) - Winamac (GMT-04:00)' },
+    { name: 'America/Indiana/Marengo', desc: 'United States of America (USA) - Marengo (GMT-04:00)' },
+    { name: 'America/Indiana/Petersburg', desc: 'United States of America (USA) - Petersburg (GMT-04:00)' },
+    { name: 'America/Indiana/Vevay', desc: 'United States of America (USA) - Vevay (GMT-04:00)' },
+    { name: 'America/Chicago', desc: 'United States of America (USA) - Chicago (GMT-05:00)' },
+    { name: 'America/Indiana/Tell_City', desc: 'United States of America (USA) - Tell City (GMT-05:00)' },
+    { name: 'America/Indiana/Knox', desc: 'United States of America (USA) - Knox (GMT-05:00)' },
+    { name: 'America/Menominee', desc: 'United States of America (USA) - Menominee (GMT-05:00)' },
+    { name: 'America/North_Dakota/Center', desc: 'United States of America (USA) - Center (GMT-05:00)' },
+    { name: 'America/North_Dakota/New_Salem', desc: 'United States of America (USA) - New Salem (GMT-05:00)' },
+    { name: 'America/North_Dakota/Beulah', desc: 'United States of America (USA) - Beulah (GMT-05:00)' },
+    { name: 'America/Denver', desc: 'United States of America (USA) - Denver (GMT-06:00)' },
+    { name: 'America/Boise', desc: 'United States of America (USA) - Boise (GMT-06:00)' },
+    { name: 'America/Phoenix', desc: 'United States of America (USA) - Phoenix (GMT-07:00)' },
+    { name: 'America/Los_Angeles', desc: 'United States of America (USA) - Los Angeles (GMT-07:00)' },
+    { name: 'America/Anchorage', desc: 'United States of America (USA) - Anchorage (GMT-08:00)' },
+    { name: 'America/Juneau', desc: 'United States of America (USA) - Juneau (GMT-08:00)' },
+    { name: 'America/Sitka', desc: 'United States of America (USA) - Sitka (GMT-08:00)' },
+    { name: 'America/Yakutat', desc: 'United States of America (USA) - Yakutat (GMT-08:00)' },
+    { name: 'America/Nome', desc: 'United States of America (USA) - Nome (GMT-08:00)' },
+    { name: 'America/Adak', desc: 'United States of America (USA) - Adak (GMT-09:00)' },
+    { name: 'America/Metlakatla', desc: 'United States of America (USA) - Metlakatla (GMT-08:00)' },
+    { name: 'Pacific/Honolulu', desc: 'United States of America (USA) - Honolulu (GMT-10:00)' },
+    { name: 'America/Montevideo', desc: 'Uruguay - Montevideo (GMT-03:00)' },
+    { name: 'Asia/Samarkand', desc: 'Uzbekistan - Samarkand (GMT+05:00)' },
+    { name: 'Asia/Tashkent', desc: 'Uzbekistan - Tashkent (GMT+05:00)' },
+    { name: 'Europe/Vatican', desc: 'Vatican City State - Vatican (GMT+02:00)' },
+    { name: 'America/St_Vincent', desc: 'Saint Vincent and Grenadines - St Vincent (GMT-04:00)' },
+    { name: 'America/Caracas', desc: 'Venezuela - Caracas (GMT-04:00)' },
+    { name: 'America/Tortola', desc: 'British Virgin Islands - Tortola (GMT-04:00)' },
+    { name: 'America/St_Thomas', desc: 'Virgin Islands, US - St Thomas (GMT-04:00)' },
+    { name: 'Asia/Ho_Chi_Minh', desc: 'Viet Nam - Ho Chi_Minh (GMT+07:00)' },
+    { name: 'Pacific/Efate', desc: 'Vanuatu - Efate (GMT+11:00)' },
+    { name: 'Pacific/Wallis', desc: 'Wallis and Futuna Islands - Wallis (GMT+12:00)' },
+    { name: 'Pacific/Apia', desc: 'Samoa - Apia (GMT+13:00)' },
+    { name: 'Asia/Aden', desc: 'Yemen - Aden (GMT+03:00)' },
+    { name: 'Indian/Mayotte', desc: 'Mayotte - Mayotte (GMT+03:00)' },
+    { name: 'Africa/Johannesburg', desc: 'South Africa - Johannesburg (GMT+02:00)' },
+    { name: 'Africa/Lusaka', desc: 'Zambia - Lusaka (GMT+02:00)' },
+    { name: 'Africa/Harare', desc: 'Zimbabwe - Harare (GMT+02:00)' },
+];
+// TODO: is this a service or a helper function?
+class UxTimezoneService {
+    /**
+     * Convert country ISO code to country name (in english)
+     */
+    iso2country(iso) {
+        return UX_COUNTRIES[iso] ? UX_COUNTRIES[iso] : iso;
+    }
+    /**
+     * Gets the list of ISO-codes for all countries
+     */
+    getCountries() {
+        const res = [];
+        for (const prop of Object.keys(UX_COUNTRIES)) {
+            res.push(prop);
+        }
+        return res;
+    }
+    getTimezones() {
+        return UX_TIMEZONES;
+    }
+    getTimezone(tz) {
+        return UX_TIMEZONES.find((item) => {
+            return item.name === tz;
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UxTimezoneService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxTimezoneService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UxTimezoneService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxTimezoneService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxTimezoneService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Generic storage service. Concrete storage services must extend this class
+ */
+class StorageService {
+}
+
+class StorageServiceMock extends StorageService {
+    name() {
+        return null;
+    }
+    get() {
+        return null;
+    }
+    set() {
+    }
+    remove() {
+    }
+}
+
+/**
+ * Generic asynchronous storage service. Concrete asynchronous storage services must extend this class
+ */
+class AsyncStorageService extends StorageService {
+    setAsync(key, value) {
+        this.set(key, value).subscribe(() => {
+        });
+    }
+    /**
+     * asynchronous helper for remove function
+     * @param key the associated key
+     */
+    removeAsync(key) {
+        this.remove(key).subscribe(() => {
+        });
+    }
+}
+
+class AsyncStorageServiceMock extends AsyncStorageService {
+    ready() {
+        // tslint:disable-next-line:deprecation
+        return of({});
+    }
+    name() {
+        return null;
+    }
+    get() {
+        // tslint:disable-next-line:deprecation
+        return of({});
+    }
+    set() {
+        // tslint:disable-next-line:deprecation
+        return of({});
+    }
+    remove() {
+        // tslint:disable-next-line:deprecation
+        return of({});
+    }
+    setAsync() {
+    }
+    removeAsync() {
+    }
+}
+
+/**
+ * localStorage service
+ */
+class LocalStorageService extends StorageService {
+    constructor(log) {
+        super();
+        this.log = log;
+    }
+    /**
+     * the name of the storage service
+     */
+    name() {
+        return LocalStorageService.NAME;
+    }
+    /**
+     * retrieve an object from local storage
+     * @param key the associated key
+     * @returns the value or undefined, if case of error
+     */
+    get(key) {
+        try {
+            const serialized = localStorage.getItem(key);
+            return serialized && JSON.parse(serialized);
+        }
+        catch (err) {
+            if (this.log) {
+                this.log.error(this.name(), 'get', err);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * sets an object in local storage
+     * @param key the associated key
+     * @param value the value to set
+     */
+    set(key, value) {
+        try {
+            const serialized = JSON.stringify(value);
+            localStorage.setItem(key, serialized);
+        }
+        catch (err) {
+            if (this.log) {
+                this.log.error(this.name(), 'set', err);
+            }
+        }
+    }
+    /**
+     * removes an object from local storage
+     * @param key the associated key
+     */
+    remove(key) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch (err) {
+            if (this.log) {
+                this.log.error(this.name(), 'remove', err);
+            }
+        }
+    }
+}
+LocalStorageService.NAME = 'LocalStorageService';
+/** @nocollapse */ /** @nocollapse */ LocalStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocalStorageService, deps: [{ token: LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LocalStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocalStorageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: LogService, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+/**
+ * sessionStorage service
+ */
+class SessionStorageService extends StorageService {
+    constructor(log) {
+        super();
+        this.log = log;
+    }
+    /**
+     * the name of the storage service
+     */
+    name() {
+        return SessionStorageService.NAME;
+    }
+    /**
+     * retrieve an object from session storage
+     * @param key the associated key
+     * @returns the value or undefined, if case of error
+     */
+    get(key) {
+        try {
+            const serialized = sessionStorage.getItem(key);
+            return serialized && JSON.parse(serialized);
+        }
+        catch (err) {
+            if (this.log) {
+                this.log.error(this.name(), 'get', err);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * sets an object in session storage
+     * @param key the associated key
+     * @param value the value to set
+     */
+    set(key, value) {
+        try {
+            const serialized = JSON.stringify(value);
+            sessionStorage.setItem(key, serialized);
+        }
+        catch (err) {
+            if (this.log) {
+                this.log.error(this.name(), 'set', err);
+            }
+        }
+    }
+    /**
+     * removes an object from session storage
+     * @param key the associated key
+     */
+    remove(key) {
+        try {
+            sessionStorage.removeItem(key);
+        }
+        catch (err) {
+            if (this.log) {
+                this.log.error(this.name(), 'remove', err);
+            }
+        }
+    }
+}
+SessionStorageService.NAME = 'SessionStorageService';
+/** @nocollapse */ /** @nocollapse */ SessionStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: SessionStorageService, deps: [{ token: LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ SessionStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: SessionStorageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: LogService, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+/** @internal */
+const localForage = 'defineDriver' in lf ? lf : lf['default'];
+const LOCAL_FORAGE_SERVICE_CONFIG_TOKEN = new InjectionToken('LOCAL_FORAGE_SERVICE_CONFIG');
+/**
+ * localforage service, using the localForage javascript library
+ * https://localforage.github.io/localForage
+ */
+class LocalForageService extends AsyncStorageService {
+    constructor(config, log) {
+        super();
+        this.config = config;
+        this.log = log;
+        // configure localforage, if specified
+        if (config) {
+            localForage.config(config);
+        }
+    }
+    /**
+     * the name of the storage service
+     */
+    name() {
+        return LocalForageService.NAME;
+    }
+    /**
+     * reflects the readiness of the storage
+     * @returns one time emission Observable<void>
+     */
+    ready() {
+        return from(localForage.ready())
+            .pipe(take(1), tap(() => {
+        }, err => {
+            if (this.log) {
+                this.log.error(this.name(), 'ready', err);
+            }
+        }));
+    }
+    /**
+     * retrieve an object from localforage
+     * @param key the associated key
+     * @returns one time emission Observable of value
+     */
+    get(key) {
+        return from(localForage.getItem(key))
+            .pipe(take(1), tap(() => {
+        }, err => {
+            if (this.log) {
+                this.log.error(this.name(), 'get', err);
+            }
+        }));
+    }
+    /**
+     * sets an object in localforage
+     * @param key the associated key
+     * @param value the value to set
+     * @returns one time emission Observable
+     */
+    set(key, value) {
+        return from(localForage.setItem(key, value))
+            .pipe(take(1), tap(() => {
+        }, err => {
+            if (this.log) {
+                this.log.error(this.name(), 'set', err);
+            }
+        }));
+    }
+    /**
+     * removes an object from localforage
+     * @param key the associated key
+     * @returns one time emission Observable
+     */
+    remove(key) {
+        return from(localForage.removeItem(key))
+            .pipe(take(1), tap(() => {
+        }, err => {
+            if (this.log) {
+                this.log.error(this.name(), 'remove', err);
+            }
+        }));
+    }
+}
+LocalForageService.NAME = 'LocalForageService';
+/** @nocollapse */ /** @nocollapse */ LocalForageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocalForageService, deps: [{ token: LOCAL_FORAGE_SERVICE_CONFIG_TOKEN, optional: true }, { token: LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LocalForageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocalForageService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocalForageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCAL_FORAGE_SERVICE_CONFIG_TOKEN]
+                }, {
+                    type: Optional
+                }] }, { type: LogService, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+/**
+ * Angular is using a gulp task to generate the locales that we dynamically import. This task can be found here
+ * https://github.com/angular/angular/blob/master/tools/gulp-tasks/cldr/cldr-data.js
+ * That task is utilizing the CLDR library to load and construct the locale for each region. This service is responsible
+ * to load those locale dynamically upon request and to update the state of the eUI app.
+ *
+ * Parts that are handles through configuration:
+ *  - update of the LOCALE_ID token
+ *  - initial dynamical load of locales
+ *  - bind to translation service for locale changes
+ */
+const LOCALE_ID_MAPPER = new InjectionToken('localeIdMapper');
+class LocaleService extends EuiService {
+    constructor(store, baseGlobalConfig, locale_id, localeMapper, i18n, log) {
+        super({ id: getLocaleId(locale_id) });
+        this.store = store;
+        this.baseGlobalConfig = baseGlobalConfig;
+        this.locale_id = locale_id;
+        this.localeMapper = localeMapper;
+        this.i18n = i18n;
+        this.log = log;
+        this.subNotifier = new Subject();
+        if (log) {
+            this.logger = log.getLogger('core.LocaleService');
+        }
+        this.config = getLocaleServiceConfigFromBase(this.baseGlobalConfig);
+        // in case no localeMapper provided, set the angular getLocaleId as default
+        if (!this.localeMapper) {
+            this.localeMapper = getLocaleId;
+        }
+    }
+    ngOnDestroy() {
+        this.subNotifier.next(void 0);
+        this.subNotifier.complete();
+    }
+    getState() {
+        return this.store.select(getLocaleState).pipe(takeUntil(this.subNotifier), 
+        // in case service didn't init fallback to LOCALE_ID token value
+        map(state => state ? state : this.stateInstance ? this.stateInstance : this.locale_id));
+    }
+    init(state) {
+        super.initEuiService();
+        if (state) {
+            this.stateInstance = state;
+        }
+        // bind language changes to locale changes
+        if (this.config?.bindWithTranslate) {
+            this.bindTranslateServiceLangChangeToState();
+        }
+        // dynamically load locale based on provided configuration
+        const availableLocales = state?.available || this.config?.available || this.getBrowserLocales() || [this.currentLocale];
+        return this.loadLocale(availableLocales).pipe(takeUntil(this.subNotifier), tap(() => this.updateState({ id: this.currentLocale })));
+    }
+    /**
+     * dynamically load locale and update the state
+     */
+    updateState(state) {
+        try {
+            const id = getLocaleId(state.id);
+            this.store.dispatch(new UpdateLocaleStateAction({ ...state, id }));
+            // update global TOKEN ID based on configuration
+            if (this.config.affectGlobalLocale) {
+                this.locale_id = id;
+            }
+        }
+        catch (e) {
+            const message = `Locale for '${state.id}' is not available.
+                 Please use addLocale('${state.id}') first`;
+            if (this.log) {
+                this.logger.info(message, e);
+            }
+            throw new Error(message);
+        }
+    }
+    addLocale(id) {
+        return this.loadLocale(id);
+    }
+    get currentLocale() {
+        return this.stateInstance.id;
+    }
+    /**
+     * load and register locale data dynamically
+     * @param locale array of locale to load
+     */
+    loadLocale(locale) {
+        locale = Array.isArray(locale) ? locale : [locale];
+        const localeImports = this.filterRegisteredLocales(locale).map(this.importDataAndExtraLocale.bind(this));
+        // in case localeImports array is empty because locale exists, Observable still needs to complete
+        if (localeImports.length < 1) {
+            return of({ success: true });
+        }
+        return forkJoin(...localeImports).pipe(takeUntil(this.subNotifier), map(localeData => {
+            // filter out null results and registerLocaleData including extra
+            localeData.filter(({ data }) => data)
+                .forEach(({ data, localeId, extraData }) => registerLocaleData(data, localeId, extraData));
+            return { success: true };
+        }), catchError(error => {
+            if (this.log) {
+                this.logger.debug(`Locale load error: ${error.message}`, error);
+            }
+            return of({ success: false, error: error });
+        }));
+    }
+    /**
+     * listen for language changes and dynamically set locale accordingly. In case of non registered locale register it
+     * dynamically.
+     */
+    bindTranslateServiceLangChangeToState() {
+        if (this.i18n) {
+            this.i18n.onStateChange.pipe(takeUntil(this.subNotifier), 
+            // BEWARE: filter is based on convention that locale id sliced(2) will match activeLang e.g. en-US => en
+            // Also, if activeLang is 'en' and locale is 'en-GB' it will not trigger locale change
+            filter(state => state?.activeLang?.toLowerCase() !== this.stateInstance?.id.slice(0, 2).toLowerCase()), 
+            // to check if registration of locale otherwise register it
+            switchMap(value => of(value).pipe(
+            // getLocaleId may throw Error(`Missing locale data for the locale "${locale}".`);
+            switchMap(i18state => {
+                // check if activeLang is null or undefined
+                if (!i18state.activeLang) {
+                    return throwError('Has i18nService initialized? If not make sure i18nService.init().subscribe(..)');
+                }
+                return of(this.localeMapper(i18state.activeLang));
+            }), catchError(error => {
+                if (this.log) {
+                    this.logger.debug(error);
+                }
+                return this.loadLocale(value.activeLang).pipe(filter((s) => s.success), map(() => this.localeMapper(value.activeLang)), catchError(e => {
+                    if (this.log) {
+                        this.logger.debug('Something went terribly really wrong during locale loading', e.err.message);
+                    }
+                    return of(e);
+                }));
+            }))), 
+            // update the "available" array attribute with newly registered
+            switchMap(id => this.getState().pipe(take(1), map((state) => {
+                const available = state?.available ? state.available : [];
+                return { ...state, id, available: Array.from(new Set([...available, id])) };
+            })))).subscribe((state) => {
+                this.updateState(state);
+            });
+        }
+    }
+    /**
+     * retrieve locales from browser
+     * @param options
+     */
+    getBrowserLocales() {
+        const browserLocales = navigator.languages === undefined ? [navigator.language] : navigator.languages;
+        if (!browserLocales) {
+            return undefined;
+        }
+        return browserLocales.map(locale => locale.trim());
+    }
+    /**
+     * if locale is already registered filtered out.
+     * @param locales A string array contains all locale id e.g. ["el", "el-CY"]
+     */
+    filterRegisteredLocales(locales) {
+        return locales.filter((loc) => {
+            try {
+                getLocaleId(loc);
+                return false;
+            }
+            catch (e) {
+                return true;
+            }
+        });
+    }
+    /**
+     * returns an Observable which loads the locale based on provided ID
+     * @param id the locale id e.g. en, el-CY
+     * @private
+     */
+    importLocale(id) {
+        // in case of an error, catch it and return null
+        return import(
+        /* webpackIgnore: true */
+        `@angular/common/locales/${id}`)
+            .then(m => m.default)
+            .catch(error => {
+            if (this.log) {
+                this.logger.debug(`Locale with ID: "${id}" failed to load. Error: ${error.message}`, error);
+            }
+            return null;
+        });
+    }
+    /**
+     * returns a Promise which loads the locale based on provided ID
+     * @param id the locale id e.g. en, el-CY
+     * @private
+     */
+    importExtraLocale(id) {
+        // in case of an error, catch it and return null
+        return import(
+        /* webpackIgnore: true */
+        `@angular/common/locales/extra/${id}`)
+            .then(m => m.default)
+            .catch(error => {
+            if (this.log) {
+                this.logger.debug(`Extra Locale with ID: "${id}" failed to load. Error: ${error.message}`, error);
+            }
+            return null;
+        });
+    }
+    /**
+     * Imports Locale and then Extra. It returns the Object which registerLocale(...) function needs.
+     * @param localeId The id of the locale
+     * @private
+     */
+    importDataAndExtraLocale(localeId) {
+        return from(this.importLocale(localeId)).pipe(mergeMap(() => from(this.importExtraLocale(localeId)).pipe(map((data, extraData) => Object.assign({}, { data, localeId, extraData }))), 1));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ LocaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocaleService, deps: [{ token: StoreService }, { token: GLOBAL_CONFIG_TOKEN }, { token: LOCALE_ID }, { token: LOCALE_ID_MAPPER, optional: true }, { token: I18nService, optional: true }, { token: LogService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LocaleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocaleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: LocaleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: StoreService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GLOBAL_CONFIG_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LOCALE_ID_MAPPER]
+                }] }, { type: I18nService, decorators: [{
+                    type: Optional
+                }] }, { type: LogService, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+// export const USER_API_CONFIG_TOKEN = new InjectionToken<UserApiConfig>('USER_API_CONFIG');
+// export const DEFAULT_USER_PREFERENCES_TOKEN = new InjectionToken<BaseUserPreferences>('DEFAULT_USER_PREFERENCES');
+class UserService extends EuiService {
+    constructor(store) {
+        super({ userId: 'annonymous' });
+        this.store = store;
+    }
+    init(userState) {
+        super.initEuiService();
+        if (typeof userState === 'object' && userState.hasOwnProperty('userId')) {
+            this.updateState(userState);
+            return of({ success: true });
+        }
+        return of({ success: false, error: 'Init object should be instance of BaseUserState' });
+    }
+    getState(keyOrMapFn) {
+        let selector = getUserState;
+        if (keyOrMapFn) {
+            switch (typeof keyOrMapFn) {
+                case 'function':
+                    selector = createSelector(getUserState, keyOrMapFn);
+                    break;
+                case 'string':
+                    selector = createSelector(getUserState, (state) => state[keyOrMapFn]);
+                    break;
+            }
+        }
+        return this.store.select(selector);
+    }
+    updateState(userState) {
+        this.store.dispatch(new UpdateUserStateAction(userState));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UserService, deps: [{ token: StoreService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: StoreService }]; } });
+
+class UserServiceMock extends UserService {
+    constructor() {
+        super(null);
+    }
+    loadUserDetails() {
+        return of({ userId: 'anonymous' });
+    }
+    observePreferencesUpdate() {
+    }
+    loadUserPreferences() {
+        return of({});
+    }
+    saveUserPreferences() {
+        return of({});
+    }
+    mergeUserPreferences() {
+    }
+    userPreferences() {
+        return of({});
+    }
+    getUserId() {
+        return of('anonymous');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UserServiceMock.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UserServiceMock, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UserServiceMock.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UserServiceMock });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UserServiceMock, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+const LANG_PARAM_KEY = 'X-Lang-Param';
+/**
+ * Interceptor for adding the current language as parameter
+ * Add the header (LANG_PARAM_KEY, <language parameter>) to your request http headers
+ */
+class AddLangParamInterceptor {
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    intercept(req, next) {
+        // take the lang param name from header, if specified
+        const langParam = req.headers.get(LANG_PARAM_KEY);
+        // if not specified, do nothing
+        if (!langParam) {
+            return next.handle(req);
+        }
+        // take the current language from the translate service
+        const langValue = this.translateService.currentLang;
+        return next.handle(req.clone({
+            // remove the lang param header from headers
+            headers: req.headers.delete(LANG_PARAM_KEY),
+            // set the lang value as new parameter
+            params: req.params.set(langParam, langValue),
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ AddLangParamInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: AddLangParamInterceptor, deps: [{ token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ AddLangParamInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: AddLangParamInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: AddLangParamInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i2.TranslateService }]; } });
+
+class CachePreventionInterceptor {
+    intercept(req, next) {
+        // if Cache-Control is already specified
+        if (req.headers.get('Cache-Control')) {
+            // keep the current configuration
+            return next.handle(req);
+        }
+        return next.handle(req.clone({
+            // prevent the cache
+            headers: req.headers.set('Cache-Control', 'No-Cache'),
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CachePreventionInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CachePreventionInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CachePreventionInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CachePreventionInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CachePreventionInterceptor, decorators: [{
+            type: Injectable
+        }] });
+
+class CorsSecurityInterceptor {
+    intercept(request, next) {
+        return next.handle(request.clone({
+            withCredentials: true
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CorsSecurityInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CorsSecurityInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CorsSecurityInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CorsSecurityInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CorsSecurityInterceptor, decorators: [{
+            type: Injectable
+        }] });
+
+class CsrfPreventionInterceptor {
+    intercept(request, next) {
+        return next.handle(request.clone({
+            headers: request.headers.set('X-Requested-With', 'XMLHttpRequest'),
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CsrfPreventionInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CsrfPreventionInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CsrfPreventionInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CsrfPreventionInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CsrfPreventionInterceptor, decorators: [{
+            type: Injectable
+        }] });
+
+// The EuLoginSessionTimeoutHandlingInterceptor assumes that the EU login client is configured with:
+// <redirectionInterceptor>eu.cec.digit.ecas.client.http.ajax.JsonAjaxRedirectionInterceptor</redirectionInterceptor>
+// WARNING: The default EU login client behaviour that provides the JSON-un-parsable login HTML page, is no longer supported!
+class EuLoginSessionTimeoutHandlingInterceptor {
+    intercept(request, next) {
+        return next.handle(request)
+            .pipe(tap((event) => {
+            this.checkRequestSuccessForEULoginSessionTimeout(request, event);
+            return event;
+        }, error => {
+            this.checkRequestErrorForEULoginSessionTimeout(request, error);
+        }));
+    }
+    checkRequestSuccessForEULoginSessionTimeout(request, event) {
+        if (event instanceof HttpResponse) {
+            if (this.isSsoResponse(event.body)) {
+                this.reauthenticate(request, event);
+            }
+        }
+    }
+    checkRequestErrorForEULoginSessionTimeout(request, response) {
+        // intentionally blank; meant for overriding
+    }
+    isSsoResponse(body) {
+        if (body) {
+            if (typeof body !== 'string') {
+                return (body.success === false &&
+                    body.status === 'ECAS_AUTHENTICATION_REQUIRED' &&
+                    body.code === 303 &&
+                    body.message === 'session expired');
+            }
+            else {
+                const html = body;
+                return ((html.indexOf('<meta name="Keywords" content="EU Login, ECAS, Authentication, Security" />') >= 0 &&
+                    html.indexOf('<meta name="Description" content="EU Login" />') >= 0) ||
+                    html.indexOf('<meta name="Description" content="European Commission Authentication Service" />') >= 0 ||
+                    html.indexOf('<title>Mock Login Form</title>') >= 0 ||
+                    html.indexOf('<title>Redirecting To ECAS</title>') >= 0 ||
+                    html === '{ success : false, status : "ECAS_AUTHENTICATION_REQUIRED", code : 303, message : "session expired" }' ||
+                    html === '{ "success" : false, "status" : "ECAS_AUTHENTICATION_REQUIRED", "code" : 303, "message": "session expired" }');
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    reauthenticate(request, response) {
+        // tslint:disable-next-line:deprecation
+        document.location.reload();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EuLoginSessionTimeoutHandlingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EuLoginSessionTimeoutHandlingInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ EuLoginSessionTimeoutHandlingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EuLoginSessionTimeoutHandlingInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EuLoginSessionTimeoutHandlingInterceptor, decorators: [{
+            type: Injectable
+        }] });
+
+const UX_ERROR_MAPPING_HANDLER_TOKEN = new InjectionToken('UX_ERROR_MAPPING_HANDLER');
+class UxRequestErrorModelInterceptor {
+    constructor(errorMappingHandler) {
+        this.errorMappingHandler = errorMappingHandler;
+    }
+    intercept(req, next) {
+        return next.handle(req)
+            .pipe(catchError((err) => {
+            if (this.errorMappingHandler) {
+                if (err instanceof HttpErrorResponse) {
+                    err = transformToUxHttpResponse(err, this.errorMappingHandler);
+                }
+            }
+            return of(err);
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ UxRequestErrorModelInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxRequestErrorModelInterceptor, deps: [{ token: UX_ERROR_MAPPING_HANDLER_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ UxRequestErrorModelInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxRequestErrorModelInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: UxRequestErrorModelInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [UX_ERROR_MAPPING_HANDLER_TOKEN]
+                }] }]; } });
+
+class OpenIdConnectInterceptor {
+    constructor() {
+        // By default, the original request should at least be retries once in case the cached API Gateway token expires:
+        this.defaultMaximumRequestRetries = 1;
+        // check if the OpenIdConnect is defined
+        if (typeof OpenIdConnect === 'undefined') {
+            console.error('Please include the script openid-login.js in your index.html file.', 'For more details, please consult the documentation regarding the Http Interceptors and OpenID Connect configuration.');
+        }
+    }
+    intercept(request, next, retryCount = 0, retryCallback) {
+        if (typeof OpenIdConnect !== 'undefined') {
+            let authorizedRequest = retryCallback;
+            if (!authorizedRequest) {
+                authorizedRequest = new Subject();
+            }
+            OpenIdConnect.getAuthorizationHeaders(request.urlWithParams, (headers) => {
+                let newRequest = request;
+                if (headers) {
+                    let newHeaders = request.headers;
+                    if (newHeaders) {
+                        for (const headerName in headers) {
+                            if (headers.hasOwnProperty(headerName)) {
+                                newHeaders = newHeaders.set(headerName, headers[headerName]);
+                            }
+                        }
+                    }
+                    else {
+                        newHeaders = new HttpHeaders(headers);
+                    }
+                    newRequest = request.clone({
+                        withCredentials: false,
+                        headers: newHeaders,
+                    });
+                }
+                const subscription = next.handle(newRequest)
+                    .pipe(catchError((response) => {
+                    return this.handleErrorResponse(response, request, next, retryCount, authorizedRequest, subscription);
+                }))
+                    .subscribe((httpEvent) => {
+                    if (httpEvent) {
+                        authorizedRequest.next(httpEvent);
+                        if (httpEvent.type === HttpEventType.Response) {
+                            if (subscription) {
+                                subscription.unsubscribe();
+                            }
+                            authorizedRequest.complete();
+                        }
+                    }
+                });
+            }, (errorResponse) => {
+                const errorProperties = {
+                    error: errorResponse,
+                };
+                if (errorResponse) {
+                    errorProperties.status = errorResponse.status;
+                    errorProperties.statusText = errorResponse.statusText;
+                }
+                return this.handleErrorResponse(new HttpErrorResponse(errorProperties), request, next, retryCount, authorizedRequest, null);
+            });
+            return authorizedRequest;
+        }
+        else {
+            return next.handle(request);
+        }
+    }
+    handleErrorResponse(response, originalRequest, next, retryCount = 0, retryCallback, subscription) {
+        if (response) {
+            if (response.error && response.error.error === 'invalid_request') {
+                // The ID token is invalid or incorrect; retrieve another one:
+                OpenIdConnect.renewIdToken();
+            }
+            else if (this.apiGatewayTokenExpired(response)) {
+                OpenIdConnect.clearCachedApiGatewayAccessToken();
+                return this.retryRequest(originalRequest, response, next, retryCount, retryCallback, subscription);
+            }
+            else if (response.status === 401 || response.status === 403) {
+                // The EU Login access token is invalid. (403)
+                // The target service is unable to read the access token, for example because the EU Login session ended. (401)
+                // Retry in case the access token became invalid too quickly:
+                return this.retryRequest(originalRequest, response, next, retryCount, retryCallback, subscription);
+            }
+            else if (response.status === 0) {
+                // One of the access token requests or the original request was not sent.
+                // Most likely one of the CORS pre-flight requests failed, or the browser is offline.
+                console.warn('The OpenID Connect call may have issues:\n' +
+                    '* the CORS pre-flight requests for the OpenID Connect access tokens or for the REST call could be failing\n' +
+                    '* the browser could be currently offline.');
+            }
+        }
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+        if (retryCallback) {
+            retryCallback.error(response);
+            retryCallback.complete();
+        }
+        return throwError(response);
+    }
+    retryRequest(originalRequest, response, next, retryCount = 0, retryCallback, subscription) {
+        if (retryCount < this.maximumRequestRetries()) {
+            this.intercept(originalRequest, next, retryCount + 1, retryCallback);
+        }
+        else {
+            console.error('The OpenID Connect call may have issues:\n' +
+                '* the client ID could be invalid\n' +
+                '* the API Gateway access token could be invalid\n' +
+                '* the EU Login access token for the target service could be invalid.');
+            if (subscription) {
+                subscription.unsubscribe();
+            }
+            if (retryCallback) {
+                retryCallback.error(response);
+                retryCallback.complete();
+            }
+        }
+        return of(null);
+    }
+    apiGatewayTokenExpired(response) {
+        if (response && response.status === 401) {
+            const message = '' + response.error;
+            return message.indexOf('<ams:code>900901</ams:code>') >= 0;
+        }
+        else {
+            return false;
+        }
+    }
+    maximumRequestRetries() {
+        if (OpenIdConnect.config && OpenIdConnect.config.maximumRequestRetries >= 0) {
+            return OpenIdConnect.config.maximumRequestRetries;
+        }
+        else {
+            return this.defaultMaximumRequestRetries;
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ OpenIdConnectInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OpenIdConnectInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ OpenIdConnectInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OpenIdConnectInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OpenIdConnectInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+class OpenIdConnectService {
+    getUserDetails() {
+        if (OpenIdConnect) {
+            const detailsString = sessionStorage.getItem(OpenIdConnect.SESSION_STORAGE_KEY_USER_DETAILS);
+            return detailsString ? JSON.parse(detailsString) : null;
+        }
+        else {
+            return null;
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ OpenIdConnectService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OpenIdConnectService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ OpenIdConnectService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OpenIdConnectService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: OpenIdConnectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class OpenIdConnectServiceMock extends OpenIdConnectService {
+    getUserDetails() {
+        return null;
+    }
+}
+
+/* BASE PACKAGE */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActivatedRouteAction, AddApiQueueItemAction, AddAppLoadedConfigModulesAction, AddLangParamInterceptor, AlertHttpErrorCallbackFn, ApiQueueService, ApiQueueServiceMock, AsyncStorageService, AsyncStorageServiceMock, BASE_LOGGER_NAME_TOKEN, BASE_NAME_TOKEN, BrowserStorageType, CONFIG_TOKEN, CORE_ROOT_GUARD, CachePreventionInterceptor, ConsoleHttpErrorCallbackFn, CoreAppActionTypes, CoreAppEffects, CoreI18nActionTypes, CoreLocaleActionTypes, CoreModule, CoreModuleEffects, CoreNotificationsActionTypes, CoreUserActionTypes, CorsSecurityInterceptor, CsrfPreventionInterceptor, DYNAMIC_COMPONENT_CONFIG, EUI_CONFIG_TOKEN, EmptyApiQueueAction, ErrorSubClass, EuLoginSessionTimeoutHandlingInterceptor, EuiCoreRootGuardClass, EuiError, EuiPermissionService, GLOBAL_CONFIG_TOKEN, GlobalErrorHandler, GrowlHttpErrorCallbackFn, HTTP_ERROR_HANDLER_CONFIG_TOKEN, HttpErrorHandlerInterceptor, I18nLoader, I18nResourceImpl, I18nService, I18nServiceMock, InitStoreAction, LANG_PARAM_KEY, LOCALE_ID_MAPPER, LOCAL_FORAGE_SERVICE_CONFIG_TOKEN, LOG_APPENDERS_TOKEN, LOG_LEVEL_TOKEN, LocalForageService, LocalStorageService, LocaleService, LogHttpErrorCallbackFn, LogModule, LogService, LogServiceMock, MODULE_CONFIG_TOKEN, MODULE_NAME_TOKEN, OpenIdConnectInterceptor, OpenIdConnectService, OpenIdConnectServiceMock, ROOT_LOG_CONFIG_TOKEN, RemoveApiQueueItemAction, SHOW_CONNECTION_STATUS_TOKEN, SessionStorageService, StorageService, StorageServiceMock, StoreService, StoreServiceMock, UX_COUNTRIES, UX_ERROR_MAPPING_HANDLER_TOKEN, UX_TIMEZONES, UpdateAppConnectionAction, UpdateAppStatusAction, UpdateAppVersionAction, UpdateCurrentModuleAction, UpdateI18nStateAction, UpdateLocaleStateAction, UpdateNotificationsListAction, UpdateUserDashboardAction, UpdateUserDetailsAction, UpdateUserPreferencesAction, UpdateUserRightsAction, UpdateUserStateAction, UserService, UserServiceMock, UxAppShellService, UxDynamicComponentService, UxDynamicMenuService, UxErrorFeedbackService, UxErrorManager, UxRequestErrorModelInterceptor, UxTimezoneService, closestMatchingParent, consumeEvent, corI18nReducers, coreAppReducers, coreLocaleReducers, coreNotificationsReducers, coreUserReducers, createEuiCoreRootGuard, diffDays, diffDaysFromToday, errorCodes, euiCoreRootGuardClass, formatNumber, getGlobalConfig, getHttpErrorHandlingConfig, getModuleConfig, getRootLogConfig, getShowConnectionStatus, getViewElement, handleError, isDefined, loadEuiDynamicEnvironmentConfig, loadState, localForage, localStorageSync, markControlsTouched, markFormGroupTouched, mergeAppHandlerConfigToAppConfig, mergeAppJsonConfigToAppConfig, offset, position, preInitApp, prepareEuiAppConfigToken, coreReducers as reducers, sessionStorageSync, translateConfig, uniqueId, validateEmail, withUxErrorManager };
+//# sourceMappingURL=eui-core.mjs.map