diff --git a/types/react-redux/index.d.ts b/types/react-redux/index.d.ts
index 5cbde2e8db..2f919581f4 100644
--- a/types/react-redux/index.d.ts
+++ b/types/react-redux/index.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for react-redux 6.0.4
+// Type definitions for react-redux 6.0
 // Project: https://github.com/reduxjs/react-redux
 // Definitions by: Qubo <https://github.com/tkqubo>,
 //                 Kenzie Togami <https://github.com/kenzierocks>,
@@ -11,6 +11,7 @@
 //                 Valentin Descamps <https://github.com/val1984>
 //                 Johann Rakotoharisoa <https://github.com/jrakotoharisoa>
 //                 Anatoli Papirovski <https://github.com/apapirovski>
+//                 Boris Sergeyev <https://github.com/surgeboris>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -42,15 +43,14 @@ import {
 } from 'redux';
 
 // Omit taken from https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html
-type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
 export interface DispatchProp<A extends Action = AnyAction> {
     dispatch: Dispatch<A>;
 }
 
-interface AdvancedComponentDecorator<TProps, TOwnProps> {
-    (component: ComponentType<TProps>): ComponentClass<TOwnProps>;
-}
+export type AdvancedComponentDecorator<TProps, TOwnProps> =
+    (component: ComponentType<TProps>) => ComponentClass<TOwnProps>;
 
 /**
  * A property P will be present if:
@@ -64,7 +64,7 @@ interface AdvancedComponentDecorator<TProps, TOwnProps> {
  * - if property P is present in InjectedProps but does not extend the
  *   DecorationTargetProps[P] definition, its definition will be that of InjectedProps[P]
  */
