Manually add best type definitions for redux, react-redux, redux-thunk

TypeScript 2.0 introduces a better way of managing type definitions of
third-party libraries using a combination of `npm` `@types` packages and
type definitions built into each package. See
microsoft/TypeScript#9184 for more details. As
a result, I will migrate most of the type definitions currently managed
by the `typings` tool over to these `npm` packages if the package
authors didn't provide their own type definitions inside each package.
That's the objective of this branch.

However, although the author of `redux` does provide a type definition
for his library (as an `index.d.ts` file inside the `redux` npm
package), other `redux` plugins like `react-redux` and 'redux-thunk` has
not updated their type definitions. As such, until those `redux` plugins
update their type definitions, the type definitions for `redux` and
those plugins will have to be "manually" managed i.e. not through an
automated system like `tsd`, `typings` or `npm` packages.

This commit adds the original version of these type definition files
i.e. the versions that can be obtained through automated commands
(listed below for reference). The next commit will slightly modify these
definitions because they were intended to be used as "modular"
definitions instead of as "global" definitions.

- The `react-redux` type definition is version 4.4.8 of the
  `@types/react-redux` npm package.

- The `redux-thunk` definition is version 2.0.27 of the
  `@types/redux-thunk` npm package.

- The `redux` definition is the one that is bundled with version 3.5.2
  of the `redux` npm package.

Author: Huy Nguyen

src/ts/custom-typings/react-redux.d.ts

@@ -0,0 +1,96 @@
+// Type definitions for react-redux 4.4.0
+// Project: https://github.com/rackt/react-redux
+// Definitions by: Qubo <https://github.com/tkqubo>, Sean Kelley <https://github.com/seansfkelley>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="react" />
+/// <reference types="redux" />
+
+import { ComponentClass, Component, StatelessComponent, ReactNode } from 'react';
+import { Store, Dispatch, ActionCreator } from 'redux';
+
+interface ComponentDecorator<TOriginalProps, TOwnProps> {
+    (component: ComponentClass<TOriginalProps> | StatelessComponent<TOriginalProps>): ComponentClass<TOwnProps>;
+}
+
+/**
+ * Decorator that infers the type from the original component
+ *
+ * Can't use the above decorator because it would default the type to {}
+ */
+export interface InferableComponentDecorator {
+    <P, TComponentConstruct extends (ComponentClass<P> | StatelessComponent<P>)>(component: TComponentConstruct): TComponentConstruct;
+}
+
+/**
+ * Connects a React component to a Redux store.
+ *
+ * - Without arguments, just wraps the component, without changing the behavior / props
+ *
+ * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior
+ * is to override ownProps (as stated in the docs), so what remains is everything that's
+ * not a state or dispatch prop
+ *
+ * - When 3rd param is passed, we don't know if ownProps propagate and whether they
+ * should be valid component props, because it depends on mergeProps implementation.
+ * As such, it is the user's responsibility to extend ownProps interface from state or
+ * dispatch props or both when applicable
+ *
+ * @param mapStateToProps
+ * @param mapDispatchToProps
+ * @param mergeProps
+ * @param options
+ */
+export declare function connect(): InferableComponentDecorator;
+
+export declare function connect<TStateProps, TDispatchProps, TOwnProps>(
+    mapStateToProps: MapStateToProps<TStateProps, TOwnProps>,
+    mapDispatchToProps?: MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | MapDispatchToPropsObject
+): ComponentDecorator<TStateProps & TDispatchProps, TOwnProps>;
+
+export declare function connect<TStateProps, TDispatchProps, TOwnProps>(
+    mapStateToProps: MapStateToProps<TStateProps, TOwnProps>,
+    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | MapDispatchToPropsObject,
+    mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps>,
+    options?: Options
+): ComponentDecorator<TStateProps & TDispatchProps, TOwnProps>;
+
+interface MapStateToProps<TStateProps, TOwnProps> {
+    (state: any, ownProps?: TOwnProps): TStateProps;
+}
+
+interface MapDispatchToPropsFunction<TDispatchProps, TOwnProps> {
+    (dispatch: Dispatch, ownProps?: TOwnProps): TDispatchProps;
+}
+
+interface MapDispatchToPropsObject {
+    [name: string]: ActionCreator;
+}
+
+interface MergeProps<TStateProps, TDispatchProps, TOwnProps> {
+    (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps): TStateProps & TDispatchProps;
+}
+
+interface Options {
+    /**
+     * If true, implements shouldComponentUpdate and shallowly compares the result of mergeProps,
+     * preventing unnecessary updates, assuming that the component is a “pure” component
+     * and does not rely on any input or state other than its props and the selected Redux store’s state.
+     * Defaults to true.
+     * @default true
+     */
+    pure: boolean;
+}
+
+export interface ProviderProps {
+    /**
+     * The single Redux store in your application.
+     */
+    store?: Store;
+    children?: ReactNode;
+}
+
+/**
+ * Makes the Redux store available to the connect() calls in the component hierarchy below.
+ */
+export declare class Provider extends Component<ProviderProps, {}> { }

src/ts/custom-typings/redux-thunk.d.ts

@@ -0,0 +1,19 @@
+// Type definitions for redux-thunk v2.0.1
+// Project: https://github.com/gaearon/redux-thunk
+// Definitions by: Qubo <https://github.com/tkqubo>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="redux" />
+
+import * as Redux from "redux";
+
+declare var thunk: ReduxThunk.Thunk;
+export default thunk;
+export as namespace ReduxThunk;
+
+declare namespace ReduxThunk {
+    export interface Thunk extends Redux.Middleware {}
+    export interface ThunkInterface {
+      <T>(dispatch: Redux.Dispatch, getState?: () => T): any;
+    }
+}