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

package/index.d.ts

@@ -6,3 +6,7 @@ export * from './src/public_api';
  * The plugin api for the stuff that a plugins needs
  */
 export * from './src/plugin_api';
+/**
+ * Private exports required for the Ivy compilation.
+ */
+export * from './src/private_api';

package/internals/index.d.ts

@@ -3,4 +3,4 @@ export { NgxsBootstrapper } from './ngxs-bootstrapper';
 export { memoize } from './memoize';
 export { INITIAL_STATE_TOKEN, InitialState } from './initial-state';
 export { PlainObjectOf, PlainObject, StateClass } from './symbols';
-export { NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY } from './internal-tokens';
+export { ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY } from './internal-tokens';

package/internals/internal-tokens.d.ts

@@ -1,9 +1,3 @@
 import { InjectionToken } from '@angular/core';
-/**
- * @see StateContextFactory as it's referenced by this token to be accessed by plugins internally
- */
-export declare const NGXS_STATE_CONTEXT_FACTORY: InjectionToken<any>;
-/**
- * @see StateFactory as it's referenced by this token to be accessed by plugins internally
- */
-export declare const NGXS_STATE_FACTORY: InjectionToken<any>;
+export declare const ɵNGXS_STATE_FACTORY: InjectionToken<any>;
+export declare const ɵNGXS_STATE_CONTEXT_FACTORY: InjectionToken<any>;

package/internals/ngxs-bootstrapper.d.ts

@@ -1,13 +1,16 @@
 import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
 export declare class NgxsBootstrapper {
     /**
      * Use `ReplaySubject`, thus we can get cached value even if the stream is completed
      */
     private bootstrap$;
-    readonly appBootstrapped$: Observable<boolean>;
+    get appBootstrapped$(): Observable<boolean>;
     /**
      * This event will be emitted after attaching `ComponentRef` of the root component
      * to the tree of views, that's a signal that application has been fully rendered
      */
     bootstrap(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsBootstrapper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxsBootstrapper>;
 }

package/internals/ngxs-store-internals.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@ngxs/store/internals" />
 export * from './index';

package/internals/package.json

@@ -1,13 +1,10 @@
 {
   "main": "../bundles/ngxs-store-internals.umd.js",
-  "module": "../fesm5/ngxs-store-internals.js",
+  "module": "../fesm2015/ngxs-store-internals.js",
   "es2015": "../fesm2015/ngxs-store-internals.js",
-  "esm5": "../esm5/internals/ngxs-store-internals.js",
   "esm2015": "../esm2015/internals/ngxs-store-internals.js",
-  "fesm5": "../fesm5/ngxs-store-internals.js",
   "fesm2015": "../fesm2015/ngxs-store-internals.js",
   "typings": "ngxs-store-internals.d.ts",
-  "metadata": "ngxs-store-internals.metadata.json",
   "sideEffects": false,
   "name": "@ngxs/store/internals"
-}
+}

package/internals/testing/helpers/ngxs-test.component.d.ts

