@ngrx/store

  • Version 12.0.0
  • Published
  • 1.02 MB
  • 1 dependency
  • MIT license

Install

npm i @ngrx/store
yarn add @ngrx/store
pnpm add @ngrx/store

Overview

RxJS powered Redux for Angular apps

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable ACTIVE_RUNTIME_CHECKS

const ACTIVE_RUNTIME_CHECKS: any;
  • Runtime checks currently in use

variable FEATURE_REDUCERS

const FEATURE_REDUCERS: any;

    variable INIT

    const INIT: string;

      variable INITIAL_REDUCERS

      const INITIAL_REDUCERS: any;

        variable INITIAL_STATE

        const INITIAL_STATE: any;

          variable META_REDUCERS

          const META_REDUCERS: any;
          • Meta reducers defined either internally by @ngrx/store or by library authors

          variable ɵb

          const ɵb: any[];

            variable ɵc

            const ɵc: any[];

              variable ɵd

              const ɵd: any[];

                variable ɵe

                const ɵe: any[];

                  variable ɵg

                  const ɵg: any[];

                    variable ɵh

                    const ɵh: any;

                      variable ɵi

                      const ɵi: any;

                        variable ɵj

                        const ɵj: any;

                          variable ɵk

                          const ɵk: any;

                            variable ɵl

                            const ɵl: any;

                              variable ɵm

                              const ɵm: any;

                                variable ɵn

                                const ɵn: any;

                                  variable ɵo

                                  const ɵo: any;

                                    variable ɵp

                                    const ɵp: any;

                                      variable ɵq

                                      const ɵq: any;
                                      • Concats the user provided meta reducers and the meta reducers provided on the multi injection token

                                      variable ɵr

                                      const ɵr: any;
                                      • Runtime checks defined by the user via forRoot()

                                      variable ɵs

                                      const ɵs: any;

                                        variable REDUCER_FACTORY

                                        const REDUCER_FACTORY: any;

                                          variable STORE_FEATURES

                                          const STORE_FEATURES: any;

                                            variable UPDATE

                                            const UPDATE: string;

                                              variable USER_PROVIDED_META_REDUCERS

                                              const USER_PROVIDED_META_REDUCERS: any;
                                              • User-defined meta reducers from StoreModule.forRoot()

                                              variable USER_RUNTIME_CHECKS

                                              const USER_RUNTIME_CHECKS: any;
                                              • Runtime checks defined by the user via an InjectionToken Defaults to _USER_RUNTIME_CHECKS

                                              Functions

                                              function combineReducers

                                              combineReducers: <T, V extends Action = Action>(
                                              reducers: ActionReducerMap<T, V>,
                                              initialState?: Partial<T>
                                              ) => ActionReducer<T, V>;

                                                function compose

                                                compose: {
                                                <A>(): (i: A) => A;
                                                <A, B>(b: (i: A) => B): (i: A) => B;
                                                <A, B, C>(c: (i: B) => C, b: (i: A) => B): (i: A) => C;
                                                <A, B, C, D>(d: (i: C) => D, c: (i: B) => C, b: (i: A) => B): (i: A) => D;
                                                <A, B, C, D, E>(
                                                e: (i: D) => E,
                                                d: (i: C) => D,
                                                c: (i: B) => C,
                                                b: (i: A) => B
                                                ): (i: A) => E;
                                                <A, B, C, D, E, F>(
                                                f: (i: E) => F,
                                                e: (i: D) => E,
                                                d: (i: C) => D,
                                                c: (i: B) => C,
                                                b: (i: A) => B
                                                ): (i: A) => F;
                                                <A = any, F = any>(...functions: any[]): (i: A) => F;
                                                };

                                                  function createAction

                                                  createAction: {
                                                  <T extends string>(type: T): ActionCreator<T, () => TypedAction<T>>;
                                                  <T extends string, P extends object>(
                                                  type: T,
                                                  config: ActionCreatorProps<P> & NotAllowedCheck<P>
                                                  ): ActionCreator<T, (props: P & NotAllowedCheck<P>) => P & TypedAction<T>>;
                                                  <T extends string, P extends any[], R extends object>(
                                                  type: T,
                                                  creator: Creator<P, R & NotAllowedCheck<R>>
                                                  ): FunctionWithParametersType<P, R & TypedAction<T>> & TypedAction<T>;
                                                  };

                                                    function createFeatureSelector

                                                    createFeatureSelector: {
                                                    <T>(featureName: string): MemoizedSelector<object, T>;
                                                    <T, V>(featureName: keyof T): MemoizedSelector<T, V, DefaultProjectorFn<V>>;
                                                    };

                                                      function createReducer

                                                      createReducer: <S, A extends Action = Action>(
                                                      initialState: S,
                                                      ...ons: ReducerTypes<S, ActionCreator[]>[]
                                                      ) => ActionReducer<S, A>;
                                                      • Creates a reducer function to handle state transitions.

                                                        Reducer creators reduce the explicitness of reducer functions with switch statements.

                                                        Parameter initialState

                                                        Provides a state value if the current state is undefined, as it is initially.

                                                        Parameter ons

                                                        Associations between actions and state changes.

                                                        Returns

                                                        A reducer function.

                                                        - Must be used with ActionCreator's (returned by createAction). Cannot be used with class-based action creators. - The returned ActionReducer should additionally be wrapped with another function, if you are using View Engine AOT. In case you are using Ivy (or only JIT View Engine) the extra wrapper function is not required.

                                                        **Declaring a reducer creator**

                                                        export const reducer = createReducer(
                                                        initialState,
                                                        on(
                                                        featureActions.actionOne,
                                                        featureActions.actionTwo,
                                                        (state, { updatedValue }) => ({ ...state, prop: updatedValue })
                                                        ),
                                                        on(featureActions.actionThree, () => initialState);
                                                        );

                                                        **Declaring a reducer creator using a wrapper function (Only needed if using View Engine AOT)**

                                                        const featureReducer = createReducer(
                                                        initialState,
                                                        on(
                                                        featureActions.actionOne,
                                                        featureActions.actionTwo,
                                                        (state, { updatedValue }) => ({ ...state, prop: updatedValue })
                                                        ),
                                                        on(featureActions.actionThree, () => initialState);
                                                        );
                                                        export function reducer(state: State | undefined, action: Action) {
                                                        return featureReducer(state, action);
                                                        }

                                                      function createReducerFactory

                                                      createReducerFactory: <T, V extends Action = Action>(
                                                      reducerFactory: ActionReducerFactory<T, V>,
                                                      metaReducers?: MetaReducer<T, V>[]
                                                      ) => ActionReducerFactory<T, V>;

                                                        function createSelector

                                                        createSelector: {
                                                        <State, S1, Result>(
                                                        s1: Selector<State, S1>,
                                                        projector: (s1: S1) => Result
                                                        ): MemoizedSelector<State, Result>;
                                                        <State, Props, S1, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        projector: (s1: S1, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, Result>(
                                                        selectors: [Selector<State, S1>],
                                                        projector: (s1: S1) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, Result>(
                                                        selectors: [SelectorWithProps<State, Props, S1>],
                                                        projector: (s1: S1, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        projector: (s1: S1, s2: S2) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        projector: (s1: S1, s2: S2, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, Result>(
                                                        selectors: [Selector<State, S1>, Selector<State, S2>],
                                                        projector: (s1: S1, s2: S2) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>
                                                        ],
                                                        projector: (s1: S1, s2: S2, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        s3: Selector<State, S3>,
                                                        projector: (s1: S1, s2: S2, s3: S3) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        s3: SelectorWithProps<State, Props, S3>,
                                                        projector: (s1: S1, s2: S2, s3: S3, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, Result>(
                                                        selectors: [Selector<State, S1>, Selector<State, S2>, Selector<State, S3>],
                                                        projector: (s1: S1, s2: S2, s3: S3) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>,
                                                        SelectorWithProps<State, Props, S3>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        s3: Selector<State, S3>,
                                                        s4: Selector<State, S4>,
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        s3: SelectorWithProps<State, Props, S3>,
                                                        s4: SelectorWithProps<State, Props, S4>,
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, Result>(
                                                        selectors: [
                                                        Selector<State, S1>,
                                                        Selector<State, S2>,
                                                        Selector<State, S3>,
                                                        Selector<State, S4>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>,
                                                        SelectorWithProps<State, Props, S3>,
                                                        SelectorWithProps<State, Props, S4>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        s3: Selector<State, S3>,
                                                        s4: Selector<State, S4>,
                                                        s5: Selector<State, S5>,
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        s3: SelectorWithProps<State, Props, S3>,
                                                        s4: SelectorWithProps<State, Props, S4>,
                                                        s5: SelectorWithProps<State, Props, S5>,
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, Result>(
                                                        selectors: [
                                                        Selector<State, S1>,
                                                        Selector<State, S2>,
                                                        Selector<State, S3>,
                                                        Selector<State, S4>,
                                                        Selector<State, S5>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>,
                                                        SelectorWithProps<State, Props, S3>,
                                                        SelectorWithProps<State, Props, S4>,
                                                        SelectorWithProps<State, Props, S5>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, props: Props) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, S6, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        s3: Selector<State, S3>,
                                                        s4: Selector<State, S4>,
                                                        s5: Selector<State, S5>,
                                                        s6: Selector<State, S6>,
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, S6, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        s3: SelectorWithProps<State, Props, S3>,
                                                        s4: SelectorWithProps<State, Props, S4>,
                                                        s5: SelectorWithProps<State, Props, S5>,
                                                        s6: SelectorWithProps<State, Props, S6>,
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        props: Props
                                                        ) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, S6, Result>(
                                                        selectors: [
                                                        Selector<State, S1>,
                                                        Selector<State, S2>,
                                                        Selector<State, S3>,
                                                        Selector<State, S4>,
                                                        Selector<State, S5>,
                                                        Selector<State, S6>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, S6, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>,
                                                        SelectorWithProps<State, Props, S3>,
                                                        SelectorWithProps<State, Props, S4>,
                                                        SelectorWithProps<State, Props, S5>,
                                                        SelectorWithProps<State, Props, S6>
                                                        ],
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        props: Props
                                                        ) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, S6, S7, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        s3: Selector<State, S3>,
                                                        s4: Selector<State, S4>,
                                                        s5: Selector<State, S5>,
                                                        s6: Selector<State, S6>,
                                                        s7: Selector<State, S7>,
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, s7: S7) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, S6, S7, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        s3: SelectorWithProps<State, Props, S3>,
                                                        s4: SelectorWithProps<State, Props, S4>,
                                                        s5: SelectorWithProps<State, Props, S5>,
                                                        s6: SelectorWithProps<State, Props, S6>,
                                                        s7: SelectorWithProps<State, Props, S7>,
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        s7: S7,
                                                        props: Props
                                                        ) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, S6, S7, Result>(
                                                        selectors: [
                                                        Selector<State, S1>,
                                                        Selector<State, S2>,
                                                        Selector<State, S3>,
                                                        Selector<State, S4>,
                                                        Selector<State, S5>,
                                                        Selector<State, S6>,
                                                        Selector<State, S7>
                                                        ],
                                                        projector: (s1: S1, s2: S2, s3: S3, s4: S4, s5: S5, s6: S6, s7: S7) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, S6, S7, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>,
                                                        SelectorWithProps<State, Props, S3>,
                                                        SelectorWithProps<State, Props, S4>,
                                                        SelectorWithProps<State, Props, S5>,
                                                        SelectorWithProps<State, Props, S6>,
                                                        SelectorWithProps<State, Props, S7>
                                                        ],
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        s7: S7,
                                                        props: Props
                                                        ) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
                                                        s1: Selector<State, S1>,
                                                        s2: Selector<State, S2>,
                                                        s3: Selector<State, S3>,
                                                        s4: Selector<State, S4>,
                                                        s5: Selector<State, S5>,
                                                        s6: Selector<State, S6>,
                                                        s7: Selector<State, S7>,
                                                        s8: Selector<State, S8>,
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        s7: S7,
                                                        s8: S8
                                                        ) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
                                                        s1: SelectorWithProps<State, Props, S1>,
                                                        s2: SelectorWithProps<State, Props, S2>,
                                                        s3: SelectorWithProps<State, Props, S3>,
                                                        s4: SelectorWithProps<State, Props, S4>,
                                                        s5: SelectorWithProps<State, Props, S5>,
                                                        s6: SelectorWithProps<State, Props, S6>,
                                                        s7: SelectorWithProps<State, Props, S7>,
                                                        s8: SelectorWithProps<State, Props, S8>,
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        s7: S7,
                                                        s8: S8,
                                                        props: Props
                                                        ) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        <State, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
                                                        selectors: [
                                                        Selector<State, S1>,
                                                        Selector<State, S2>,
                                                        Selector<State, S3>,
                                                        Selector<State, S4>,
                                                        Selector<State, S5>,
                                                        Selector<State, S6>,
                                                        Selector<State, S7>,
                                                        Selector<State, S8>
                                                        ],
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        s7: S7,
                                                        s8: S8
                                                        ) => Result
                                                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                                                        <State, Props, S1, S2, S3, S4, S5, S6, S7, S8, Result>(
                                                        selectors: [
                                                        SelectorWithProps<State, Props, S1>,
                                                        SelectorWithProps<State, Props, S2>,
                                                        SelectorWithProps<State, Props, S3>,
                                                        SelectorWithProps<State, Props, S4>,
                                                        SelectorWithProps<State, Props, S5>,
                                                        SelectorWithProps<State, Props, S6>,
                                                        SelectorWithProps<State, Props, S7>,
                                                        SelectorWithProps<State, Props, S8>
                                                        ],
                                                        projector: (
                                                        s1: S1,
                                                        s2: S2,
                                                        s3: S3,
                                                        s4: S4,
                                                        s5: S5,
                                                        s6: S6,
                                                        s7: S7,
                                                        s8: S8,
                                                        props: Props
                                                        ) => Result
                                                        ): MemoizedSelectorWithProps<State, Props, Result, DefaultProjectorFn<Result>>;
                                                        };
                                                        • Deprecated

                                                          Selectors with props are deprecated, for more info see

                                                        function createSelectorFactory

                                                        createSelectorFactory: {
                                                        <T = any, V = any>(memoize: MemoizeFn): (
                                                        ...input: any[]
                                                        ) => MemoizedSelector<T, V>;
                                                        <T = any, V = any>(memoize: MemoizeFn, options: SelectorFactoryConfig<T, V>): (
                                                        ...input: any[]
                                                        ) => MemoizedSelector<T, V, DefaultProjectorFn<V>>;
                                                        <T = any, Props = any, V = any>(memoize: MemoizeFn): (
                                                        ...input: any[]
                                                        ) => MemoizedSelectorWithProps<T, Props, V, DefaultProjectorFn<V>>;
                                                        <T = any, Props = any, V = any>(
                                                        memoize: MemoizeFn,
                                                        options: SelectorFactoryConfig<T, V>
                                                        ): (
                                                        ...input: any[]
                                                        ) => MemoizedSelectorWithProps<T, Props, V, DefaultProjectorFn<V>>;
                                                        };
                                                        • Deprecated

                                                          Selectors with props are deprecated, for more info see

                                                        function defaultMemoize

                                                        defaultMemoize: (
                                                        projectionFn: AnyFn,
                                                        isArgumentsEqual?: typeof isEqualCheck,
                                                        isResultEqual?: typeof isEqualCheck
                                                        ) => MemoizedProjection;

                                                          function defaultStateFn

                                                          defaultStateFn: (
                                                          state: any,
                                                          selectors: Selector<any, any>[] | SelectorWithProps<any, any, any>[],
                                                          props: any,
                                                          memoizedProjector: MemoizedProjection
                                                          ) => any;

                                                            function isNgrxMockEnvironment

                                                            isNgrxMockEnvironment: () => boolean;

                                                              function on

                                                              on: <
                                                              State,
                                                              Creators extends readonly ActionCreator<string, Creator<any[], object>>[]
                                                              >(
                                                              ...args: [
                                                              ...creators: Creators,
                                                              reducer: OnReducer<State extends infer S ? S : never, Creators>
                                                              ]
                                                              ) => ReducerTypes<State, Creators>;
                                                              • Associates actions with a given state change function. A state change function must be provided as the last parameter.

                                                                Parameter args

                                                                ActionCreator's followed by a state change function.

                                                                Returns

                                                                an association of action types with a state change function.

                                                                on(AuthApiActions.loginSuccess, (state, { user }) => ({ ...state, user }))

                                                              function ɵba

                                                              ɵba: ({
                                                              strictActionSerializability,
                                                              strictStateSerializability,
                                                              }: RuntimeChecks) => MetaReducer;

                                                                function ɵbb

                                                                ɵbb: ({
                                                                strictActionImmutability,
                                                                strictStateImmutability,
                                                                }: RuntimeChecks) => MetaReducer;

                                                                  function ɵbc

                                                                  ɵbc: ({ strictActionWithinNgZone }: RuntimeChecks) => MetaReducer;

                                                                    function ɵbd

                                                                    ɵbd: (runtimeChecks?: Partial<RuntimeChecks>) => Provider[];

                                                                      function ɵbe

                                                                      ɵbe: () => Provider[];

                                                                        function ɵbf

                                                                        ɵbf: (runtimeChecks: RuntimeChecks) => RuntimeChecks;

                                                                          function ɵbg

                                                                          ɵbg: (config: RuntimeChecks) => void;

                                                                            function ɵf

                                                                            ɵf: (a: any, b: any) => boolean;

                                                                              function ɵt

                                                                              ɵt: (injector: any, reducers: ActionReducerMap<any, any>) => unknown;

                                                                                function ɵu

                                                                                ɵu: (
                                                                                injector: any,
                                                                                configs: StoreConfig<any, any>[] | InjectionToken<StoreConfig<any, any>>[],
                                                                                featureStores: StoreFeature<any, any>[]
                                                                                ) => (
                                                                                | StoreFeature<any, any>
                                                                                | { key: string; reducerFactory: any; metaReducers: any; initialState: any }
                                                                                )[];

                                                                                  function ɵv

                                                                                  ɵv: (
                                                                                  injector: any,
                                                                                  reducerCollection: ActionReducerMap<any, any>[]
                                                                                  ) => unknown[];

                                                                                    function ɵw

                                                                                    ɵw: (initialState: any) => any;

                                                                                      function ɵx

                                                                                      ɵx: (
                                                                                      metaReducers: MetaReducer[],
                                                                                      userProvidedMetaReducers: MetaReducer[]
                                                                                      ) => MetaReducer[];

                                                                                        function ɵy

                                                                                        ɵy: (store: Store<any>) => any;

                                                                                          function ɵz

                                                                                          ɵz: (runtimeChecks?: Partial<RuntimeChecks>) => RuntimeChecks;

                                                                                            function props

                                                                                            props: <P extends object>() => ActionCreatorProps<P>;

                                                                                              function reduceState

                                                                                              reduceState: <T, V extends Action = Action>(
                                                                                              stateActionPair: StateActionPair<T, V> | undefined,
                                                                                              [action, reducer]: [V, ActionReducer<T, V>]
                                                                                              ) => StateActionPair<T, V>;

                                                                                                function resultMemoize

                                                                                                resultMemoize: (
                                                                                                projectionFn: AnyFn,
                                                                                                isResultEqual: ComparatorFn
                                                                                                ) => MemoizedProjection;

                                                                                                  function select

                                                                                                  select: {
                                                                                                  <T, K>(mapFn: (state: T) => K): (source$: any) => any;
                                                                                                  <T, Props, K>(mapFn: (state: T, props: Props) => K, props: Props): (
                                                                                                  source$: any
                                                                                                  ) => any;
                                                                                                  <T, a extends keyof T>(key: a): (source$: any) => any;
                                                                                                  <T, a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): (
                                                                                                  source$: any
                                                                                                  ) => any;
                                                                                                  <T, a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
                                                                                                  key1: a,
                                                                                                  key2: b,
                                                                                                  key3: c
                                                                                                  ): (source$: any) => any;
                                                                                                  <
                                                                                                  T,
                                                                                                  a extends keyof T,
                                                                                                  b extends keyof T[a],
                                                                                                  c extends keyof T[a][b],
                                                                                                  d extends keyof T[a][b][c]
                                                                                                  >(
                                                                                                  key1: a,
                                                                                                  key2: b,
                                                                                                  key3: c,
                                                                                                  key4: d
                                                                                                  ): (source$: any) => any;
                                                                                                  <
                                                                                                  T,
                                                                                                  a extends keyof T,
                                                                                                  b extends keyof T[a],
                                                                                                  c extends keyof T[a][b],
                                                                                                  d extends keyof T[a][b][c],
                                                                                                  e extends keyof T[a][b][c][d]
                                                                                                  >(
                                                                                                  key1: a,
                                                                                                  key2: b,
                                                                                                  key3: c,
                                                                                                  key4: d,
                                                                                                  key5: e
                                                                                                  ): (source$: any) => any;
                                                                                                  <
                                                                                                  T,
                                                                                                  a extends keyof T,
                                                                                                  b extends keyof T[a],
                                                                                                  c extends keyof T[a][b],
                                                                                                  d extends keyof T[a][b][c],
                                                                                                  e extends keyof T[a][b][c][d],
                                                                                                  f extends keyof T[a][b][c][d][e]
                                                                                                  >(
                                                                                                  key1: a,
                                                                                                  key2: b,
                                                                                                  key3: c,
                                                                                                  key4: d,
                                                                                                  key5: e,
                                                                                                  key6: f
                                                                                                  ): (source$: any) => any;
                                                                                                  <
                                                                                                  T,
                                                                                                  a extends keyof T,
                                                                                                  b extends keyof T[a],
                                                                                                  c extends keyof T[a][b],
                                                                                                  d extends keyof T[a][b][c],
                                                                                                  e extends keyof T[a][b][c][d],
                                                                                                  f extends keyof T[a][b][c][d][e],
                                                                                                  K = any
                                                                                                  >(
                                                                                                  key1: a,
                                                                                                  key2: b,
                                                                                                  key3: c,
                                                                                                  key4: d,
                                                                                                  key5: e,
                                                                                                  key6: f,
                                                                                                  ...paths: string[]
                                                                                                  ): (source$: any) => any;
                                                                                                  };
                                                                                                  • Deprecated

                                                                                                    Selectors with props are deprecated, for more info see

                                                                                                  function setNgrxMockEnvironment

                                                                                                  setNgrxMockEnvironment: (value: boolean) => void;

                                                                                                    function union

                                                                                                    union: <
                                                                                                    C extends { [key: string]: ActionCreator<string, Creator<any[], object>> }
                                                                                                    >(
                                                                                                    creators: C
                                                                                                    ) => ReturnType<C[keyof C]>;

                                                                                                      Classes

                                                                                                      class ActionsSubject

                                                                                                      class ActionsSubject extends BehaviorSubject<Action> implements OnDestroy {}

                                                                                                        constructor

                                                                                                        constructor();

                                                                                                          method complete

                                                                                                          complete: () => void;

                                                                                                            method next

                                                                                                            next: (action: Action) => void;

                                                                                                              method ngOnDestroy

                                                                                                              ngOnDestroy: () => void;

                                                                                                                class ReducerManager

                                                                                                                class ReducerManager
                                                                                                                extends BehaviorSubject<ActionReducer<any, any>>
                                                                                                                implements OnDestroy {}

                                                                                                                  constructor

                                                                                                                  constructor(
                                                                                                                  dispatcher: ReducerManagerDispatcher,
                                                                                                                  initialState: any,
                                                                                                                  reducers: ActionReducerMap<any, any>,
                                                                                                                  reducerFactory: ActionReducerFactory<any, any>
                                                                                                                  );

                                                                                                                    method addFeature

                                                                                                                    addFeature: (feature: StoreFeature<any, any>) => void;

                                                                                                                      method addFeatures

                                                                                                                      addFeatures: (features: StoreFeature<any, any>[]) => void;

                                                                                                                        method addReducer

                                                                                                                        addReducer: (key: string, reducer: ActionReducer<any, any>) => void;

                                                                                                                          method addReducers

                                                                                                                          addReducers: (reducers: { [key: string]: ActionReducer<any, any> }) => void;

                                                                                                                            method ngOnDestroy

                                                                                                                            ngOnDestroy: () => void;

                                                                                                                              method removeFeature

                                                                                                                              removeFeature: (feature: StoreFeature<any, any>) => void;

                                                                                                                                method removeFeatures

                                                                                                                                removeFeatures: (features: StoreFeature<any, any>[]) => void;

                                                                                                                                  method removeReducer

                                                                                                                                  removeReducer: (featureKey: string) => void;

                                                                                                                                    method removeReducers

                                                                                                                                    removeReducers: (featureKeys: string[]) => void;

                                                                                                                                      class ReducerManagerDispatcher

                                                                                                                                      abstract class ReducerManagerDispatcher extends ActionsSubject {}

                                                                                                                                        class ReducerObservable

                                                                                                                                        abstract class ReducerObservable extends Observable<ActionReducer<any, any>> {}

                                                                                                                                          class ScannedActionsSubject

                                                                                                                                          class ScannedActionsSubject extends Subject<Action> implements OnDestroy {}

                                                                                                                                            method ngOnDestroy

                                                                                                                                            ngOnDestroy: () => void;

                                                                                                                                              class State

                                                                                                                                              class State<T> extends BehaviorSubject<any> implements OnDestroy {}

                                                                                                                                                constructor

                                                                                                                                                constructor(
                                                                                                                                                actions$: ActionsSubject,
                                                                                                                                                reducer$: ReducerObservable,
                                                                                                                                                scannedActions: ScannedActionsSubject,
                                                                                                                                                initialState: any
                                                                                                                                                );

                                                                                                                                                  property INIT

                                                                                                                                                  static readonly INIT: string;

                                                                                                                                                    method ngOnDestroy

                                                                                                                                                    ngOnDestroy: () => void;

                                                                                                                                                      class StateObservable

                                                                                                                                                      abstract class StateObservable extends Observable<any> {}

                                                                                                                                                        class Store

                                                                                                                                                        class Store<T = object> extends Observable<T> implements Observer<Action> {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(
                                                                                                                                                          state$: StateObservable,
                                                                                                                                                          actionsObserver: ActionsSubject,
                                                                                                                                                          reducerManager: ReducerManager
                                                                                                                                                          );

                                                                                                                                                            method addReducer

                                                                                                                                                            addReducer: <State, Actions extends Action = Action>(
                                                                                                                                                            key: string,
                                                                                                                                                            reducer: ActionReducer<State, Actions>
                                                                                                                                                            ) => void;

                                                                                                                                                              method complete

                                                                                                                                                              complete: () => void;

                                                                                                                                                                method dispatch

                                                                                                                                                                dispatch: <V extends Action = Action>(
                                                                                                                                                                action: V &
                                                                                                                                                                FunctionIsNotAllowed<
                                                                                                                                                                V,
                                                                                                                                                                'Functions are not allowed to be dispatched. Did you forget to call the action creator function?'
                                                                                                                                                                >
                                                                                                                                                                ) => void;

                                                                                                                                                                  method error

                                                                                                                                                                  error: (err: any) => void;

                                                                                                                                                                    method lift

                                                                                                                                                                    lift: <R>(operator: any) => Store<R>;

                                                                                                                                                                      method next

                                                                                                                                                                      next: (action: Action) => void;

                                                                                                                                                                        method removeReducer

                                                                                                                                                                        removeReducer: <Key extends Extract<keyof T, string>>(key: Key) => void;

                                                                                                                                                                          method select

                                                                                                                                                                          select: {
                                                                                                                                                                          <K>(mapFn: (state: T) => K): any;
                                                                                                                                                                          <K, Props = any>(mapFn: (state: T, props: Props) => K, props: Props): any;
                                                                                                                                                                          <a extends keyof T>(key: a): any;
                                                                                                                                                                          <a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): any;
                                                                                                                                                                          <a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
                                                                                                                                                                          key1: a,
                                                                                                                                                                          key2: b,
                                                                                                                                                                          key3: c
                                                                                                                                                                          ): any;
                                                                                                                                                                          <
                                                                                                                                                                          a extends keyof T,
                                                                                                                                                                          b extends keyof T[a],
                                                                                                                                                                          c extends keyof T[a][b],
                                                                                                                                                                          d extends keyof T[a][b][c]
                                                                                                                                                                          >(
                                                                                                                                                                          key1: a,
                                                                                                                                                                          key2: b,
                                                                                                                                                                          key3: c,
                                                                                                                                                                          key4: d
                                                                                                                                                                          ): any;
                                                                                                                                                                          <
                                                                                                                                                                          a extends keyof T,
                                                                                                                                                                          b extends keyof T[a],
                                                                                                                                                                          c extends keyof T[a][b],
                                                                                                                                                                          d extends keyof T[a][b][c],
                                                                                                                                                                          e extends keyof T[a][b][c][d]
                                                                                                                                                                          >(
                                                                                                                                                                          key1: a,
                                                                                                                                                                          key2: b,
                                                                                                                                                                          key3: c,
                                                                                                                                                                          key4: d,
                                                                                                                                                                          key5: e
                                                                                                                                                                          ): any;
                                                                                                                                                                          <
                                                                                                                                                                          a extends keyof T,
                                                                                                                                                                          b extends keyof T[a],
                                                                                                                                                                          c extends keyof T[a][b],
                                                                                                                                                                          d extends keyof T[a][b][c],
                                                                                                                                                                          e extends keyof T[a][b][c][d],
                                                                                                                                                                          f extends keyof T[a][b][c][d][e]
                                                                                                                                                                          >(
                                                                                                                                                                          key1: a,
                                                                                                                                                                          key2: b,
                                                                                                                                                                          key3: c,
                                                                                                                                                                          key4: d,
                                                                                                                                                                          key5: e,
                                                                                                                                                                          key6: f
                                                                                                                                                                          ): any;
                                                                                                                                                                          <
                                                                                                                                                                          a extends keyof T,
                                                                                                                                                                          b extends keyof T[a],
                                                                                                                                                                          c extends keyof T[a][b],
                                                                                                                                                                          d extends keyof T[a][b][c],
                                                                                                                                                                          e extends keyof T[a][b][c][d],
                                                                                                                                                                          f extends keyof T[a][b][c][d][e],
                                                                                                                                                                          K = any
                                                                                                                                                                          >(
                                                                                                                                                                          key1: a,
                                                                                                                                                                          key2: b,
                                                                                                                                                                          key3: c,
                                                                                                                                                                          key4: d,
                                                                                                                                                                          key5: e,
                                                                                                                                                                          key6: f,
                                                                                                                                                                          ...paths: string[]
                                                                                                                                                                          ): any;
                                                                                                                                                                          };
                                                                                                                                                                          • Deprecated

                                                                                                                                                                            Selectors with props are deprecated, for more info see

                                                                                                                                                                          class StoreFeatureModule

                                                                                                                                                                          class StoreFeatureModule implements OnDestroy {}

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor(
                                                                                                                                                                            features: StoreFeature<any, any>[],
                                                                                                                                                                            featureReducers: ActionReducerMap<any, Action>[],
                                                                                                                                                                            reducerManager: ReducerManager,
                                                                                                                                                                            root: StoreRootModule,
                                                                                                                                                                            actionCheck: any
                                                                                                                                                                            );

                                                                                                                                                                              method ngOnDestroy

                                                                                                                                                                              ngOnDestroy: () => void;

                                                                                                                                                                                class StoreModule

                                                                                                                                                                                class StoreModule {}

                                                                                                                                                                                  method forFeature

                                                                                                                                                                                  static forFeature: {
                                                                                                                                                                                  <T, V extends Action = Action>(
                                                                                                                                                                                  featureName: string,
                                                                                                                                                                                  reducers:
                                                                                                                                                                                  | ActionReducerMap<T, V>
                                                                                                                                                                                  | InjectionToken<ActionReducerMap<T, V>>,
                                                                                                                                                                                  config?: StoreConfig<T, V> | InjectionToken<StoreConfig<T, V>>
                                                                                                                                                                                  ): any;
                                                                                                                                                                                  <T, V extends Action = Action>(
                                                                                                                                                                                  featureName: string,
                                                                                                                                                                                  reducer: any,
                                                                                                                                                                                  config?: any
                                                                                                                                                                                  ): any;
                                                                                                                                                                                  <T, V extends Action = Action>(slice: FeatureSlice<T, V>, config?: any): any;
                                                                                                                                                                                  };

                                                                                                                                                                                    method forRoot

                                                                                                                                                                                    static forRoot: <T, V extends Action = Action>(
                                                                                                                                                                                    reducers: ActionReducerMap<T, V> | InjectionToken<ActionReducerMap<T, V>>,
                                                                                                                                                                                    config?: RootStoreConfig<T, V>
                                                                                                                                                                                    ) => any;

                                                                                                                                                                                      class StoreRootModule

                                                                                                                                                                                      class StoreRootModule {}

                                                                                                                                                                                        constructor

                                                                                                                                                                                        constructor(
                                                                                                                                                                                        actions$: ActionsSubject,
                                                                                                                                                                                        reducer$: ReducerObservable,
                                                                                                                                                                                        scannedActions$: ScannedActionsSubject,
                                                                                                                                                                                        store: Store<any>,
                                                                                                                                                                                        guard: any,
                                                                                                                                                                                        actionCheck: any
                                                                                                                                                                                        );

                                                                                                                                                                                          Interfaces

                                                                                                                                                                                          interface Action

                                                                                                                                                                                          interface Action {}

                                                                                                                                                                                            property type

                                                                                                                                                                                            type: string;

                                                                                                                                                                                              interface ActionCreatorProps

                                                                                                                                                                                              interface ActionCreatorProps<T> {}

                                                                                                                                                                                                interface ActionReducer

                                                                                                                                                                                                interface ActionReducer<T, V extends Action = Action> {}
                                                                                                                                                                                                • A function that takes an Action and a State, and returns a State. See createReducer.

                                                                                                                                                                                                call signature

                                                                                                                                                                                                (state: T | undefined, action: V): T;

                                                                                                                                                                                                  interface ActionReducerFactory

                                                                                                                                                                                                  interface ActionReducerFactory<T, V extends Action = Action> {}

                                                                                                                                                                                                    call signature

                                                                                                                                                                                                    (
                                                                                                                                                                                                    reducerMap: ActionReducerMap<T, V>,
                                                                                                                                                                                                    initialState?: InitialState<T>
                                                                                                                                                                                                    ): ActionReducer<T, V>;

                                                                                                                                                                                                      interface FeatureSlice

                                                                                                                                                                                                      interface FeatureSlice<T, V extends Action = Action> {}
                                                                                                                                                                                                      • An object with the name and the reducer for the feature.

                                                                                                                                                                                                      property name

                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                        property reducer

                                                                                                                                                                                                        reducer: ActionReducer<T, V>;

                                                                                                                                                                                                          interface MemoizedSelector

                                                                                                                                                                                                          interface MemoizedSelector<State, Result, ProjectorFn = DefaultProjectorFn<Result>>
                                                                                                                                                                                                          extends Selector<State, Result> {}

                                                                                                                                                                                                            property clearResult

                                                                                                                                                                                                            clearResult: () => void;

                                                                                                                                                                                                              property projector

                                                                                                                                                                                                              projector: ProjectorFn;

                                                                                                                                                                                                                property setResult

                                                                                                                                                                                                                setResult: (result?: Result) => void;

                                                                                                                                                                                                                  method release

                                                                                                                                                                                                                  release: () => void;

                                                                                                                                                                                                                    interface MemoizedSelectorWithProps

                                                                                                                                                                                                                    interface MemoizedSelectorWithProps<
                                                                                                                                                                                                                    State,
                                                                                                                                                                                                                    Props,
                                                                                                                                                                                                                    Result,
                                                                                                                                                                                                                    ProjectorFn = DefaultProjectorFn<Result>
                                                                                                                                                                                                                    > extends SelectorWithProps<State, Props, Result> {}
                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                      Selectors with props are deprecated, for more info see

                                                                                                                                                                                                                    property clearResult

                                                                                                                                                                                                                    clearResult: () => void;

                                                                                                                                                                                                                      property projector

                                                                                                                                                                                                                      projector: ProjectorFn;

                                                                                                                                                                                                                        property setResult

                                                                                                                                                                                                                        setResult: (result?: Result) => void;

                                                                                                                                                                                                                          method release

                                                                                                                                                                                                                          release: () => void;

                                                                                                                                                                                                                            interface ɵa

                                                                                                                                                                                                                            interface StoreFeature<T, V extends Action = Action> {}

                                                                                                                                                                                                                              property initialState

                                                                                                                                                                                                                              initialState?: InitialState<T>;

                                                                                                                                                                                                                                property key

                                                                                                                                                                                                                                key: string;

                                                                                                                                                                                                                                  property metaReducers

                                                                                                                                                                                                                                  metaReducers?: MetaReducer<T, V>[];

                                                                                                                                                                                                                                    property reducerFactory

                                                                                                                                                                                                                                    reducerFactory: ActionReducerFactory<T, V>;

                                                                                                                                                                                                                                      property reducers

                                                                                                                                                                                                                                      reducers: ActionReducerMap<T, V> | ActionReducer<T, V>;

                                                                                                                                                                                                                                        interface ReducerTypes

                                                                                                                                                                                                                                        interface ReducerTypes<State, Creators extends readonly ActionCreator[]> {}
                                                                                                                                                                                                                                        • Return type of the on fn. Contains the action reducer coupled to one or more action types.

                                                                                                                                                                                                                                        property reducer

                                                                                                                                                                                                                                        reducer: OnReducer<State, Creators>;

                                                                                                                                                                                                                                          property types

                                                                                                                                                                                                                                          types: ExtractActionTypes<Creators>;

                                                                                                                                                                                                                                            interface RootStoreConfig

                                                                                                                                                                                                                                            interface RootStoreConfig<T, V extends Action = Action> extends StoreConfig<T, V> {}

                                                                                                                                                                                                                                              property runtimeChecks

                                                                                                                                                                                                                                              runtimeChecks?: Partial<RuntimeChecks>;

                                                                                                                                                                                                                                                interface RuntimeChecks

                                                                                                                                                                                                                                                interface RuntimeChecks {}

                                                                                                                                                                                                                                                  property strictActionImmutability

                                                                                                                                                                                                                                                  strictActionImmutability: boolean;
                                                                                                                                                                                                                                                  • Verifies that actions aren't mutated

                                                                                                                                                                                                                                                  property strictActionSerializability

                                                                                                                                                                                                                                                  strictActionSerializability: boolean;
                                                                                                                                                                                                                                                  • Verifies if the actions are serializable. Please note, you may not need to set it to true unless you are storing/replaying actions using external resources, for example localStorage.

                                                                                                                                                                                                                                                  property strictActionTypeUniqueness

                                                                                                                                                                                                                                                  strictActionTypeUniqueness?: boolean;
                                                                                                                                                                                                                                                  • Verifies that action types are not registered more than once

                                                                                                                                                                                                                                                  property strictActionWithinNgZone

                                                                                                                                                                                                                                                  strictActionWithinNgZone: boolean;
                                                                                                                                                                                                                                                  • Verifies that actions are dispatched within NgZone

                                                                                                                                                                                                                                                  property strictStateImmutability

                                                                                                                                                                                                                                                  strictStateImmutability: boolean;
                                                                                                                                                                                                                                                  • Verifies that the state isn't mutated

                                                                                                                                                                                                                                                  property strictStateSerializability

                                                                                                                                                                                                                                                  strictStateSerializability: boolean;
                                                                                                                                                                                                                                                  • Verifies if the state is serializable

                                                                                                                                                                                                                                                  interface StoreConfig

                                                                                                                                                                                                                                                  interface StoreConfig<T, V extends Action = Action> {}

                                                                                                                                                                                                                                                    property initialState

                                                                                                                                                                                                                                                    initialState?: InitialState<T>;

                                                                                                                                                                                                                                                      property metaReducers

                                                                                                                                                                                                                                                      metaReducers?: MetaReducer<T, V>[];

                                                                                                                                                                                                                                                        property reducerFactory

                                                                                                                                                                                                                                                        reducerFactory?: ActionReducerFactory<T, V>;

                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                          type ActionCreator

                                                                                                                                                                                                                                                          type ActionCreator<T extends string = string, C extends Creator = Creator> = C &
                                                                                                                                                                                                                                                          TypedAction<T>;
                                                                                                                                                                                                                                                          • See Creator.

                                                                                                                                                                                                                                                          type ActionReducerMap

                                                                                                                                                                                                                                                          type ActionReducerMap<T, V extends Action = Action> = {
                                                                                                                                                                                                                                                          [p in keyof T]: ActionReducer<T[p], V>;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            type ActionType

                                                                                                                                                                                                                                                            type ActionType<A> = A extends ActionCreator<infer T, infer C>
                                                                                                                                                                                                                                                            ? ReturnType<C> & {
                                                                                                                                                                                                                                                            type: T;
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                            : never;

                                                                                                                                                                                                                                                              type Creator

                                                                                                                                                                                                                                                              type Creator<
                                                                                                                                                                                                                                                              P extends any[] = any[],
                                                                                                                                                                                                                                                              R extends object = object
                                                                                                                                                                                                                                                              > = FunctionWithParametersType<P, R>;
                                                                                                                                                                                                                                                              • A function that returns an object in the shape of the Action interface. Configured using createAction.

                                                                                                                                                                                                                                                              type DefaultProjectorFn

                                                                                                                                                                                                                                                              type DefaultProjectorFn<T> = (...args: any[]) => T;

                                                                                                                                                                                                                                                                type FunctionWithParametersType

                                                                                                                                                                                                                                                                type FunctionWithParametersType<P extends unknown[], R = void> = (...args: P) => R;

                                                                                                                                                                                                                                                                  type MemoizedProjection

                                                                                                                                                                                                                                                                  type MemoizedProjection = {
                                                                                                                                                                                                                                                                  memoized: AnyFn;
                                                                                                                                                                                                                                                                  reset: () => void;
                                                                                                                                                                                                                                                                  setResult: (result?: any) => void;
                                                                                                                                                                                                                                                                  clearResult: () => void;
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    type MemoizeFn

                                                                                                                                                                                                                                                                    type MemoizeFn = (t: AnyFn) => MemoizedProjection;

                                                                                                                                                                                                                                                                      type MetaReducer

                                                                                                                                                                                                                                                                      type MetaReducer<T = any, V extends Action = Action> = (
                                                                                                                                                                                                                                                                      reducer: ActionReducer<T, V>
                                                                                                                                                                                                                                                                      ) => ActionReducer<T, V>;

                                                                                                                                                                                                                                                                        type NotAllowedCheck

                                                                                                                                                                                                                                                                        type NotAllowedCheck<T extends object> = T extends any[]
                                                                                                                                                                                                                                                                        ? ArraysAreNotAllowed
                                                                                                                                                                                                                                                                        : T extends {
                                                                                                                                                                                                                                                                        type: any;
                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                        ? TypePropertyIsNotAllowed
                                                                                                                                                                                                                                                                        : keyof T extends never
                                                                                                                                                                                                                                                                        ? EmptyObjectsAreNotAllowed
                                                                                                                                                                                                                                                                        : unknown;

                                                                                                                                                                                                                                                                          type Selector

                                                                                                                                                                                                                                                                          type Selector<T, V> = (state: T) => V;

                                                                                                                                                                                                                                                                            type SelectorWithProps

                                                                                                                                                                                                                                                                            type SelectorWithProps<State, Props, Result> = (
                                                                                                                                                                                                                                                                            state: State,
                                                                                                                                                                                                                                                                            props: Props
                                                                                                                                                                                                                                                                            ) => Result;
                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                              Selectors with props are deprecated, for more info see

                                                                                                                                                                                                                                                                            Package Files (15)

                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                            Peer Dependencies (2)

                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@ngrx/store.

                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@ngrx/store)
                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@ngrx/store"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>