diff --git a/.travis.yml b/.travis.yml
index 8d76e3004..e9c9205a1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,5 +6,6 @@ before_install:
 script:
   - npm run lint
   - npm run test:cov
+  - npm run test:typescript
 after_success:
   - npm run coverage
diff --git a/index.d.ts b/index.d.ts
new file mode 100644
index 000000000..886cc1d75
--- /dev/null
+++ b/index.d.ts
@@ -0,0 +1,67 @@
+import { ComponentClass, Component, StatelessComponent } from 'react';
+import { Store, Dispatch, ActionCreator, Action } from 'redux';
+
+interface ComponentDecorator<TOriginalProps, TOwnProps> {
+  (component: StatelessComponent<TOriginalProps>|ComponentClass<TOriginalProps>): ComponentClass<TOwnProps>;
+}
+
+/**
+ * Following 5 functions cover all possible ways connect could be invoked
+ *
+ * - State: Redux state interface (the same one used by Store<S>)
+ * - TOwnProps: Props passed to the wrapping component
+ * - TStateProps: Result of MapStateToProps
+ * - TDispatchProps: Result of MapDispatchToProps
+ */
+export function connect<State, TOwnProps>(): ComponentDecorator<{ dispatch: Dispatch<State> } & TOwnProps, TOwnProps>;
+
+export function connect<State, TOwnProps, TStateProps>(
+  mapStateToProps: FuncOrSelf<MapStateToProps<State, TOwnProps, TStateProps>>,
+): ComponentDecorator<TStateProps & { dispatch: Dispatch<State> } & TOwnProps, TOwnProps>;
+
+export function connect<State, TOwnProps, TStateProps, TDispatchProps>(
+  mapStateToProps: FuncOrSelf<MapStateToProps<State, TOwnProps, TStateProps>> | null,
+  mapDispatchToProps: FuncOrSelf<MapDispatchToPropsFunction<State, TOwnProps, TDispatchProps> | MapDispatchToPropsObject & TDispatchProps>
+): ComponentDecorator<TStateProps & TDispatchProps & TOwnProps, TOwnProps>;
+
+export function connect<State, TOwnProps, TStateProps, TDispatchProps, TMergeProps>(
+  mapStateToProps: FuncOrSelf<MapStateToProps<State, TOwnProps, TStateProps>> | null,
+  mapDispatchToProps: FuncOrSelf<MapDispatchToPropsFunction<State, TOwnProps, TDispatchProps> | MapDispatchToPropsObject & TDispatchProps>|null,
+  mergeProps: MergeProps<TOwnProps, TStateProps, TDispatchProps, TMergeProps> | null,
+  options?: Options
+): ComponentDecorator<TMergeProps, TOwnProps>;
+
+interface MapDispatchToPropsObject {
+  [name: string]: ActionCreator<Action> | ThunkedActionCreator;
+}
+
+type ThunkedActionCreator = (...args: any[]) => (dispatch: Dispatch<any>) => void
+
+interface MapStateToProps<State, TOwnProps, TStateProps> {
+  (state: State, ownProps: TOwnProps): TStateProps;
+}
+
+interface MapDispatchToPropsFunction<State, TOwnProps, TDispatchProps> {
+  (dispatch: Dispatch<State>, ownProps: TOwnProps): TDispatchProps;
+}
+
+interface MergeProps<TOwnProps, TStateProps, TDispatchProps, TMergeProps> {
+  (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps): TMergeProps;
+}
+
+interface Options {
+  pure?: boolean;
+  withRef?: boolean;
+}
+
+type FuncOrSelf<T> = T | (() => T);
+
+/**
+ * Typescript does not support generic components in tsx yet in an intuïtive way which is the reason we avoid a
+ * generic parameter in Store here by using any as the type
+ */
+export interface ProviderProps {
+  store: Store<any>;
+}
+
+export class Provider extends Component<ProviderProps, {}> { }
diff --git a/package.json b/package.json
index d02f57e74..517c12bb9 100644
--- a/package.json
+++ b/package.json
@@ -5,6 +5,7 @@
   "main": "./lib/index.js",
   "module": "es/index.js",
   "jsnext:main": "es/index.js",
