@ngrx/store

  • Version 12.4.0
  • Published
  • 1.06 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 createFeature

                                                    createFeature: <
                                                    AppState extends Record<string, any>,
                                                    FeatureName extends keyof AppState & string = keyof AppState & string,
                                                    FeatureState extends AppState[FeatureName] = AppState[FeatureName]
                                                    >(
                                                    featureConfig: FeatureConfig<FeatureName, FeatureState> &
                                                    NotAllowedFeatureStateCheck<FeatureState>
                                                    ) => Feature<AppState, FeatureName, FeatureState>;
                                                    • A function that accepts a feature name and a feature reducer, and creates a feature selector and a selector for each feature state property.

                                                      Parameter featureConfig

                                                      An object that contains a feature name and a feature reducer.

                                                      Returns

                                                      An object that contains a feature name, a feature reducer, a feature selector, a the selector for each feature state property.

                                                      **With Application State**

                                                      interface AppState {
                                                      products: ProductsState;
                                                      }
                                                      interface ProductsState {
                                                      products: Product[];
                                                      selectedId: string | null;
                                                      }
                                                      const initialState: ProductsState = {
                                                      products: [],
                                                      selectedId: null,
                                                      };
                                                      // AppState is passed as a generic argument
                                                      const productsFeature = createFeature<AppState>({
                                                      name: 'products',
                                                      reducer: createReducer(
                                                      initialState,
                                                      on(ProductsApiActions.loadSuccess(state, { products }) => ({
                                                      ...state,
                                                      products,
                                                      }),
                                                      ),
                                                      });
                                                      const {
                                                      selectProductsState, // type: MemoizedSelector<AppState, ProductsState>
                                                      selectProducts, // type: MemoizedSelector<AppState, Product[]>
                                                      selectSelectedId, // type: MemoizedSelector<AppState, string | null>
                                                      } = productsFeature;

                                                      **Without Application State**

                                                      const productsFeature = createFeature({
                                                      name: 'products',
                                                      reducer: createReducer(initialState),
                                                      });
                                                      const {
                                                      selectProductsState, // type: MemoizedSelector<Record<string, any>, ProductsState>
                                                      selectProducts, // type: MemoizedSelector<Record<string, any>, Product[]>
                                                      selectSelectedId, // type: MemoizedSelector<Record<string, any, string | null>
                                                      } = productsFeature;

                                                    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, readonly 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>
                                                                                                                  );

                                                                                                                    property currentReducers

                                                                                                                    readonly currentReducers: ActionReducerMap<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 FeatureConfig

                                                                                                                                                                                                        interface FeatureConfig<FeatureName extends string, FeatureState> {}

                                                                                                                                                                                                          property name

                                                                                                                                                                                                          name: FeatureName;

                                                                                                                                                                                                            property reducer

                                                                                                                                                                                                            reducer: ActionReducer<FeatureState>;

                                                                                                                                                                                                              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 (16)

                                                                                                                                                                                                                                                                                    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>