The Reducer Switch Builder is used to build a reducer switch statement via method chaining. You must have created Action Creators for each action type you want to handle prior to using this.

RejectedActionCreator<TPayload>

An Action Creator to create rejected actions for async thunks.

RejectedAction<TArg, TPayload>

An action dispatched when the thunk is rejected with an optional payload.

RejectedMeta<TArg>

The metadata of the thunk when it is rejected.

RejectedWithValueException<TPayload>

An exception thrown when a Thunk is rejected.

SliceReducerSwitchBuilder<TState>

The Slice Reducer Switch Builder is used to build a reducer switch statement via method chaining. This builder does not require you to create Action Creators. It will automatically create them for you.

Slice<TState, TStoreState>

A Slice is a collection of reducers and actions for a specific domain. It is a convenient way to bundle them together for use in a Redux store.

StoreExtensions

Extensions for the IDispatchable.

StoreFactory

Factory methods to create Redux stores.

Store<TStoreState>

A store holds the whole state tree of your application. The only way to change the state inside it is to dispatch an action on it. Your application should only have a single store in a Redux app. As your app grows, instead of adding stores, you split the root reducer into smaller reducers independently operating on the different parts of the state tree.

The store has the following responsibilities:
- Holds application state
- Allows access to state via GetState()
- Allows state to be updated via Dispatch(IAction)
- Registers listeners via Subscribe<TSelected>(Selector<TStoreState, TSelected>, Listener<TSelected>, SubscribeOptions<TSelected>)
- Handles unregistering of listeners via the function returned by Subscribe<TSelected>(Selector<TStoreState, TSelected>, Listener<TSelected>, SubscribeOptions<TSelected>)

Here are some important principles you should understand about Reducers:
- Reducers are the only way to update the state.
- Reducers are pure functions that take the previous state and an action, and return the next state.
- Reducers must be pure functions. They should not mutate the state, perform side effects like API calls or routing transitions, or call non-pure functions.
- Reducers must not do asynchronous logic.
- Reducers must not call other Reducer<TState>.
- Reducers must not call Subscribe<TSelected>(Selector<TStoreState, TSelected>, Listener<TSelected>, SubscribeOptions<TSelected>).
- Reducers must not call GetState()
- Reducers must not call Dispatch(IAction)

SubscriptionBase<TStore, TState, TSelected>

A base subscription to a store for a selected state.

Subscription<TState, TSelected>

A subscription to a store for a selected state.

SwitchBuilder<TBuilder, TState>

Base implementation of a switch statement builder to generate a reducer.

Thunk

Utility class for creating thunk middleware.

ThunkAPI<TArg, TPayload>

An interface to interact with the thunk during the execution. You can use this interface to abort the thunk, reject the thunk with a value, or fulfill the thunk with a value. You also have access to the store to dispatch new actions.