@types/redux-actions

combineActions: (
    ...actionTypes: Array<ActionFunctions<any> | string | symbol>
) => CombinedActionType;

createAction: {
    (actionType: string): ActionFunctionAny<Action<any>>;
    <Payload>(
        actionType: string,
        payloadCreator: ActionFunction0<Payload>
    ): ActionFunction0<Action<Payload>>;
    <Payload, Arg1>(
        actionType: string,
        payloadCreator: ActionFunction1<Arg1, Payload>
    ): ActionFunction1<Arg1, Action<Payload>>;
    <Payload, Arg1, Arg2>(
        actionType: string,
        payloadCreator: ActionFunction2<Arg1, Arg2, Payload>
    ): ActionFunction2<Arg1, Arg2, Action<Payload>>;
    <Payload, Arg1, Arg2, Arg3>(
        actionType: string,
        payloadCreator: ActionFunction3<Arg1, Arg2, Arg3, Payload>
    ): ActionFunction3<Arg1, Arg2, Arg3, Action<Payload>>;
    <Payload, Arg1, Arg2, Arg3, Arg4>(
        actionType: string,
        payloadCreator: ActionFunction4<Arg1, Arg2, Arg3, Arg4, Payload>
    ): ActionFunction4<Arg1, Arg2, Arg3, Arg4, Action<Payload>>;
    <Payload>(actionType: string): ActionFunction1<Payload, Action<Payload>>;
    <Meta>(
        actionType: string,
        payloadCreator: null,
        metaCreator: ActionFunctionAny<Meta>
    ): ActionFunctionAny<ActionMeta<any, Meta>>;
    <Payload, Meta>(
        actionType: string,
        payloadCreator: ActionFunctionAny<Payload>,
        metaCreator: ActionFunctionAny<Meta>
    ): ActionFunctionAny<ActionMeta<Payload, Meta>>;
    <Payload, Meta, Arg1>(
        actionType: string,
        payloadCreator: ActionFunction1<Arg1, Payload>,
        metaCreator: ActionFunction1<Arg1, Meta>
    ): ActionFunction1<Arg1, ActionMeta<Payload, Meta>>;
    <Payload, Meta, Arg1, Arg2>(
        actionType: string,
        payloadCreator: ActionFunction2<Arg1, Arg2, Payload>,
        metaCreator: ActionFunction2<Arg1, Arg2, Meta>
    ): ActionFunction2<Arg1, Arg2, ActionMeta<Payload, Meta>>;
    <Payload, Meta, Arg1, Arg2, Arg3>(
        actionType: string,
        payloadCreator: ActionFunction3<Arg1, Arg2, Arg3, Payload>,
        metaCreator: ActionFunction3<Arg1, Arg2, Arg3, Meta>
    ): ActionFunction3<Arg1, Arg2, Arg3, ActionMeta<Payload, Meta>>;
    <Payload, Meta, Arg1, Arg2, Arg3, Arg4>(
        actionType: string,
        payloadCreator: ActionFunction4<Arg1, Arg2, Arg3, Arg4, Payload>,
        metaCreator: ActionFunction4<Arg1, Arg2, Arg3, Arg4, Meta>
    ): ActionFunction4<Arg1, Arg2, Arg3, Arg4, ActionMeta<Payload, Meta>>;
};

createActions: {
    <Payload>(
        actionMapOrIdentityAction: ActionMap<Payload, any> | string,
        ...identityActions: Array<string | Options>
    ): { [actionName: string]: ActionFunctionAny<Action<Payload>> };
    (
        actionMapOrIdentityAction: string | ActionMap<any, any>,
        ...identityActions: (string | Options)[]
    ): { [actionName: string]: ActionFunctionAny<Action<any>> };
};

handleAction: {
    <State, Payload>(
        actionType: string | ActionFunctions<Payload> | CombinedActionType,
        reducer: Reducer<State, Payload> | ReducerNextThrow<State, Payload>,
        initialState: State
    ): ReduxCompatibleReducer<State, Payload>;
    <State, Payload, Meta>(
        actionType:
            | string
            | CombinedActionType
            | ActionWithMetaFunctions<Payload, Meta>,
        reducer:
            | ReducerMeta<State, Payload, Meta>
            | ReducerNextThrowMeta<State, Payload, Meta>,
        initialState: State
    ): ReduxCompatibleReducerMeta<State, Payload, Meta>;
};

handleActions: {
    <StateAndPayload>(
        reducerMap: ReducerMap<StateAndPayload, StateAndPayload>,
        initialState: StateAndPayload,
        options?: Options
    ): ReduxCompatibleReducer<StateAndPayload, StateAndPayload>;
    <State, Payload>(
        reducerMap: ReducerMap<State, Payload>,
        initialState: State,
        options?: Options
    ): ReduxCompatibleReducer<State, Payload>;
    <State, Payload, Meta>(
        reducerMap: ReducerMapMeta<State, Payload, Meta>,
        initialState: State,
        options?: Options
    ): ReduxCompatibleReducerMeta<State, Payload, Meta>;
};

type ActionFunction0<R> = () => R;

type ActionFunction1<T1, R> = (t1: T1) => R;

type ActionFunction2<T1, T2, R> = (t1: T1, t2: T2) => R;

type ActionFunction3<T1, T2, T3, R> = (t1: T1, t2: T2, t3: T3) => R;

type ActionFunction4<T1, T2, T3, T4, R> = (t1: T1, t2: T2, t3: T3, t4: T4) => R;

type ActionFunctionAny<R> = (...args: any[]) => R;

type ActionFunctions<Payload> = BaseActionFunctions<Action<Payload>>;

type ActionWithMetaFunctions<Payload, Meta> = BaseActionFunctions<
    ActionMeta<Payload, Meta>
>;

type BaseActionFunctions<TAction> =
    | ActionFunction0<TAction>
    | ActionFunction1<any, TAction>
    | ActionFunction2<any, any, TAction>
    | ActionFunction3<any, any, any, TAction>
    | ActionFunction4<any, any, any, any, TAction>
    | ActionFunctionAny<TAction>;

type Reducer<State, Payload> = (state: State, action: Action<Payload>) => State;

type ReducerMapValue<State, Payload> =
    | Reducer<State, Payload>
    | ReducerNextThrow<State, Payload>
    | ReducerMap<State, Payload>;

type ReducerMeta<State, Payload, Meta> = (
    state: State,
    action: ActionMeta<Payload, Meta>
) => State;

type ReduxCompatibleReducer<State, Payload> = (
    state: State | undefined,
    action: Action<Payload>
) => State;

type ReduxCompatibleReducerMeta<State, Payload, Meta> = (
    state: State | undefined,
    action: ActionMeta<Payload, Meta>
) => State;