@ngxs/store 3.7.4 → 3.7.5

package/operators/index.d.ts

@@ -1,13 +1,13 @@
-/**
- * @module
- * @description
- * Entry point for all public APIs of this package.
- */
-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 { updateItem } from './update-item';
-export { removeItem } from './remove-item';
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+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 { updateItem } from './update-item';
+export { removeItem } from './remove-item';

package/operators/insert-item.d.ts

@@ -1,7 +1,7 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
-/**
- * @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>[]>;
+import { StateOperator } from '@ngxs/store';
+import { RepairType } from './utils';
+/**
+ * @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>[]>;

package/operators/internals.d.ts

@@ -1,2 +1,2 @@
-import { RepairType } from './utils';
-export declare type Predicate<T = any> = (value?: RepairType<T> | Readonly<RepairType<T>>) => boolean;
+import { RepairType } from './utils';
+export declare type Predicate<T = any> = (value?: RepairType<T> | Readonly<RepairType<T>>) => boolean;

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

@@ -1,4 +1,4 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';

package/operators/patch.d.ts

@@ -1,10 +1,10 @@
-import { StateOperator } from '@ngxs/store';
-export declare type PatchSpec<T> = {
-    [P in keyof T]?: T[P] | StateOperator<NonNullable<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 {};
+import { StateOperator } from '@ngxs/store';
+export declare type PatchSpec<T> = {
+    [P in keyof T]?: T[P] | StateOperator<NonNullable<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 {};

package/operators/remove-item.d.ts

@@ -1,7 +1,7 @@
-import { StateOperator } from '@ngxs/store';
-import { Predicate } from './internals';
-import { RepairType } 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>[]>;
+import { StateOperator } from '@ngxs/store';
+import { Predicate } from './internals';
+import { RepairType } 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>[]>;

package/operators/update-item.d.ts

@@ -1,10 +1,10 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
-import { Predicate } from './internals';
-/**
- * @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>[]>;
+import { StateOperator } from '@ngxs/store';
+import { RepairType } from './utils';
+import { Predicate } from './internals';
+/**
+ * @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>[]>;

package/operators/utils.d.ts

@@ -1,9 +1,9 @@
-import { StateOperator } from '@ngxs/store';
-import { Predicate } from './internals';
-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);
+import { StateOperator } from '@ngxs/store';
+import { Predicate } from './internals';
+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.4",
+  "version": "3.7.5",
   "license": "MIT",
   "sideEffects": true,
   "peerDependencies": {

package/src/actions/actions.d.ts

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

package/src/actions/symbols.d.ts

@@ -1,21 +1,21 @@
-export interface ActionDef<T = any, U = any> {
-    type: string;
-    new (...args: T[]): U;
-}
-export declare type ActionType = ActionDef | {
-    type: string;
-};
-/**
- * Actions that can be provided in a action decorator.
- */
-export interface ActionOptions {
-    /**
-     * Cancel the previous uncompleted observable(s).
-     */
-    cancelUncompleted?: boolean;
-}
-export interface ActionHandlerMetaData {
-    fn: string | symbol;
-    options: ActionOptions;
-    type: string;
-}
+export interface ActionDef<T = any, U = any> {
+    type: string;
+    new (...args: T[]): U;
+}
+export declare type ActionType = ActionDef | {
+    type: string;
+};
+/**
+ * Actions that can be provided in a action decorator.
+ */
+export interface ActionOptions {
+    /**
+     * Cancel the previous uncompleted observable(s).
+     */
+    cancelUncompleted?: boolean;
+}
+export interface ActionHandlerMetaData {
+    fn: string | symbol;
+    options: ActionOptions;
+    type: string;
+}

package/src/actions-stream.d.ts

