@ngrx/store

  • Version 14.3.1
  • Published
  • 1.03 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: InjectionToken<RuntimeChecks>;
  • Runtime checks currently in use

variable FEATURE_REDUCERS

const FEATURE_REDUCERS: InjectionToken<unknown>;

    variable FEATURE_STATE_PROVIDER

    const FEATURE_STATE_PROVIDER: InjectionToken<void>;
    • InjectionToken that registers feature states. Mainly used to provide a hook that can be injected to ensure feature state is loaded before something that depends on it.

    variable INIT

    const INIT: string;

      variable INITIAL_REDUCERS

      const INITIAL_REDUCERS: InjectionToken<unknown>;

        variable INITIAL_STATE

        const INITIAL_STATE: InjectionToken<unknown>;

          variable META_REDUCERS

          const META_REDUCERS: InjectionToken<MetaReducer<any, Action>[]>;
          • Meta reducers defined either internally by @ngrx/store or by library authors

          variable REDUCER_FACTORY

          const REDUCER_FACTORY: InjectionToken<unknown>;

            variable ROOT_STORE_PROVIDER

            const ROOT_STORE_PROVIDER: InjectionToken<void>;
            • InjectionToken that registers the global Store. Mainly used to provide a hook that can be injected to ensure the root state is loaded before something that depends on it.

            variable STORE_FEATURES

            const STORE_FEATURES: InjectionToken<unknown>;

              variable UPDATE

              const UPDATE: string;

                variable USER_PROVIDED_META_REDUCERS

                const USER_PROVIDED_META_REDUCERS: InjectionToken<MetaReducer<any, Action>[]>;
                • User-defined meta reducers from StoreModule.forRoot()

                variable USER_RUNTIME_CHECKS

                const USER_RUNTIME_CHECKS: InjectionToken<RuntimeChecks>;
                • 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 createActionGroup

                      createActionGroup: <
                      Source extends string,
                      Events extends Record<
                      string,
                      Creator<any[], object> | ActionCreatorProps<unknown>
                      >
                      >(
                      config: ActionGroupConfig<Source, Events>
                      ) => ActionGroup<Source, Events>;
                      • A function that creates a group of action creators with the same source.

                        Parameter config

                        An object that contains a source and dictionary of events. An event is a key-value pair of an event name and event props.

                        Returns

                        A dictionary of action creators. The name of each action creator is created by camel casing the event name. The type of each action is created using the "[Source] Event Name" pattern.

                        const authApiActions = createActionGroup({
                        source: 'Auth API',
                        events: {
                        // defining events with payload using the `props` function
                        'Login Success': props<{ userId: number; token: string }>(),
                        'Login Failure': props<{ error: string }>(),
                        // defining an event without payload using the `emptyProps` function
                        'Logout Success': emptyProps(),
                        // defining an event with payload using the props factory
                        'Logout Failure': (error: Error) => ({ error }),
                        },
                        });
                        // action type: "[Auth API] Login Success"
                        authApiActions.loginSuccess({ userId: 10, token: 'ngrx' });
                        // action type: "[Auth API] Login Failure"
                        authApiActions.loginFailure({ error: 'Login Failure!' });
                        // action type: "[Auth API] Logout Success"
                        authApiActions.logoutSuccess();
                        // action type: "[Auth API] Logout Failure";
                        authApiActions.logoutFailure(new Error('Logout Failure!'));

                      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, and a 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>>;
                      };
                      • Deprecated

                        Feature selectors with a root state are deprecated, for more info see

                      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, S1, S2, Result>(
                        s1: Selector<State, S1>,
                        s2: Selector<State, S2>,
                        projector: (s1: S1, s2: S2) => Result
                        ): MemoizedSelector<State, 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, 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, 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, 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, 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, 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, Slices extends unknown[], Result>(
                        ...args: [...slices: Selector<State, unknown>[], projector: unknown] &
                        [
                        ...slices: { [i in keyof Slices]: Selector<State, Slices[i]> },
                        projector: (...s: Slices) => Result
                        ]
                        ): MemoizedSelector<State, Result, DefaultProjectorFn<Result>>;
                        <State, Props, S1, Result>(
                        s1: SelectorWithProps<State, Props, S1>,
                        projector: (s1: S1, props: Props) => Result
                        ): MemoizedSelectorWithProps<State, Props, 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, 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, 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, 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, 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, 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, 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, Slices extends unknown[], Result>(
                        selectors: Selector<State, unknown>[] &
                        [...{ [i in keyof Slices]: Selector<State, Slices[i]> }],
                        projector: (...s: Slices) => 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, 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, 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, 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, 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, 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, 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, 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 emptyProps

                            emptyProps: () => ActionCreatorProps<void>;

                              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 props

                                props: <
                                P extends SafeProps,
                                SafeProps = NotAllowedInPropsCheck<P>
                                >() => ActionCreatorProps<P>;

                                  function provideState

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

                                    function provideStore

                                    provideStore: <T, V extends Action = Action>(
                                    reducers?: ActionReducerMap<T, V> | InjectionToken<ActionReducerMap<T, V>>,
                                    config?: RootStoreConfig<T, V>
                                    ) => ImportedNgModuleProviders;

                                      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$: Observable<T>) => Observable<K>;
                                          <T, Props, K>(mapFn: (state: T, props: Props) => K, props: Props): (
                                          source$: Observable<T>
                                          ) => Observable<K>;
                                          <T, a extends keyof T>(key: a): (source$: Observable<T>) => Observable<T[a]>;
                                          <T, a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): (
                                          source$: Observable<T>
                                          ) => Observable<T[a][b]>;
                                          <T, a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
                                          key1: a,
                                          key2: b,
                                          key3: c
                                          ): (source$: Observable<T>) => Observable<T[a][b][c]>;
                                          <
                                          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$: Observable<T>) => Observable<T[a][b][c][d]>;
                                          <
                                          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$: Observable<T>) => Observable<T[a][b][c][d][e]>;
                                          <
                                          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$: Observable<T>) => Observable<T[a][b][c][d][e][f]>;
                                          <
                                          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$: Observable<T>) => Observable<K>;
                                          };
                                          • 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();

                                                  property ɵfac

                                                  static ɵfac: i0.ɵɵFactoryDeclaration<ActionsSubject, never>;

                                                    property ɵprov

                                                    static ɵprov: i0.ɵɵInjectableDeclaration<ActionsSubject>;

                                                      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>;

                                                                  property ɵfac

                                                                  static ɵfac: i0.ɵɵFactoryDeclaration<ReducerManager, never>;

                                                                    property ɵprov

                                                                    static ɵprov: i0.ɵɵInjectableDeclaration<ReducerManager>;

                                                                      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 {}

                                                                                              property ɵfac

                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<ScannedActionsSubject, never>;

                                                                                                property ɵprov

                                                                                                static ɵprov: i0.ɵɵInjectableDeclaration<ScannedActionsSubject>;

                                                                                                  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;

                                                                                                          property ɵfac

                                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<State<any>, never>;

                                                                                                            property ɵprov

                                                                                                            static ɵprov: i0.ɵɵInjectableDeclaration<State<any>>;

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

                                                                                                                      property ɵfac

                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<Store<any>, never>;

                                                                                                                        property ɵprov

                                                                                                                        static ɵprov: i0.ɵɵInjectableDeclaration<Store<any>>;

                                                                                                                          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: Operator<T, R>) => 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): Observable<K>;
                                                                                                                                        <K, Props = any>(
                                                                                                                                        mapFn: (state: T, props: Props) => K,
                                                                                                                                        props: Props
                                                                                                                                        ): Observable<K>;
                                                                                                                                        <a extends keyof T>(key: a): Observable<T[a]>;
                                                                                                                                        <a extends keyof T, b extends keyof T[a]>(key1: a, key2: b): Observable<
                                                                                                                                        T[a][b]
                                                                                                                                        >;
                                                                                                                                        <a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(
                                                                                                                                        key1: a,
                                                                                                                                        key2: b,
                                                                                                                                        key3: c
                                                                                                                                        ): Observable<T[a][b][c]>;
                                                                                                                                        <
                                                                                                                                        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
                                                                                                                                        ): Observable<T[a][b][c][d]>;
                                                                                                                                        <
                                                                                                                                        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
                                                                                                                                        ): Observable<T[a][b][c][d][e]>;
                                                                                                                                        <
                                                                                                                                        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
                                                                                                                                        ): Observable<T[a][b][c][d][e][f]>;
                                                                                                                                        <
                                                                                                                                        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[]
                                                                                                                                        ): Observable<K>;
                                                                                                                                        };
                                                                                                                                        • 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
                                                                                                                                          );

                                                                                                                                            property ɵfac

                                                                                                                                            static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                                                            StoreFeatureModule,
                                                                                                                                            [null, null, null, null, { optional: true }]
                                                                                                                                            >;

                                                                                                                                              property ɵinj

                                                                                                                                              static ɵinj: i0.ɵɵInjectorDeclaration<StoreFeatureModule>;

                                                                                                                                                property ɵmod

                                                                                                                                                static ɵmod: i0.ɵɵNgModuleDeclaration<StoreFeatureModule, never, never, never>;

                                                                                                                                                  method ngOnDestroy

                                                                                                                                                  ngOnDestroy: () => void;

                                                                                                                                                    class StoreModule

                                                                                                                                                    class StoreModule {}

                                                                                                                                                      property ɵfac

                                                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<StoreModule, never>;

                                                                                                                                                        property ɵinj

                                                                                                                                                        static ɵinj: i0.ɵɵInjectorDeclaration<StoreModule>;

                                                                                                                                                          property ɵmod

                                                                                                                                                          static ɵmod: i0.ɵɵNgModuleDeclaration<StoreModule, never, never, never>;

                                                                                                                                                            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>>
                                                                                                                                                            ): ModuleWithProviders<StoreFeatureModule>;
                                                                                                                                                            <T, V extends Action = Action>(
                                                                                                                                                            featureName: string,
                                                                                                                                                            reducer: any,
                                                                                                                                                            config?: any
                                                                                                                                                            ): ModuleWithProviders<StoreFeatureModule>;
                                                                                                                                                            <T, V extends Action = Action>(
                                                                                                                                                            slice: FeatureSlice<T, V>
                                                                                                                                                            ): ModuleWithProviders<StoreFeatureModule>;
                                                                                                                                                            };

                                                                                                                                                              method forRoot

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

                                                                                                                                                                class StoreRootModule

                                                                                                                                                                class StoreRootModule {}

                                                                                                                                                                  constructor

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

                                                                                                                                                                    property ɵfac

                                                                                                                                                                    static ɵfac: i0.ɵɵFactoryDeclaration<
                                                                                                                                                                    StoreRootModule,
                                                                                                                                                                    [null, null, null, null, { optional: true }, { optional: true }]
                                                                                                                                                                    >;

                                                                                                                                                                      property ɵinj

                                                                                                                                                                      static ɵinj: i0.ɵɵInjectorDeclaration<StoreRootModule>;

                                                                                                                                                                        property ɵmod

                                                                                                                                                                        static ɵmod: i0.ɵɵNgModuleDeclaration<StoreRootModule, never, never, never>;

                                                                                                                                                                          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 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<
                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                [P in keyof T]: T[P];
                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                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 EnvironmentProviders

                                                                                                                                                                                                                                          type EnvironmentProviders = ImportedNgModuleProviders;
                                                                                                                                                                                                                                          • An alias type of ImportedNgModuleProviders that better describes where the providers are allowed to be registered.

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

                                                                                                                                                                                                                                                      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>