@ngxs/store 3.8.2-dev.master-09bece1 → 3.8.2-dev.master-b0e24dd

package/index.d.ts

@@ -1,12 +1,615 @@
+import * as i0 from '@angular/core';
+import { Type, ModuleWithProviders, Injector, OnDestroy, Signal, EnvironmentProviders } from '@angular/core';
+import { ɵSharedSelectorOptions as _SharedSelectorOptions, ɵStateClass as _StateClass, ɵActionOptions as _ActionOptions, ɵPlainObjectOf as _PlainObjectOf, ɵStateClassInternal as _StateClassInternal, ɵActionHandlerMetaData as _ActionHandlerMetaData, ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵRuntimeSelectorContext as _RuntimeSelectorContext, StateToken, ɵStoreOptions as _StoreOptions, ɵExtractTokenType as _ExtractTokenType } from '@ngxs/store/internals';
+export { ɵActionOptions as ActionOptions, StateToken } from '@ngxs/store/internals';
+import { Observable, Subject, Subscription, OperatorFunction } from 'rxjs';
+import { StateOperator } from '@ngxs/store/operators';
+export { StateOperator } from '@ngxs/store/operators';
+import { NgxsPluginFn, NgxsPlugin } from '@ngxs/store/plugins';
+export { InitState, NGXS_PLUGINS, NgxsNextPluginFn, NgxsPlugin, NgxsPluginFn, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue } from '@ngxs/store/plugins';
+
+interface NgxsExecutionStrategy {
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}
+
 /**
- * The public api for consumers of @ngxs/store
+ * The NGXS config settings.
  */
-export * from './src/public_api';
+declare class NgxsConfig {
+    /**
+     * 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.
+     */
+    developmentMode: boolean;
+    compatibility: {
+        /**
+         * Support a strict Content Security Policy.
+         * This will circumvent some optimisations that violate a strict CSP through the use of `new Function(...)`.
+         * (default: false)
+         */
+        strictContentSecurityPolicy: boolean;
+    };
+    /**
+     * 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)
+     */
+    executionStrategy: Type<NgxsExecutionStrategy>;
+    /**
+     * Defining shared selector options
+     */
+    selectorOptions: _SharedSelectorOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsConfig, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxsConfig>;
+}
+
 /**
- * The plugin api for the stuff that a plugins needs
+ * State context provided to the actions in the state.
  */
-export * from './src/plugin_api';
+interface StateContext<T> {
+    /**
+     * Get the current state.
+     */
+    getState(): T;
+    /**
+     * Reset the state to a new value.
+     */
+    setState(val: T | StateOperator<T>): void;
+    /**
+     * Patch the existing state with the provided value.
+     */
+    patchState(val: Partial<T>): void;
+    /**
+     * Dispatch a new action and return the dispatched observable.
+     */
+    dispatch(actions: any | any[]): Observable<void>;
+}
 /**
- * Private exports required for the Ivy compilation.
+ * 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.
  */