@@ -1,5 +1,8 @@
 import { AfterViewInit, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
 export declare class NgxsTestComponent implements OnInit, AfterViewInit {
     ngOnInit(): void;
     ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsTestComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxsTestComponent, "app-root", never, {}, {}, never, never>;
 }

package/internals/testing/helpers/ngxs-test.module.d.ts

@@ -1,4 +1,10 @@
 import { ApplicationRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./ngxs-test.component";
+import * as i2 from "@angular/platform-browser";
 export declare class NgxsTestModule {
     static ngDoBootstrap(app: ApplicationRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsTestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsTestModule, [typeof i1.NgxsTestComponent], [typeof i2.BrowserModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsTestModule>;
 }

package/internals/testing/ngxs-store-internals-testing.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@ngxs/store/internals/testing" />
 export * from './index';

package/internals/testing/package.json

@@ -1,13 +1,10 @@
 {
   "main": "../../bundles/ngxs-store-internals-testing.umd.js",
-  "module": "../../fesm5/ngxs-store-internals-testing.js",
+  "module": "../../fesm2015/ngxs-store-internals-testing.js",
   "es2015": "../../fesm2015/ngxs-store-internals-testing.js",
-  "esm5": "../../esm5/internals/testing/ngxs-store-internals-testing.js",
   "esm2015": "../../esm2015/internals/testing/ngxs-store-internals-testing.js",
-  "fesm5": "../../fesm5/ngxs-store-internals-testing.js",
   "fesm2015": "../../fesm2015/ngxs-store-internals-testing.js",
   "typings": "ngxs-store-internals-testing.d.ts",
-  "metadata": "ngxs-store-internals-testing.metadata.json",
   "sideEffects": false,
   "name": "@ngxs/store/internals/testing"
-}
+}

package/ngxs-store.d.ts

@@ -1,21 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@ngxs/store" />
 export * from './index';
-export { InternalActions as ɵb, OrderedSubject as ɵa } from './src/actions-stream';
-export { SelectFactory as ɵs } from './src/decorators/select/select-factory';
-export { InternalNgxsExecutionStrategy as ɵq } from './src/execution/internal-ngxs-execution-strategy';
-export { NGXS_EXECUTION_STRATEGY as ɵi, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh } from './src/execution/symbols';
-export { InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm } from './src/internal/dispatcher';
-export { InternalErrorReporter as ɵr } from './src/internal/error-handler';
-export { StateClassInternal as ɵt, ensureSelectorMetadata as ɵw, ensureStoreMetadata as ɵu, getSelectorMetadata as ɵx, getStoreMetadata as ɵv } from './src/internal/internals';
-export { LifecycleStateManager as ɵy } from './src/internal/lifecycle-state-manager';
-export { StateContextFactory as ɵn } from './src/internal/state-context-factory';
-export { StateFactory as ɵk } from './src/internal/state-factory';
-export { InternalStateOperations as ɵo } from './src/internal/state-operations';
-export { NgxsFeatureModule as ɵz } from './src/modules/ngxs-feature.module';
-export { NgxsRootModule as ɵj } from './src/modules/ngxs-root.module';
-export { PluginManager as ɵp } from './src/plugin-manager';
-export { TokenName as ɵba } from './src/state-token/symbols';
-export { FEATURE_STATE_TOKEN as ɵd, NgxsConfig as ɵf, ROOT_STATE_TOKEN as ɵc, SELECTOR_META_KEY as ɵe } from './src/symbols';
-export { mergeDeep as ɵg } from './src/utils/utils';

package/operators/append.d.ts

@@ -1,6 +1,5 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
+import { NoInfer, StateOperator } from './types';
 /**
  * @param items - Specific items to append to the end of an array
  */
-export declare function append<T>(items: T[]): StateOperator<RepairType<T>[]>;
+export declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;

package/operators/compose.d.ts

@@ -1,2 +1,2 @@
-import { StateOperator } from '@ngxs/store';
-export declare function compose<T>(...operators: StateOperator<T>[]): StateOperator<T>;
+import { NoInfer, StateOperator } from './types';
+export declare function compose<T>(...operators: NoInfer<StateOperator<T>[]>): StateOperator<T>;

package/operators/iif.d.ts

@@ -1,6 +1,5 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
-import { Predicate } from './internals';
+import { NoInfer, StateOperator } from './types';
+import { Predicate } from './utils';
 /**
  * @param condition - Condition can be a plain boolean value or a function,
  * that returns boolean, also this function can take a value as an argument
@@ -8,4 +7,4 @@ import { Predicate } from './internals';
  * @param trueOperatorOrValue - Any value or a state operator
  * @param elseOperatorOrValue - Any value or a state operator
  */
-export declare function iif<T>(condition: Predicate<T> | boolean, trueOperatorOrValue: StateOperator<T> | T, elseOperatorOrValue?: StateOperator<T> | T): StateOperator<RepairType<T>>;
+export declare function iif<T>(condition: NoInfer<Predicate<T>> | boolean, trueOperatorOrValue: NoInfer<StateOperator<T> | T>, elseOperatorOrValue?: NoInfer<StateOperator<T> | T>): StateOperator<T>;

package/operators/index.d.ts

@@ -7,7 +7,8 @@ export { append } from './append';
 export { compose } from './compose';
 export { iif } from './iif';
 export { insertItem } from './insert-item';
-export { patch } from './patch';
-export { isStateOperator } from './utils';
+export { patch, ɵPatchSpec } from './patch';
+export { isStateOperator, isPredicate, Predicate } from './utils';
 export { updateItem } from './update-item';
 export { removeItem } from './remove-item';
+export { ExistingState, NoInfer, StateOperator } from './types';

package/operators/insert-item.d.ts

@@ -1,7 +1,6 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
+import { NoInfer, StateOperator } from './types';
 /**
  * @param value - Value to insert
  * @param [beforePosition] -  Specified index to insert value before, optional
  */
-export declare function insertItem<T>(value: T, beforePosition?: number): StateOperator<RepairType<T>[]>;
+export declare function insertItem<T>(value: NoInfer<T>, beforePosition?: number): StateOperator<T[]>;

package/operators/ngxs-store-operators.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@ngxs/store/operators" />
 export * from './index';

package/operators/package.json

@@ -1,13 +1,10 @@
 {
   "main": "../bundles/ngxs-store-operators.umd.js",
-  "module": "../fesm5/ngxs-store-operators.js",
+  "module": "../fesm2015/ngxs-store-operators.js",
   "es2015": "../fesm2015/ngxs-store-operators.js",
-  "esm5": "../esm5/operators/ngxs-store-operators.js",
   "esm2015": "../esm2015/operators/ngxs-store-operators.js",
-  "fesm5": "../fesm5/ngxs-store-operators.js",
   "fesm2015": "../fesm2015/ngxs-store-operators.js",
   "typings": "ngxs-store-operators.d.ts",
-  "metadata": "ngxs-store-operators.metadata.json",
   "sideEffects": false,
   "name": "@ngxs/store/operators"
-}
+}

package/operators/patch.d.ts

@@ -1,10 +1,7 @@
-import { StateOperator } from '@ngxs/store';
-export declare type PatchSpec<T> = {
-    [P in keyof T]?: T[P] | StateOperator<NonNullable<T[P]>>;
+import { NoInfer, StateOperator } from './types';
+declare type NotUndefined<T> = T extends undefined ? never : T;
+export declare type ɵPatchSpec<T> = {
+    [P in keyof T]?: T[P] | StateOperator<NotUndefined<T[P]>>;
 };
-declare type PatchValues<T> = {
-    readonly [P in keyof T]?: T[P] extends (...args: any[]) => infer R ? R : T[P];
-};
-declare type PatchOperator<T> = <U extends PatchValues<T>>(existing: Readonly<U>) => U;
-export declare function patch<T>(patchObject: PatchSpec<T>): PatchOperator<T>;
+export declare function patch<T extends Record<string, any>>(patchObject: NoInfer<ɵPatchSpec<T>>): StateOperator<T>;
 export {};

package/operators/remove-item.d.ts

@@ -1,7 +1,6 @@
-import { StateOperator } from '@ngxs/store';
-import { Predicate } from './internals';
-import { RepairType } from './utils';
+import { NoInfer, StateOperator } from './types';
+import { Predicate } from './utils';
 /**
  * @param selector - index or predicate to remove an item from an array by
  */
-export declare function removeItem<T>(selector: number | Predicate<T>): StateOperator<RepairType<T>[]>;
+export declare function removeItem<T>(selector: number | NoInfer<Predicate<T>>): StateOperator<T[]>;

package/operators/types.d.ts

@@ -0,0 +1,56 @@
+declare type _NoInfer<T> = T extends infer S ? S : never;
+/**
+ * Blocks the ability of the typescript inferrence engine to be able to use the provided type as part of
+ * inferring any type parameters from this usage.
+ * @example
+ * Primarily used to wrap parameters of functions in order to prevent the TypeScript inferrence engine
+ * from inferring a type parameter of the function from the value provided to this parameter.
+ * This essentially blocks the Contravariance of the function (through its parameters) so that the
+ * function type parameter is purely determined by the Covariant requirements of the function's return type.
+ * This is key to creating `StateOperator`s that are typed based on their contextual usage and not on the arguments
+ * provided to them. This is critical for type safety and intellisense for State Operators.
+ * Here is an example of how this benefits a state operator:
+ * ```ts
+ * declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;
+ * declare function appendBad<T>(items: T[]): StateOperator<T[]>;
+ *
+ * interface AAA {
+ *   foo?: boolean;
+ *   bar?: boolean;
+ * }
+ *
+ * // Works
+ * // (T in append is correctly inferred as AAA)
+ * patch<{ test: AAA[] }>({ test: append([{ foo: true }]) });
+ *
+ * // Incorrectly throws: Type 'AAA' is not assignable to type '{ foo: true; }'.ts(2322)
+ * // (T in appendBad is incorrectly inferred as { foo: true; })
+ * patch<{ test: AAA[] }>({ test: appendBad([{ foo: true }]) });
+ * ```
+ *
+ */
+export declare type NoInfer<T> = T extends (infer O)[] ? _NoInfer<O>[] : _NoInfer<T>;
+/**
+ * IMPORTANT NOTE: This should not be used externally to the library, rather
+ * the exported type `ExistingState<T>` should be used instead.
+ *
+ * Used to convert a type to its readonly form. This can be given any type, from
+ * primitives to objects or arrays that could already be readonly or not.
+ * This does not apply the readonly construct to nested objects, but only to the top level type.
+ */
+declare type ɵAsReadonly<T> = T extends Readonly<infer O> ? (O extends T ? Readonly<T> : T) : T;
+/**
+ * Represents the existing state that is passed into a `StateOperator` which should
+ * not be modified but will be used to build the new state returned by the `StateOperator`.
+ */
+export declare type ExistingState<T> = T extends any ? ɵAsReadonly<T> : never;
+/**
+ * This is a monotype unary function that is used to create a new state from an existing state.
+ * A state operator is usually created by a function that is given some data
+ * to integrate with the state and returns a state operator which integrates this data or instruction.
+ *
+ * In state management terminology this creator function is commonly referred to as a state operator
+ * because it represents the operation to be performed. ie. `patch`, `append`, `insertItem`, `compose`, `iif`, etc.
+ */
+export declare type StateOperator<T> = (existing: ExistingState<T>) => T;
+export {};

package/operators/update-item.d.ts

@@ -1,10 +1,9 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
-import { Predicate } from './internals';
+import { NoInfer, StateOperator } from './types';
+import { Predicate } from './utils';
 /**
  * @param selector - Index of item in the array or a predicate function
  * that can be provided in `Array.prototype.findIndex`
  * @param operatorOrValue - New value under the `selector` index or a
  * function that can be applied to an existing value
  */
-export declare function updateItem<T>(selector: number | Predicate<T>, operatorOrValue: T | StateOperator<T>): StateOperator<RepairType<T>[]>;
+export declare function updateItem<T>(selector: number | NoInfer<Predicate<T>>, operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>): StateOperator<T[]>;

package/operators/utils.d.ts

@@ -1,9 +1,8 @@
-import { StateOperator } from '@ngxs/store';
-import { Predicate } from './internals';
+import { StateOperator } from './types';
+export declare type Predicate<T = any> = (value: T | Readonly<T>) => boolean;
 export declare function isStateOperator<T>(value: T | StateOperator<T>): value is StateOperator<T>;
 export declare function isUndefined(value: any): value is undefined;
 export declare function isPredicate<T>(value: Predicate<T> | boolean | number): value is Predicate<T>;
 export declare function isNumber(value: any): value is number;
 export declare function invalidIndex(index: number): boolean;
 export declare function isNil<T>(value: T | null | undefined): value is null | undefined;
-export declare type RepairType<T> = T extends true ? boolean : (T extends false ? boolean : T);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../../node_modules/ng-packagr/package.schema.json",
   "name": "@ngxs/store",
-  "version": "3.7.6",
+  "version": "3.8.0-dev.master-c341c15",
   "license": "MIT",
   "sideEffects": true,
   "peerDependencies": {
@@ -9,16 +9,13 @@
     "rxjs": ">=6.5.5"
   },
   "main": "bundles/ngxs-store.umd.js",
-  "module": "fesm5/ngxs-store.js",
+  "module": "fesm2015/ngxs-store.js",
   "es2015": "fesm2015/ngxs-store.js",
-  "esm5": "esm5/ngxs-store.js",
   "esm2015": "esm2015/ngxs-store.js",
-  "fesm5": "fesm5/ngxs-store.js",
   "fesm2015": "fesm2015/ngxs-store.js",
   "typings": "ngxs-store.d.ts",
-  "metadata": "ngxs-store.metadata.json",
   "dependencies": {
-    "tslib": "^1.9.0"
+    "tslib": "^2.2.0"
   },
   "repository": {
     "type": "git",
@@ -63,4 +60,4 @@
     "type": "opencollective",
     "url": "https://opencollective.com/ngxs"
   }
-}
+}

package/src/actions/actions.d.ts

@@ -3,13 +3,13 @@ import { PlainObject } from '@ngxs/store/internals';
  * Init action
  */
 export declare class InitState {
-    static readonly type: string;
+    static get type(): string;
 }
 /**
  * Update action
  */
 export declare class UpdateState {
     addedStates?: PlainObject | undefined;
-    static readonly type: string;
+    static get type(): string;
     constructor(addedStates?: PlainObject | undefined);
 }

package/src/actions-stream.d.ts

@@ -1,6 +1,8 @@
 import { OnDestroy } from '@angular/core';
-import { Subject, Observable } from 'rxjs';
+import { Observable } from 'rxjs';
 import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+import { OrderedSubject } from './internal/custom-rxjs-subjects';
+import * as i0 from "@angular/core";
 /**
  * Status of a dispatched action
  */
@@ -15,37 +17,21 @@ export interface ActionContext<T = any> {
     action: T;
     error?: Error;
 }
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * 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');
- * ```
- * 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`.
- */
-export declare class OrderedSubject<T> extends Subject<T> {
-    private _itemQueue;
-    private _busyPushingNext;
-    next(value?: T): void;
-}
 /**
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
 export declare class InternalActions extends OrderedSubject<ActionContext> implements OnDestroy {
     ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalActions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalActions>;
 }
 /**
  * Action stream that is emitted anytime an action is dispatched.
  *
  * You can listen to this in services to react without stores.
  */
-export declare class Actions extends Observable<any> {
+export declare class Actions extends Observable<ActionContext> {
     constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
+    static ɵfac: i0.ɵɵFactoryDeclaration<Actions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Actions>;
 }

package/src/decorators/select/select-factory.d.ts

@@ -1,6 +1,7 @@
 import { OnDestroy } from '@angular/core';
 import { Store } from '../../store';
 import { NgxsConfig } from '../../symbols';
+import * as i0 from "@angular/core";
 /**
  * Allows the select decorator to get access to the DI store, this is used internally
  * in `@Select` decorator.
@@ -10,4 +11,6 @@ export declare class SelectFactory implements OnDestroy {
     static config: NgxsConfig | null;
     constructor(store: Store, config: NgxsConfig);
     ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectFactory>;
 }

package/src/decorators/selector/selector.d.ts

@@ -1,5 +1,10 @@
+import { SelectorDef } from '../../selectors';
 import { SelectorType } from './symbols';
 /**
- * Decorator for memoizing a state selector.
+ * Decorator for creating a state selector for the current state.
  */
-export declare function Selector<T>(selectors?: T[]): SelectorType<T>;
+export declare function Selector(): SelectorType<unknown>;
+/**
+ * Decorator for creating a state selector from the provided selectors (and optionally the container State, depending on the applicable Selector Options).
+ */
+export declare function Selector<T extends SelectorDef<any>>(selectors: T[]): SelectorType<T>;

package/src/decorators/state.d.ts

@@ -3,4 +3,4 @@ import { StoreOptions } from '../symbols';
 /**
  * Decorates a class with ngxs state information.
  */
-export declare function State<T>(options: StoreOptions<T>): (target: StateClass<any>) => void;
+export declare function State<T>(options: StoreOptions<T>): (target: StateClass) => void;

package/src/dev-features/ngxs-development.module.d.ts

@@ -0,0 +1,9 @@
+import { ModuleWithProviders } from '@angular/core';
+import { NgxsDevelopmentOptions } from './symbols';
+import * as i0 from "@angular/core";
+export declare class NgxsDevelopmentModule {
+    static forRoot(options: NgxsDevelopmentOptions): ModuleWithProviders<NgxsDevelopmentModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsDevelopmentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsDevelopmentModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsDevelopmentModule>;
+}

package/src/dev-features/ngxs-unhandled-actions-logger.d.ts

@@ -0,0 +1,17 @@
+import { ActionType } from '../actions/symbols';
+import { NgxsDevelopmentOptions } from './symbols';
+import * as i0 from "@angular/core";
+export declare class NgxsUnhandledActionsLogger {
+    /**
+     * These actions should be ignored by default; the user can increase this
+     * list in the future via the `ignoreActions` method.
+     */
+    private _ignoredActions;
+    constructor(options: NgxsDevelopmentOptions);
+    /**
+     * Adds actions to the internal list of actions that should be ignored.
+     */
+    ignoreActions(...actions: ActionType[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsUnhandledActionsLogger, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxsUnhandledActionsLogger>;
+}

package/src/dev-features/symbols.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import { ActionType } from '../actions/symbols';
+export interface NgxsDevelopmentOptions {
+    warnOnUnhandledActions: true | {
+        ignore: ActionType[];
+    };
+}
+export declare const NGXS_DEVELOPMENT_OPTIONS: InjectionToken<NgxsDevelopmentOptions>;

package/src/execution/dispatch-outside-zone-ngxs-execution-strategy.d.ts

@@ -1,5 +1,6 @@
 import { NgZone } from '@angular/core';
 import { NgxsExecutionStrategy } from './symbols';
+import * as i0 from "@angular/core";
 export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {
     private _ngZone;
     private _platformId;
@@ -8,4 +9,6 @@ export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExe
     leave<T>(func: () => T): T;
     private runInsideAngular;
     private runOutsideAngular;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DispatchOutsideZoneNgxsExecutionStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DispatchOutsideZoneNgxsExecutionStrategy>;
 }

package/src/execution/internal-ngxs-execution-strategy.d.ts

@@ -1,7 +1,10 @@
 import { NgxsExecutionStrategy } from './symbols';
+import * as i0 from "@angular/core";
 export declare class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {
     private _executionStrategy;
     constructor(_executionStrategy: NgxsExecutionStrategy);
     enter<T>(func: () => T): T;
     leave<T>(func: () => T): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalNgxsExecutionStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalNgxsExecutionStrategy>;
 }

package/src/execution/noop-ngxs-execution-strategy.d.ts

@@ -1,5 +1,8 @@
 import { NgxsExecutionStrategy } from './symbols';
+import * as i0 from "@angular/core";
 export declare class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {
     enter<T>(func: () => T): T;
     leave<T>(func: () => T): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoopNgxsExecutionStrategy, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoopNgxsExecutionStrategy>;
 }

package/src/internal/custom-rxjs-subjects.d.ts

@@ -0,0 +1,37 @@
+import { Subject, BehaviorSubject } from 'rxjs';
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * 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');
+ * ```
+ * 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`.
+ */
+export declare class OrderedSubject<T> extends Subject<T> {
+    next: (value?: T | undefined) => void;
+}
+/**
+ * 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`.
+ */
+export declare class OrderedBehaviorSubject<T> extends BehaviorSubject<T> {
+    next: (value: T) => void;
+}

package/src/internal/dispatcher.d.ts

@@ -4,6 +4,7 @@ import { ActionContext, InternalActions } from '../actions-stream';
 import { StateStream } from './state-stream';
 import { PluginManager } from '../plugin-manager';
 import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
+import * as i0 from "@angular/core";
 /**
  * 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
@@ -11,6 +12,8 @@ import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execut
  * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
  */
 export declare class InternalDispatchedActionResults extends Subject<ActionContext> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalDispatchedActionResults, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalDispatchedActionResults>;
 }
 export declare class InternalDispatcher {
     private _actions;
@@ -28,4 +31,6 @@ export declare class InternalDispatcher {
     private dispatchSingle;
     private getActionResultStream;
     private createDispatchObservable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalDispatcher>;
 }