@@ -1,49 +1,49 @@
-import { Subject, Observable } from 'rxjs';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-/**
- * Status of a dispatched action
- */
-export declare const enum ActionStatus {
-    Dispatched = "DISPATCHED",
-    Successful = "SUCCESSFUL",
-    Canceled = "CANCELED",
-    Errored = "ERRORED"
-}
-export interface ActionContext<T = any> {
-    status: ActionStatus;
-    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> {
-}
-/**
- * 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> {
-    constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
-}
+import { Subject, Observable } from 'rxjs';
+import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+/**
+ * Status of a dispatched action
+ */
+export declare const enum ActionStatus {
+    Dispatched = "DISPATCHED",
+    Successful = "SUCCESSFUL",
+    Canceled = "CANCELED",
+    Errored = "ERRORED"
+}
+export interface ActionContext<T = any> {
+    status: ActionStatus;
+    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> {
+}
+/**
+ * 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> {
+    constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
+}

package/src/configs/messages.config.d.ts

@@ -1,11 +1,11 @@
-export declare function throwStateNameError(name: string): never;
-export declare function throwStateNamePropertyError(): never;
-export declare function throwStateUniqueError(current: string, newName: string, oldName: string): never;
-export declare function throwStateDecoratorError(name: string): never;
-export declare function throwActionDecoratorError(): never;
-export declare function throwSelectorDecoratorError(): never;
-export declare function getZoneWarningMessage(): string;
-export declare function getUndecoratedStateInIvyWarningMessage(name: string): string;
-export declare function throwSelectFactoryNotConnectedError(): never;
-export declare function throwPatchingArrayError(): never;
-export declare function throwPatchingPrimitiveError(): never;
+export declare function throwStateNameError(name: string): never;
+export declare function throwStateNamePropertyError(): never;
+export declare function throwStateUniqueError(current: string, newName: string, oldName: string): never;
+export declare function throwStateDecoratorError(name: string): never;
+export declare function throwActionDecoratorError(): never;
+export declare function throwSelectorDecoratorError(): never;
+export declare function getZoneWarningMessage(): string;
+export declare function getUndecoratedStateInIvyWarningMessage(name: string): string;
+export declare function throwSelectFactoryNotConnectedError(): never;
+export declare function throwPatchingArrayError(): never;
+export declare function throwPatchingPrimitiveError(): never;

package/src/decorators/action.d.ts

@@ -1,5 +1,5 @@
-import { ActionType, ActionOptions } from '../actions/symbols';
-/**
- * Decorates a method with a action information.
- */
-export declare function Action(actions: ActionType | ActionType[], options?: ActionOptions): MethodDecorator;
+import { ActionType, ActionOptions } from '../actions/symbols';
+/**
+ * Decorates a method with a action information.
+ */
+export declare function Action(actions: ActionType | ActionType[], options?: ActionOptions): MethodDecorator;

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

@@ -1,13 +1,13 @@
-import { OnDestroy } from '@angular/core';
-import { Store } from '../../store';
-import { NgxsConfig } from '../../symbols';
-/**
- * Allows the select decorator to get access to the DI store, this is used internally
- * in `@Select` decorator.
- */
-export declare class SelectFactory implements OnDestroy {
-    static store: Store | null;
-    static config: NgxsConfig | null;
-    constructor(store: Store, config: NgxsConfig);
-    ngOnDestroy(): void;
-}
+import { OnDestroy } from '@angular/core';
+import { Store } from '../../store';
+import { NgxsConfig } from '../../symbols';
+/**
+ * Allows the select decorator to get access to the DI store, this is used internally
+ * in `@Select` decorator.
+ */
+export declare class SelectFactory implements OnDestroy {
+    static store: Store | null;
+    static config: NgxsConfig | null;
+    constructor(store: Store, config: NgxsConfig);
+    ngOnDestroy(): void;
+}

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

@@ -1,4 +1,4 @@
-/**
- * Decorator for selecting a slice of state from the store.
- */
-export declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;
+/**
+ * Decorator for selecting a slice of state from the store.
+ */
+export declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;

package/src/decorators/select/symbols.d.ts

@@ -1,14 +1,10 @@
-import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { Store } from '../../store';
-import { NgxsConfig } from '../../symbols';
-import { StateToken } from '../../state-token/state-token';
-import { ExtractTokenType } from '../../state-token/symbols';
-export declare function createSelectObservable<T = any>(selector: any, store: Store | null): Observable<T>;
-export declare function createSelectorFn(config: NgxsConfig | null, name: string, rawSelector?: any, paths?: string[]): SelectorFn;
-/**
- * @example If `foo$` => make it just `foo`
- */
-export declare function removeDollarAtTheEnd(name: string): string;
-export declare type SelectorFn = ((state: any, ...states: any[]) => any) | string | Type<any> | StateToken<any>;
-export declare type PropertyType<T> = T extends StateToken<any> ? Observable<ExtractTokenType<T>> : T extends (...args: any[]) => any ? Observable<ReturnType<T>> : any;
+import { Observable } from 'rxjs';
+import { StateToken } from '../../state-token/state-token';
+import { ExtractTokenType } from '../../state-token/symbols';
+export declare function createSelectObservable<T = any>(selector: any): Observable<T>;
+export declare function createSelectorFn(name: string, rawSelector?: any, paths?: string[]): any;
+/**
+ * @example If `foo$` => make it just `foo`
+ */
+export declare function removeDollarAtTheEnd(name: string): string;
+export declare type PropertyType<T> = T extends StateToken<any> ? Observable<ExtractTokenType<T>> : T extends (...args: any[]) => any ? Observable<ReturnType<T>> : any;

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

@@ -1,5 +1,5 @@
-import { SelectorType } from './symbols';
-/**
- * Decorator for memoizing a state selector.
- */
-export declare function Selector<T>(selectors?: T[]): SelectorType<T>;
+import { SelectorType } from './symbols';
+/**
+ * Decorator for memoizing a state selector.
+ */
+export declare function Selector<T>(selectors?: T[]): SelectorType<T>;

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

@@ -1,4 +1,4 @@
-import { StateToken } from '../../state-token/state-token';
-import { ExtractTokenType } from '../../state-token/symbols';
-export declare type SelectorSpec<T, U> = [T] extends [never] ? ((...states: any[]) => any) : (T extends StateToken<any> ? (state: ExtractTokenType<T>) => U : (...states: any[]) => any);
-export declare type SelectorType<T> = <U>(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>) => TypedPropertyDescriptor<SelectorSpec<T, U>> | void;
+import { StateToken } from '../../state-token/state-token';
+import { ExtractTokenType } from '../../state-token/symbols';
+export declare type SelectorSpec<T, U> = [T] extends [never] ? ((...states: any[]) => any) : (T extends StateToken<any> ? (state: ExtractTokenType<T>) => U : (...states: any[]) => any);
+export declare type SelectorType<T> = <U>(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>) => TypedPropertyDescriptor<SelectorSpec<T, U>> | void;

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

@@ -1,5 +1,5 @@
-import { SharedSelectorOptions } from '../internal/internals';
-/**
- * Decorator for setting selector options at a method or class level.
- */
-export declare function SelectorOptions(options: SharedSelectorOptions): ClassDecorator & MethodDecorator;
+import { SharedSelectorOptions } from '../internal/internals';
+/**
+ * Decorator for setting selector options at a method or class level.
+ */
+export declare function SelectorOptions(options: SharedSelectorOptions): ClassDecorator & MethodDecorator;

package/src/decorators/state.d.ts

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

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

@@ -1,11 +1,11 @@
-import { NgZone } from '@angular/core';
-import { NgxsExecutionStrategy } from './symbols';
-export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    private _ngZone;
-    private _platformId;
-    constructor(_ngZone: NgZone, _platformId: string);
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-    private runInsideAngular;
-    private runOutsideAngular;
-}
+import { NgZone } from '@angular/core';
+import { NgxsExecutionStrategy } from './symbols';
+export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {
+    private _ngZone;
+    private _platformId;
+    constructor(_ngZone: NgZone, _platformId: string);
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+    private runInsideAngular;
+    private runOutsideAngular;
+}

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

@@ -1,7 +1,7 @@
-import { NgxsExecutionStrategy } from './symbols';
-export declare class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    private _executionStrategy;
-    constructor(_executionStrategy: NgxsExecutionStrategy);
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}
+import { NgxsExecutionStrategy } from './symbols';
+export declare class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {
+    private _executionStrategy;
+    constructor(_executionStrategy: NgxsExecutionStrategy);
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}

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