-type Matching<InjectedProps, DecorationTargetProps> = {
+export type Matching<InjectedProps, DecorationTargetProps> = {
 	[P in keyof DecorationTargetProps]: P extends keyof InjectedProps
 		? InjectedProps[P] extends DecorationTargetProps[P]
 			? DecorationTargetProps[P]
@@ -82,7 +82,7 @@ type Matching<InjectedProps, DecorationTargetProps> = {
  * required by the decorated (right hand side) component.
  * But any property required by the decorated component must be satisfied by the injected property.
  */
-type Shared<
+export type Shared<
     InjectedProps,
     DecorationTargetProps extends Shared<InjectedProps, DecorationTargetProps>
     > = {
@@ -90,28 +90,41 @@ type Shared<
     };
 
 // Infers prop type from component C
-type GetProps<C> = C extends ComponentType<infer P> ? P : never;
+export type GetProps<C> = C extends ComponentType<infer P> ? P : never;
 
 // Applies LibraryManagedAttributes (proper handling of defaultProps
 // and propTypes), as well as defines WrappedComponent.
-type ConnectedComponentClass<C, P> = ComponentClass<JSX.LibraryManagedAttributes<C, P>> & {
+export type ConnectedComponentClass<C, P> = ComponentClass<JSX.LibraryManagedAttributes<C, P>> & {
 	WrappedComponent: C;
-}
+};
 
 // Injects props and removes them from the prop requirements.
 // Will not pass through the injected props if they are passed in during
 // render. Also adds new prop requirements from TNeedsProps.
-export interface InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> {
+export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> =
 	<C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>>(
 		component: C
-	): ConnectedComponentClass<C, Omit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> & TNeedsProps>
-}
+	) => ConnectedComponentClass<C, Omit<GetProps<C>, keyof Shared<TInjectedProps, GetProps<C>>> & TNeedsProps>;
 
 // Injects props and removes them from the prop requirements.
 // Will not pass through the injected props if they are passed in during
 // render.
 export type InferableComponentEnhancer<TInjectedProps> =
-    InferableComponentEnhancerWithProps<TInjectedProps, {}>
+    InferableComponentEnhancerWithProps<TInjectedProps, {}>;
+
+export type HandleThunkActionCreator<TActionCreator> =
+    TActionCreator extends (...args: any[]) => (...args: any[]) => any
+        ? ReturnType<TActionCreator>
+        : TActionCreator;
+
+// redux-thunk middleware returns thunk's return value from dispatch call
+// https://github.com/reduxjs/redux-thunk#composition
+export type WithThunkActionCreators<TDispatchProps> =
+    TDispatchProps extends { [key: string]: any }
+        ? {
+            [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>
+        }
+        : TDispatchProps;
 
 /**
  * Connects a React component to a Redux store.
@@ -133,6 +146,7 @@ export type InferableComponentEnhancer<TInjectedProps> =
  * @param options
  */
 export interface Connect {
+    // tslint:disable:no-unnecessary-generics
     (): InferableComponentEnhancer<DispatchProp>;
 
     <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = {}>(
@@ -142,12 +156,18 @@ export interface Connect {
     <no_state = {}, TDispatchProps = {}, TOwnProps = {}>(
         mapStateToProps: null | undefined,
         mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
+    ): InferableComponentEnhancerWithProps<
+        WithThunkActionCreators<TDispatchProps>,
+        TOwnProps
+    >;
 
     <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = {}>(
         mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
         mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
+    ): InferableComponentEnhancerWithProps<
+        TStateProps & WithThunkActionCreators<TDispatchProps>,
+        TOwnProps
+    >;
 
     <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, TMergedProps = {}, State = {}>(
         mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
@@ -171,6 +191,7 @@ export interface Connect {
         mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
         mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
         mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,
+        options?: Options<State, TStateProps, TOwnProps, TMergedProps>
     ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
 
     <TStateProps = {}, no_dispatch = {}, TOwnProps = {}, State = {}>(
@@ -185,56 +206,51 @@ export interface Connect {
         mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
         mergeProps: null | undefined,
         options: Options<{}, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TDispatchProps, TOwnProps>;
+    ): InferableComponentEnhancerWithProps<
+        WithThunkActionCreators<TDispatchProps>,
+        TOwnProps
+    >;
 
     <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, State = {}>(
         mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
         mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
         mergeProps: null | undefined,
         options: Options<State, TStateProps, TOwnProps>
-    ): InferableComponentEnhancerWithProps<TStateProps & TDispatchProps, TOwnProps>;
-
-    <TStateProps = {}, TDispatchProps = {}, TOwnProps = {}, TMergedProps = {}, State = {}>(
-        mapStateToProps: MapStateToPropsParam<TStateProps, TOwnProps, State>,
-        mapDispatchToProps: MapDispatchToPropsParam<TDispatchProps, TOwnProps>,
-        mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps>,
-        options: Options<State, TStateProps, TOwnProps, TMergedProps>
-    ): InferableComponentEnhancerWithProps<TMergedProps, TOwnProps>;
+    ): InferableComponentEnhancerWithProps<
+        TStateProps & WithThunkActionCreators<TDispatchProps>,
+        TOwnProps
+    >;
+    // tslint:enable:no-unnecessary-generics
 }
 
 /**
  * The connect function. See {@type Connect} for details.
  */
-export declare const connect: Connect;
+export const connect: Connect;
 
-interface MapStateToProps<TStateProps, TOwnProps, State> {
-    (state: State, ownProps: TOwnProps): TStateProps;
-}
+export type MapStateToProps<TStateProps, TOwnProps, State> =
+    (state: State, ownProps: TOwnProps) => TStateProps;
 
-interface MapStateToPropsFactory<TStateProps, TOwnProps, State> {
-    (initialState: State, ownProps: TOwnProps): MapStateToProps<TStateProps, TOwnProps, State>;
-}
+export type MapStateToPropsFactory<TStateProps, TOwnProps, State> =
+    (initialState: State, ownProps: TOwnProps) => MapStateToProps<TStateProps, TOwnProps, State>;
 
-type MapStateToPropsParam<TStateProps, TOwnProps, State> = MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
+export type MapStateToPropsParam<TStateProps, TOwnProps, State> = MapStateToPropsFactory<TStateProps, TOwnProps, State> | MapStateToProps<TStateProps, TOwnProps, State> | null | undefined;
 
-interface MapDispatchToPropsFunction<TDispatchProps, TOwnProps> {
-    (dispatch: Dispatch<Action>, ownProps: TOwnProps): TDispatchProps;
-}
+export type MapDispatchToPropsFunction<TDispatchProps, TOwnProps> =
+    (dispatch: Dispatch<Action>, ownProps: TOwnProps) => TDispatchProps;
 
-type MapDispatchToProps<TDispatchProps, TOwnProps> =
+export type MapDispatchToProps<TDispatchProps, TOwnProps> =
     MapDispatchToPropsFunction<TDispatchProps, TOwnProps> | TDispatchProps;
 
-interface MapDispatchToPropsFactory<TDispatchProps, TOwnProps> {
-    (dispatch: Dispatch<Action>, ownProps: TOwnProps): MapDispatchToProps<TDispatchProps, TOwnProps>;
-}
+export type MapDispatchToPropsFactory<TDispatchProps, TOwnProps> =
+    (dispatch: Dispatch<Action>, ownProps: TOwnProps) => MapDispatchToProps<TDispatchProps, TOwnProps>;
 
-type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
+export type MapDispatchToPropsParam<TDispatchProps, TOwnProps> = MapDispatchToPropsFactory<TDispatchProps, TOwnProps> | MapDispatchToProps<TDispatchProps, TOwnProps>;
 
-interface MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> {
-    (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps): TMergedProps;
-}
+export type MergeProps<TStateProps, TDispatchProps, TOwnProps, TMergedProps> =
+    (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps) => TMergedProps;
 
-interface Options<State = {}, TStateProps = {}, TOwnProps = {}, TMergedProps = {}> extends ConnectOptions {
+export interface Options<State = {}, TStateProps = {}, TOwnProps = {}, TMergedProps = {}> extends ConnectOptions {
     /**
      * If true, implements shouldComponentUpdate and shallowly compares the result of mergeProps,
      * preventing unnecessary updates, assuming that the component is a “pure” component
@@ -275,11 +291,12 @@ interface Options<State = {}, TStateProps = {}, TOwnProps = {}, TMergedProps = {
  * assumptions about defaults or memoization of results, leaving those responsibilities to the caller.It does not
  * modify the component class passed to it; instead, it returns a new, connected component class for you to use.
  *
- * @param selectorFactory The selector factory. See {@type SelectorFactory} for details.
+ * @param selectorFactory The selector factory. See SelectorFactory type for details.
  * @param connectOptions If specified, further customizes the behavior of the connector. Additionally, any extra
  *     options will be passed through to your <code>selectorFactory</code> in the <code>factoryOptions</code> argument.
  */
-export declare function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(
+export function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions = {}>(
+    // tslint:disable-next-line no-unnecessary-generics
     selectorFactory: SelectorFactory<S, TProps, TOwnProps, TFactoryOptions>,
     connectOptions?: ConnectOptions & TFactoryOptions
 ): AdvancedComponentDecorator<TProps, TOwnProps>;
@@ -292,13 +309,10 @@ export declare function connectAdvanced<S, TProps, TOwnProps, TFactoryOptions =
  * call, the component will not be re-rendered. It's the responsibility of <code>selector</code> to return that
  * previous object when appropriate.
  */
-export interface SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> {
-    (dispatch: Dispatch<Action>, factoryOptions: TFactoryOptions): Selector<S, TProps, TOwnProps>
-}
+export type SelectorFactory<S, TProps, TOwnProps, TFactoryOptions> =
+    (dispatch: Dispatch<Action>, factoryOptions: TFactoryOptions) => Selector<S, TProps, TOwnProps>;
 
-export interface Selector<S, TProps, TOwnProps> {
-    (state: S, ownProps: TOwnProps): TProps
-}
+export type Selector<S, TProps, TOwnProps> = (state: S, ownProps: TOwnProps) => TProps;
 
 export interface ConnectOptions {
     /**
@@ -308,13 +322,13 @@ export interface ConnectOptions {
      * @default name => 'ConnectAdvanced('+name+')'
      * @param componentName
      */
-    getDisplayName?: (componentName: string) => string
+    getDisplayName?: (componentName: string) => string;
     /**
      * Shown in error messages. Usually overridden by wrapper functions.
      *
      * @default 'connectAdvanced'
      */
-    methodName?: string
+    methodName?: string;
     /**
      * If defined, a property named this value will be added to the props passed to the wrapped component. Its value
      * will be the number of times the component has been rendered, which can be useful for tracking down unnecessary
@@ -322,27 +336,27 @@ export interface ConnectOptions {
      *
      * @default undefined
      */
-    renderCountProp?: string
+    renderCountProp?: string;
     /**
      * Controls whether the connector component subscribes to redux store state changes. If set to false, it will only
      * re-render on <code>componentWillReceiveProps</code>.
      *
      * @default true
      */
-    shouldHandleStateChanges?: boolean
+    shouldHandleStateChanges?: boolean;
     /**
      * The key of props/context to get the store. You probably only need this if you are in the inadvisable position of
      * having multiple stores.
      *
      * @default 'store'
      */
-    storeKey?: string
+    storeKey?: string;
     /**
      * If true, stores a ref to the wrapped component instance and makes it available via getWrappedInstance() method.
      *
      * @default false
      */
-    withRef?: boolean
+    withRef?: boolean;
 }
 
 export interface ProviderProps<A extends Action = AnyAction> {
@@ -364,4 +378,4 @@ export class Provider<A extends Action = AnyAction> extends Component<ProviderPr
  *
  * @param storeKey The key of the context on which to set the store.
  */
-export declare function createProvider(storeKey: string): typeof Provider;
+export function createProvider(storeKey: string): typeof Provider;
diff --git a/types/react-redux/react-redux-tests.tsx b/types/react-redux/react-redux-tests.tsx
index 3b25b25843..aff8515e87 100644
--- a/types/react-redux/react-redux-tests.tsx
+++ b/types/react-redux/react-redux-tests.tsx
@@ -1,4 +1,3 @@
-import { Component, ReactElement } from 'react';
 import * as React from 'react';
 import * as ReactDOM from 'react-dom';
 import { Store, Dispatch, AnyAction, ActionCreator, createStore, bindActionCreators, ActionCreatorsMapObject, Reducer } from 'redux';
@@ -13,250 +12,273 @@ import objectAssign = require('object-assign');
 // Test cases written in a way to isolate types and variables and verify the
 // output of `connect` to make sure the signature is what is expected
 
-namespace Empty {
-    interface OwnProps { foo: string, dispatch: Dispatch }
+function Empty() {
+    interface OwnProps {
+        dispatch: Dispatch;
+        foo: string;
+    }
 
-    class TestComponent extends Component<OwnProps> {}
+    class TestComponent extends React.Component<OwnProps> {}
 
-    const Test = connect()(TestComponent)
+    const Test = connect()(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapState {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
+function MapState() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
 
-    class TestComponent extends Component<OwnProps & StateProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps> {}
 
     const mapStateToProps = (_: any) => ({
         bar: 1
-    })
+    });
 
     const Test = connect(
         mapStateToProps
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapStateWithDispatchProp {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number, dispatch: Dispatch }
+function MapStateWithDispatchProp() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; dispatch: Dispatch; }
 
-    class TestComponent extends Component<OwnProps & StateProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps> {}
 
     const mapStateToProps = (_: any) => ({
         bar: 1
-    })
+    });
 
     const Test = connect(
         mapStateToProps
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapStateFactory {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
+function MapStateFactory() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
 
-    class TestComponent extends Component<OwnProps & StateProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps> {}
 
     const mapStateToProps = () => () => ({
         bar: 1
-    })
+    });
 
     const Test = connect(
         mapStateToProps
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapDispatch {
-    interface OwnProps { foo: string }
-    interface DispatchProps { onClick: () => void }
+function MapDispatch() {
+    interface OwnProps { foo: string; }
+    interface DispatchProps { onClick: () => void; }
 
-    class TestComponent extends Component<OwnProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & DispatchProps> {}
 
     const mapDispatchToProps = () => ({
         onClick: () => {}
-    })
+    });
 
     const TestNull = connect(
         null,
         mapDispatchToProps,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verifyNull = <TestNull foo='bar' />
+    const verifyNull = <TestNull foo='bar' />;
 
     const TestUndefined = connect(
         undefined,
         mapDispatchToProps,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verifyUndefined = <TestUndefined foo='bar' />
+    const verifyUndefined = <TestUndefined foo='bar' />;
 }
 
-namespace MapStateAndDispatchObject {
-    interface ClickPayload { count: number }
+function MapDispatchWithThunkActionCreators() {
+    class TestComponent extends React.Component<{
+        foo: string,
+        onClick(): void,
+        thunkAction(): Promise<void>
+    }> {}
+
+    const mapDispatchToProps = () => ({
+        onClick: () => {},
+        thunkAction: () => async () => {}
+    });
+
+    const Test = connect(
+        null,
+        mapDispatchToProps,
+    )(TestComponent);
+
+    const verify = <Test foo='bar' />;
+}
+
+function MapStateAndDispatchObject() {
+    interface ClickPayload { count: number; }
     const onClick: ActionCreator<ClickPayload> = () => ({ count: 1 });
     const dispatchToProps = {
         onClick,
     };
 
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
-    interface DispatchProps { onClick: ActionCreator<ClickPayload> }
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
+    interface DispatchProps { onClick: ActionCreator<ClickPayload>; }
 
     const mapStateToProps = (_: any, __: OwnProps): StateProps => ({
         bar: 1
-    })
+    });
 
-    class TestComponent extends Component<OwnProps & StateProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps & DispatchProps> {}
 
     const Test = connect(
         mapStateToProps,
         dispatchToProps,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapDispatchFactory {
-    interface OwnProps { foo: string }
-    interface DispatchProps { onClick: () => void }
+function MapDispatchFactory() {
+    interface OwnProps { foo: string; }
+    interface DispatchProps { onClick: () => void; }
 
-    class TestComponent extends Component<OwnProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & DispatchProps> {}
 
     const mapDispatchToPropsFactory = () => () => ({
         onClick: () => {}
-    })
+    });
 
     const TestNull = connect(
         null,
         mapDispatchToPropsFactory,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verifyNull = <TestNull foo='bar' />
+    const verifyNull = <TestNull foo='bar' />;
 
     const TestUndefined = connect(
         undefined,
         mapDispatchToPropsFactory,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verifyUndefined = <TestUndefined foo='bar' />
+    const verifyUndefined = <TestUndefined foo='bar' />;
 }
 
-namespace MapStateAndDispatch {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
-    interface DispatchProps { onClick: () => void }
+function MapStateAndDispatch() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
+    interface DispatchProps { onClick: () => void; }
 
-    class TestComponent extends Component<OwnProps & StateProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps & DispatchProps> {}
 
     const mapStateToProps = () => ({
         bar: 1
-    })
+    });
 
     const mapDispatchToProps = () => ({
         onClick: () => {}
-    })
+    });
 
     const Test = connect(
         mapStateToProps,
         mapDispatchToProps,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapStateFactoryAndDispatch {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
-    interface DispatchProps { onClick: () => void }
+function MapStateFactoryAndDispatch() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
+    interface DispatchProps { onClick: () => void; }
 
-    const mapStateToPropsFactory = () => () =>({
+    const mapStateToPropsFactory = () => () => ({
         bar: 1
-    })
+    });
 
     const mapDispatchToProps = () => ({
         onClick: () => {}
-    })
+    });
 
-    class TestComponent extends Component<OwnProps & StateProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps & DispatchProps> {}
 
     const Test = connect(
         mapStateToPropsFactory,
         mapDispatchToProps,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapStateFactoryAndDispatchFactory {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
-    interface DispatchProps { onClick: () => void }
+function MapStateFactoryAndDispatchFactory() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
+    interface DispatchProps { onClick: () => void; }
 
-    const mapStateToPropsFactory = () => () =>({
+    const mapStateToPropsFactory = () => () => ({
         bar: 1
-    })
+    });
 
     const mapDispatchToPropsFactory = () => () => ({
         onClick: () => {}
-    })
+    });
 
-    class TestComponent extends Component<OwnProps & StateProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps & DispatchProps> {}
 
     const Test = connect(
         mapStateToPropsFactory,
         mapDispatchToPropsFactory,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapStateAndDispatchAndMerge {
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
-    interface DispatchProps { onClick: () => void }
+function MapStateAndDispatchAndMerge() {
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
+    interface DispatchProps { onClick: () => void; }
 
-    class TestComponent extends Component<OwnProps & StateProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps & DispatchProps> {}
 
     const mapStateToProps = () => ({
         bar: 1
-    })
+    });
 
     const mapDispatchToProps = () => ({
         onClick: () => {}
-    })
+    });
 
     const mergeProps = (stateProps: StateProps, dispatchProps: DispatchProps) => (
-        Object.assign({}, stateProps, dispatchProps)
-    )
+        { ...stateProps, ...dispatchProps }
+    );
 
     const Test = connect(
         mapStateToProps,
         mapDispatchToProps,
         mergeProps,
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
-namespace MapStateAndOptions {
+function MapStateAndOptions() {
     interface State { state: string; }
-    interface OwnProps { foo: string }
-    interface StateProps { bar: number }
-    interface DispatchProps { dispatch: Dispatch }
+    interface OwnProps { foo: string; }
+    interface StateProps { bar: number; }
+    interface DispatchProps { dispatch: Dispatch; }
 
-    class TestComponent extends Component<OwnProps & StateProps & DispatchProps> {}
+    class TestComponent extends React.Component<OwnProps & StateProps & DispatchProps> {}
 
     const mapStateToProps = (state: State) => ({
         bar: 1
-    })
+    });
 
     const areStatePropsEqual = (next: StateProps, current: StateProps) => true;
 
@@ -268,17 +290,17 @@ namespace MapStateAndOptions {
             pure: true,
             areStatePropsEqual,
         }
-    )(TestComponent)
+    )(TestComponent);
 
-    const verify = <Test foo='bar' />
+    const verify = <Test foo='bar' />;
 }
 
 interface CounterState {
     counter: number;
 }
-declare var increment: Function;
+declare var increment: () => { type: string };
 
-class Counter extends Component<any, any> {
+class Counter extends React.Component<any, any> {
     render() {
         return (
             <button onClick={this.props.onIncrement}>
@@ -306,49 +328,46 @@ connect(
     mapDispatchToProps
 )(Counter);
 
-
 @connect(mapStateToProps)
-class CounterContainer extends Component<any, any> {
-
+class CounterContainer extends React.Component<any, any> {
 }
 
 // Ensure connect's first two arguments can be replaced by wrapper functions
-interface ICounterStateProps {
-    value: number
+interface CounterStateProps {
+    value: number;
 }
-interface ICounterDispatchProps {
-    onIncrement: () => void
+interface CounterDispatchProps {
+    onIncrement: () => void;
 }
 // with higher order functions
-connect<ICounterStateProps, ICounterDispatchProps, {}, CounterState>(
+connect<CounterStateProps, CounterDispatchProps, {}, CounterState>(
     () => mapStateToProps,
     () => mapDispatchToProps
 )(Counter);
 // with higher order functions using parameters
-connect<ICounterStateProps, ICounterDispatchProps, {}, CounterState>(
+connect<CounterStateProps, CounterDispatchProps, {}, CounterState>(
     (initialState: CounterState, ownProps) => mapStateToProps,
     (dispatch: Dispatch, ownProps) => mapDispatchToProps
 )(Counter);
 // only first argument
-connect<ICounterStateProps, {}, {}, CounterState>(
+connect<CounterStateProps, {}, {}, CounterState>(
     () => mapStateToProps
 )(Counter);
 // wrap only one argument
-connect<ICounterStateProps, ICounterDispatchProps, {}, CounterState>(
+connect<CounterStateProps, CounterDispatchProps, {}, CounterState>(
     mapStateToProps,
     () => mapDispatchToProps
 )(Counter);
 // with extra arguments
-connect<ICounterStateProps, ICounterDispatchProps, {}, ICounterStateProps & ICounterDispatchProps, CounterState>(
+connect<CounterStateProps, CounterDispatchProps, {}, CounterStateProps & CounterDispatchProps, CounterState>(
     () => mapStateToProps,
     () => mapDispatchToProps,
-    (s: ICounterStateProps, d: ICounterDispatchProps) =>
+    (s: CounterStateProps, d: CounterDispatchProps) =>
         objectAssign({}, s, d),
     { pure: true }
 )(Counter);
 
-
-class App extends Component<any, any> {
+class App extends React.Component<any, any> {
     render() {
         return null;
     }
@@ -367,10 +386,9 @@ ReactDOM.render((
 // https://github.com/rackt/react-redux/blob/master/docs/api.md
 //
 declare var store: Store<TodoState>;
-class MyRootComponent extends Component<any, any> {
-
+class MyRootComponent extends React.Component<any, any> {
 }
-class TodoApp extends Component<any, any> {}
+class TodoApp extends React.Component<any, any> {}
 interface TodoState {
     todos: string[]|string;
 }
@@ -379,11 +397,11 @@ interface TodoProps {
 }
 interface DispatchProps {
     addTodo(userId: number, text: string): void;
-    action: Function;
+    action: () => any;
 }
 declare var actionCreators: () => {
-    action: Function;
-}
+    action: () => any;
+};
 declare var dispatchActionCreators: () => DispatchProps;
 declare var addTodo: () => { type: string; };
 declare var todoActionCreators: { [type: string]: (...args: any[]) => any; };
@@ -396,28 +414,12 @@ ReactDOM.render(
     document.body
 );
 
-//TODO: for React Router 0.13
-////TODO: error TS2339: Property 'run' does not exist on type 'typeof "react-router"'.
-////TODO: error TS2339: Property 'HistoryLocation' does not exist on type 'typeof "react-router"'.
-//declare var routes: any;
-//Router.run(routes, Router.HistoryLocation, (Handler, routerState) => { // note "routerState" here
-//    ReactDOM.render(
-//        <Provider store={store}>
-//            {/*
-//             //TODO: error TS2339: Property 'routerState' does not exist on type 'RouteProp'.
-//             {() => <Handler routerState={routerState} />} // note "routerState" here: important to pass it down
-//            */}
-//        </Provider>,
-//        document.getElementById('root')
-//    );
-//});
-
 // Inject just dispatch and don't listen to store
 
-const AppWrap = (props: DispatchProp & { children?: React.ReactNode }) => <div />
+const AppWrap = (props: DispatchProp & { children?: React.ReactNode }) => <div />;
 const WrappedApp = connect()(AppWrap);
 
-<WrappedApp />
+<WrappedApp />;
 
 // Inject dispatch and every field in the global state
 
@@ -431,20 +433,8 @@ function mapStateToProps2(state: TodoState) {
 
 export default connect(mapStateToProps2)(TodoApp);
 
-// Inject todos and all action creators (addTodo, completeTodo, ...)
-
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 connect(mapStateToProps2, actionCreators)(TodoApp);
 
-// Inject todos and all action creators (addTodo, completeTodo, ...) as actions
-
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 function mapDispatchToProps2(dispatch: Dispatch) {
     return { actions: bindActionCreators(actionCreators, dispatch) };
 }
@@ -453,10 +443,6 @@ connect(mapStateToProps2, mapDispatchToProps2)(TodoApp);
 
 // Inject todos and a specific action creator (addTodo)
 
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 function mapDispatchToProps3(dispatch: Dispatch) {
     return bindActionCreators({ addTodo }, dispatch);
 }
@@ -465,10 +451,6 @@ connect(mapStateToProps2, mapDispatchToProps3)(TodoApp);
 
 // Inject todos, todoActionCreators as todoActions, and counterActionCreators as counterActions
 
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 function mapDispatchToProps4(dispatch: Dispatch) {
     return {
         todoActions: bindActionCreators(todoActionCreators, dispatch),
@@ -480,10 +462,6 @@ connect(mapStateToProps2, mapDispatchToProps4)(TodoApp);
 
 // Inject todos, and todoActionCreators and counterActionCreators together as actions
 
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 function mapDispatchToProps5(dispatch: Dispatch) {
     return {
         actions: bindActionCreators(objectAssign({}, todoActionCreators, counterActionCreators), dispatch)
@@ -494,10 +472,6 @@ connect(mapStateToProps2, mapDispatchToProps5)(TodoApp);
 
 // Inject todos, and all todoActionCreators and counterActionCreators directly as props
 
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 function mapDispatchToProps6(dispatch: Dispatch) {
     return bindActionCreators(objectAssign({}, todoActionCreators, counterActionCreators), dispatch);
 }
@@ -514,10 +488,6 @@ connect(mapStateToProps3)(TodoApp);
 
 // Inject todos of a specific user depending on props, and inject props.userId into the action
 
-//function mapStateToProps(state) {
-//    return { todos: state.todos };
-//}
-
 function mergeProps(stateProps: TodoState, dispatchProps: DispatchProps, ownProps: TodoProps): DispatchProps & TodoState & TodoProps {
     return objectAssign({}, ownProps, dispatchProps, {
         todos: stateProps.todos[ownProps.userId],
@@ -527,9 +497,8 @@ function mergeProps(stateProps: TodoState, dispatchProps: DispatchProps, ownProp
 
 connect(mapStateToProps2, dispatchActionCreators, mergeProps)(MyRootComponent);
 
-
-//https://github.com/DefinitelyTyped/DefinitelyTyped/issues/14622#issuecomment-279820358
-//Allow for undefined mapStateToProps
+// https://github.com/DefinitelyTyped/DefinitelyTyped/issues/14622#issuecomment-279820358
+// Allow for undefined mapStateToProps
 connect(undefined, mapDispatchToProps6)(TodoApp);
 
 interface TestProp {
@@ -540,7 +509,7 @@ interface TestState {
     isLoaded: boolean;
     state1: number;
 }
-class TestComponent extends Component<TestProp & DispatchProp, TestState> { }
+class TestComponent extends React.Component<TestProp & DispatchProp, TestState> { }
 const WrappedTestComponent = connect()(TestComponent);
 
 // return value of the connect()(TestComponent) is assignable to a ComponentClass<TestProp>
@@ -550,23 +519,19 @@ const ADecoratedTestComponent: React.ComponentClass<TestProp> = WrappedTestCompo
 
 const ATestComponent: React.ComponentClass<TestProp> = TestComponent;  // $ExpectError
 
-class NonComponent {}
-// this doesn't compile
-//connect()(NonComponent);
-
 // stateless functions
 interface HelloMessageProps {
-    dispatch: Dispatch
+    dispatch: Dispatch;
     name: string;
- }
+}
 const HelloMessage: React.StatelessComponent<HelloMessageProps> = (props) => {
     return <div>Hello {props.name}</div>;
-}
-let ConnectedHelloMessage = connect()(HelloMessage);
+};
+const ConnectedHelloMessage = connect()(HelloMessage);
 ReactDOM.render(<ConnectedHelloMessage name="Sebastian" />, document.getElementById('content'));
 
 // stateless functions that uses mapStateToProps and mapDispatchToProps
-namespace TestStatelessFunctionWithMapArguments {
+function TestStatelessFunctionWithMapArguments() {
     interface GreetingProps {
         name: string;
         onClick: () => void;
@@ -597,7 +562,7 @@ namespace TestStatelessFunctionWithMapArguments {
 }
 
 // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/8787
-namespace TestTOwnPropsInference {
+function TestTOwnPropsInference() {
     interface OwnProps {
         own: string;
     }
@@ -640,8 +605,8 @@ namespace TestTOwnPropsInference {
     // React.createElement(ConnectedWithTypeHint, { anything: 'goes!' });
 
     interface AllProps {
-        own: string
-        state: string
+        own: string;
+        state: string;
     }
 
     class AllPropsComponent extends React.Component<AllProps & DispatchProp> {
@@ -650,18 +615,18 @@ namespace TestTOwnPropsInference {
         }
     }
 
-    type PickedOwnProps = Pick<AllProps, "own">
-    type PickedStateProps = Pick<AllProps, "state">
+    type PickedOwnProps = Pick<AllProps, "own">;
+    type PickedStateProps = Pick<AllProps, "state">;
 
     const mapStateToPropsForPicked: MapStateToProps<PickedStateProps, PickedOwnProps, {}> = (state: any): PickedStateProps => {
-        return { state: "string" }
-    }
+        return { state: "string" };
+    };
     const ConnectedWithPickedOwnProps = connect(mapStateToPropsForPicked)(AllPropsComponent);
-    <ConnectedWithPickedOwnProps own="blah" />
+    <ConnectedWithPickedOwnProps own="blah" />;
 }
 
 // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/16021
-namespace TestMergedPropsInference {
+function TestMergedPropsInference() {
     interface StateProps {
         state: string;
     }
@@ -717,13 +682,13 @@ namespace TestMergedPropsInference {
     )(MergedPropsComponent);
 }
 
-namespace Issue16652 {
+function Issue16652() {
     interface PassedProps {
         commentIds: string[];
     }
 
     interface GeneratedStateProps {
-        comments: ({ id: string } | undefined)[];
+        comments: Array<({ id: string } | undefined)>;
     }
 
     class CommentList extends React.Component<PassedProps & GeneratedStateProps & DispatchProp> {}
@@ -738,47 +703,46 @@ namespace Issue16652 {
         CommentList
     );
 
-    <ConnectedCommentList commentIds={['a', 'b', 'c']} />
+    <ConnectedCommentList commentIds={['a', 'b', 'c']} />;
 }
 
-namespace Issue15463 {
-    interface ISpinnerProps{
+function Issue15463() {
+    interface SpinnerProps {
         showGlobalSpinner: boolean;
     }
 
-    class SpinnerClass extends React.Component<ISpinnerProps & DispatchProp> {
+    class SpinnerClass extends React.Component<SpinnerProps & DispatchProp> {
         render() {
             return (<div />);
         }
     }
 
-    export const Spinner = connect((state: any) => {
+    const Spinner = connect((state: any) => {
         return { showGlobalSpinner: true };
     })(SpinnerClass);
 
-    <Spinner />
+    <Spinner />;
 }
 
-namespace RemoveInjectedAndPassOnRest {
+function RemoveInjectedAndPassOnRest() {
     interface TProps {
         showGlobalSpinner: boolean;
         foo: string;
     }
-    class SpinnerClass extends React.Component<TProps & DispatchProp, {}> {
+    class SpinnerClass extends React.Component<TProps & DispatchProp> {
         render() {
             return (<div />);
         }
     }
 
-    export const Spinner = connect((state: any) => {
+    const Spinner = connect((state: any) => {
         return { showGlobalSpinner: true };
     })(SpinnerClass);
 
-    <Spinner foo='bar' />
+    <Spinner foo='bar' />;
 }
 
-namespace TestControlledComponentWithoutDispatchProp {
-
+function TestControlledComponentWithoutDispatchProp() {
     interface MyState {
         count: number;
     }
@@ -795,7 +759,7 @@ namespace TestControlledComponentWithoutDispatchProp {
     function mapStateToProps(state: MyState) {
         return {
             label: `The count is ${state.count}`,
-        }
+        };
     }
 
     class MyComponent extends React.Component<MyProps> {
@@ -812,80 +776,79 @@ namespace TestControlledComponentWithoutDispatchProp {
     const MyControlledFuncComponent = connect(mapStateToProps)(MyFuncComponent);
 }
 
-namespace TestDispatchToPropsAsObject {
-	const onClick: ActionCreator<{}> = () => ({});
-	const mapStateToProps = (state: any) => {
-		return {
-			title: state.app.title as string,
-		};
-	};
-	const dispatchToProps = {
-		onClick,
-	};
-
-	type Props = { title: string; } & typeof dispatchToProps;
-	const HeaderComponent: React.StatelessComponent<Props> = (props) => {
-		return <h1>{props.title}</h1>;
-	}
-
-	const Header = connect(mapStateToProps, dispatchToProps)(HeaderComponent);
-	<Header />
-}
-
-namespace TestInferredFunctionalComponentWithExplicitOwnProps {
-  type Props = {
-    title: string,
-    extraText: string,
-    onClick: () => void,
-  };
-
-	const Header = connect(
-		(
-			{ app: { title }}: { app: { title: string }},
-			{ extraText }: { extraText: string }
-		) => ({
-			title,
-			extraText
-		}),
-		(dispatch) => ({
-			onClick: () => dispatch({ type: 'test' })
-		})
-	)(({ title, extraText, onClick }: Props) => {
-		return <h1 onClick={onClick}>{title} {extraText}</h1>;
-	});
-	<Header extraText='text'/>
-}
-
-namespace TestInferredFunctionalComponentWithImplicitOwnProps {
-
-  type Props = {
-    title: string,
-    extraText: string,
-    onClick: () => void,
-  };
-
-	const Header = connect(
-		(
-			{ app: { title }}: { app: { title: string }},
-		) => ({
-			title,
-		}),
-		(dispatch) => ({
-			onClick: () => dispatch({ type: 'test' })
-		})
-	)(({ title, extraText, onClick }: Props) => {
-		return <h1 onClick={onClick}>{title} {extraText}</h1>;
-	});
-	<Header extraText='text'/>
-}
-
-namespace TestWrappedComponent {
-    type InnerProps = {
-        name: string,
+function TestDispatchToPropsAsObject() {
+    const onClick: ActionCreator<{}> = () => ({});
+    const mapStateToProps = (state: any) => {
+        return {
+            title: state.app.title as string,
+        };
     };
+    const dispatchToProps = {
+        onClick,
+    };
+
+    type Props = { title: string; } & typeof dispatchToProps;
+    const HeaderComponent: React.StatelessComponent<Props> = (props) => {
+        return <h1>{props.title}</h1>;
+    };
+
+    const Header = connect(mapStateToProps, dispatchToProps)(HeaderComponent);
+    <Header />;
+}
+
+function TestInferredFunctionalComponentWithExplicitOwnProps() {
+    interface Props {
+        title: string;
+        extraText: string;
+        onClick: () => void;
+    }
+
+    const Header = connect(
+        (
+            { app: { title }}: { app: { title: string }},
+            { extraText }: { extraText: string }
+        ) => ({
+            title,
+            extraText
+        }),
+        (dispatch) => ({
+            onClick: () => dispatch({ type: 'test' })
+        })
+    )(({ title, extraText, onClick }: Props) => {
+        return <h1 onClick={onClick}>{title} {extraText}</h1>;
+    });
+    <Header extraText='text'/>;
+}
+
+function TestInferredFunctionalComponentWithImplicitOwnProps() {
+    interface Props {
+        title: string;
+        extraText: string;
+        onClick: () => void;
+    }
+
+    const Header = connect(
+        (
+            { app: { title }}: { app: { title: string }},
+        ) => ({
+            title,
+        }),
+        (dispatch) => ({
+            onClick: () => dispatch({ type: 'test' })
+        })
+    )(({ title, extraText, onClick }: Props) => {
+        return <h1 onClick={onClick}>{title} {extraText}</h1>;
+    });
+    <Header extraText='text'/>;
+}
+
+function TestWrappedComponent() {
+    interface InnerProps {
+        name: string;
+    }
     const Inner: React.StatelessComponent<InnerProps> = (props) => {
         return <h1>{props.name}</h1>;
-    }
+    };
 
     const mapStateToProps = (state: any) => {
         return {
@@ -901,17 +864,17 @@ namespace TestWrappedComponent {
     const TestConnected = (props: any) => <Connected />;
 }
 
-namespace TestCreateProvider {
+function TestCreateProvider() {
     const STORE_KEY = 'myStore';
 
     const MyStoreProvider = createProvider(STORE_KEY);
 
-    const myStoreConnect: Connect = function(
+    const myStoreConnect: Connect = (
         mapStateToProps?: any,
         mapDispatchToProps?: any,
         mergeProps?: any,
         options: Options = {},
-    ) {
+    ) => {
         options.storeKey = STORE_KEY;
         return connect(
             mapStateToProps,
@@ -921,11 +884,11 @@ namespace TestCreateProvider {
         );
     };
 
-    interface State { a: number };
+    interface State { a: number; }
     const store = createStore<State, AnyAction, {}, {}>(() => ({ a: 1 }));
     const myStore = createStore<State, AnyAction, {}, {}>(() => ({ a: 2 }));
 
-    interface AProps { a: number };
+    interface AProps { a: number; }
     const A = (props: AProps) => (<h1>A is {props.a}</h1>);
     const A1 = connect<AProps, {}, {}, State>(state => state)(A);
     const A2 = myStoreConnect<AProps, {}, {}, State>(state => state)(A);
@@ -945,8 +908,7 @@ namespace TestCreateProvider {
     ReactDOM.render(<Combined />, document.body);
 }
 
-namespace TestWithoutTOwnPropsDecoratedInference {
-
+function TestWithoutTOwnPropsDecoratedInference() {
     interface ForwardedProps {
         forwarded: string;
     }
@@ -994,8 +956,8 @@ namespace TestWithoutTOwnPropsDecoratedInference {
     React.createElement(ConnectedWithTypeHintStateless, { own: 'string' });  // $ExpectError
 
     interface AllProps {
-        own: string
-        state: string
+        own: string;
+        state: string;
     }
 
     class AllPropsComponent extends React.Component<AllProps & DispatchProp<any>> {
@@ -1004,18 +966,18 @@ namespace TestWithoutTOwnPropsDecoratedInference {
         }
     }
 
-    type PickedOwnProps = Pick<AllProps, "own">
-    type PickedStateProps = Pick<AllProps, "state">
+    type PickedOwnProps = Pick<AllProps, "own">;
+    type PickedStateProps = Pick<AllProps, "state">;
 
     const mapStateToPropsForPicked: MapStateToProps<PickedStateProps, PickedOwnProps, {}> = (state: any): PickedStateProps => {
-        return { state: "string" }
-    }
+        return { state: "string" };
+    };
     const ConnectedWithPickedOwnProps = connect(mapStateToPropsForPicked)(AllPropsComponent);
-    <ConnectedWithPickedOwnProps own="blah" />
+    <ConnectedWithPickedOwnProps own="blah" />;
 }
 
 // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/25321#issuecomment-387659500
-namespace ProviderAcceptsStoreWithCustomAction {
+function ProviderAcceptsStoreWithCustomAction() {
     const reducer: Reducer<
         { foo: number } | undefined,
         { type: "foo"; payload: number }
@@ -1030,166 +992,165 @@ namespace ProviderAcceptsStoreWithCustomAction {
     );
 }
 
-namespace TestOptionalPropsMergedCorrectly {
-  interface OptionalDecorationProps {
-    foo: string,
-    bar: number,
-    optionalProp?: boolean,
-    dependsOnDispatch?: () => void,
-  }
+function TestOptionalPropsMergedCorrectly() {
+    interface OptionalDecorationProps {
+        foo: string;
+        bar: number;
+        optionalProp?: boolean;
+        dependsOnDispatch?: () => void;
+    }
 
-  class Component extends React.Component<OptionalDecorationProps> {
-      render () {
-          return <div />;
-      }
-  }
+    class Component extends React.Component<OptionalDecorationProps> {
+        render() {
+            return <div />;
+        }
+    }
 
-  type MapStateProps = {
-      foo: string,
-      bar: number,
-      optionalProp: boolean,
-  }
+    interface MapStateProps {
+        foo: string;
+        bar: number;
+        optionalProp: boolean;
+    }
 
-  type MapDispatchProps = {
-    dependsOnDispatch: () => void
-  }
+    interface MapDispatchProps {
+        dependsOnDispatch: () => void;
+    }
 
-  function mapStateToProps (state: any): MapStateProps {
-    return {
-        foo: 'foo',
-        bar: 42,
-        optionalProp: true,
-    };
-  }
+    function mapStateToProps(state: any): MapStateProps {
+        return {
+            foo: 'foo',
+            bar: 42,
+            optionalProp: true,
+        };
+    }
 
-  function mapDispatchToProps (dispatch: any): MapDispatchProps {
-    return {
-      dependsOnDispatch: () => {}
-    };
-  }
+    function mapDispatchToProps(dispatch: any): MapDispatchProps {
+        return {
+            dependsOnDispatch: () => {}
+        };
+    }
 
-  connect(mapStateToProps, mapDispatchToProps)(Component)
+    connect(mapStateToProps, mapDispatchToProps)(Component);
 }
 
-namespace TestMoreGeneralDecorationProps {
-  // connect() should support decoration props that are more permissive
-  // than the injected props, as long as the injected props can satisfy
-  // the decoration props.
-  interface MoreGeneralDecorationProps {
-    foo: string | number,
-    bar: number | 'foo',
-    optionalProp?: boolean | Object,
-    dependsOnDispatch?: () => void,
-  }
+function TestMoreGeneralDecorationProps() {
+    // connect() should support decoration props that are more permissive
+    // than the injected props, as long as the injected props can satisfy
+    // the decoration props.
+    interface MoreGeneralDecorationProps {
+        foo: string | number;
+        bar: number | 'foo';
+        optionalProp?: boolean | object;
+        dependsOnDispatch?: () => void;
+    }
 
-  class Component extends React.Component<MoreGeneralDecorationProps> {
-      render () {
-          return <div />;
-      }
-  }
+    class Component extends React.Component<MoreGeneralDecorationProps> {
+        render() {
+            return <div />;
+        }
+    }
 
-  type MapStateProps = {
-      foo: string,
-      bar: number,
-      optionalProp: boolean,
-  }
+    interface MapStateProps {
+        foo: string;
+        bar: number;
+        optionalProp: boolean;
+    }
 
-  type MapDispatchProps = {
-    dependsOnDispatch: () => void
-  }
+    interface MapDispatchProps {
+        dependsOnDispatch: () => void;
+    }
 
-  function mapStateToProps (state: any): MapStateProps {
-    return {
-        foo: 'foo',
-        bar: 42,
-        optionalProp: true,
-    };
-  }
+    function mapStateToProps(state: any): MapStateProps {
+        return {
+            foo: 'foo',
+            bar: 42,
+            optionalProp: true,
+        };
+    }
 
-  function mapDispatchToProps (dispatch: any): MapDispatchProps {
-    return {
-      dependsOnDispatch: () => {}
-    };
-  }
+    function mapDispatchToProps(dispatch: any): MapDispatchProps {
+        return {
+            dependsOnDispatch: () => {}
+        };
+    }
 
-  connect(mapStateToProps, mapDispatchToProps)(Component)
+    connect(mapStateToProps, mapDispatchToProps)(Component);
 }
 
-namespace TestFailsMoreSpecificInjectedProps {
-  interface MoreSpecificDecorationProps {
-    foo: string,
-    bar: number,
-    dependsOnDispatch: () => void,
-  }
+function TestFailsMoreSpecificInjectedProps() {
+    interface MoreSpecificDecorationProps {
+        foo: string;
+        bar: number;
+        dependsOnDispatch: () => void;
+    }
 
-  class Component extends React.Component<MoreSpecificDecorationProps> {
-      render () {
-          return <div />;
-      }
-  }
+    class Component extends React.Component<MoreSpecificDecorationProps> {
+        render() {
+            return <div />;
+        }
+    }
 
-  type MapStateProps = {
-    foo: string | number,
-    bar: number | 'foo',
-    dependsOnDispatch?: () => void,
-  }
+    interface MapStateProps {
+        foo: string | number;
+        bar: number | 'foo';
+        dependsOnDispatch?: () => void;
+    }
 
-  type MapDispatchProps = {
-    dependsOnDispatch?: () => void
-  }
+    interface MapDispatchProps {
+        dependsOnDispatch?: () => void;
+    }
 
-  function mapStateToProps (state: any): MapStateProps {
-    return {
-        foo: 'foo',
-        bar: 42,
-    };
-  }
+    function mapStateToProps(state: any): MapStateProps {
+        return {
+            foo: 'foo',
+            bar: 42,
+        };
+    }
 
-  function mapDispatchToProps (dispatch: any): MapDispatchProps {
-    return {
-      dependsOnDispatch: () => {}
-    };
-  }
+    function mapDispatchToProps(dispatch: any): MapDispatchProps {
+        return {
+            dependsOnDispatch: () => {}
+        };
+    }
 
-  // Since it is possible the injected props could fail to satisfy the decoration props,
-  // the following line should fail to compile.
-  connect(mapStateToProps, mapDispatchToProps)(Component) // $ExpectError
-
-  // Confirm that this also fails with functional components
-  const FunctionalComponent = (props: MoreSpecificDecorationProps) => null
-  connect(mapStateToProps, mapDispatchToProps)(Component) // $ExpectError
+    // Since it is possible the injected props could fail to satisfy the decoration props,
+    // the following line should fail to compile.
+    connect(mapStateToProps, mapDispatchToProps)(Component); // $ExpectError
 
+    // Confirm that this also fails with functional components
+    const FunctionalComponent = (props: MoreSpecificDecorationProps) => null;
+    connect(mapStateToProps, mapDispatchToProps)(Component); // $ExpectError
 }
 
-namespace TestLibraryManagedAttributes {
-	interface OwnProps {
-		bar: number,
-		fn: () => void,
-	}
+function TestLibraryManagedAttributes() {
+    interface OwnProps {
+        bar: number;
+        fn: () => void;
+    }
 
-	type MapStateProps = {
-		foo: string,
-	}
+    interface MapStateProps {
+        foo: string;
+    }
 
-	class Component extends React.Component<OwnProps & MapStateProps> {
-		static defaultProps = {
-			bar: 0,
-		}
+    class Component extends React.Component<OwnProps & MapStateProps> {
+        static defaultProps = {
+            bar: 0,
+        };
 
-		render () {
-			return <div />;
-		}
-	}
+        render() {
+            return <div />;
+        }
+    }
 
-	function mapStateToProps (state: any): MapStateProps {
-		return {
-			foo: 'foo',
-		};
-	}
+    function mapStateToProps(state: any): MapStateProps {
+        return {
+            foo: 'foo',
+        };
+    }
 
-	const ConnectedComponent = connect(mapStateToProps)(Component);
-	<ConnectedComponent fn={() => {}} />
+    const ConnectedComponent = connect(mapStateToProps)(Component);
+    <ConnectedComponent fn={() => {}} />;
 
-	const ConnectedComponent2 = connect<MapStateProps, void, OwnProps>(mapStateToProps)(Component);
-	<ConnectedComponent2 fn={() => {}} />
+    const ConnectedComponent2 = connect<MapStateProps, void, OwnProps>(mapStateToProps)(Component);
+    <ConnectedComponent2 fn={() => {}} />;
 }
diff --git a/types/react-redux/tslint.json b/types/react-redux/tslint.json
index 5a8bb3dd4d..f93cf8562a 100644
--- a/types/react-redux/tslint.json
+++ b/types/react-redux/tslint.json
@@ -1,81 +1,3 @@
 {
-    "extends": "dtslint/dt.json",
-    "rules": {
-        "adjacent-overload-signatures": false,
-        "array-type": false,
-        "arrow-return-shorthand": false,
-        "ban-types": false,
-        "callable-types": false,
-        "comment-format": false,
-        "dt-header": false,
-        "eofline": false,
-        "export-just-namespace": false,
-        "import-spacing": false,
-        "interface-name": false,
-        "interface-over-type-literal": false,
-        "jsdoc-format": false,
-        "max-line-length": false,
-        "member-access": false,
-        "new-parens": false,
-        "no-any-union": false,
-        "no-boolean-literal-compare": false,
-        "no-conditional-assignment": false,
-        "no-consecutive-blank-lines": false,
-        "no-construct": false,
-        "no-declare-current-package": false,
-        "no-duplicate-imports": false,
-        "no-duplicate-variable": false,
-        "no-empty-interface": false,
-        "no-for-in-array": false,
-        "no-inferrable-types": false,
-        "no-internal-module": false,
-        "no-irregular-whitespace": false,
-        "no-mergeable-namespace": false,
-        "no-misused-new": false,
-        "no-namespace": false,
-        "no-object-literal-type-assertion": false,
-        "no-padding": false,
-        "no-redundant-jsdoc": false,
-        "no-redundant-jsdoc-2": false,
-        "no-redundant-undefined": false,
-        "no-reference-import": false,
-        "no-relative-import-in-test": false,
-        "no-self-import": false,
-        "no-single-declare-module": false,
-        "no-string-throw": false,
-        "no-unnecessary-callback-wrapper": false,
-        "no-unnecessary-class": false,
-        "no-unnecessary-generics": false,
-        "no-unnecessary-qualifier": false,
-        "no-unnecessary-type-assertion": false,
-        "no-useless-files": false,
-        "no-var-keyword": false,
-        "no-var-requires": false,
-        "no-void-expression": false,
-        "no-trailing-whitespace": false,
-        "object-literal-key-quotes": false,
-        "object-literal-shorthand": false,
-        "one-line": false,
-        "one-variable-per-declaration": false,
-        "only-arrow-functions": false,
-        "prefer-conditional-expression": false,
-        "prefer-const": false,
-        "prefer-declare-function": false,
-        "prefer-for-of": false,
-        "prefer-method-signature": false,
-        "prefer-object-spread": false,
-        "prefer-template": false,
-        "radix": false,
-        "semicolon": false,
-        "space-before-function-paren": false,
-        "space-within-parens": false,
-        "strict-export-declare-modifiers": false,
-        "trim-file": false,
-        "triple-equals": false,
-        "typedef-whitespace": false,
-        "unified-signatures": false,
-        "use-default-type-parameter": false,
-        "void-return": false,
-        "whitespace": false
-    }
+    "extends": "dtslint/dt.json"
 }