@ngxs/store 3.7.6 → 3.8.0-dev.master-c341c15

package/fesm2015/ngxs-store.js

@@ -1,97 +1,48 @@
-import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, ErrorHandler, Injector, Optional, SkipSelf, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
-import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
+import * as i0 from '@angular/core';
+import { NgZone, PLATFORM_ID, Injectable, Inject, InjectionToken, inject, INJECTOR, ɵglobal, ErrorHandler, Optional, SkipSelf, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import * as i5 from '@ngxs/store/internals';
+import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, queueScheduler } from 'rxjs';
-import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, observeOn, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
+import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable } from 'rxjs';
+import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @param {?} name
- * @return {?}
- */
 function throwStateNameError(name) {
     throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);
 }
-/**
- * @return {?}
- */
 function throwStateNamePropertyError() {
     throw new Error(`States must register a 'name' property.`);
 }
-/**
- * @param {?} current
- * @param {?} newName
- * @param {?} oldName
- * @return {?}
- */
 function throwStateUniqueError(current, newName, oldName) {
     throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);
 }
-/**
- * @param {?} name
- * @return {?}
- */
 function throwStateDecoratorError(name) {
     throw new Error(`States must be decorated with @State() decorator, but "${name}" isn't.`);
 }
-/**
- * @return {?}
- */
 function throwActionDecoratorError() {
     throw new Error('@Action() decorator cannot be used with static methods.');
 }
-/**
- * @return {?}
- */
 function throwSelectorDecoratorError() {
     throw new Error('Selectors only work on methods.');
 }