@@ -1,5 +1,5 @@
-import { NgxsExecutionStrategy } from './symbols';
-export declare class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}
+import { NgxsExecutionStrategy } from './symbols';
+export declare class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}

package/src/execution/symbols.d.ts

@@ -1,10 +1,10 @@
-import { InjectionToken, Type } from '@angular/core';
-/**
- * The strategy that might be provided by users through `options.executionStrategy`.
- */
-export declare const USER_PROVIDED_NGXS_EXECUTION_STRATEGY: InjectionToken<Type<NgxsExecutionStrategy> | undefined>;
-export declare const NGXS_EXECUTION_STRATEGY: InjectionToken<NgxsExecutionStrategy>;
-export interface NgxsExecutionStrategy {
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}
+import { InjectionToken, Type } from '@angular/core';
+/**
+ * The strategy that might be provided by users through `options.executionStrategy`.
+ */
+export declare const USER_PROVIDED_NGXS_EXECUTION_STRATEGY: InjectionToken<Type<NgxsExecutionStrategy> | undefined>;
+export declare const NGXS_EXECUTION_STRATEGY: InjectionToken<NgxsExecutionStrategy>;
+export interface NgxsExecutionStrategy {
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}

package/src/internal/dispatcher.d.ts

@@ -1,32 +1,32 @@
-import { Injector } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
-import { ActionContext, InternalActions } from '../actions-stream';
-import { StateStream } from './state-stream';
-import { PluginManager } from '../plugin-manager';
-import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
-/**
- * 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
- * for the observable returned by the dispatch(...) call.
- * 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> {
-}
-export declare class InternalDispatcher {
-    private _injector;
-    private _actions;
-    private _actionResults;
-    private _pluginManager;
-    private _stateStream;
-    private _ngxsExecutionStrategy;
-    private _errorHandler;
-    constructor(_injector: Injector, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: StateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy);
-    /**
-     * Dispatches event(s).
-     */
-    dispatch(actionOrActions: any | any[]): Observable<any>;
-    private dispatchByEvents;
-    private dispatchSingle;
-    private getActionResultStream;
-    private createDispatchObservable;
-}
+import { Injector } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { ActionContext, InternalActions } from '../actions-stream';
+import { StateStream } from './state-stream';
+import { PluginManager } from '../plugin-manager';
+import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
+/**
+ * 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
+ * for the observable returned by the dispatch(...) call.
+ * 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> {
+}
+export declare class InternalDispatcher {
+    private _injector;
+    private _actions;
+    private _actionResults;
+    private _pluginManager;
+    private _stateStream;
+    private _ngxsExecutionStrategy;
+    private _errorHandler;
+    constructor(_injector: Injector, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: StateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy);
+    /**
+     * Dispatches event(s).
+     */
+    dispatch(actionOrActions: any | any[]): Observable<any>;
+    private dispatchByEvents;
+    private dispatchSingle;
+    private getActionResultStream;
+    private createDispatchObservable;
+}