+  "typings": "./index.d.ts",
   "scripts": {
     "build:commonjs": "cross-env BABEL_ENV=commonjs babel src --out-dir lib",
     "build:es": "cross-env BABEL_ENV=es babel src --out-dir es",
@@ -17,6 +18,7 @@
     "test": "cross-env BABEL_ENV=commonjs NODE_ENV=test mocha --compilers js:babel-register --recursive --require ./test/setup.js",
     "test:watch": "npm test -- --watch",
     "test:cov": "cross-env NODE_ENV=test nyc npm test",
+    "test:typescript": "typings-tester --dir test/typescript",
     "coverage": "nyc report --reporter=text-lcov > coverage.lcov && codecov"
   },
   "repository": {
@@ -27,7 +29,8 @@
     "dist",
     "lib",
     "src",
-    "es"
+    "es",
+    "index.d.ts"
   ],
   "keywords": [
     "react",
@@ -47,6 +50,7 @@
   },
   "homepage": "https://github.com/gaearon/react-redux",
   "devDependencies": {
+    "@types/react": "^16.0.18",
     "babel-cli": "^6.3.17",
     "babel-core": "^6.3.26",
     "babel-eslint": "^7.1.1",
@@ -98,7 +102,9 @@
     "rollup-plugin-commonjs": "^8.0.2",
     "rollup-plugin-node-resolve": "^3.0.0",
     "rollup-plugin-replace": "^1.1.1",
-    "rollup-plugin-uglify": "^2.0.1"
+    "rollup-plugin-uglify": "^2.0.1",
+    "typescript": "^2.0.10",
+    "typings-tester": "^0.2.0"
   },
   "dependencies": {
     "hoist-non-react-statics": "^2.2.1",
diff --git a/test/typescript/test.tsx b/test/typescript/test.tsx
new file mode 100644
index 000000000..df9179db6
--- /dev/null
+++ b/test/typescript/test.tsx
@@ -0,0 +1,358 @@
+import * as React from 'react'
+import {Dispatch, Store} from "redux";
+import {connect, Provider} from "../../index";
+
+
+function testNoArgs() {
+  const Connected = connect()(props => {
+    // typings:expect-error
+    props.foo;
+
+    return <button onClick={() => props.dispatch({type: 'CLICKED'})}/>;
+  });
+
+  // typings:expect-error
+  const c = <Connected foo="foo"/>;
+
+  const ConnectedWithProps = connect<{}, {foo: string}>()(props => {
+    props.foo;
+    return <button onClick={() => props.dispatch({type: 'CLICKED'})}/>;
+  });
+
+  const cp = <ConnectedWithProps foo="foo"/>;
+
+  const connectorWithProps = connect<{}, {foo: string}>();
+
+  // typings:expect-error
+  connectorWithProps((props: {bar: string}) => <div/>);
+}
+
+
+function testMapState() {
+  type MyState = {foo: string, bar: number};
+
+  // typings:expect-error
+  connect<MyState, {}, {}>((state: {baz: boolean}) => ({}));
+
+  const Connected = connect(
+    (state: MyState, props: {baz: boolean}) => {
+      return {
+        foo: state.foo,
+        fizz: props.baz,
+      };
+    },
+  )(props => {
+    const foo: string = props.foo;
+    const baz: boolean = props.baz;
+    const fizz: boolean = props.fizz;
+
+    // typings:expect-error
+    props.bar;
+
+    props.dispatch({type: 'ACTION'});
+
+    return <div/>;
+  });
+
+  // typings:expect-error
+  <Connected/>;
+
+  <Connected baz/>;
+
+  // typings:expect-error
+  <Connected baz="baz"/>;
+
+  const Connected2 = connect<MyState, {baz: boolean}, {foo: string, fizz: boolean}>(
+    () => (state: MyState, props: {baz: boolean}) => {
+      return {
+        foo: state.foo,
+        fizz: props.baz,
+      };
+    }
+  )(props => {
+    const foo: string = props.foo;
+    const baz: boolean = props.baz;
+    const fizz: boolean = props.fizz;
+
+    // typings:expect-error
+    props.bar;
+
+    props.dispatch({type: 'ACTION'});
+
+    return <div/>;
+  });
+
+  // typings:expect-error
+  <Connected2/>;
+
+  <Connected2 baz/>;
+
+  // typings:expect-error
+  <Connected2 baz="baz"/>;
+}
+
+
+function testMapDispatch() {
+  type MyState = {foo: string};
+
+  const Connected = connect(
+    (state: MyState) => {
+      return {
+        foo: state.foo,
+      };
+    },
+    (dispatch: Dispatch<MyState>) => {
+      return {
+        handleClick() {
+          dispatch({type: 'CLICKED'});
+        },
+      };
+    },
+  )(props => {
+    const foo: string = props.foo;
+    // typings:expect-error
+    props.bar;
+
+    // typings:expect-error
+    props.dispatch({type: 'TYPE'});
+
+    return <button onClick={props.handleClick}/>;
+  });
+
+  <Connected/>;
+  // typings:expect-error
+  <Connected bar={42}/>;
+
+  type Props = {bar: number};
+  const ConnectedWithProps = connect(
+    (state: MyState) => {
+      return {foo: state.foo};
+    },
+    (dispatch: Dispatch<MyState>, props: Props) => {
+      return {
+        handleClick() {
+          dispatch({type: 'CLICKED', bar: props.bar});
+        },
+      };
+    },
+  )(props => {
+    const foo: string = props.foo;
+    const bar: number = props.bar;
+
+    // typings:expect-error
+    props.dispatch({type: 'TYPE'});
+
+    return <button onClick={props.handleClick}/>;
+  });
+
+  // typings:expect-error
+  <ConnectedWithProps/>;
+
+  <ConnectedWithProps bar={42}/>;
+
+  const ConnectedWithDispatchObject = connect(
+    (state: MyState) => {
+      return {foo: state.foo};
+    },
+    {
+      handleClick() {
+        return {type: 'CLICKED'};
+      },
+    },
+  )(props => {
+    const foo: string = props.foo;
+    // typings:expect-error
+    props.bar;
+
+    // typings:expect-error
+    props.dispatch({type: 'TYPE'});
+
+    return <button onClick={props.handleClick}/>;
+  });
+
+  // typings:expect-error
+  connect(
+    null,
+    {
+      handleClick: () => 'not-an-action',
+    },
+  );
+
+  connect(
+    null,
+    {
+      handleClick: () => dispatch => {
+        // typings:expect-error
+        dispatch({notType: 'SOME_ACTION'});
+      },
+    },
+  );
+
+  connect(
+    null,
+    {
+      handleClick: (a: string) => dispatch => {
+        dispatch({type: 'SOME_ACTION', a});
+      },
+    },
+  )(props => {
+    // works but return type is wrong. Cannot do much better until mapped types land in TS stable.
+    // Not a big deal since user expects void.
+    props.handleClick('works')
+
+    // typings:expect-error
+    props.handleClick(1)
+    return <hr/>
+  });
+
+  connect<{}, {}, {}, {handleClick(a: string): void}>(
+    null,
+    {
+      handleClick: (a: string) => (dispatch: Dispatch<MyState>) => {
+        dispatch({type: 'SOME_ACTION', a});
+      },
+    },
+  )(props => {
+    // works and return type is correct (from template variable). 
+    props.handleClick('works')
+
+    // typings:expect-error
+    props.handleClick(1)
+    return <hr/>
+  });
+
+}
+
+function testMergeProps() {
+  type MyState = {foo: string};
+
+  const connector = connect(
+    (state: MyState) => {
+      return {foo: state.foo};
+    },
+    (dispatch: Dispatch<MyState>) => {
+      return {
+        handleClick() {
+          dispatch({type: 'CLICKED'});
+        },
+      };
+    },
+    (stateProps, dispatchProps) => {
+      // typings:expect-error
+      stateProps.bar;
+      // typings:expect-error
+      dispatchProps.foo;
+
+      return {stateProps, dispatchProps};
+    }
+  );
+
+  // typings:expect-error
+  connector((props: {bar: number}) => <div/>);
+
+  const Connected = connector(props => {
+    // typings:expect-error
+    props.foo;
+    // typings:expect-error
+    props.handleClick;
+
+    const foo: string = props.stateProps.foo;
+
+    return <button onClick={props.dispatchProps.handleClick}/>;
+  });
+
+  // typings:expect-error
+  <Connected foo="fizz"/>;
+
+  <Connected/>;
+
+  type MyProps = {bar: number};
+
+  const Connected2 = connect(
+    (state: MyState, props: MyProps) => {
+      return {
+        foo: state.foo,
+        baz: props.bar,
+      };
+    },
+    (dispatch: Dispatch<MyState>, props: MyProps) => {
+      // typings:expect-error
+      props.foo;
+
+      return {
+        handleClick() {
+          dispatch({type: 'CLICKED', bar: props.bar});
+        },
+      };
+    },
+    (stateProps, dispatchProps, ownProps) => {
+      // typings:expect-error
+      stateProps.bar;
+      // typings:expect-error
+      dispatchProps.bar;
+      // typings:expect-error
+      ownProps.foo;
+
+      return {
+        fizz: stateProps.foo,
+        bazz: stateProps.baz,
+        buzz: ownProps.bar,
+        clickHandler: dispatchProps.handleClick,
+      }
+    }
+  )(props => {
+    // typings:expect-error
+    props.foo;
+    // typings:expect-error
+    props.baz;
+    // typings:expect-error
+    props.bar;
+    // typings:expect-error
+    props.handleClick;
+
+    const fizz: string = props.fizz;
+    const bazz: number = props.bazz;
+    const buzz: number = props.buzz;
+
+    return <button onClick={props.clickHandler}/>;
+  });
+
+  // typings:expect-error
+  <Connected2 foo="foo"/>;
+  // typings:expect-error
+  <Connected2 handleClick={() => {}}/>;
+  // typings:expect-error
+  <Connected2/>;
+
+  <Connected2 bar={1}/>;
+}
+
+function testOptions() {
+  // typings:expect-error
+  connect(null, null, null, {pure: 1});
+  // typings:expect-error
+  connect(null, null, null, {withRef: 1});
+
+  connect(null, null, null, {pure: true});
+  connect(null, null, null, {withRef: true});
+  connect(null, null, null, {pure: true, withRef: true});
+
+  connect(
+    (state: {foo: string}) => ({foo: state.foo}),
+    null,
+    null,
+    {pure: true}
+  );
+}
+
+function testProvider() {
+  // typings:expect-error
+  <Provider/>;
+  // typings:expect-error
+  <Provider store=""/>;
+  // typings:expect-error
+  <Provider store={null}/>;
+
+  let store: Store<{}> = {} as Store<{}>;
+  <Provider store={store}/>;
+}
diff --git a/test/typescript/tsconfig.json b/test/typescript/tsconfig.json
new file mode 100644
index 000000000..47fb5656e
--- /dev/null
+++ b/test/typescript/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "jsx": "react",
+    "noImplicitAny": true,
+    "strictNullChecks": true
+  }
+}