-/**
- * @return {?}
- */
 function getZoneWarningMessage() {
     return ('Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
         'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
         'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
 }
-/**
- * @param {?} name
- * @return {?}
- */
 function getUndecoratedStateInIvyWarningMessage(name) {
     return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;
 }
-/**
- * @return {?}
- */
 function throwSelectFactoryNotConnectedError() {
     throw new Error('You have forgotten to import the NGXS module!');
 }
-/**
- * @return {?}
- */
 function throwPatchingArrayError() {
     throw new Error('Patching arrays is not supported.');
 }
-/**
- * @return {?}
- */
 function throwPatchingPrimitiveError() {
     throw new Error('Patching primitives is not supported.');
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class DispatchOutsideZoneNgxsExecutionStrategy {
-    /**
-     * @param {?} _ngZone
-     * @param {?} _platformId
-     */
     constructor(_ngZone, _platformId) {
         this._ngZone = _ngZone;
         this._platformId = _platformId;
@@ -101,43 +52,21 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
             verifyZoneIsNotNooped(_ngZone);
         }
     }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     enter(func) {
         if (isPlatformServer(this._platformId)) {
             return this.runInsideAngular(func);
         }
         return this.runOutsideAngular(func);
     }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     leave(func) {
         return this.runInsideAngular(func);
     }
-    /**
-     * @private
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     runInsideAngular(func) {
         if (NgZone.isInAngularZone()) {
             return func();
         }
         return this._ngZone.run(func);
     }
-    /**
-     * @private
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     runOutsideAngular(func) {
         if (NgZone.isInAngularZone()) {
             return this._ngZone.runOutsideAngular(func);
@@ -145,33 +74,17 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
         return func();
     }
 }
-DispatchOutsideZoneNgxsExecutionStrategy.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-/** @nocollapse */
-DispatchOutsideZoneNgxsExecutionStrategy.ctorParameters = () => [
-    { type: NgZone },
-    { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
-];
-/** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ngInjectableDef = defineInjectable({ factory: function DispatchOutsideZoneNgxsExecutionStrategy_Factory() { return new DispatchOutsideZoneNgxsExecutionStrategy(inject(NgZone), inject(PLATFORM_ID)); }, token: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: "root" });
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype._ngZone;
-    /**
-     * @type {?}
-     * @private
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype._platformId;
-}
+/** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
 // Caretaker note: this should exist as a separate function and not a class method,
 // since class methods are not tree-shakable.
-/**
- * @param {?} ngZone
- * @return {?}
- */
 function verifyZoneIsNotNooped(ngZone) {
     // `NoopNgZone` is not exposed publicly as it doesn't expect
     // to be used outside of the core Angular code, thus we just have
@@ -182,21 +95,11 @@ function verifyZoneIsNotNooped(ngZone) {
     console.warn(getZoneWarningMessage());
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const ROOT_STATE_TOKEN = new InjectionToken('ROOT_STATE_TOKEN');
-/** @type {?} */
 const FEATURE_STATE_TOKEN = new InjectionToken('FEATURE_STATE_TOKEN');
-/** @type {?} */
 const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');
-/** @type {?} */
 const META_KEY = 'NGXS_META';
-/** @type {?} */
 const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
-/** @type {?} */
 const SELECTOR_META_KEY = 'NGXS_SELECTOR_META';
 /**
  * The NGXS config settings.
@@ -215,7 +118,6 @@ class NgxsConfig {
          */
         this.selectorOptions = {
             injectContainerState: true,
-            // TODO: default is true in v3, will change in v4
             suppressErrors: true // TODO: default is true in v3, will change in v4
         };
         this.compatibility = {
@@ -224,402 +126,70 @@ class NgxsConfig {
         this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
     }
 }
-NgxsConfig.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-NgxsConfig.ctorParameters = () => [];
-if (false) {
-    /**
-     * Run in development mode. This will add additional debugging features:
-     * - Object.freeze on the state and actions to guarantee immutability
-     * (default: false)
-     *
-     * Note: this property will be accounted only in development mode when using the Ivy compiler.
-     * It makes sense to use it only during development to ensure there're no state mutations.
-     * When building for production, the Object.freeze will be tree-shaken away.
-     * @type {?}
-     */
-    NgxsConfig.prototype.developmentMode;
-    /** @type {?} */
-    NgxsConfig.prototype.compatibility;
-    /**
-     * Determines the execution context to perform async operations inside. An implementation can be
-     * provided to override the default behaviour where the async operations are run
-     * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
-     * These observable behaviours are from:
-     *   `\@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
-     * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
-     * application doesn't rely on zone.js running change detection then you can switch to the
-     * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
-     * (default: null)
-     * @type {?}
-     */
-    NgxsConfig.prototype.executionStrategy;
-    /**
-     * Defining the default state before module initialization
-     * This is convenient if we need to create a define our own set of states.
-     * @deprecated will be removed after v4
-     * (default: {})
-     * @type {?}
-     */
-    NgxsConfig.prototype.defaultsState;
-    /**
-     * Defining shared selector options
-     * @type {?}
-     */
-    NgxsConfig.prototype.selectorOptions;
-}
-/**
- * State context provided to the actions in the state.
- * @record
- * @template T
- */
-function StateContext() { }
-if (false) {
-    /**
-     * Get the current state.
-     * @return {?}
-     */
-    StateContext.prototype.getState = function () { };
-    /**
-     * Reset the state to a new value.
-     * @param {?} val
-     * @return {?}
-     */
-    StateContext.prototype.setState = function (val) { };
-    /**
-     * Patch the existing state with the provided value.
-     * @param {?} val
-     * @return {?}
-     */
-    StateContext.prototype.patchState = function (val) { };
-    /**
-     * Dispatch a new action and return the dispatched observable.
-     * @param {?} actions
-     * @return {?}
-     */
-    StateContext.prototype.dispatch = function (actions) { };
-}
-/**
- * Plugin interface
- * @record
- */
-function NgxsPlugin() { }
-if (false) {
-    /**
-     * Handle the state/action before its submitted to the state handlers.
-     * @param {?} state
-     * @param {?} action
-     * @param {?} next
-     * @return {?}
-     */
-    NgxsPlugin.prototype.handle = function (state, action, next) { };
-}
-/**
- * Options that can be provided to the store.
- * @record
- * @template T
- */
-function StoreOptions() { }
-if (false) {
-    /**
-     * Name of the state. Required.
-     * @type {?}
-     */
-    StoreOptions.prototype.name;
-    /**
-     * Default values for the state. If not provided, uses empty object.
-     * @type {?|undefined}
-     */
-    StoreOptions.prototype.defaults;
-    /**
-     * Sub states for the given state.
-     * @type {?|undefined}
-     */
-    StoreOptions.prototype.children;
-}
+/** @nocollapse */ NgxsConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ NgxsConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsConfig });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsConfig, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
 /**
  * Represents a basic change from a previous to a new value for a single state instance.
  * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
- * @template T
  */
 class NgxsSimpleChange {
-    /**
-     * @param {?} previousValue
-     * @param {?} currentValue
-     * @param {?} firstChange
-     */
     constructor(previousValue, currentValue, firstChange) {
         this.previousValue = previousValue;
         this.currentValue = currentValue;
         this.firstChange = firstChange;
     }
 }
-if (false) {
-    /** @type {?} */
-    NgxsSimpleChange.prototype.previousValue;
-    /** @type {?} */
-    NgxsSimpleChange.prototype.currentValue;
-    /** @type {?} */
-    NgxsSimpleChange.prototype.firstChange;
-}
-/**
- * On init interface
- * @record
- */
-function NgxsOnInit() { }
-if (false) {
-    /**
-     * @param {?} ctx
-     * @return {?}
-     */
-    NgxsOnInit.prototype.ngxsOnInit = function (ctx) { };
-}
-/**
- * On change interface
- * @record
- */
-function NgxsOnChanges() { }
-if (false) {
-    /**
-     * @param {?} change
-     * @return {?}
-     */
-    NgxsOnChanges.prototype.ngxsOnChanges = function (change) { };
-}
-/**
- * After bootstrap interface
- * @record
- */
-function NgxsAfterBootstrap() { }
-if (false) {
-    /**
-     * @param {?} ctx
-     * @return {?}
-     */
-    NgxsAfterBootstrap.prototype.ngxsAfterBootstrap = function (ctx) { };
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class NoopNgxsExecutionStrategy {
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     enter(func) {
         return func();
     }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     leave(func) {
         return func();
     }
 }
-NoopNgxsExecutionStrategy.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-/** @nocollapse */ NoopNgxsExecutionStrategy.ngInjectableDef = defineInjectable({ factory: function NoopNgxsExecutionStrategy_Factory() { return new NoopNgxsExecutionStrategy(); }, token: NoopNgxsExecutionStrategy, providedIn: "root" });
+/** @nocollapse */ NoopNgxsExecutionStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NoopNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ NoopNgxsExecutionStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NoopNgxsExecutionStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NoopNgxsExecutionStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * The strategy that might be provided by users through `options.executionStrategy`.
- * @type {?}
  */
 const USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');
 /*
  * Internal execution strategy injection token
  */
-/** @type {?} */
 const NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY', {
     providedIn: 'root',
-    factory: (/**
-     * @return {?}
-     */
-    () => {
-        /** @type {?} */
+    factory: () => {
         const injector = inject(INJECTOR);
-        /** @type {?} */
         const executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);
         return executionStrategy
             ? injector.get(executionStrategy)
             : injector.get(typeof ɵglobal.Zone !== 'undefined'
                 ? DispatchOutsideZoneNgxsExecutionStrategy
                 : NoopNgxsExecutionStrategy);
-    })
+    }
 });
-/**
- * @record
- */
-function NgxsExecutionStrategy() { }
-if (false) {
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NgxsExecutionStrategy.prototype.enter = function (func) { };
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NgxsExecutionStrategy.prototype.leave = function (func) { };
-}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T, U
- */
-function StateClassInternal() { }
-if (false) {
-    /* Skipping unnamed member:
-    [META_KEY]?: MetaDataModel;*/
-    /* Skipping unnamed member:
-    [META_OPTIONS_KEY]?: StoreOptions<U>;*/
-}
-/**
- * @record
- * @template T
- */
-function StateOperations() { }
-if (false) {
-    /**
-     * @return {?}
-     */
-    StateOperations.prototype.getState = function () { };
-    /**
-     * @param {?} val
-     * @return {?}
-     */
-    StateOperations.prototype.setState = function (val) { };
-    /**
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    StateOperations.prototype.dispatch = function (actionOrActions) { };
-}
-/**
- * @record
- */
-function MetaDataModel() { }
-if (false) {
-    /** @type {?} */
-    MetaDataModel.prototype.name;
-    /** @type {?} */
-    MetaDataModel.prototype.actions;
-    /** @type {?} */
-    MetaDataModel.prototype.defaults;
-    /** @type {?} */
-    MetaDataModel.prototype.path;
-    /** @type {?} */
-    MetaDataModel.prototype.makeRootSelector;
-    /** @type {?|undefined} */
-    MetaDataModel.prototype.children;
-}
-/**
- * @record
- */
-function RuntimeSelectorContext() { }
-if (false) {
-    /**
-     * @param {?} key
-     * @return {?}
-     */
-    RuntimeSelectorContext.prototype.getStateGetter = function (key) { };
-    /**
-     * @param {?=} localOptions
-     * @return {?}
-     */
-    RuntimeSelectorContext.prototype.getSelectorOptions = function (localOptions) { };
-}
-/**
- * @record
- */
-function SharedSelectorOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    SharedSelectorOptions.prototype.injectContainerState;
-    /** @type {?|undefined} */
-    SharedSelectorOptions.prototype.suppressErrors;
-}
-/**
- * @record
- */
-function SelectorMetaDataModel() { }
-if (false) {
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.makeRootSelector;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.originalFn;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.containerClass;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.selectorName;
-    /** @type {?} */
-    SelectorMetaDataModel.prototype.getSelectorOptions;
-}
-/**
- * @record
- */
-function MappedStore() { }
-if (false) {
-    /** @type {?} */
-    MappedStore.prototype.name;
-    /** @type {?} */
-    MappedStore.prototype.isInitialised;
-    /** @type {?} */
-    MappedStore.prototype.actions;
-    /** @type {?} */
-    MappedStore.prototype.defaults;
-    /** @type {?} */
-    MappedStore.prototype.instance;
-    /** @type {?} */
-    MappedStore.prototype.path;
-}
-/**
- * @record
- */
-function StatesAndDefaults() { }
-if (false) {
-    /** @type {?} */
-    StatesAndDefaults.prototype.defaults;
-    /** @type {?} */
-    StatesAndDefaults.prototype.states;
-}
 /**
  * Ensures metadata is attached to the class and returns it.
  *
  * @ignore
- * @param {?} target
- * @return {?}
  */
-function ensureStoreMetadata(target) {
+function ensureStoreMetadata$1(target) {
     if (!target.hasOwnProperty(META_KEY)) {
-        /** @type {?} */
         const defaultMetadata = {
             name: null,
             actions: {},
             defaults: {},
             path: null,
-            /**
-             * @param {?} context
-             * @return {?}
-             */
             makeRootSelector(context) {
                 return context.getStateGetter(defaultMetadata.name);
             },
@@ -627,50 +197,40 @@ function ensureStoreMetadata(target) {
         };
         Object.defineProperty(target, META_KEY, { value: defaultMetadata });
     }
-    return getStoreMetadata(target);
+    return getStoreMetadata$1(target);
 }
 /**
  * Get the metadata attached to the state class if it exists.
  *
  * @ignore
- * @param {?} target
- * @return {?}
  */
-function getStoreMetadata(target) {
-    return (/** @type {?} */ (target[META_KEY]));
+function getStoreMetadata$1(target) {
+    return target[META_KEY];
 }
 /**
  * Ensures metadata is attached to the selector and returns it.
  *
  * @ignore
- * @param {?} target
- * @return {?}
  */
-function ensureSelectorMetadata(target) {
+function ensureSelectorMetadata$1(target) {
     if (!target.hasOwnProperty(SELECTOR_META_KEY)) {
-        /** @type {?} */
         const defaultMetadata = {
             makeRootSelector: null,
             originalFn: null,
             containerClass: null,
             selectorName: null,
-            getSelectorOptions: (/**
-             * @return {?}
-             */
-            () => ({}))
+            getSelectorOptions: () => ({})
         };
         Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });
     }
-    return getSelectorMetadata(target);
+    return getSelectorMetadata$1(target);
 }
 /**
  * Get the metadata attached to the selector if it exists.
  *
  * @ignore
- * @param {?} target
- * @return {?}
  */
-function getSelectorMetadata(target) {
+function getSelectorMetadata$1(target) {
     return target[SELECTOR_META_KEY];
 }
 /**
@@ -682,22 +242,10 @@ function getSelectorMetadata(target) {
  * See perf hit: https://jsperf.com/fast-value-getter-given-path/1
  *
  * @ignore
- * @param {?} paths
- * @return {?}
  */
 function compliantPropGetter(paths) {
-    /** @type {?} */
     const copyOfPaths = paths.slice();
-    return (/**
-     * @param {?} obj
-     * @return {?}
-     */
-    obj => copyOfPaths.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @return {?}
-     */
-    (acc, part) => acc && acc[part]), obj));
+    return obj => copyOfPaths.reduce((acc, part) => acc && acc[part], obj);
 }
 /**
  * The generated function is faster than:
@@ -705,26 +253,18 @@ function compliantPropGetter(paths) {
  * - memoize
  *
  * @ignore
- * @param {?} paths
- * @return {?}
  */
 function fastPropGetter(paths) {
-    /** @type {?} */
     const segments = paths;
-    /** @type {?} */
     let seg = 'store.' + segments[0];
-    /** @type {?} */
     let i = 0;
-    /** @type {?} */
     const l = segments.length;
-    /** @type {?} */
     let expr = seg;
     while (++i < l) {
         expr = expr + ' && ' + (seg = seg + '.' + segments[i]);
     }
-    /** @type {?} */
     const fn = new Function('store', 'return ' + expr + ';');
-    return (/** @type {?} */ (fn));
+    return fn;
 }
 /**
  * Get a deeply nested value. Example:
@@ -732,9 +272,6 @@ function fastPropGetter(paths) {
  *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
  *
  * @ignore
- * @param {?} paths
- * @param {?} config
- * @return {?}
  */
 function propGetter(paths, config) {
     if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {
@@ -761,39 +298,22 @@ function propGetter(paths, config) {
  *  };
  *
  * @ignore
- * @param {?} stateClasses
- * @return {?}
  */
 function buildGraph(stateClasses) {
-    /** @type {?} */
-    const findName = (/**
-     * @param {?} stateClass
-     * @return {?}
-     */
-    (stateClass) => {
-        /** @type {?} */
-        const meta = stateClasses.find((/**
-         * @param {?} g
-         * @return {?}
-         */
-        g => g === stateClass));
+    const findName = (stateClass) => {
+        const meta = stateClasses.find(g => g === stateClass);
         // Caretaker note: we have still left the `typeof` condition in order to avoid
         // creating a breaking change for projects that still use the View Engine.
         if ((typeof ngDevMode === 'undefined' || ngDevMode) && !meta) {
             throw new Error(`Child state not found: ${stateClass}. \r\nYou may have forgotten to add states to module`);
         }
-        return (/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (meta))[META_KEY])).name));
-    });
-    return stateClasses.reduce((/**
-     * @param {?} result
-     * @param {?} stateClass
-     * @return {?}
-     */
-    (result, stateClass) => {
-        const { name, children } = (/** @type {?} */ (stateClass[META_KEY]));
-        result[(/** @type {?} */ (name))] = (children || []).map(findName);
+        return meta[META_KEY].name;
+    };
+    return stateClasses.reduce((result, stateClass) => {
+        const { name, children } = stateClass[META_KEY];
+        result[name] = (children || []).map(findName);
         return result;
-    }), {});
+    }, {});
 }
 /**
  * Given a states array, returns object graph
@@ -804,21 +324,13 @@ function buildGraph(stateClasses) {
  *  };
  *
  * @ignore
- * @param {?} states
- * @return {?}
  */
 function nameToState(states) {
-    return states.reduce((/**
-     * @param {?} result
-     * @param {?} stateClass
-     * @return {?}
-     */
-    (result, stateClass) => {
-        /** @type {?} */
-        const meta = (/** @type {?} */ (stateClass[META_KEY]));
-        result[(/** @type {?} */ (meta.name))] = stateClass;
+    return states.reduce((result, stateClass) => {
+        const meta = stateClass[META_KEY];
+        result[meta.name] = stateClass;
         return result;
-    }), {});
+    }, {});
 }
 /**
  * Given a object relationship graph will return the full path
@@ -839,30 +351,19 @@ function nameToState(states) {
  *  };
  *
  * @ignore
- * @param {?} obj
- * @param {?=} newObj
- * @return {?}
  */
 function findFullParentPath(obj, newObj = {}) {
-    /** @type {?} */
-    const visit = (/**
-     * @param {?} child
-     * @param {?} keyToFind
-     * @return {?}
-     */
-    (child, keyToFind) => {
+    const visit = (child, keyToFind) => {
         for (const key in child) {
             if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {
-                /** @type {?} */
                 const parent = visit(child, key);
                 return parent !== null ? `${parent}.${key}` : key;
             }
         }
         return null;
-    });
+    };
     for (const key in obj) {
         if (obj.hasOwnProperty(key)) {
-            /** @type {?} */
             const parent = visit(obj, key);
             newObj[key] = parent ? `${parent}.${key}` : key;
         }
@@ -887,31 +388,17 @@ function findFullParentPath(obj, newObj = {}) {
  *  ];
  *
  * @ignore
- * @param {?} graph
- * @return {?}
  */
 function topologicalSort(graph) {
-    /** @type {?} */
     const sorted = [];
-    /** @type {?} */
     const visited = {};
-    /** @type {?} */
-    const visit = (/**
-     * @param {?} name
-     * @param {?=} ancestors
-     * @return {?}
-     */
-    (name, ancestors = []) => {
+    const visit = (name, ancestors = []) => {
         if (!Array.isArray(ancestors)) {
             ancestors = [];
         }
         ancestors.push(name);
         visited[name] = true;
-        graph[name].forEach((/**
-         * @param {?} dep
-         * @return {?}
-         */
-        (dep) => {
+        graph[name].forEach((dep) => {
             // Caretaker note: we have still left the `typeof` condition in order to avoid
             // creating a breaking change for projects that still use the View Engine.
             if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {
@@ -921,38 +408,26 @@ function topologicalSort(graph) {
                 return;
             }
             visit(dep, ancestors.slice(0));
-        }));
+        });
         if (sorted.indexOf(name) < 0) {
             sorted.push(name);
         }
-    });
-    Object.keys(graph).forEach((/**
-     * @param {?} k
-     * @return {?}
-     */
-    k => visit(k)));
+    };
+    Object.keys(graph).forEach(k => visit(k));
     return sorted.reverse();
 }
 /**
  * Returns if the parameter is a object or not.
  *
  * @ignore
- * @param {?} obj
- * @return {?}
  */
-function isObject(obj) {
+function isObject$1(obj) {
     return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Returns the type from an action instance/class.
  * @ignore
- * @param {?} action
- * @return {?}
  */
 function getActionTypeFromInstance(action) {
     if (action.constructor && action.constructor.type) {
@@ -965,19 +440,12 @@ function getActionTypeFromInstance(action) {
 /**
  * Matches a action
  * @ignore
- * @param {?} action1
- * @return {?}
  */
 function actionMatcher(action1) {
-    /** @type {?} */
     const type1 = getActionTypeFromInstance(action1);
-    return (/**
-     * @param {?} action2
-     * @return {?}
-     */
-    function (action2) {
+    return function (action2) {
         return type1 === getActionTypeFromInstance(action2);
-    });
+    };
 }
 /**
  * Set a deeply nested value. Example:
@@ -988,27 +456,12 @@ function actionMatcher(action1) {
  * While it traverses it also creates new objects from top down.
  *
  * @ignore
- * @type {?}
  */
-const setValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @param {?} val
- * @return {?}
- */
-(obj, prop, val) => {
+const setValue = (obj, prop, val) => {
     obj = Object.assign({}, obj);
-    /** @type {?} */
     const split = prop.split('.');
-    /** @type {?} */
     const lastIndex = split.length - 1;
-    split.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @param {?} index
-     * @return {?}
-     */
-    (acc, part, index) => {
+    split.reduce((acc, part, index) => {
         if (index === lastIndex) {
             acc[part] = val;
         }
@@ -1016,28 +469,17 @@ const setValue = (/**
             acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);
         }
         return acc && acc[part];
-    }), obj);
+    }, obj);
     return obj;
-});
+};
 /**
  * Get a deeply nested value. Example:
  *
  *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
  *
  * @ignore
- * @type {?}
  */
-const getValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @return {?}
- */
-(obj, prop) => prop.split('.').reduce((/**
- * @param {?} acc
- * @param {?} part
- * @return {?}
- */
-(acc, part) => acc && acc[part]), obj));
+const getValue = (obj, prop) => prop.split('.').reduce((acc, part) => acc && acc[part], obj);
 /**
  * Simple object check.
  *
@@ -1045,36 +487,24 @@ const getValue = (/**
  *    isObject(1) //=> false
  *
  * @ignore
- * @type {?}
  */
-const isObject$1 = (/**
- * @param {?} item
- * @return {?}
- */
-(item) => {
+const isObject = (item) => {
     return item && typeof item === 'object' && !Array.isArray(item);
-});
+};
 /**
  * Deep merge two objects.
  *
  *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
  *
- * \@param base base object onto which `sources` will be applied
- * @type {?}
- */
-const mergeDeep = (/**
- * @param {?} base
- * @param {...?} sources
- * @return {?}
+ * @param base base object onto which `sources` will be applied
  */
-(base, ...sources) => {
+const mergeDeep = (base, ...sources) => {
     if (!sources.length)
         return base;
-    /** @type {?} */
     const source = sources.shift();
-    if (isObject$1(base) && isObject$1(source)) {
+    if (isObject(base) && isObject(source)) {
         for (const key in source) {
-            if (isObject$1(source[key])) {
+            if (isObject(source[key])) {
                 if (!base[key])
                     Object.assign(base, { [key]: {} });
                 mergeDeep(base[key], source[key]);
@@ -1085,29 +515,12 @@ const mergeDeep = (/**
         }
     }
     return mergeDeep(base, ...sources);
-});
+};
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T, E
- */
-function ActionCompletion() { }
-if (false) {
-    /** @type {?} */
-    ActionCompletion.prototype.action;
-    /** @type {?} */
-    ActionCompletion.prototype.result;
-}
 /**
  * RxJS operator for selecting out specific actions.
  *
  * This will grab actions that have just been dispatched as well as actions that have completed
- * @param {...?} allowedTypes
- * @return {?}
  */
 function ofAction(...allowedTypes) {
     return ofActionOperator(allowedTypes);
@@ -1116,8 +529,6 @@ function ofAction(...allowedTypes) {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been dispatched
- * @param {...?} allowedTypes
- * @return {?}
  */
 function ofActionDispatched(...allowedTypes) {
     return ofActionOperator(allowedTypes, ["DISPATCHED" /* Dispatched */]);
@@ -1126,8 +537,6 @@ function ofActionDispatched(...allowedTypes) {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been successfully completed
- * @param {...?} allowedTypes
- * @return {?}
  */
 function ofActionSuccessful(...allowedTypes) {
     return ofActionOperator(allowedTypes, ["SUCCESSFUL" /* Successful */]);
@@ -1136,8 +545,6 @@ function ofActionSuccessful(...allowedTypes) {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been canceled
- * @param {...?} allowedTypes
- * @return {?}
  */
 function ofActionCanceled(...allowedTypes) {
     return ofActionOperator(allowedTypes, ["CANCELED" /* Canceled */]);
@@ -1146,11 +553,8 @@ function ofActionCanceled(...allowedTypes) {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just been completed
- * @param {...?} allowedTypes
- * @return {?}
  */
 function ofActionCompleted(...allowedTypes) {
-    /** @type {?} */
     const allowedStatuses = [
         "SUCCESSFUL" /* Successful */,
         "CANCELED" /* Canceled */,
@@ -1162,243 +566,135 @@ function ofActionCompleted(...allowedTypes) {
  * RxJS operator for selecting out specific actions.
  *
  * This will ONLY grab actions that have just thrown an error
- * @param {...?} allowedTypes
- * @return {?}
  */
 function ofActionErrored(...allowedTypes) {
     return ofActionOperator(allowedTypes, ["ERRORED" /* Errored */]);
 }
-/**
- * @param {?} allowedTypes
- * @param {?=} statuses
- * @param {?=} mapOperator
- * @return {?}
- */
 function ofActionOperator(allowedTypes, statuses, 
 // This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,
 // since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`
 // defaults to `any`, thus there is no sense from union type.
 mapOperator = mapAction) {
-    /** @type {?} */
     const allowedMap = createAllowedActionTypesMap(allowedTypes);
-    /** @type {?} */
     const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);
-    return (/**
-     * @param {?} o
-     * @return {?}
-     */
-    function (o) {
+    return function (o) {
         return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());
-    });
+    };
 }
-/**
- * @param {?} allowedTypes
- * @param {?=} allowedStatuses
- * @return {?}
- */
 function filterStatus(allowedTypes, allowedStatuses) {
-    return filter((/**
-     * @param {?} ctx
-     * @return {?}
-     */
-    (ctx) => {
-        /** @type {?} */
-        const actionType = (/** @type {?} */ (getActionTypeFromInstance(ctx.action)));
-        /** @type {?} */
+    return filter((ctx) => {
+        const actionType = getActionTypeFromInstance(ctx.action);
         const typeMatch = allowedTypes[actionType];
-        /** @type {?} */
         const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;
         return typeMatch && statusMatch;
-    }));
+    });
 }
-/**
- * @return {?}
- */
 function mapActionResult() {
-    return map((/**
-     * @param {?} __0
-     * @return {?}
-     */
-    ({ action, status, error }) => {
-        return (/** @type {?} */ ({
+    return map(({ action, status, error }) => {
+        return {
             action,
             result: {
                 successful: "SUCCESSFUL" /* Successful */ === status,
                 canceled: "CANCELED" /* Canceled */ === status,
                 error
             }
-        }));
-    }));
+        };
+    });
 }
-/**
- * @template T
- * @return {?}
- */
 function mapAction() {
-    return map((/**
-     * @param {?} ctx
-     * @return {?}
-     */
-    (ctx) => (/** @type {?} */ (ctx.action))));
+    return map((ctx) => ctx.action);
 }
-/**
- * @record
- */
-function FilterMap() { }
-/**
- * @param {?} types
- * @return {?}
- */
 function createAllowedActionTypesMap(types) {
-    return types.reduce((/**
-     * @param {?} filterMap
-     * @param {?} klass
-     * @return {?}
-     */
-    (filterMap, klass) => {
-        filterMap[(/** @type {?} */ (getActionTypeFromInstance(klass)))] = true;
+    return types.reduce((filterMap, klass) => {
+        filterMap[getActionTypeFromInstance(klass)] = true;
         return filterMap;
-    }), (/** @type {?} */ ({})));
+    }, {});
 }
-/**
- * @param {?} statuses
- * @return {?}
- */
 function createAllowedStatusesMap(statuses) {
-    return statuses.reduce((/**
-     * @param {?} filterMap
-     * @param {?} status
-     * @return {?}
-     */
-    (filterMap, status) => {
+    return statuses.reduce((filterMap, status) => {
         filterMap[status] = true;
         return filterMap;
-    }), (/** @type {?} */ ({})));
+    }, {});
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Returns operator that will run
  * `subscribe` outside of the ngxs execution context
- * @template T
- * @param {?} ngxsExecutionStrategy
- * @return {?}
  */
 function leaveNgxs(ngxsExecutionStrategy) {
-    return (/**
-     * @param {?} source
-     * @return {?}
-     */
-    (source) => {
-        return new Observable((/**
-         * @param {?} sink
-         * @return {?}
-         */
-        (sink) => {
+    return (source) => {
+        return new Observable((sink) => {
             return source.subscribe({
-                /**
-                 * @param {?} value
-                 * @return {?}
-                 */
                 next(value) {
-                    ngxsExecutionStrategy.leave((/**
-                     * @return {?}
-                     */
-                    () => sink.next(value)));
+                    ngxsExecutionStrategy.leave(() => sink.next(value));
                 },
-                /**
-                 * @param {?} error
-                 * @return {?}
-                 */
                 error(error) {
-                    ngxsExecutionStrategy.leave((/**
-                     * @return {?}
-                     */
-                    () => sink.error(error)));
+                    ngxsExecutionStrategy.leave(() => sink.error(error));
                 },
-                /**
-                 * @return {?}
-                 */
                 complete() {
-                    ngxsExecutionStrategy.leave((/**
-                     * @return {?}
-                     */
-                    () => sink.complete()));
+                    ngxsExecutionStrategy.leave(() => sink.complete());
                 }
             });
-        }));
-    });
+        });
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class InternalNgxsExecutionStrategy {
-    /**
-     * @param {?} _executionStrategy
-     */
     constructor(_executionStrategy) {
         this._executionStrategy = _executionStrategy;
     }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     enter(func) {
         return this._executionStrategy.enter(func);
     }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
     leave(func) {
         return this._executionStrategy.leave(func);
     }
 }
-InternalNgxsExecutionStrategy.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-InternalNgxsExecutionStrategy.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [NGXS_EXECUTION_STRATEGY,] }] }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalNgxsExecutionStrategy.prototype._executionStrategy;
-}
+/** @nocollapse */ InternalNgxsExecutionStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [{ token: NGXS_EXECUTION_STRATEGY }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalNgxsExecutionStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalNgxsExecutionStrategy });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGXS_EXECUTION_STRATEGY]
+                }] }]; } });
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {string} */
-const ActionStatus = {
-    Dispatched: 'DISPATCHED',
-    Successful: 'SUCCESSFUL',
-    Canceled: 'CANCELED',
-    Errored: 'ERRORED',
-};
-/**
- * @record
- * @template T
- */
-function ActionContext() { }
-if (false) {
-    /** @type {?} */
-    ActionContext.prototype.status;
-    /** @type {?} */
-    ActionContext.prototype.action;
-    /** @type {?|undefined} */
-    ActionContext.prototype.error;
+ * This wraps the provided function, and will enforce the following:
+ * - The calls will execute in the order that they are made
+ * - A call will only be initiated when the previous call has completed
+ * - If there is a call currently executing then the new call will be added
+ *   to the queue and the function will return immediately
+ *
+ * NOTE: The following assumptions about the operation must hold true:
+ * - The operation is synchronous in nature
+ * - If any asynchronous side effects of the call exist, it should not
+ *   have any bearing on the correctness of the next call in the queue
+ * - The operation has a void return
+ * - The caller should not assume that the call has completed upon
+ *   return of the function
+ * - The caller can assume that all the queued calls will complete
+ *   within the current microtask
+ * - The only way that a call will encounter another call in the queue
+ *   would be if the call at the front of the queue initiated this call
+ *   as part of its synchronous execution
+ */
+function orderedQueueOperation(operation) {
+    const callsQueue = [];
+    let busyPushingNext = false;
+    return function callOperation(...args) {
+        if (busyPushingNext) {
+            callsQueue.unshift(args);
+            return;
+        }
+        busyPushingNext = true;
+        operation(...args);
+        while (callsQueue.length > 0) {
+            const nextCallArgs = callsQueue.pop();
+            nextCallArgs && operation(...nextCallArgs);
+        }
+        busyPushingNext = false;
+    };
 }
 /**
  * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
@@ -1406,126 +702,85 @@ if (false) {
  * For example, given the following code:
  * ```typescript
  *   const subject = new Subject<string>();
- * subject.subscribe(value => {
- * if (value === 'start') subject.next('end');
- * });
- * subject.subscribe(value => { });
- * subject.next('start');
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
  * ```
  * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
  * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- * @template T
  */
 class OrderedSubject extends Subject {
     constructor() {
         super(...arguments);
-        this._itemQueue = [];
-        this._busyPushingNext = false;
-    }
-    /**
-     * @param {?=} value
-     * @return {?}
-     */
-    next(value) {
-        if (this._busyPushingNext) {
-            this._itemQueue.unshift((/** @type {?} */ (value)));
-            return;
-        }
-        this._busyPushingNext = true;
-        super.next(value);
-        while (this._itemQueue.length > 0) {
-            /** @type {?} */
-            const nextValue = this._itemQueue.pop();
-            super.next(nextValue);
-        }
-        this._busyPushingNext = false;
+        this.next = orderedQueueOperation((value) => super.next(value));
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    OrderedSubject.prototype._itemQueue;
-    /**
-     * @type {?}
-     * @private
-     */
-    OrderedSubject.prototype._busyPushingNext;
+/**
+ * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard BehaviorSubject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new BehaviorSubject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+class OrderedBehaviorSubject extends BehaviorSubject {
+    constructor() {
+        super(...arguments);
+        this.next = orderedQueueOperation((value) => super.next(value));
+    }
 }
+
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
 class InternalActions extends OrderedSubject {
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         this.complete();
     }
 }
-InternalActions.decorators = [
-    { type: Injectable }
-];
+/** @nocollapse */ InternalActions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalActions, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalActions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalActions });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalActions, decorators: [{
+            type: Injectable
+        }] });
 /**
  * Action stream that is emitted anytime an action is dispatched.
  *
  * You can listen to this in services to react without stores.
  */
 class Actions extends Observable {
-    // This has to be `Observable<ActionContext>` in the v4. Because `InternalActions`
-    // is a `Subject<ActionContext>`. Leave it as `any` to avoid breaking changes
-    /**
-     * @param {?} internalActions$
-     * @param {?} internalExecutionStrategy
-     */
     constructor(internalActions$, internalExecutionStrategy) {
-        /** @type {?} */
         const sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy), 
         // The `InternalActions` subject emits outside of the Angular zone.
         // We have to re-enter the Angular zone for any incoming consumer.
         // The `share()` operator reduces the number of change detections.
         // This would call leave only once for any stream emission across all active subscribers.
         share());
-        super((/**
-         * @param {?} observer
-         * @return {?}
-         */
-        observer => {
-            /** @type {?} */
+        super(observer => {
             const childSubscription = sharedInternalActions$.subscribe({
-                next: (/**
-                 * @param {?} ctx
-                 * @return {?}
-                 */
-                ctx => observer.next(ctx)),
-                error: (/**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                error => observer.error(error)),
-                complete: (/**
-                 * @return {?}
-                 */
-                () => observer.complete())
+                next: ctx => observer.next(ctx),
+                error: error => observer.error(error),
+                complete: () => observer.complete()
             });
             observer.add(childSubscription);
-        }));
+        });
     }
 }
-Actions.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-Actions.ctorParameters = () => [
-    { type: InternalActions },
-    { type: InternalNgxsExecutionStrategy }
-];
+/** @nocollapse */ Actions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions, deps: [{ token: InternalActions }, { token: InternalNgxsExecutionStrategy }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ Actions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: InternalActions }, { type: InternalNgxsExecutionStrategy }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Composes a array of functions from left to right. Example:
  *
@@ -1546,30 +801,12 @@ Actions.ctorParameters = () => [
  * the last function should not call `next`.
  *
  * @ignore
- * @type {?}
- */
-const compose = (/**
- * @param {?} funcs
- * @return {?}
  */
-(funcs) => (/**
- * @param {...?} args
- * @return {?}
- */
-(...args) => {
-    /** @type {?} */
-    const curr = (/** @type {?} */ (funcs.shift()));
-    return curr(...args, (/**
-     * @param {...?} nextArgs
-     * @return {?}
-     */
-    (...nextArgs) => compose(funcs)(...nextArgs)));
-}));
+const compose = (funcs) => (...args) => {
+    const curr = funcs.shift();
+    return curr(...args, (...nextArgs) => compose(funcs)(...nextArgs));
+};
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * This operator is used for piping the observable result
  * from the `dispatch()`. It has a "smart" error handling
@@ -1581,69 +818,34 @@ const compose = (/**
  * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`
  * 4) `toPromise()` without `catch` -> do `handleError()`
  * 5) `toPromise()` with `catch` -> don't `handleError()`
- * @template T
- * @param {?} internalErrorReporter
- * @param {?} ngxsExecutionStrategy
- * @return {?}
  */
 function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
-    return (/**
-     * @param {?} source
-     * @return {?}
-     */
-    (source) => {
-        /** @type {?} */
+    return (source) => {
         let subscribed = false;
         source.subscribe({
-            error: (/**
-             * @param {?} error
-             * @return {?}
-             */
-            error => {
+            error: error => {
                 // Do not trigger change detection for a microtask. This depends on the execution
                 // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`
                 // leaves the Angular zone.
-                ngxsExecutionStrategy.enter((/**
-                 * @return {?}
-                 */
-                () => Promise.resolve().then((/**
-                 * @return {?}
-                 */
-                () => {
+                ngxsExecutionStrategy.enter(() => Promise.resolve().then(() => {
                     if (!subscribed) {
-                        ngxsExecutionStrategy.leave((/**
-                         * @return {?}
-                         */
-                        () => internalErrorReporter.reportErrorSafely(error)));
+                        ngxsExecutionStrategy.leave(() => internalErrorReporter.reportErrorSafely(error));
                     }
-                }))));
-            })
+                }));
+            }
         });
-        return new Observable((/**
-         * @param {?} subscriber
-         * @return {?}
-         */
-        subscriber => {
+        return new Observable(subscriber => {
             subscribed = true;
             return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
-        }));
-    });
+        });
+    };
 }
 class InternalErrorReporter {
-    /**
-     * @param {?} _injector
-     */
     constructor(_injector) {
         this._injector = _injector;
-        /**
-         * Will be set lazily to be backward compatible.
-         */
-        this._errorHandler = (/** @type {?} */ (null));
+        /** Will be set lazily to be backward compatible. */
+        this._errorHandler = null;
     }
-    /**
-     * @param {?} error
-     * @return {?}
-     */
     reportErrorSafely(error) {
         if (this._errorHandler === null) {
             this._errorHandler = this._injector.get(ErrorHandler);
@@ -1658,43 +860,21 @@ class InternalErrorReporter {
         catch (_a) { }
     }
 }
-InternalErrorReporter.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-/** @nocollapse */
-InternalErrorReporter.ctorParameters = () => [
-    { type: Injector }
-];
-/** @nocollapse */ InternalErrorReporter.ngInjectableDef = defineInjectable({ factory: function InternalErrorReporter_Factory() { return new InternalErrorReporter(inject(INJECTOR)); }, token: InternalErrorReporter, providedIn: "root" });
-if (false) {
-    /**
-     * Will be set lazily to be backward compatible.
-     * @type {?}
-     * @private
-     */
-    InternalErrorReporter.prototype._errorHandler;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalErrorReporter.prototype._injector;
-}
+/** @nocollapse */ InternalErrorReporter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalErrorReporter, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalErrorReporter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalErrorReporter, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalErrorReporter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * BehaviorSubject of the entire state.
  * @ignore
  */
-class StateStream extends BehaviorSubject {
+class StateStream extends OrderedBehaviorSubject {
     constructor() {
         super({});
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.
         // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users
@@ -1702,84 +882,46 @@ class StateStream extends BehaviorSubject {
         this.complete();
     }
 }
-StateStream.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-StateStream.ctorParameters = () => [];
+/** @nocollapse */ StateStream.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ StateStream.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class PluginManager {
-    /**
-     * @param {?} _parentManager
-     * @param {?} _pluginHandlers
-     */
     constructor(_parentManager, _pluginHandlers) {
         this._parentManager = _parentManager;
         this._pluginHandlers = _pluginHandlers;
         this.plugins = [];
         this.registerHandlers();
     }
-    /**
-     * @private
-     * @return {?}
-     */
     get rootPlugins() {
         return (this._parentManager && this._parentManager.plugins) || this.plugins;
     }
-    /**
-     * @private
-     * @return {?}
-     */
     registerHandlers() {
-        /** @type {?} */
         const pluginHandlers = this.getPluginHandlers();
         this.rootPlugins.push(...pluginHandlers);
     }
-    /**
-     * @private
-     * @return {?}
-     */
     getPluginHandlers() {
-        /** @type {?} */
         const handlers = this._pluginHandlers || [];
-        return handlers.map((/**
-         * @param {?} plugin
-         * @return {?}
-         */
-        (plugin) => (/** @type {?} */ ((plugin.handle ? plugin.handle.bind(plugin) : plugin)))));
-    }
-}
-PluginManager.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-PluginManager.ctorParameters = () => [
-    { type: PluginManager, decorators: [{ type: Optional }, { type: SkipSelf }] },
-    { type: Array, decorators: [{ type: Inject, args: [NGXS_PLUGINS,] }, { type: Optional }] }
-];
-if (false) {
-    /** @type {?} */
-    PluginManager.prototype.plugins;
-    /**
-     * @type {?}
-     * @private
-     */
-    PluginManager.prototype._parentManager;
-    /**
-     * @type {?}
-     * @private
-     */
-    PluginManager.prototype._pluginHandlers;
-}
+        return handlers.map((plugin) => (plugin.handle ? plugin.handle.bind(plugin) : plugin));
+    }
+}
+/** @nocollapse */ PluginManager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PluginManager, deps: [{ token: PluginManager, optional: true, skipSelf: true }, { token: NGXS_PLUGINS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ PluginManager.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PluginManager });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PluginManager, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: PluginManager, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGXS_PLUGINS]
+                }, {
+                    type: Optional
+                }] }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Internal Action result stream that is emitted when an action is completed.
  * This is used as a method of returning the action result to the dispatcher
@@ -1788,18 +930,12 @@ if (false) {
  */
 class InternalDispatchedActionResults extends Subject {
 }
-InternalDispatchedActionResults.decorators = [
-    { type: Injectable }
-];
+/** @nocollapse */ InternalDispatchedActionResults.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatchedActionResults, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalDispatchedActionResults.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatchedActionResults });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
+            type: Injectable
+        }] });
 class InternalDispatcher {
-    /**
-     * @param {?} _actions
-     * @param {?} _actionResults
-     * @param {?} _pluginManager
-     * @param {?} _stateStream
-     * @param {?} _ngxsExecutionStrategy
-     * @param {?} _internalErrorReporter
-     */
     constructor(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
         this._actions = _actions;
         this._actionResults = _actionResults;
@@ -1810,102 +946,50 @@ class InternalDispatcher {
     }
     /**
      * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
      */
     dispatch(actionOrActions) {
-        /** @type {?} */
-        const result = this._ngxsExecutionStrategy.enter((/**
-         * @return {?}
-         */
-        () => this.dispatchByEvents(actionOrActions)));
+        const result = this._ngxsExecutionStrategy.enter(() => this.dispatchByEvents(actionOrActions));
         return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
     }
-    /**
-     * @private
-     * @param {?} actionOrActions
-     * @return {?}
-     */
     dispatchByEvents(actionOrActions) {
         if (Array.isArray(actionOrActions)) {
             if (actionOrActions.length === 0)
                 return of(this._stateStream.getValue());
-            return forkJoin(actionOrActions.map((/**
-             * @param {?} action
-             * @return {?}
-             */
-            action => this.dispatchSingle(action))));
+            return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));
         }
         else {
             return this.dispatchSingle(actionOrActions);
         }
     }
-    /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
     dispatchSingle(action) {
         if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            /** @type {?} */
             const type = getActionTypeFromInstance(action);
             if (!type) {
-                /** @type {?} */
                 const error = new Error(`This action doesn't have a type property: ${action.constructor.name}`);
                 return throwError(error);
             }
         }
-        /** @type {?} */
         const prevState = this._stateStream.getValue();
-        /** @type {?} */
         const plugins = this._pluginManager.plugins;
-        return ((/** @type {?} */ (compose([
+        return compose([
             ...plugins,
-            (/**
-             * @param {?} nextState
-             * @param {?} nextAction
-             * @return {?}
-             */
             (nextState, nextAction) => {
                 if (nextState !== prevState) {
                     this._stateStream.next(nextState);
                 }
-                /** @type {?} */
                 const actionResult$ = this.getActionResultStream(nextAction);
-                actionResult$.subscribe((/**
-                 * @param {?} ctx
-                 * @return {?}
-                 */
-                ctx => this._actions.next(ctx)));
+                actionResult$.subscribe(ctx => this._actions.next(ctx));
                 this._actions.next({ action: nextAction, status: "DISPATCHED" /* Dispatched */ });
                 return this.createDispatchObservable(actionResult$);
-            })
-        ])(prevState, action)))).pipe(shareReplay());
+            }
+        ])(prevState, action).pipe(shareReplay());
     }
-    /**
-     * @private
-     * @param {?} action
-     * @return {?}
-     */
     getActionResultStream(action) {
-        return this._actionResults.pipe(filter((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        (ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* Dispatched */)), take(1), shareReplay());
+        return this._actionResults.pipe(filter((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* Dispatched */), take(1), shareReplay());
     }
-    /**
-     * @private
-     * @param {?} actionResult$
-     * @return {?}
-     */
     createDispatchObservable(actionResult$) {
         return actionResult$
-            .pipe(exhaustMap((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        (ctx) => {
+            .pipe(exhaustMap((ctx) => {
             switch (ctx.status) {
                 case "SUCCESSFUL" /* Successful */:
                     return of(this._stateStream.getValue());
@@ -1914,79 +998,25 @@ class InternalDispatcher {
                 default:
                     return EMPTY;
             }
-        })))
+        }))
             .pipe(shareReplay());
     }
 }
-InternalDispatcher.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-InternalDispatcher.ctorParameters = () => [
-    { type: InternalActions },
-    { type: InternalDispatchedActionResults },
-    { type: PluginManager },
-    { type: StateStream },
-    { type: InternalNgxsExecutionStrategy },
-    { type: InternalErrorReporter }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._actions;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._actionResults;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._pluginManager;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._ngxsExecutionStrategy;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalDispatcher.prototype._internalErrorReporter;
-}
+/** @nocollapse */ InternalDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatcher, deps: [{ token: InternalActions }, { token: InternalDispatchedActionResults }, { token: PluginManager }, { token: StateStream }, { token: InternalNgxsExecutionStrategy }, { token: InternalErrorReporter }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatcher });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatcher, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: InternalActions }, { type: InternalDispatchedActionResults }, { type: PluginManager }, { type: StateStream }, { type: InternalNgxsExecutionStrategy }, { type: InternalErrorReporter }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Object freeze code
  * https://github.com/jsdf/deep-freeze
- * @type {?}
  */
-const deepFreeze = (/**
- * @param {?} o
- * @return {?}
- */
-(o) => {
+const deepFreeze = (o) => {
     Object.freeze(o);
-    /** @type {?} */
     const oIsFunction = typeof o === 'function';
-    /** @type {?} */
     const hasOwnProp = Object.prototype.hasOwnProperty;
-    Object.getOwnPropertyNames(o).forEach((/**
-     * @param {?} prop
-     * @return {?}
-     */
-    function (prop) {
+    Object.getOwnPropertyNames(o).forEach(function (prop) {
         if (hasOwnProp.call(o, prop) &&
             (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
             o[prop] !== null &&
@@ -1994,24 +1024,15 @@ const deepFreeze = (/**
             !Object.isFrozen(o[prop])) {
             deepFreeze(o[prop]);
         }
-    }));
+    });
     return o;
-});
+};
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * State Context factory class
  * @ignore
  */
 class InternalStateOperations {
-    /**
-     * @param {?} _stateStream
-     * @param {?} _dispatcher
-     * @param {?} _config
-     */
     constructor(_stateStream, _dispatcher, _config) {
         this._stateStream = _stateStream;
         this._dispatcher = _dispatcher;
@@ -2019,25 +1040,12 @@ class InternalStateOperations {
     }
     /**
      * Returns the root state operators.
-     * @return {?}
      */
     getRootStateOperations() {
-        /** @type {?} */
         const rootStateOperations = {
-            getState: (/**
-             * @return {?}
-             */
-            () => this._stateStream.getValue()),
-            setState: (/**
-             * @param {?} newState
-             * @return {?}
-             */
-            (newState) => this._stateStream.next(newState)),
-            dispatch: (/**
-             * @param {?} actionOrActions
-             * @return {?}
-             */
-            (actionOrActions) => this._dispatcher.dispatch(actionOrActions))
+            getState: () => this._stateStream.getValue(),
+            setState: (newState) => this._stateStream.next(newState),
+            dispatch: (actionOrActions) => this._dispatcher.dispatch(actionOrActions)
         };
         if (typeof ngDevMode === 'undefined' || ngDevMode) {
             return this._config.developmentMode
@@ -2048,145 +1056,68 @@ class InternalStateOperations {
             return rootStateOperations;
         }
     }
-    /**
-     * @param {?} results
-     * @return {?}
-     */
     setStateToTheCurrentWithNew(results) {
-        /** @type {?} */
         const stateOperations = this.getRootStateOperations();
         // Get our current stream
-        /** @type {?} */
         const currentState = stateOperations.getState();
         // Set the state to the current + new
-        stateOperations.setState(Object.assign({}, currentState, results.defaults));
+        stateOperations.setState(Object.assign(Object.assign({}, currentState), results.defaults));
     }
 }
-InternalStateOperations.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-InternalStateOperations.ctorParameters = () => [
-    { type: StateStream },
-    { type: InternalDispatcher },
-    { type: NgxsConfig }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalStateOperations.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalStateOperations.prototype._dispatcher;
-    /**
-     * @type {?}
-     * @private
-     */
-    InternalStateOperations.prototype._config;
-}
-/**
- * @param {?} root
- * @return {?}
- */
+/** @nocollapse */ InternalStateOperations.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, deps: [{ token: StateStream }, { token: InternalDispatcher }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ InternalStateOperations.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: StateStream }, { type: InternalDispatcher }, { type: NgxsConfig }]; } });
 function ensureStateAndActionsAreImmutable(root) {
     return {
-        getState: (/**
-         * @return {?}
-         */
-        () => root.getState()),
-        setState: (/**
-         * @param {?} value
-         * @return {?}
-         */
-        value => {
-            /** @type {?} */
+        getState: () => root.getState(),
+        setState: value => {
             const frozenValue = deepFreeze(value);
             return root.setState(frozenValue);
-        }),
-        dispatch: (/**
-         * @param {?} actions
-         * @return {?}
-         */
-        actions => {
+        },
+        dispatch: actions => {
             return root.dispatch(actions);
-        })
+        }
     };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @param {?} val
- * @return {?}
- */
-function simplePatch(val) {
-    return (/**
-     * @param {?} existingState
-     * @return {?}
-     */
-    (existingState) => {
-        if (Array.isArray(val)) {
-            throwPatchingArrayError();
-        }
-        else if (typeof val !== 'object') {
-            throwPatchingPrimitiveError();
+function simplePatch(value) {
+    return (existingState) => {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            if (Array.isArray(value)) {
+                throwPatchingArrayError();
+            }
+            else if (typeof value !== 'object') {
+                throwPatchingPrimitiveError();
+            }
         }
-        /** @type {?} */
-        const newState = Object.assign({}, ((/** @type {?} */ (existingState))));
-        for (const key in val) {
+        const newState = Object.assign({}, existingState);
+        for (const key in value) {
             // deep clone for patch compatibility
-            // noinspection JSUnfilteredForInLoop (IDE)
-            newState[key] = ((/** @type {?} */ (val)))[key];
+            newState[key] = value[key];
         }
-        return (/** @type {?} */ (newState));
-    });
+        return newState;
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * State Context factory class
  * @ignore
  */
 class StateContextFactory {
-    /**
-     * @param {?} _internalStateOperations
-     */
     constructor(_internalStateOperations) {
         this._internalStateOperations = _internalStateOperations;
     }
     /**
      * Create the state context
-     * @template T
-     * @param {?} mappedStore
-     * @return {?}
      */
     createStateContext(mappedStore) {
-        /** @type {?} */
         const root = this._internalStateOperations.getRootStateOperations();
-        /**
-         * @param {?} currentAppState
-         * @return {?}
-         */
         function getState(currentAppState) {
             return getValue(currentAppState, mappedStore.path);
         }
-        /**
-         * @param {?} currentAppState
-         * @param {?} newValue
-         * @return {?}
-         */
         function setStateValue(currentAppState, newValue) {
-            /** @type {?} */
             const newAppState = setValue(currentAppState, mappedStore.path, newValue);
             root.setState(newAppState);
             return newAppState;
@@ -2197,93 +1128,43 @@ class StateContextFactory {
             // This needs to be fixed, but is a 'breaking' change.
             // I will do this fix in a subsequent PR and we can decide how to handle it.
         }
-        /**
-         * @param {?} currentAppState
-         * @param {?} stateOperator
-         * @return {?}
-         */
         function setStateFromOperator(currentAppState, stateOperator) {
-            /** @type {?} */
             const local = getState(currentAppState);
-            /** @type {?} */
             const newValue = stateOperator(local);
             return setStateValue(currentAppState, newValue);
         }
-        /**
-         * @param {?} value
-         * @return {?}
-         */
         function isStateOperator(value) {
             return typeof value === 'function';
         }
         return {
-            /**
-             * @return {?}
-             */
             getState() {
-                /** @type {?} */
                 const currentAppState = root.getState();
                 return getState(currentAppState);
             },
-            /**
-             * @param {?} val
-             * @return {?}
-             */
             patchState(val) {
-                /** @type {?} */
                 const currentAppState = root.getState();
-                /** @type {?} */
                 const patchOperator = simplePatch(val);
                 return setStateFromOperator(currentAppState, patchOperator);
             },
-            /**
-             * @param {?} val
-             * @return {?}
-             */
             setState(val) {
-                /** @type {?} */
                 const currentAppState = root.getState();
                 return isStateOperator(val)
                     ? setStateFromOperator(currentAppState, val)
                     : setStateValue(currentAppState, val);
             },
-            /**
-             * @param {?} actions
-             * @return {?}
-             */
             dispatch(actions) {
                 return root.dispatch(actions);
             }
         };
     }
 }
-StateContextFactory.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-StateContextFactory.ctorParameters = () => [
-    { type: InternalStateOperations }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateContextFactory.prototype._internalStateOperations;
-}
+/** @nocollapse */ StateContextFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateContextFactory, deps: [{ token: InternalStateOperations }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ StateContextFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateContextFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateContextFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: InternalStateOperations }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @abstract
- */
 class StoreValidators {
-    /**
-     * @param {?} name
-     * @return {?}
-     */
     static checkThatStateIsNamedCorrectly(name) {
         if (!name) {
             throwStateNamePropertyError();
@@ -2292,88 +1173,112 @@ class StoreValidators {
             throwStateNameError(name);
         }
     }
-    /**
-     * @param {?} stateName
-     * @param {?} state
-     * @param {?} statesByName
-     * @return {?}
-     */
     static checkThatStateNameIsUnique(stateName, state, statesByName) {
-        /** @type {?} */
         const existingState = statesByName[stateName];
         if (existingState && existingState !== state) {
             throwStateUniqueError(stateName, state.name, existingState.name);
         }
     }
-    /**
-     * @param {?} stateClasses
-     * @return {?}
-     */
     static checkThatStateClassesHaveBeenDecorated(stateClasses) {
-        stateClasses.forEach((/**
-         * @param {?} stateClass
-         * @return {?}
-         */
-        (stateClass) => {
-            if (!getStoreMetadata(stateClass)) {
+        stateClasses.forEach((stateClass) => {
+            if (!getStoreMetadata$1(stateClass)) {
                 throwStateDecoratorError(stateClass.name);
             }
-        }));
+        });
     }
 }
 StoreValidators.stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StoreValidators.stateNameRegex;
-}
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * All provided or injected tokens must have `\@Injectable` decorator
- * (previously, injected tokens without `\@Injectable` were allowed
+ * All provided or injected tokens must have `@Injectable` decorator
+ * (previously, injected tokens without `@Injectable` were allowed
  * if another decorator was used, e.g. pipes).
- * @param {?} stateClass
- * @return {?}
  */
 function ensureStateClassIsInjectable(stateClass) {
     // `ɵprov` is a static property added by the NGCC compiler. It always exists in
     // AOT mode because this property is added before runtime. If an application is running in
     // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`
     // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.
-    if (ɵivyEnabled) {
-        /** @type {?} */
-        /** @nocollapse */ const ngInjectableDef = stateClass.ɵprov;
-        if (!ngInjectableDef) {
-            // Don't warn if Ivy is disabled or `ɵprov` exists on the class
-            console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));
-        }
+    const ngInjectableDef = stateClass.ɵprov;
+    if (!ngInjectableDef) {
+        // Don't warn if Ivy is disabled or `ɵprov` exists on the class
+        console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));
     }
 }
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Init action
+ */
+class InitState {
+    static get type() {
+        // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+        return '@@INIT';
+    }
+}
+/**
+ * Update action
  */
+class UpdateState {
+    constructor(addedStates) {
+        this.addedStates = addedStates;
+    }
+    static get type() {
+        // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+        return '@@UPDATE_STATE';
+    }
+}
+
+const NGXS_DEVELOPMENT_OPTIONS = new InjectionToken('NGXS_DEVELOPMENT_OPTIONS', {
+    providedIn: 'root',
+    factory: () => ({ warnOnUnhandledActions: true })
+});
+
+class NgxsUnhandledActionsLogger {
+    constructor(options) {
+        /**
+         * These actions should be ignored by default; the user can increase this
+         * list in the future via the `ignoreActions` method.
+         */
+        this._ignoredActions = new Set([InitState.type, UpdateState.type]);
+        if (typeof options.warnOnUnhandledActions === 'object') {
+            this.ignoreActions(...options.warnOnUnhandledActions.ignore);
+        }
+    }
+    /**
+     * Adds actions to the internal list of actions that should be ignored.
+     */
+    ignoreActions(...actions) {
+        for (const action of actions) {
+            this._ignoredActions.add(action.type);
+        }
+    }
+    /** @internal */
+    warn(action) {
+        const actionShouldBeIgnored = Array.from(this._ignoredActions).some(type => type === getActionTypeFromInstance(action));
+        if (actionShouldBeIgnored) {
+            return;
+        }
+        action =
+            action.constructor && action.constructor.name !== 'Object'
+                ? action.constructor.name
+                : action.type;
+        console.warn(`The ${action} action has been dispatched but hasn't been handled. This may happen if the state with an action handler for this action is not registered.`);
+    }
+}
+/** @nocollapse */ NgxsUnhandledActionsLogger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [{ token: NGXS_DEVELOPMENT_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ NgxsUnhandledActionsLogger.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsUnhandledActionsLogger });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGXS_DEVELOPMENT_OPTIONS]
+                }] }]; } });
+
 /**
  * State factory class
  * @ignore
  */
 class StateFactory {
-    /**
-     * @param {?} _injector
-     * @param {?} _config
-     * @param {?} _parentFactory
-     * @param {?} _actions
-     * @param {?} _actionResults
-     * @param {?} _stateContextFactory
-     * @param {?} _initialState
-     */
     constructor(_injector, _config, _parentFactory, _actions, _actionResults, _stateContextFactory, _initialState) {
         this._injector = _injector;
         this._config = _config;
@@ -2386,91 +1291,52 @@ class StateFactory {
         this._states = [];
         this._statesByName = {};
         this._statePaths = {};
-        this.getRuntimeSelectorContext = memoize((/**
-         * @return {?}
-         */
-        () => {
-            /** @type {?} */
+        this.getRuntimeSelectorContext = memoize(() => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
             const stateFactory = this;
-            /**
-             * @param {?} key
-             * @return {?}
-             */
             function resolveGetter(key) {
-                /** @type {?} */
                 const path = stateFactory.statePaths[key];
                 return path ? propGetter(path.split('.'), stateFactory._config) : null;
             }
-            /** @type {?} */
             const context = this._parentFactory
                 ? this._parentFactory.getRuntimeSelectorContext()
                 : {
-                    /**
-                     * @param {?} key
-                     * @return {?}
-                     */
                     getStateGetter(key) {
-                        /** @type {?} */
                         let getter = resolveGetter(key);
                         if (getter) {
                             return getter;
                         }
-                        return (/**
-                         * @param {...?} args
-                         * @return {?}
-                         */
-                        (...args) => {
+                        return (...args) => {
                             // Late loaded getter
                             if (!getter) {
                                 getter = resolveGetter(key);
                             }
                             return getter ? getter(...args) : undefined;
-                        });
+                        };
                     },
-                    /**
-                     * @param {?=} localOptions
-                     * @return {?}
-                     */
                     getSelectorOptions(localOptions) {
-                        /** @type {?} */
                         const globalSelectorOptions = stateFactory._config.selectorOptions;
-                        return Object.assign({}, globalSelectorOptions, (localOptions || {}));
+                        return Object.assign(Object.assign({}, globalSelectorOptions), (localOptions || {}));
                     }
                 };
             return context;
-        }));
+        });
     }
-    /**
-     * @return {?}
-     */
     get states() {
         return this._parentFactory ? this._parentFactory.states : this._states;
     }
-    /**
-     * @return {?}
-     */
     get statesByName() {
         return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
     }
-    /**
-     * @private
-     * @return {?}
-     */
     get statePaths() {
         return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
     }
-    /**
-     * @private
-     * @param {?} defaults
-     * @return {?}
-     */
     static cloneDefaults(defaults) {
-        /** @type {?} */
         let value = {};
         if (Array.isArray(defaults)) {
             value = defaults.slice();
         }
-        else if (isObject(defaults)) {
+        else if (isObject$1(defaults)) {
             value = Object.assign({}, defaults);
         }
         else if (defaults === undefined) {
@@ -2481,20 +1347,13 @@ class StateFactory {
         }
         return value;
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
-        // I'm using non-null assertion here since `_actionsSubscrition` will
-        // be 100% defined. This is because `ngOnDestroy()` cannot be invoked
-        // on the `StateFactory` until its initialized :) An it's initialized
-        // for the first time along with the `NgxsRootModule`.
-        (/** @type {?} */ (this._actionsSubscription)).unsubscribe();
+        // This is being non-null asserted since `_actionsSubscrition` is
+        // initialized within the constructor.
+        this._actionsSubscription.unsubscribe();
     }
     /**
      * Add a new state to the global defs.
-     * @param {?} stateClasses
-     * @return {?}
      */
     add(stateClasses) {
         // Caretaker note: we have still left the `typeof` condition in order to avoid
@@ -2505,23 +1364,15 @@ class StateFactory {
         const { newStates } = this.addToStatesMap(stateClasses);
         if (!newStates.length)
             return [];
-        /** @type {?} */
         const stateGraph = buildGraph(newStates);
-        /** @type {?} */
         const sortedStates = topologicalSort(stateGraph);
-        /** @type {?} */
         const paths = findFullParentPath(stateGraph);
-        /** @type {?} */
         const nameGraph = nameToState(newStates);
-        /** @type {?} */
         const bootstrappedStores = [];
         for (const name of sortedStates) {
-            /** @type {?} */
             const stateClass = nameGraph[name];
-            /** @type {?} */
             const path = paths[name];
-            /** @type {?} */
-            const meta = (/** @type {?} */ (stateClass[META_KEY]));
+            const meta = stateClass[META_KEY];
             this.addRuntimeInfoToMeta(meta, path);
             // Note: previously we called `ensureStateClassIsInjectable` within the
             // `State` decorator. This check is moved here because the `ɵprov` property
@@ -2530,7 +1381,6 @@ class StateFactory {
             if (typeof ngDevMode === 'undefined' || ngDevMode) {
                 ensureStateClassIsInjectable(stateClass);
             }
-            /** @type {?} */
             const stateMap = {
                 name,
                 path,
@@ -2551,80 +1401,43 @@ class StateFactory {
     }
     /**
      * Add a set of states to the store and return the defaults
-     * @param {?} stateClasses
-     * @return {?}
      */
     addAndReturnDefaults(stateClasses) {
-        /** @type {?} */
         const classes = stateClasses || [];
-        /** @type {?} */
         const mappedStores = this.add(classes);
-        /** @type {?} */
-        const defaults = mappedStores.reduce((/**
-         * @param {?} result
-         * @param {?} mappedStore
-         * @return {?}
-         */
-        (result, mappedStore) => setValue(result, mappedStore.path, mappedStore.defaults)), {});
+        const defaults = mappedStores.reduce((result, mappedStore) => setValue(result, mappedStore.path, mappedStore.defaults), {});
         return { defaults, states: mappedStores };
     }
     /**
      * Bind the actions to the handlers
-     * @return {?}
      */
     connectActionHandlers() {
         if (this._actionsSubscription !== null)
             return;
-        /** @type {?} */
         const dispatched$ = new Subject();
         this._actionsSubscription = this._actions
-            .pipe(filter((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        (ctx) => ctx.status === "DISPATCHED" /* Dispatched */)), mergeMap((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        ctx => {
+            .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* Dispatched */), mergeMap(ctx => {
             dispatched$.next(ctx);
-            /** @type {?} */
             const action = ctx.action;
-            return this.invokeActions(dispatched$, (/** @type {?} */ (action))).pipe(map((/**
-             * @return {?}
-             */
-            () => (/** @type {?} */ ({ action, status: "SUCCESSFUL" /* Successful */ })))), defaultIfEmpty((/** @type {?} */ ({ action, status: "CANCELED" /* Canceled */ }))), catchError((/**
-             * @param {?} error
-             * @return {?}
-             */
-            error => of((/** @type {?} */ ({ action, status: "ERRORED" /* Errored */, error }))))));
-        })))
-            .subscribe((/**
-         * @param {?} ctx
-         * @return {?}
-         */
-        ctx => this._actionResults.next(ctx)));
+            return this.invokeActions(dispatched$, action).pipe(map(() => ({ action, status: "SUCCESSFUL" /* Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* Canceled */ }), catchError(error => of({ action, status: "ERRORED" /* Errored */, error })));
+        }))
+            .subscribe(ctx => this._actionResults.next(ctx));
     }
     /**
      * Invoke actions on the states.
-     * @param {?} dispatched$
-     * @param {?} action
-     * @return {?}
      */
     invokeActions(dispatched$, action) {
-        /** @type {?} */
-        const type = (/** @type {?} */ (getActionTypeFromInstance(action)));
-        /** @type {?} */
+        const type = getActionTypeFromInstance(action);
         const results = [];
+        // Determines whether the dispatched action has been handled, this is assigned
+        // to `true` within the below `for` loop if any `actionMetas` has been found.
+        let actionHasBeenHandled = false;
         for (const metadata of this.states) {
-            /** @type {?} */
             const actionMetas = metadata.actions[type];
             if (actionMetas) {
                 for (const actionMeta of actionMetas) {
-                    /** @type {?} */
                     const stateContext = this._stateContextFactory.createStateContext(metadata);
                     try {
-                        /** @type {?} */
                         let result = metadata.instance[actionMeta.fn](stateContext, action);
                         if (result instanceof Promise) {
                             result = from(result);
@@ -2638,11 +1451,7 @@ class StateFactory {
                             // `handler(ctx) { return EMPTY; }`
                             // then the action will be canceled.
                             // See https://github.com/ngxs/store/issues/1568
-                            result = result.pipe(mergeMap((/**
-                             * @param {?} value
-                             * @return {?}
-                             */
-                            (value) => {
+                            result = result.pipe(mergeMap((value) => {
                                 if (value instanceof Promise) {
                                     return from(value);
                                 }
@@ -2650,10 +1459,10 @@ class StateFactory {
                                     return value;
                                 }
                                 return of(value);
-                            })), defaultIfEmpty({}));
+                            }), defaultIfEmpty({}));
                             if (actionMeta.options.cancelUncompleted) {
                                 // todo: ofActionDispatched should be used with action class
-                                result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
+                                result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched(action))));
                             }
                         }
                         else {
@@ -2664,33 +1473,36 @@ class StateFactory {
                     catch (e) {
                         results.push(throwError(e));
                     }
+                    actionHasBeenHandled = true;
                 }
             }
         }
+        // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
+        // only during development.
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !actionHasBeenHandled) {
+            const unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);
+            // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the
+            // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`
+            // didn't return `null` so we may ensure the module has been imported.
+            if (unhandledActionsLogger) {
+                unhandledActionsLogger.warn(action);
+            }
+        }
         if (!results.length) {
             results.push(of({}));
         }
         return forkJoin(results);
     }
-    /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
     addToStatesMap(stateClasses) {
-        /** @type {?} */
         const newStates = [];
-        /** @type {?} */
         const statesMap = this.statesByName;
         for (const stateClass of stateClasses) {
-            /** @type {?} */
-            const stateName = (/** @type {?} */ (getStoreMetadata(stateClass).name));
+            const stateName = getStoreMetadata$1(stateClass).name;
             // Caretaker note: we have still left the `typeof` condition in order to avoid
             // creating a breaking change for projects that still use the View Engine.
             if (typeof ngDevMode === 'undefined' || ngDevMode) {
                 StoreValidators.checkThatStateNameIsUnique(stateName, stateClass, statesMap);
             }
-            /** @type {?} */
             const unmountedState = !statesMap[stateName];
             if (unmountedState) {
                 newStates.push(stateClass);
@@ -2699,210 +1511,51 @@ class StateFactory {
         }
         return { newStates };
     }
-    /**
-     * @private
-     * @param {?} meta
-     * @param {?} path
-     * @return {?}
-     */
     addRuntimeInfoToMeta(meta, path) {
-        this.statePaths[(/** @type {?} */ (meta.name))] = path;
+        this.statePaths[meta.name] = path;
         // TODO: v4 - we plan to get rid of the path property because it is non-deterministic
         // we can do this when we get rid of the incorrectly exposed getStoreMetadata
         // We will need to come up with an alternative in v4 because this is used by many plugins
         meta.path = path;
     }
     /**
-     * \@description
+     * @description
      * the method checks if the state has already been added to the tree
      * and completed the life cycle
-     * @private
-     * @param {?} name
-     * @param {?} path
-     * @return {?}
+     * @param name
+     * @param path
      */
     hasBeenMountedAndBootstrapped(name, path) {
-        /** @type {?} */
         const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
         return this.statesByName[name] && valueIsBootstrappedInInitialState;
     }
 }
-StateFactory.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-StateFactory.ctorParameters = () => [
-    { type: Injector },
-    { type: NgxsConfig },
-    { type: StateFactory, decorators: [{ type: Optional }, { type: SkipSelf }] },
-    { type: InternalActions },
-    { type: InternalDispatchedActionResults },
-    { type: StateContextFactory },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actionsSubscription;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._states;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._statesByName;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._statePaths;
-    /** @type {?} */
-    StateFactory.prototype.getRuntimeSelectorContext;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._injector;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._config;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._parentFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actions;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._actionResults;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._stateContextFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    StateFactory.prototype._initialState;
-}
+/** @nocollapse */ StateFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory, deps: [{ token: i0.Injector }, { token: NgxsConfig }, { token: StateFactory, optional: true, skipSelf: true }, { token: InternalActions }, { token: InternalDispatchedActionResults }, { token: StateContextFactory }, { token: INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ StateFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: NgxsConfig }, { type: StateFactory, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: InternalActions }, { type: InternalDispatchedActionResults }, { type: StateContextFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INITIAL_STATE_TOKEN]
+                }] }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-const SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';
-/** @type {?} */
-const selectorOptionsMetaAccessor = {
-    getOptions: (/**
-     * @param {?} target
-     * @return {?}
-     */
-    (target) => {
-        return (target && ((/** @type {?} */ (target)))[SELECTOR_OPTIONS_META_KEY]) || {};
-    }),
-    defineOptions: (/**
-     * @param {?} target
-     * @param {?} options
-     * @return {?}
-     */
-    (target, options) => {
-        if (!target)
-            return;
-        ((/** @type {?} */ (target)))[SELECTOR_OPTIONS_META_KEY] = options;
-    })
-};
-/**
- * @record
- */
-function CreationMetadata() { }
-if (false) {
-    /** @type {?} */
-    CreationMetadata.prototype.containerClass;
-    /** @type {?} */
-    CreationMetadata.prototype.selectorName;
-    /** @type {?|undefined} */
-    CreationMetadata.prototype.getSelectorOptions;
-}
-/**
- * @record
- */
-function RuntimeSelectorInfo() { }
-if (false) {
-    /** @type {?} */
-    RuntimeSelectorInfo.prototype.selectorOptions;
-    /** @type {?} */
-    RuntimeSelectorInfo.prototype.argumentSelectorFunctions;
-}
-/**
- * Function for creating a selector
- * @template T
- * @param {?} selectors The selectors to use to create the arguments of this function
- * @param {?} originalFn The original function being made into a selector
- * @param {?=} creationMetadata
- * @return {?}
- */
-function createSelector(selectors, originalFn, creationMetadata) {
-    /** @type {?} */
-    const containerClass = creationMetadata && creationMetadata.containerClass;
-    /** @type {?} */
-    const wrappedFn = (/** @type {?} */ ((/**
-     * @param {...?} args
-     * @return {?}
-     */
-    function wrappedSelectorFn(...args) {
-        /** @type {?} */
-        const returnValue = originalFn.apply(containerClass, args);
-        if (returnValue instanceof Function) {
-            /** @type {?} */
-            const innerMemoizedFn = memoize.apply(null, [returnValue]);
-            return innerMemoizedFn;
-        }
-        return returnValue;
-    })));
-    /** @type {?} */
-    const memoizedFn = memoize(wrappedFn);
-    Object.setPrototypeOf(memoizedFn, originalFn);
-    /** @type {?} */
-    const selectorMetaData = setupSelectorMetadata(originalFn, creationMetadata);
-    /** @type {?} */
-    const makeRootSelector = (/**
-     * @param {?} context
-     * @return {?}
-     */
-    (context) => {
+function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
+    return (context) => {
         const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);
-        return (/**
-         * @param {?} rootState
-         * @return {?}
-         */
-        function selectFromRoot(rootState) {
+        return function selectFromRoot(rootState) {
             // Determine arguments from the app state using the selectors
-            /** @type {?} */
-            const results = argumentSelectorFunctions.map((/**
-             * @param {?} argFn
-             * @return {?}
-             */
-            argFn => argFn(rootState)));
+            const results = argumentSelectorFunctions.map((argFn) => argFn(rootState));
             // if the lambda tries to access a something on the
             // state that doesn't exist, it will throw a TypeError.
             // since this is quite usual behaviour, we simply return undefined if so.
             try {
-                return memoizedFn(...results);
+                return memoizedSelectorFn(...results);
             }
             catch (ex) {
                 if (ex instanceof TypeError && selectorOptions.suppressErrors) {
@@ -2910,91 +1563,42 @@ function createSelector(selectors, originalFn, creationMetadata) {
                 }
                 throw ex;
             }
-        });
-    });
-    selectorMetaData.makeRootSelector = makeRootSelector;
-    return memoizedFn;
+        };
+    };
 }
-/**
- * @template T
- * @param {?} originalFn
- * @param {?} creationMetadata
- * @return {?}
- */
-function setupSelectorMetadata(originalFn, creationMetadata) {
-    /** @type {?} */
-    const selectorMetaData = ensureSelectorMetadata(originalFn);
-    selectorMetaData.originalFn = originalFn;
-    /** @type {?} */
-    let getExplicitSelectorOptions = (/**
-     * @return {?}
-     */
-    () => ({}));
-    if (creationMetadata) {
-        selectorMetaData.containerClass = creationMetadata.containerClass;
-        selectorMetaData.selectorName = creationMetadata.selectorName;
-        getExplicitSelectorOptions =
-            creationMetadata.getSelectorOptions || getExplicitSelectorOptions;
-    }
-    /** @type {?} */
-    const selectorMetaDataClone = Object.assign({}, selectorMetaData);
-    selectorMetaData.getSelectorOptions = (/**
-     * @return {?}
-     */
-    () => getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions()));
-    return selectorMetaData;
+function createMemoizedSelectorFn(originalFn, creationMetadata) {
+    const containerClass = creationMetadata && creationMetadata.containerClass;
+    const wrappedFn = function wrappedSelectorFn(...args) {
+        const returnValue = originalFn.apply(containerClass, args);
+        if (returnValue instanceof Function) {
+            const innerMemoizedFn = memoize.apply(null, [returnValue]);
+            return innerMemoizedFn;
+        }
+        return returnValue;
+    };
+    const memoizedFn = memoize(wrappedFn);
+    Object.setPrototypeOf(memoizedFn, originalFn);
+    return memoizedFn;
 }
-/**
- * @param {?} context
- * @param {?} selectorMetaData
- * @param {?=} selectors
- * @return {?}
- */
 function getRuntimeSelectorInfo(context, selectorMetaData, selectors = []) {
-    /** @type {?} */
     const localSelectorOptions = selectorMetaData.getSelectorOptions();
-    /** @type {?} */
     const selectorOptions = context.getSelectorOptions(localSelectorOptions);
-    /** @type {?} */
     const selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);
-    /** @type {?} */
-    const argumentSelectorFunctions = selectorsToApply.map((/**
-     * @param {?} selector
-     * @return {?}
-     */
-    selector => {
-        /** @type {?} */
+    const argumentSelectorFunctions = selectorsToApply.map((selector) => {
         const factory = getRootSelectorFactory(selector);
         return factory(context);
-    }));
+    });
     return {
         selectorOptions,
-        argumentSelectorFunctions
+        argumentSelectorFunctions,
     };
 }
-/**
- * @param {?} selectorMetaData
- * @param {?} explicitOptions
- * @return {?}
- */
-function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
-    return Object.assign({}, (selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {}), (selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {}), (selectorMetaData.getSelectorOptions() || {}), explicitOptions);
-}
-/**
- * @param {?=} selectors
- * @param {?=} selectorOptions
- * @param {?=} containerClass
- * @return {?}
- */
 function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
-    /** @type {?} */
     const selectorsToApply = [];
-    /** @type {?} */
     const canInjectContainerState = selectors.length === 0 || selectorOptions.injectContainerState;
     if (containerClass && canInjectContainerState) {
         // If we are on a state class, add it as the first selector parameter
-        /** @type {?} */
-        const metadata = getStoreMetadata(containerClass);
+        const metadata = getStoreMetadata$1(containerClass);
         if (metadata) {
             selectorsToApply.push(containerClass);
         }
@@ -3007,31 +1611,14 @@ function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
 /**
  * This function gets the factory function to create the selector to get the selected slice from the app state
  * @ignore
- * @param {?} selector
- * @return {?}
  */
 function getRootSelectorFactory(selector) {
-    /** @type {?} */
-    const metadata = getSelectorMetadata(selector) || getStoreMetadata(selector);
-    return (metadata && metadata.makeRootSelector) || ((/**
-     * @return {?}
-     */
-    () => selector));
+    const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);
+    return (metadata && metadata.makeRootSelector) || (() => selector);
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+// tslint:disable:unified-signatures
 class Store {
-    /**
-     * @param {?} _stateStream
-     * @param {?} _internalStateOperations
-     * @param {?} _config
-     * @param {?} _internalExecutionStrategy
-     * @param {?} _stateFactory
-     * @param {?} initialStateValue
-     */
     constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
         this._stateStream = _stateStream;
         this._internalStateOperations = _internalStateOperations;
@@ -3043,29 +1630,18 @@ class Store {
          * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
          * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
          */
-        this._selectableStateStream = this._stateStream.pipe(observeOn(queueScheduler), leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
+        this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
         this.initStateStream(initialStateValue);
     }
     /**
      * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
      */
     dispatch(actionOrActions) {
         return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
     }
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
     select(selector) {
-        /** @type {?} */
         const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._selectableStateStream.pipe(map(selectorFn), catchError((/**
-         * @param {?} err
-         * @return {?}
-         */
-        (err) => {
+        return this._selectableStateStream.pipe(map(selectorFn), catchError((err) => {
             // if error is TypeError we swallow it to prevent usual errors with property access
             const { suppressErrors } = this._config.selectorOptions;
             if (err instanceof TypeError && suppressErrors) {
@@ -3073,28 +1649,17 @@ class Store {
             }
             // rethrow other errors
             return throwError(err);
-        })), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
+        }), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
     }
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
     selectOnce(selector) {
         return this.select(selector).pipe(take(1));
     }
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
     selectSnapshot(selector) {
-        /** @type {?} */
         const selectorFn = this.getStoreBoundSelectorFn(selector);
         return selectorFn(this._stateStream.getValue());
     }
     /**
      * Allow the user to subscribe to the root of the state
-     * @param {?=} fn
-     * @return {?}
      */
     subscribe(fn) {
         return this._selectableStateStream
@@ -3103,7 +1668,6 @@ class Store {
     }
     /**
      * Return the raw value of the state.
-     * @return {?}
      */
     snapshot() {
         return this._internalStateOperations.getRootStateOperations().getState();
@@ -3111,104 +1675,38 @@ class Store {
     /**
      * Reset the state to a specific point in time. This method is useful
      * for plugin's who need to modify the state directly or unit testing.
-     * @param {?} state
-     * @return {?}
      */
     reset(state) {
         return this._internalStateOperations.getRootStateOperations().setState(state);
     }
-    /**
-     * @private
-     * @param {?} selector
-     * @return {?}
-     */
     getStoreBoundSelectorFn(selector) {
-        /** @type {?} */
         const makeSelectorFn = getRootSelectorFactory(selector);
-        /** @type {?} */
         const runtimeContext = this._stateFactory.getRuntimeSelectorContext();
         return makeSelectorFn(runtimeContext);
     }
-    /**
-     * @private
-     * @param {?} initialStateValue
-     * @return {?}
-     */
     initStateStream(initialStateValue) {
-        /** @type {?} */
         const value = this._stateStream.value;
-        /** @type {?} */
         const storeIsEmpty = !value || Object.keys(value).length === 0;
         if (storeIsEmpty) {
-            /** @type {?} */
             const defaultStateNotEmpty = Object.keys(this._config.defaultsState).length > 0;
-            /** @type {?} */
             const storeValues = defaultStateNotEmpty
-                ? Object.assign({}, this._config.defaultsState, initialStateValue) : initialStateValue;
+                ? Object.assign(Object.assign({}, this._config.defaultsState), initialStateValue) : initialStateValue;
             this._stateStream.next(storeValues);
         }
     }
 }
-Store.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-Store.ctorParameters = () => [
-    { type: StateStream },
-    { type: InternalStateOperations },
-    { type: NgxsConfig },
-    { type: InternalNgxsExecutionStrategy },
-    { type: StateFactory },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
-];
-if (false) {
-    /**
-     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-     * @type {?}
-     * @private
-     */
-    Store.prototype._selectableStateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._internalStateOperations;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._config;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._internalExecutionStrategy;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._stateFactory;
-}
+/** @nocollapse */ Store.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Store, deps: [{ token: StateStream }, { token: InternalStateOperations }, { token: NgxsConfig }, { token: InternalNgxsExecutionStrategy }, { token: StateFactory }, { token: INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ Store.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Store });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Store, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: StateStream }, { type: InternalStateOperations }, { type: NgxsConfig }, { type: InternalNgxsExecutionStrategy }, { type: StateFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INITIAL_STATE_TOKEN]
+                }] }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class LifecycleStateManager {
-    /**
-     * @param {?} _store
-     * @param {?} _internalErrorReporter
-     * @param {?} _internalStateOperations
-     * @param {?} _stateContextFactory
-     * @param {?} _bootstrapper
-     */
     constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
         this._store = _store;
         this._internalErrorReporter = _internalErrorReporter;
@@ -3217,78 +1715,34 @@ class LifecycleStateManager {
         this._bootstrapper = _bootstrapper;
         this._destroy$ = new Subject();
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         this._destroy$.next();
     }
-    /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
     ngxsBootstrap(action, results) {
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter((/**
-         * @return {?}
-         */
-        () => !!results)), tap((/**
-         * @return {?}
-         */
-        () => this._invokeInitOnStates((/** @type {?} */ (results)).states))), mergeMap((/**
-         * @return {?}
-         */
-        () => this._bootstrapper.appBootstrapped$)), filter((/**
-         * @param {?} appBootstrapped
-         * @return {?}
-         */
-        appBootstrapped => !!appBootstrapped)), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        error => {
+            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._bootstrapper.appBootstrapped$), filter(appBootstrapped => !!appBootstrapped), catchError(error => {
             // The `SafeSubscriber` (which is used by most RxJS operators) re-throws
             // errors asynchronously (`setTimeout(() => { throw error })`). This might
             // break existing user's code or unit tests. We catch the error manually to
             // be backward compatible with the old behavior.
             this._internalErrorReporter.reportErrorSafely(error);
             return EMPTY;
-        })), takeUntil(this._destroy$))
-            .subscribe((/**
-         * @return {?}
-         */
-        () => this._invokeBootstrapOnStates((/** @type {?} */ (results)).states)));
+        }), takeUntil(this._destroy$))
+            .subscribe(() => this._invokeBootstrapOnStates(results.states));
     }
-    /**
-     * @private
-     * @param {?} mappedStores
-     * @return {?}
-     */
     _invokeInitOnStates(mappedStores) {
         for (const mappedStore of mappedStores) {
-            /** @type {?} */
             const instance = mappedStore.instance;
             if (instance.ngxsOnChanges) {
                 this._store
-                    .select((/**
-                 * @param {?} state
-                 * @return {?}
-                 */
-                state => getValue(state, mappedStore.path)))
+                    .select(state => getValue(state, mappedStore.path))
                     .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))
-                    .subscribe((/**
-                 * @param {?} __0
-                 * @return {?}
-                 */
-                ([previousValue, currentValue]) => {
-                    /** @type {?} */
+                    .subscribe(([previousValue, currentValue]) => {
                     const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
-                    (/** @type {?} */ (instance.ngxsOnChanges))(change);
-                }));
+                    instance.ngxsOnChanges(change);
+                });
             }
             if (instance.ngxsOnInit) {
                 instance.ngxsOnInit(this._getStateContext(mappedStore));
@@ -3296,93 +1750,33 @@ class LifecycleStateManager {
             mappedStore.isInitialised = true;
         }
     }
-    /**
-     * @private
-     * @param {?} mappedStores
-     * @return {?}
-     */
     _invokeBootstrapOnStates(mappedStores) {
         for (const mappedStore of mappedStores) {
-            /** @type {?} */
             const instance = mappedStore.instance;
             if (instance.ngxsAfterBootstrap) {
                 instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));
             }
         }
     }
-    /**
-     * @private
-     * @param {?} mappedStore
-     * @return {?}
-     */
     _getStateContext(mappedStore) {
         return this._stateContextFactory.createStateContext(mappedStore);
     }
 }
-LifecycleStateManager.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-LifecycleStateManager.ctorParameters = () => [
-    { type: Store },
-    { type: InternalErrorReporter },
-    { type: InternalStateOperations },
-    { type: StateContextFactory },
-    { type: NgxsBootstrapper }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._destroy$;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._store;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._internalErrorReporter;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._internalStateOperations;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._stateContextFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype._bootstrapper;
-}
+/** @nocollapse */ LifecycleStateManager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LifecycleStateManager, deps: [{ token: Store }, { token: InternalErrorReporter }, { token: InternalStateOperations }, { token: StateContextFactory }, { token: i5.NgxsBootstrapper }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ LifecycleStateManager.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LifecycleStateManager });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LifecycleStateManager, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Store }, { type: InternalErrorReporter }, { type: InternalStateOperations }, { type: StateContextFactory }, { type: i5.NgxsBootstrapper }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Allows the select decorator to get access to the DI store, this is used internally
- * in `\@Select` decorator.
+ * in `@Select` decorator.
  */
 class SelectFactory {
-    /**
-     * @param {?} store
-     * @param {?} config
-     */
     constructor(store, config) {
         SelectFactory.store = store;
         SelectFactory.config = config;
     }
-    /**
-     * @return {?}
-     */
     ngOnDestroy() {
         SelectFactory.store = null;
         SelectFactory.config = null;
@@ -3390,80 +1784,19 @@ class SelectFactory {
 }
 SelectFactory.store = null;
 SelectFactory.config = null;
-SelectFactory.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-SelectFactory.ctorParameters = () => [
-    { type: Store },
-    { type: NgxsConfig }
-];
-if (false) {
-    /** @type {?} */
-    SelectFactory.store;
-    /** @type {?} */
-    SelectFactory.config;
-}
+/** @nocollapse */ SelectFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectFactory, deps: [{ token: Store }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ SelectFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: Store }, { type: NgxsConfig }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Init action
- */
-class InitState {
-    /**
-     * @return {?}
-     */
-    static get type() {
-        // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-        return '@@INIT';
-    }
-}
-/**
- * Update action
- */
-class UpdateState {
-    /**
-     * @param {?=} addedStates
-     */
-    constructor(addedStates) {
-        this.addedStates = addedStates;
-    }
-    /**
-     * @return {?}
-     */
-    static get type() {
-        // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-        return '@@UPDATE_STATE';
-    }
-}
-if (false) {
-    /** @type {?} */
-    UpdateState.prototype.addedStates;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Root module
  * @ignore
  */
 class NgxsRootModule {
-    /**
-     * @param {?} factory
-     * @param {?} internalStateOperations
-     * @param {?} _store
-     * @param {?} _select
-     * @param {?=} states
-     * @param {?=} lifecycleStateManager
-     */
     constructor(factory, internalStateOperations, _store, _select, states = [], lifecycleStateManager) {
         // Add stores to the state graph and return their defaults
-        /** @type {?} */
         const results = factory.addAndReturnDefaults(states);
         internalStateOperations.setStateToTheCurrentWithNew(results);
         // Connect our actions stream
@@ -3472,42 +1805,28 @@ class NgxsRootModule {
         lifecycleStateManager.ngxsBootstrap(new InitState(), results);
     }
 }
-NgxsRootModule.decorators = [
-    { type: NgModule }
-];
-/** @nocollapse */
-NgxsRootModule.ctorParameters = () => [
-    { type: StateFactory },
-    { type: InternalStateOperations },
-    { type: Store },
-    { type: SelectFactory },
-    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [ROOT_STATE_TOKEN,] }] },
-    { type: LifecycleStateManager }
-];
+/** @nocollapse */ NgxsRootModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule, deps: [{ token: StateFactory }, { token: InternalStateOperations }, { token: Store }, { token: SelectFactory }, { token: ROOT_STATE_TOKEN, optional: true }, { token: LifecycleStateManager }], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsRootModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule });
+/** @nocollapse */ NgxsRootModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule, decorators: [{
+            type: NgModule
+        }], ctorParameters: function () { return [{ type: StateFactory }, { type: InternalStateOperations }, { type: Store }, { type: SelectFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ROOT_STATE_TOKEN]
+                }] }, { type: LifecycleStateManager }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Feature module
  * @ignore
  */
 class NgxsFeatureModule {
-    /**
-     * @param {?} _store
-     * @param {?} internalStateOperations
-     * @param {?} factory
-     * @param {?=} states
-     * @param {?=} lifecycleStateManager
-     */
     constructor(_store, internalStateOperations, factory, states = [], lifecycleStateManager) {
         // Since FEATURE_STATE_TOKEN is a multi token, we need to
         // flatten it [[Feature1State, Feature2State], [Feature3State]]
-        /** @type {?} */
         const flattenedStates = NgxsFeatureModule.flattenStates(states);
         // add stores to the state graph and return their defaults
-        /** @type {?} */
         const results = factory.addAndReturnDefaults(flattenedStates);
         if (results.states.length) {
             internalStateOperations.setStateToTheCurrentWithNew(results);
@@ -3515,45 +1834,28 @@ class NgxsFeatureModule {
             lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);
         }
     }
-    /**
-     * @private
-     * @param {?=} states
-     * @return {?}
-     */
     static flattenStates(states = []) {
-        return states.reduce((/**
-         * @param {?} total
-         * @param {?} values
-         * @return {?}
-         */
-        (total, values) => total.concat(values)), []);
-    }
-}
-NgxsFeatureModule.decorators = [
-    { type: NgModule }
-];
-/** @nocollapse */
-NgxsFeatureModule.ctorParameters = () => [
-    { type: Store },
-    { type: InternalStateOperations },
-    { type: StateFactory },
-    { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [FEATURE_STATE_TOKEN,] }] },
-    { type: LifecycleStateManager }
-];
+        return states.reduce((total, values) => total.concat(values), []);
+    }
+}
+/** @nocollapse */ NgxsFeatureModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule, deps: [{ token: Store }, { token: InternalStateOperations }, { token: StateFactory }, { token: FEATURE_STATE_TOKEN, optional: true }, { token: LifecycleStateManager }], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsFeatureModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule });
+/** @nocollapse */ NgxsFeatureModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule, decorators: [{
+            type: NgModule
+        }], ctorParameters: function () { return [{ type: Store }, { type: InternalStateOperations }, { type: StateFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FEATURE_STATE_TOKEN]
+                }] }, { type: LifecycleStateManager }]; } });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Ngxs Module
  */
 class NgxsModule {
     /**
      * Root module factory
-     * @param {?=} states
-     * @param {?=} options
-     * @return {?}
      */
     static forRoot(states = [], options = {}) {
         return {
@@ -3580,8 +1882,6 @@ class NgxsModule {
     }
     /**
      * Feature module factory
-     * @param {?=} states
-     * @return {?}
      */
     static forFeature(states = []) {
         return {
@@ -3598,12 +1898,6 @@ class NgxsModule {
             ]
         };
     }
-    /**
-     * @private
-     * @param {?} states
-     * @param {?} options
-     * @return {?}
-     */
     static ngxsTokenProviders(states, options) {
         return [
             {
@@ -3634,87 +1928,51 @@ class NgxsModule {
                 useFactory: NgxsModule.getInitialState
             },
             {
-                provide: NGXS_STATE_CONTEXT_FACTORY,
+                provide: ɵNGXS_STATE_CONTEXT_FACTORY,
                 useExisting: StateContextFactory
             },
             {
-                provide: NGXS_STATE_FACTORY,
+                provide: ɵNGXS_STATE_FACTORY,
                 useExisting: StateFactory
             }
         ];
     }
-    /**
-     * @private
-     * @param {?} options
-     * @return {?}
-     */
     static ngxsConfigFactory(options) {
         return mergeDeep(new NgxsConfig(), options);
     }
-    /**
-     * @private
-     * @param {?} bootstrapper
-     * @return {?}
-     */
     static appBootstrapListenerFactory(bootstrapper) {
-        return (/**
-         * @return {?}
-         */
-        () => bootstrapper.bootstrap());
+        return () => bootstrapper.bootstrap();
     }
-    /**
-     * @private
-     * @return {?}
-     */
     static getInitialState() {
         return InitialState.pop();
     }
 }
 NgxsModule.ROOT_OPTIONS = new InjectionToken('ROOT_OPTIONS');
-NgxsModule.decorators = [
-    { type: NgModule }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    NgxsModule.ROOT_OPTIONS;
-}
+/** @nocollapse */ NgxsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule });
+/** @nocollapse */ NgxsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule, decorators: [{
+            type: NgModule
+        }] });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Decorates a method with a action information.
- * @param {?} actions
- * @param {?=} options
- * @return {?}
  */
 function Action(actions, options) {
-    return (/**
-     * @param {?} target
-     * @param {?} name
-     * @return {?}
-     */
-    (target, name) => {
+    return (target, name) => {
         // Caretaker note: we have still left the `typeof` condition in order to avoid
         // creating a breaking change for projects that still use the View Engine.
         if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            /** @type {?} */
             const isStaticMethod = target.hasOwnProperty('prototype');
             if (isStaticMethod) {
                 throwActionDecoratorError();
             }
         }
-        /** @type {?} */
-        const meta = ensureStoreMetadata(target.constructor);
+        const meta = ensureStoreMetadata$1(target.constructor);
         if (!Array.isArray(actions)) {
             actions = [actions];
         }
         for (const action of actions) {
-            /** @type {?} */
             const type = action.type;
             if (!meta.actions[type]) {
                 meta.actions[type] = [];
@@ -3725,50 +1983,20 @@ function Action(actions, options) {
                 type
             });
         }
-    });
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- * @template T
- */
-function MutateMetaOptions() { }
-if (false) {
-    /** @type {?} */
-    MutateMetaOptions.prototype.meta;
-    /** @type {?} */
-    MutateMetaOptions.prototype.inheritedStateClass;
-    /** @type {?} */
-    MutateMetaOptions.prototype.optionsWithInheritance;
-}
 /**
  * Decorates a class with ngxs state information.
- * @template T
- * @param {?} options
- * @return {?}
  */
 function State(options) {
-    /**
-     * @param {?} inheritedStateClass
-     * @return {?}
-     */
     function getStateOptions(inheritedStateClass) {
-        /** @type {?} */
         const inheritanceOptions = inheritedStateClass[META_OPTIONS_KEY] || {};
-        return (/** @type {?} */ (Object.assign({}, inheritanceOptions, options)));
+        return Object.assign(Object.assign({}, inheritanceOptions), options);
     }
-    /**
-     * @param {?} params
-     * @return {?}
-     */
     function mutateMetaData(params) {
         const { meta, inheritedStateClass, optionsWithInheritance } = params;
         const { children, defaults, name } = optionsWithInheritance;
-        /** @type {?} */
         const stateName = typeof name === 'string' ? name : (name && name.getName()) || null;
         // Caretaker note: we have still left the `typeof` condition in order to avoid
         // creating a breaking change for projects that still use the View Engine.
@@ -3776,102 +2004,56 @@ function State(options) {
             StoreValidators.checkThatStateIsNamedCorrectly(stateName);
         }
         if (inheritedStateClass.hasOwnProperty(META_KEY)) {
-            /** @type {?} */
             const inheritedMeta = inheritedStateClass[META_KEY] || {};
-            meta.actions = Object.assign({}, meta.actions, inheritedMeta.actions);
+            meta.actions = Object.assign(Object.assign({}, meta.actions), inheritedMeta.actions);
         }
         meta.children = children;
         meta.defaults = defaults;
         meta.name = stateName;
     }
-    return (/**
-     * @param {?} target
-     * @return {?}
-     */
-    (target) => {
-        /** @type {?} */
+    return (target) => {
         const stateClass = target;
-        /** @type {?} */
-        const meta = ensureStoreMetadata(stateClass);
-        /** @type {?} */
+        const meta = ensureStoreMetadata$1(stateClass);
         const inheritedStateClass = Object.getPrototypeOf(stateClass);
-        /** @type {?} */
         const optionsWithInheritance = getStateOptions(inheritedStateClass);
         mutateMetaData({ meta, inheritedStateClass, optionsWithInheritance });
         stateClass[META_OPTIONS_KEY] = optionsWithInheritance;
-    });
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const DOLLAR_CHAR_CODE = 36;
-/**
- * @template T
- * @param {?} selector
- * @return {?}
- */
 function createSelectObservable(selector) {
     if (!SelectFactory.store) {
         throwSelectFactoryNotConnectedError();
     }
-    return (/** @type {?} */ (SelectFactory.store)).select(selector);
+    return SelectFactory.store.select(selector);
 }
-/**
- * @param {?} name
- * @param {?=} rawSelector
- * @param {?=} paths
- * @return {?}
- */
 function createSelectorFn(name, rawSelector, paths = []) {
     rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;
     if (typeof rawSelector === 'string') {
-        /** @type {?} */
         const propsArray = paths.length
             ? [rawSelector, ...paths]
             : rawSelector.split('.');
-        return propGetter(propsArray, (/** @type {?} */ (SelectFactory.config)));
+        return propGetter(propsArray, SelectFactory.config);
     }
     return rawSelector;
 }
 /**
- * \@example If `foo$` => make it just `foo`
- * @param {?} name
- * @return {?}
+ * @example If `foo$` => make it just `foo`
  */
 function removeDollarAtTheEnd(name) {
-    /** @type {?} */
     const lastCharIndex = name.length - 1;
-    /** @type {?} */
     const dollarAtTheEnd = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;
     return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Decorator for selecting a slice of state from the store.
- * @template T
- * @param {?=} rawSelector
- * @param {...?} paths
- * @return {?}
  */
 function Select(rawSelector, ...paths) {
-    return (/**
-     * @param {?} target
-     * @param {?} key
-     * @return {?}
-     */
-    function (target, key) {
-        /** @type {?} */
+    return function (target, key) {
         const name = key.toString();
-        /** @type {?} */
         const selectorId = `__${name}__selector`;
-        /** @type {?} */
         const selector = createSelectorFn(name, rawSelector, paths);
         Object.defineProperties(target, {
             [selectorId]: {
@@ -3882,39 +2064,52 @@ function Select(rawSelector, ...paths) {
             [name]: {
                 enumerable: true,
                 configurable: true,
-                /**
-                 * @return {?}
-                 */
                 get() {
                     return this[selectorId] || (this[selectorId] = createSelectObservable(selector));
                 }
             }
         });
-    });
+    };
+}
+
+const SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';
+const selectorOptionsMetaAccessor = {
+    getOptions: (target) => {
+        return (target && target[SELECTOR_OPTIONS_META_KEY]) || {};
+    },
+    defineOptions: (target, options) => {
+        if (!target)
+            return;
+        target[SELECTOR_OPTIONS_META_KEY] = options;
+    },
+};
+function setupSelectorMetadata(originalFn, creationMetadata) {
+    const selectorMetaData = ensureSelectorMetadata$1(originalFn);
+    selectorMetaData.originalFn = originalFn;
+    let getExplicitSelectorOptions = () => ({});
+    if (creationMetadata) {
+        selectorMetaData.containerClass = creationMetadata.containerClass;
+        selectorMetaData.selectorName = creationMetadata.selectorName || null;
+        getExplicitSelectorOptions =
+            creationMetadata.getSelectorOptions || getExplicitSelectorOptions;
+    }
+    const selectorMetaDataClone = Object.assign({}, selectorMetaData);
+    selectorMetaData.getSelectorOptions = () => getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions());
+    return selectorMetaData;
+}
+function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, (selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {})), (selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {})), (selectorMetaData.getSelectorOptions() || {})), explicitOptions);
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * Decorator for setting selector options at a method or class level.
- * @param {?} options
- * @return {?}
  */
 function SelectorOptions(options) {
-    return (/** @type {?} */ (((/**
-     * @template T
-     * @param {?} target
-     * @param {?} methodName
-     * @param {?} descriptor
-     * @return {?}
-     */
-    function decorate(target, methodName, descriptor) {
+    return (function decorate(target, methodName, descriptor) {
         if (methodName) {
+            descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, methodName));
             // Method Decorator
-            /** @type {?} */
-            const originalFn = descriptor.value || ((/** @type {?} */ (descriptor))).originalFn;
+            const originalFn = descriptor.value || descriptor.originalFn;
             if (originalFn) {
                 selectorOptionsMetaAccessor.defineOptions(originalFn, options);
             }
@@ -3923,192 +2118,171 @@ function SelectorOptions(options) {
             // Class Decorator
             selectorOptionsMetaAccessor.defineOptions(target, options);
         }
-    }))));
+    });
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- */
-function MetaDataModel$1() { }
-if (false) {
-    /** @type {?} */
-    MetaDataModel$1.prototype.name;
-    /** @type {?} */
-    MetaDataModel$1.prototype.actions;
-    /** @type {?} */
-    MetaDataModel$1.prototype.defaults;
-    /** @type {?} */
-    MetaDataModel$1.prototype.path;
-    /** @type {?|undefined} */
-    MetaDataModel$1.prototype.children;
-}
-/**
- * @record
- */
-function SelectorMetaDataModel$1() { }
-if (false) {
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.originalFn;
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.containerClass;
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.selectorName;
-    /** @type {?} */
-    SelectorMetaDataModel$1.prototype.getSelectorOptions;
+function ensureStoreMetadata(target) {
+    return ensureStoreMetadata$1(target);
 }
-/**
- * @param {?} target
- * @return {?}
- */
-function ensureStoreMetadata$1(target) {
-    return ensureStoreMetadata(target);
+function getStoreMetadata(target) {
+    return getStoreMetadata$1(target);
 }
-/**
- * @param {?} target
- * @return {?}
- */
-function getStoreMetadata$1(target) {
-    return getStoreMetadata(target);
+function ensureSelectorMetadata(target) {
+    return ensureSelectorMetadata$1(target);
 }
-/**
- * @param {?} target
- * @return {?}
- */
-function ensureSelectorMetadata$1(target) {
-    return ensureSelectorMetadata(target);
+function getSelectorMetadata(target) {
+    return getSelectorMetadata$1(target);
 }
-/**
- * @param {?} target
- * @return {?}
- */
-function getSelectorMetadata$1(target) {
-    return getSelectorMetadata(target);
+
+function createSelector(selectors, projector, creationMetadata) {
+    const memoizedFn = createMemoizedSelectorFn(projector, creationMetadata);
+    const selectorMetaData = setupSelectorMetadata(projector, creationMetadata);
+    selectorMetaData.makeRootSelector = createRootSelectorFactory(selectorMetaData, selectors, memoizedFn);
+    return memoizedFn;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Decorator for memoizing a state selector.
- * @template T
- * @param {?=} selectors
- * @return {?}
- */
 function Selector(selectors) {
-    return (/**
-     * @template U
-     * @param {?} target
-     * @param {?} key
-     * @param {?} descriptor
-     * @return {?}
-     */
-    (target, key, descriptor) => {
+    return (target, key, descriptor) => {
+        descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, key));
+        const originalFn = descriptor === null || descriptor === void 0 ? void 0 : descriptor.value;
         // Caretaker note: we have still left the `typeof` condition in order to avoid
         // creating a breaking change for projects that still use the View Engine.
         if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            /** @type {?} */
-            const isNotMethod = !(descriptor && descriptor.value !== null);
-            if (isNotMethod) {
+            if (originalFn && typeof originalFn !== 'function') {
                 throwSelectorDecoratorError();
             }
         }
-        /** @type {?} */
-        const originalFn = descriptor.value;
-        /** @type {?} */
-        const memoizedFn = createSelector(selectors, (/** @type {?} */ (originalFn)), {
+        const memoizedFn = createSelector(selectors, originalFn, {
             containerClass: target,
             selectorName: key.toString(),
-            /**
-             * @return {?}
-             */
             getSelectorOptions() {
                 return {};
-            }
+            },
         });
-        /** @type {?} */
         const newDescriptor = {
             configurable: true,
-            /**
-             * @return {?}
-             */
             get() {
                 return memoizedFn;
-            }
+            },
         };
         // Add hidden property to descriptor
-        ((/** @type {?} */ (newDescriptor)))['originalFn'] = originalFn;
+        newDescriptor['originalFn'] = originalFn;
         return newDescriptor;
-    });
+    };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- */
 class StateToken {
-    /**
-     * @param {?} name
-     */
     constructor(name) {
         this.name = name;
-        /** @type {?} */
-        const selectorMetadata = ensureSelectorMetadata((/** @type {?} */ (this)));
-        selectorMetadata.makeRootSelector = (/**
-         * @param {?} runtimeContext
-         * @return {?}
-         */
-        (runtimeContext) => {
+        const selectorMetadata = ensureSelectorMetadata$1(this);
+        selectorMetadata.makeRootSelector = (runtimeContext) => {
             return runtimeContext.getStateGetter(this.name);
-        });
+        };
     }
-    /**
-     * @return {?}
-     */
     getName() {
         return this.name;
     }
-    /**
-     * @return {?}
-     */
     toString() {
         return `StateToken[${this.name}]`;
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateToken.prototype.name;
+
+class NgxsDevelopmentModule {
+    static forRoot(options) {
+        return {
+            ngModule: NgxsDevelopmentModule,
+            providers: [
+                NgxsUnhandledActionsLogger,
+                { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
+            ]
+        };
+    }
 }
+/** @nocollapse */ NgxsDevelopmentModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ NgxsDevelopmentModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule });
+/** @nocollapse */ NgxsDevelopmentModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
+            type: NgModule
+        }] });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+function ensureValidSelector(selector, context = {}) {
+    const noun = context.noun || 'selector';
+    const prefix = context.prefix ? context.prefix + ': ' : '';
+    ensureValueProvided(selector, { noun, prefix: context.prefix });
+    const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);
+    if (!metadata) {
+        throw new Error(`${prefix}The value provided as the ${noun} is not a valid selector.`);
+    }
+}
+function ensureValueProvided(value, context = {}) {
+    const noun = context.noun || 'value';
+    const prefix = context.prefix ? context.prefix + ': ' : '';
+    if (!value) {
+        throw new Error(`${prefix}A ${noun} must be provided.`);
+    }
+}
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+function createModelSelector(selectorMap) {
+    const selectorKeys = Object.keys(selectorMap);
+    const selectors = Object.values(selectorMap);
+    ensureValidSelectorMap({
+        prefix: '[createModelSelector]',
+        selectorMap,
+        selectorKeys,
+        selectors,
+    });
+    return createSelector(selectors, (...args) => {
+        return selectorKeys.reduce((obj, key, index) => {
+            obj[key] = args[index];
+            return obj;
+        }, {});
+    });
+}
+function ensureValidSelectorMap({ prefix, selectorMap, selectorKeys, selectors, }) {
+    ensureValueProvided(selectorMap, { prefix, noun: 'selector map' });
+    ensureValueProvided(typeof selectorMap === 'object', { prefix, noun: 'valid selector map' });
+    ensureValueProvided(selectorKeys.length, { prefix, noun: 'non-empty selector map' });
+    selectors.forEach((selector, index) => ensureValidSelector(selector, {
+        prefix,
+        noun: `selector for the '${selectorKeys[index]}' property`,
+    }));
+}
+
+function createPickSelector(selector, keys) {
+    ensureValidSelector(selector, { prefix: '[createPickSelector]' });
+    const validKeys = keys.filter(Boolean);
+    const selectors = validKeys.map((key) => createSelector([selector], (s) => s[key]));
+    return createSelector([...selectors], (...props) => {
+        return validKeys.reduce((acc, key, index) => {
+            acc[key] = props[index];
+            return acc;
+        }, {});
+    });
+}
+
+function createPropertySelectors(parentSelector) {
+    ensureValidSelector(parentSelector, {
+        prefix: '[createPropertySelectors]',
+        noun: 'parent selector',
+    });
+    const cache = {};
+    return new Proxy({}, {
+        get(_target, prop) {
+            const selector = cache[prop] ||
+                createSelector([parentSelector], (s) => s === null || s === void 0 ? void 0 : s[prop]);
+            cache[prop] = selector;
+            return selector;
+        },
+    });
+}
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * The public api for consumers of @ngxs/store
  */
 
 /**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NgxsRootModule as ɵj, StateFactory as ɵk, InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm, StateContextFactory as ɵn, InternalStateOperations as ɵo, PluginManager as ɵp, InternalNgxsExecutionStrategy as ɵq, InternalErrorReporter as ɵr, SelectFactory as ɵs, ensureStoreMetadata as ɵu, getStoreMetadata as ɵv, ensureSelectorMetadata as ɵw, getSelectorMetadata as ɵx, LifecycleStateManager as ɵy, NgxsFeatureModule as ɵz };
+export { Action, Actions, InitState, NGXS_PLUGINS, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ensureSelectorMetadata, ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata, getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
 //# sourceMappingURL=ngxs-store.js.map