-export * from './src/private_api';
+declare class NgxsSimpleChange<T = any> {
+    readonly previousValue: T;
+    readonly currentValue: T;
+    readonly firstChange: boolean;
+    constructor(previousValue: T, currentValue: T, firstChange: boolean);
+}
+/**
+ * On init interface
+ */
+interface NgxsOnInit {
+    ngxsOnInit(ctx: StateContext<any>): void;
+}
+/**
+ * On change interface
+ */
+interface NgxsOnChanges {
+    ngxsOnChanges(change: NgxsSimpleChange): void;
+}
+/**
+ * After bootstrap interface
+ */
+interface NgxsAfterBootstrap {
+    ngxsAfterBootstrap(ctx: StateContext<any>): void;
+}
+type NgxsModuleOptions = Partial<NgxsConfig>;
+
+/**
+ * @ignore
+ */
+declare class NgxsRootModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsRootModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsRootModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsRootModule>;
+}
+
+/**
+ * @ignore
+ */
+declare class NgxsFeatureModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsFeatureModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsFeatureModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsFeatureModule>;
+}
+
+declare class NgxsModule {
+    static forRoot(states?: _StateClass[], options?: NgxsModuleOptions): ModuleWithProviders<NgxsRootModule>;
+    static forFeature(states?: _StateClass[]): ModuleWithProviders<NgxsFeatureModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsModule>;
+}
+
+interface ActionDef<T = any, U = any> {
+    type: string;
+    new (...args: T[]): U;
+}
+type ActionType = ActionDef | {
+    type: string;
+};
+
+/**
+ * Decorates a method with a action information.
+ */
+declare function Action(actions: ActionType | ActionType[], options?: _ActionOptions): MethodDecorator;
+
+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>;
+}
+
+type StatesByName = _PlainObjectOf<_StateClassInternal>;
+interface StateOperations<T> {
+    getState(): T;
+    setState(val: T): void;
+    dispatch(actionOrActions: any | any[]): Observable<void>;
+}
+interface MappedStore {
+    name: string;
+    isInitialised: boolean;
+    actions: _PlainObjectOf<_ActionHandlerMetaData[]>;
+    defaults: any;
+    instance: any;
+    path: string;
+}
+interface StatesAndDefaults {
+    defaults: any;
+    states: MappedStore[];
+}
+
+declare class InternalErrorReporter {
+    private _injector;
+    /** Will be set lazily to be backward compatible. */
+    private _errorHandler;
+    constructor(_injector: Injector);
+    reportErrorSafely(error: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalErrorReporter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalErrorReporter>;
+}
+
+/**
+ * Status of a dispatched action
+ */
+declare const enum ActionStatus {
+    Dispatched = "DISPATCHED",
+    Successful = "SUCCESSFUL",
+    Canceled = "CANCELED",
+    Errored = "ERRORED"
+}
+interface ActionContext<T = any> {
+    status: ActionStatus;
+    action: T;
+    error?: Error;
+}
+/**
+ * Internal Action stream that is emitted anytime an action is dispatched.
+ */
+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.
+ */
+declare class Actions extends Observable<ActionContext> {
+    constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
+    static ɵfac: i0.ɵɵFactoryDeclaration<Actions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Actions>;
+}
+
+declare class PluginManager {
+    private _parentManager;
+    private _pluginHandlers;
+    plugins: NgxsPluginFn[];
+    constructor(_parentManager: PluginManager, _pluginHandlers: NgxsPlugin[]);
+    private get rootPlugins();
+    private registerHandlers;
+    private getPluginHandlers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluginManager, [{ optional: true; skipSelf: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PluginManager>;
+}
+
+/**
+ * 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.
+ */
+declare class InternalDispatchedActionResults extends Subject<ActionContext> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalDispatchedActionResults, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalDispatchedActionResults>;
+}
+declare class InternalDispatcher {
+    private _actions;
+    private _actionResults;
+    private _pluginManager;
+    private _stateStream;
+    private _ngxsExecutionStrategy;
+    private _internalErrorReporter;
+    constructor(_actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: _StateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy, _internalErrorReporter: InternalErrorReporter);
+    /**
+     * Dispatches event(s).
+     */
+    dispatch(actionOrActions: any | any[]): Observable<void>;
+    private dispatchByEvents;
+    private dispatchSingle;
+    private getActionResultStream;
+    private createDispatchObservable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalDispatcher>;
+}
+
+/**
+ * @ignore
+ */
+declare class InternalStateOperations {
+    private _stateStream;
+    private _dispatcher;
+    private _config;
+    constructor(_stateStream: _StateStream, _dispatcher: InternalDispatcher, _config: NgxsConfig);
+    /**
+     * Returns the root state operators.
+     */
+    getRootStateOperations(): StateOperations<any>;
+    setStateToTheCurrentWithNew(results: StatesAndDefaults): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InternalStateOperations, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InternalStateOperations>;
+}
+
+/**
+ * State Context factory class
+ * @ignore
+ */
+declare class StateContextFactory {
+    private _internalStateOperations;
+    constructor(_internalStateOperations: InternalStateOperations);
+    /**
+     * Create the state context
+     */
+    createStateContext<T>(mappedStore: MappedStore): StateContext<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateContextFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateContextFactory>;
+}
+
+/**
+ * The `StateFactory` class adds root and feature states to the graph.
+ * This extracts state names from state classes, checks if they already
+ * exist in the global graph, throws errors if their names are invalid, etc.
+ * See its constructor, state factories inject state factories that are
+ * parent-level providers. This is required to get feature states from the
+ * injector on the same level.
+ *
+ * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.
+ * The `StateFactory` is initialized on the feature level and goes through `...states`
+ * to get them from the injector through `injector.get(state)`.
+ * @ignore
+ */
+declare class StateFactory implements OnDestroy {
+    private _injector;
+    private _config;
+    private _parentFactory;
+    private _actions;
+    private _actionResults;
+    private _stateContextFactory;
+    private _initialState;
+    private _actionsSubscription;
+    private _propGetter;
+    constructor(_injector: Injector, _config: NgxsConfig, _parentFactory: StateFactory, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _stateContextFactory: StateContextFactory, _initialState: any);
+    private _states;
+    get states(): MappedStore[];
+    private _statesByName;
+    get statesByName(): StatesByName;
+    private _statePaths;
+    private get statePaths();
+    getRuntimeSelectorContext: () => _RuntimeSelectorContext;
+    ngOnDestroy(): void;
+    /**
+     * Add a new state to the global defs.
+     */
+    add(stateClasses: _StateClassInternal[]): MappedStore[];
+    /**
+     * Add a set of states to the store and return the defaults
+     */
+    addAndReturnDefaults(stateClasses: _StateClassInternal[]): StatesAndDefaults;
+    connectActionHandlers(): void;
+    /**
+     * Invoke actions on the states.
+     */
+    invokeActions(dispatched$: Observable<ActionContext>, action: any): Observable<unknown[]>;
+    private addToStatesMap;
+    private addRuntimeInfoToMeta;
+    private hasBeenMountedAndBootstrapped;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateFactory, [null, null, { optional: true; skipSelf: true; }, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateFactory>;
+}
+
+type SelectorFunc<TModel> = (...arg: any[]) => TModel;
+type TypedSelector<TModel> = StateToken<TModel> | SelectorFunc<TModel>;
+type StateSelector = _StateClass<any>;
+type SelectorDef<TModel> = StateSelector | TypedSelector<TModel>;
+type SelectorReturnType<T extends SelectorDef<any>> = T extends StateToken<infer R1> ? R1 : T extends SelectorFunc<infer R2> ? R2 : T extends _StateClass<any> ? any : never;
+
+interface SelectorMap {
+    [key: string]: TypedSelector<any>;
+}
+type ModelSelector<T extends SelectorMap> = (...args: any[]) => MappedResult<T>;
+type MappedResult<TSelectorMap> = {
+    [P in keyof TSelectorMap]: TSelectorMap[P] extends TypedSelector<infer R> ? R : never;
+};
+declare function createModelSelector<T extends SelectorMap>(selectorMap: T): ModelSelector<T>;
+
+type KeysToValues<T, Keys extends (keyof T)[]> = {
+    [Index in keyof Keys]: Keys[Index] extends keyof T ? T[Keys[Index]] : never;
+};
+declare function createPickSelector<TModel, Keys extends (keyof TModel)[]>(selector: TypedSelector<TModel>, keys: [...Keys]): (...props: KeysToValues<TModel, Keys>) => Pick<TModel, Keys[number]>;
+
+type PropertySelectors<TModel> = {
+    [P in keyof NonNullable<TModel>]-?: (model: TModel) => TModel extends null | undefined ? undefined : NonNullable<TModel>[P];
+};
+declare function createPropertySelectors<TModel>(parentSelector: SelectorDef<TModel>): PropertySelectors<TModel>;
+
+interface CreationMetadata {
+    containerClass: any;
+    selectorName: string;
+    getSelectorOptions?: () => _SharedSelectorOptions;
+}
+
+type SelectorArg = SelectorDef<any>;
+/**
+ * Function for creating a selector
+ * @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
+ */
+declare function createSelector<S1 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>) => any>(selectors: [S1], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>) => any>(selectors: [S1, S2], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>) => any>(selectors: [S1, S2, S3], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>) => any>(selectors: [S1, S2, S3, S4], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>) => any>(selectors: [S1, S2, S3, S4, S5], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>, s6: SelectorReturnType<S6>) => any>(selectors: [S1, S2, S3, S4, S5, S6], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, S7 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>, s6: SelectorReturnType<S6>, s7: SelectorReturnType<S7>) => any>(selectors: [S1, S2, S3, S4, S5, S6, S7], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<S1 extends SelectorArg, S2 extends SelectorArg, S3 extends SelectorArg, S4 extends SelectorArg, S5 extends SelectorArg, S6 extends SelectorArg, S7 extends SelectorArg, S8 extends SelectorArg, TProjector extends (s1: SelectorReturnType<S1>, s2: SelectorReturnType<S2>, s3: SelectorReturnType<S3>, s4: SelectorReturnType<S4>, s5: SelectorReturnType<S5>, s6: SelectorReturnType<S6>, s7: SelectorReturnType<S7>, s8: SelectorReturnType<S8>) => any>(selectors: [S1, S2, S3, S4, S5, S6, S7, S8], projector: TProjector, creationMetadata?: Partial<CreationMetadata>): TProjector;
+declare function createSelector<T extends (...args: any[]) => any>(selectors: SelectorArg[] | undefined, projector: T, creationMetadata?: Partial<CreationMetadata>): T;
+
+declare class Store {
+    private _stateStream;
+    private _internalStateOperations;
+    private _config;
+    private _internalExecutionStrategy;
+    private _stateFactory;
+    /**
+     * 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.
+     */
+    private _selectableStateStream;
+    constructor(_stateStream: _StateStream, _internalStateOperations: InternalStateOperations, _config: NgxsConfig, _internalExecutionStrategy: InternalNgxsExecutionStrategy, _stateFactory: StateFactory, initialStateValue: any);
+    /**
+     * Dispatches event(s).
+     */
+    dispatch(actionOrActions: any | any[]): Observable<void>;
+    /**
+     * Selects a slice of data from the store.
+     */
+    select<T>(selector: TypedSelector<T>): Observable<T>;
+    /**
+     * Select one slice of data from the store.
+     */
+    selectOnce<T>(selector: TypedSelector<T>): Observable<T>;
+    /**
+     * Select a snapshot from the state.
+     */
+    selectSnapshot<T>(selector: TypedSelector<T>): T;
+    /**
+     * Select a signal from the state.
+     */
+    selectSignal<T>(selector: TypedSelector<T>): Signal<T>;
+    /**
+     * Allow the user to subscribe to the root of the state
+     */
+    subscribe(fn?: (value: any) => void): Subscription;
+    /**
+     * Return the raw value of the state.
+     */
+    snapshot(): any;
+    /**
+     * 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.
+     */
+    reset(state: any): void;
+    private getStoreBoundSelectorFn;
+    private initStateStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Store, [null, null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Store>;
+}
+
+/**
+ * Decorates a class with ngxs state information.
+ */
+declare function State<T>(options: _StoreOptions<T>): (target: _StateClass) => void;
+
+/**
+ * Decorator for selecting a slice of state from the store.
+ */
+declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;
+
+/**
+ * Decorator for setting selector options at a method or class level.
+ */
+declare function SelectorOptions(options: _SharedSelectorOptions): ClassDecorator & MethodDecorator;
+
+type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>;
+/**
+ * Given a POJO, returns the POJO type, given a class constructor object, returns the type of the class.
+ *
+ * This utility type exists due to the complexity of ActionType being either an ActionDef class or the plain
+ * `{ type: string }` type (or similar compatible POJO types).
+ */
+type Constructed<T> = T extends new (...args: any[]) => infer U ? U : T;
+interface ActionCompletion<T = any, E = Error> {
+    action: T;
+    result: {
+        successful: boolean;
+        canceled: boolean;
+        error?: E;
+    };
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will grab actions that have just been dispatched as well as actions that have completed
+ */
+declare function ofAction<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been dispatched
+ */
+declare function ofActionDispatched<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been successfully completed
+ */
+declare function ofActionSuccessful<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been canceled
+ */
+declare function ofActionCanceled<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been completed
+ */
+declare function ofActionCompleted<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, ActionCompletion<Constructed<T[TupleKeys<T>]>>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just thrown an error
+ */
+declare function ofActionErrored<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, ActionCompletion<Constructed<T[TupleKeys<T>]>>>;
+
+type SelectorSpec<T, U> = [T] extends [never] ? (...states: any[]) => any : T extends StateToken<any> ? (state: _ExtractTokenType<T>) => U : (...states: any[]) => any;
+type SelectorType<T> = <U>(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>) => TypedPropertyDescriptor<SelectorSpec<T, U>> | void;
+
+/**
+ * Decorator for creating a state selector for the current state.
+ */
+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).
+ */
+declare function Selector<T extends SelectorDef<any>>(selectors: T[]): SelectorType<T>;
+
+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>;
+}
+
+interface NgxsDevelopmentOptions {
+    warnOnUnhandledActions: true | {
+        ignore: ActionType[];
+    };
+}
+
+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>;
+}
+
+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>;
+}
+
+/**
+ * This function provides global store providers and initializes the store.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideStore([CountriesState])]
+ * });
+ * ```
+ *
+ * The `provideStore` may be optionally called with a config before the list of features:
+ *
+ * ```ts
+ * provideStore([CountriesState], {
+ *   developmentMode: !environment.production
+ * });
+ * ```
+ */
+declare function provideStore(states?: _StateClass[], ...features: EnvironmentProviders[]): EnvironmentProviders;
+declare function provideStore(states?: _StateClass[], options?: NgxsModuleOptions, ...features: EnvironmentProviders[]): EnvironmentProviders;
+
+/**
+ * This version serves as a standalone alternative to `NgxsModule.forFeature`.
+ * It can be used in a similar manner to register feature states, but at the
+ * `Route` providers level:
+ *
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'products',
+ *     loadComponent: async () => {...},
+ *     providers: [provideStates([ProductsState])]
+ *   }
+ * ];
+ * ```
+ */
+declare function provideStates(states: _StateClass[], ...features: EnvironmentProviders[]): EnvironmentProviders;
+
+/**
+ * This function registers a custom global plugin for the state.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(
+ *       [CountriesState],
+ *       withNgxsPlugin(LogoutPlugin)
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+declare function withNgxsPlugin(plugin: Type<NgxsPlugin>): EnvironmentProviders;
+
+export { Action, type ActionCompletion, type ActionContext, ActionStatus, type ActionType, Actions, type NgxsAfterBootstrap, NgxsDevelopmentModule, type NgxsDevelopmentOptions, type NgxsExecutionStrategy, NgxsModule, type NgxsModuleOptions, type NgxsOnChanges, type NgxsOnInit, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, type PropertySelectors, Select, Selector, SelectorOptions, State, type StateContext, Store, type TypedSelector, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, withNgxsPlugin, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };