redux-typescript-example.ts

namespace Redux {
  export interface Action<TType extends string, TPayload> {
    type: TType;
    payload: TPayload;
  }

  export interface Thunk<TAction, TResult> {
    (dispatch: Dispatch<TAction>, getState: () => any): TResult;
  }

  export interface Dispatch<TAction> {
    (action: TAction): void;
    <TResult>(thunk: Thunk<TAction, TResult>): TResult;
  }
}

namespace Example {

  namespace ActionTypes {
    export type REQUEST = 'REQUEST';
    export type COMPLETE = 'COMPLETE';
    export type FAILURE = 'FAILURE';

    export const REQUEST: REQUEST = 'REQUEST';
    export const COMPLETE: COMPLETE = 'COMPLETE';
    export const FAILURE: FAILURE = 'FAILURE';
  }

  type TypedAction =
      Redux.Action<ActionTypes.REQUEST, { value: string }>
    | Redux.Action<ActionTypes.COMPLETE, { result: any }>
    | Redux.Action<ActionTypes.FAILURE, { error: any }>
    ;

  namespace ActionCreators {

    export function request(value: string): Thunk<TypedAction, Promise<string>> {
      return (dispatch) => {
        dispatch({
          type: ActionTypes.REQUEST,
          payload: { value, bla: '' },
        });

        const promise = new Promise((resolve) => {
          resolve('OK: ' + value);
        });

        promise.then(
          result => dispatch(requestComplete(result)),
          error => dispatch(requestFailure(error))
        );

        return promise;
      };
    }

    export function requestComplete(result: any): TypedAction {
      return {
        type: ActionTypes.COMPLETE,
        payload: { result },
      };
    }

    export function requestFailure(error: any): TypedAction {
      return {
        type: ActionTypes.FAILURE,
        payload: { error },
      };
    }

    export function reducer(state, action: TypedAction) {
      switch (action.type) {
        case ActionTypes.REQUEST: {
          const { payload } = action;
          return Object.assign({}, state, { value: payload.value });
        }
        case ActionTypes.COMPLETE: {
          const { payload } = action;
          return Object.assign({}, state, { result: payload.result });
        }
        case ActionTypes.FAILURE:{
          const { payload } = action;
          return Object.assign({}, state, { error: payload.error });
        }
      }
    }

  }
}