Split out react addons

react-addons-create-fragment/index.d.ts

@@ -3,14 +3,8 @@
 // Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+import * as React from 'react';
 
+export = createFragment;
 
-declare namespace __React {
-    namespace __Addons {
-        export function createFragment(object: { [key: string]: ReactNode }): ReactFragment;
-    }
-}
-
-declare module "react-addons-create-fragment" {
-    export = __React.__Addons.createFragment;
-}
+declare function createFragment(object: { [key: string]: React.ReactNode }): React.ReactFragment;

react-addons-create-fragment/tsconfig.json

@@ -1,14 +1,16 @@
 {
+    "files": [
+        "index.d.ts"
+    ],
     "compilerOptions": {
         "module": "commonjs",
         "target": "es6",
         "noImplicitAny": true,
         "strictNullChecks": false,
-        "baseUrl": "../../",
-        "typesRoot": "../../",
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
         "noEmit": true
-    },
-    "files": [
-        "index.d.ts"
-    ]
+    }
 }

react-addons-css-transition-group/index.d.ts

@@ -0,0 +1,30 @@
+// Type definitions for React v0.14 (react-addons-css-transition-group)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { ComponentClass } from 'react';
+import { TransitionGroupProps } from 'react-addons-transition-group';
+
+declare var CSSTransitionGroup: CSSTransitionGroup;
+type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
+export = CSSTransitionGroup;
+
+interface CSSTransitionGroupTransitionName {
+    enter: string;
+    enterActive?: string;
+    leave: string;
+    leaveActive?: string;
+    appear?: string;
+    appearActive?: string;
+}
+
+interface CSSTransitionGroupProps extends TransitionGroupProps {
+    transitionName: string | CSSTransitionGroupTransitionName;
+    transitionAppear?: boolean;
+    transitionAppearTimeout?: number;
+    transitionEnter?: boolean;
+    transitionEnterTimeout?: number;
+    transitionLeave?: boolean;
+    transitionLeaveTimeout?: number;
+}

react-addons-css-transition-group/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-linked-state-mixin/index.d.ts

@@ -0,0 +1,25 @@
+// Type definitions for React v0.14 (react-addons-linked-state-mixin)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { Mixin } from 'react';
+
+declare var LinkedStateMixin: LinkedStateMixin;
+export = LinkedStateMixin;
+
+interface ReactLink<T> {
+    value: T;
+    requestChange(newValue: T): void;
+}
+
+interface LinkedStateMixin extends Mixin<any, any> {
+    linkState<T>(key: string): ReactLink<T>;
+}
+
+declare module 'react' {
+    interface HTMLAttributes {
+        checkedLink?: ReactLink<boolean>;
+        valueLink?: ReactLink<boolean | string | number>;
+    }
+}

react-addons-linked-state-mixin/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-perf/index.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for React v0.14 (react-addons-perf)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+export = Perf;
+
+interface ComponentPerfContext {
+    current: string;
+    owner: string;
+}
+
+interface NumericPerfContext {
+    [key: string]: number;
+}
+
+interface Measurements {
+    exclusive: NumericPerfContext;
+    inclusive: NumericPerfContext;
+    render: NumericPerfContext;
+    counts: NumericPerfContext;
+    writes: NumericPerfContext;
+    displayNames: {
+        [key: string]: ComponentPerfContext;
+    };
+    totalTime: number;
+}
+
+declare namespace Perf {
+    export function start(): void;
+    export function stop(): void;
+    export function printInclusive(measurements: Measurements[]): void;
+    export function printExclusive(measurements: Measurements[]): void;
+    export function printWasted(measurements: Measurements[]): void;
+    export function printDOM(measurements: Measurements[]): void;
+    export function getLastMeasurements(): Measurements[];
+}

react-addons-perf/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-pure-render-mixin/index.d.ts

@@ -1,22 +1,11 @@
-// Type definitions for React v0.14 (namespace)
+// Type definitions for React v0.14 (react-addons-pure-render-mixin)
 // Project: http://facebook.github.io/react/
 // Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+import { Mixin } from 'react';
 
+declare var PureRenderMixin: PureRenderMixin;
+export = PureRenderMixin;
 
-
-
-
-
-
-
-
-
-
-import React = __React;
-import ReactDOM = __React.__DOM;
-
-declare namespace __React {
-    export import addons = __React.__Addons;
-}
+interface PureRenderMixin extends Mixin<any, any> { }

react-addons-pure-render-mixin/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-shallow-compare/index.d.ts

@@ -0,0 +1,13 @@
+// Type definitions for React v0.14 (react-addons-css-transition-group)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { Component } from 'react';
+
+declare function shallowCompare<P, S>(
+    component: Component<P, S>,
+    nextProps: P,
+    nextState: S): boolean;
+
+export = shallowCompare;

react-addons-shallow-compare/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-test-utils/index.d.ts

@@ -0,0 +1,168 @@
+// Type definitions for React v0.14 (react-addons-test-utils)
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { AbstractView, Component, ComponentClass,
+    ReactElement, ReactInstance, ClassType,
+    DOMElement, SFCElement, CElement,
+    ReactHTMLElement, DOMAttributes, SFC } from 'react';
+
+export = TestUtils;
+
+declare namespace TestUtils {
+    export interface OptionalEventProperties {
+        bubbles?: boolean;
+        cancelable?: boolean;
+        currentTarget?: EventTarget;
+        defaultPrevented?: boolean;
+        eventPhase?: number;
+        isTrusted?: boolean;
+        nativeEvent?: Event;
+        preventDefault?(): void;
+        stopPropagation?(): void;
+        target?: EventTarget;
+        timeStamp?: Date;
+        type?: string;
+    }
+
+    export interface SyntheticEventData extends OptionalEventProperties {
+        altKey?: boolean;
+        button?: number;
+        buttons?: number;
+        clientX?: number;
+        clientY?: number;
+        changedTouches?: TouchList;
+        charCode?: boolean;
+        clipboardData?: DataTransfer;
+        ctrlKey?: boolean;
+        deltaMode?: number;
+        deltaX?: number;
+        deltaY?: number;
+        deltaZ?: number;
+        detail?: number;
+        getModifierState?(key: string): boolean;
+        key?: string;
+        keyCode?: number;
+        locale?: string;
+        location?: number;
+        metaKey?: boolean;
+        pageX?: number;
+        pageY?: number;
+        relatedTarget?: EventTarget;
+        repeat?: boolean;
+        screenX?: number;
+        screenY?: number;
+        shiftKey?: boolean;
+        targetTouches?: TouchList;
+        touches?: TouchList;
+        view?: AbstractView;
+        which?: number;
+    }
+
+    export interface EventSimulator {
+        (element: Element | Component<any, any>, eventData?: SyntheticEventData): void;
+    }
+
+    export interface MockedComponentClass {
+        new(): any;
+    }
+
+    export interface ShallowRenderer {
+        getRenderOutput<E extends ReactElement<any>>(): E;
+        getRenderOutput(): ReactElement<any>;
+        render(element: ReactElement<any>, context?: any): void;
+        unmount(): void;
+    }
+
+    export namespace Simulate {
+        export var blur: EventSimulator;
+        export var change: EventSimulator;
+        export var click: EventSimulator;
+        export var copy: EventSimulator;
+        export var cut: EventSimulator;
+        export var doubleClick: EventSimulator;
+        export var drag: EventSimulator;
+        export var dragEnd: EventSimulator;
+        export var dragEnter: EventSimulator;
+        export var dragExit: EventSimulator;
+        export var dragLeave: EventSimulator;
+        export var dragOver: EventSimulator;
+        export var dragStart: EventSimulator;
+        export var drop: EventSimulator;
+        export var focus: EventSimulator;
+        export var input: EventSimulator;
+        export var keyDown: EventSimulator;
+        export var keyPress: EventSimulator;
+        export var keyUp: EventSimulator;
+        export var mouseDown: EventSimulator;
+        export var mouseEnter: EventSimulator;
+        export var mouseLeave: EventSimulator;
+        export var mouseMove: EventSimulator;
+        export var mouseOut: EventSimulator;
+        export var mouseOver: EventSimulator;
+        export var mouseUp: EventSimulator;
+        export var paste: EventSimulator;
+        export var scroll: EventSimulator;
+        export var submit: EventSimulator;
+        export var touchCancel: EventSimulator;
+        export var touchEnd: EventSimulator;
+        export var touchMove: EventSimulator;
+        export var touchStart: EventSimulator;
+        export var wheel: EventSimulator;
+    }
+
+    export function renderIntoDocument<T extends Element>(
+        element: DOMElement<any, T>): T;
+    export function renderIntoDocument(
+        element: SFCElement<any>): void;
+    export function renderIntoDocument<T extends Component<any, any>>(
+        element: CElement<any, T>): T;
+    export function renderIntoDocument<P>(
+        element: ReactElement<P>): Component<P, {}> | Element | void;
+
+    export function mockComponent(
+        mocked: MockedComponentClass, mockTagName?: string): typeof TestUtils;
+
+    export function isElementOfType<T extends HTMLElement>(
+        element: ReactElement<any>, type: string): element is ReactHTMLElement<T>;
+    export function isElementOfType<P extends DOMAttributes, T extends Element>(
+        element: ReactElement<any>, type: string): element is DOMElement<P, T>;
+    export function isElementOfType<P>(
+        element: ReactElement<any>, type: SFC<P>): element is SFCElement<P>;
+    export function isElementOfType<P, T extends Component<P, {}>, C extends ComponentClass<P>>(
+        element: ReactElement<any>, type: ClassType<P, T, C>): element is CElement<P, T>;
+
+    export function isDOMComponent(instance: ReactInstance): instance is Element;
+    export function isCompositeComponent(instance: ReactInstance): instance is Component<any, any>;
+    export function isCompositeComponentWithType<T extends Component<any, any>, C extends ComponentClass<any>>(
+        instance: ReactInstance, type: ClassType<any, T, C>): T;
+
+    export function findAllInRenderedTree(
+        root: Component<any, any>,
+        fn: (i: ReactInstance) => boolean): ReactInstance[];
+
+    export function scryRenderedDOMComponentsWithClass(
+        root: Component<any, any>,
+        className: string): Element[];
+    export function findRenderedDOMComponentWithClass(
+        root: Component<any, any>,
+        className: string): Element;
+
+    export function scryRenderedDOMComponentsWithTag(
+        root: Component<any, any>,
+        tagName: string): Element[];
+    export function findRenderedDOMComponentWithTag(
+        root: Component<any, any>,
+        tagName: string): Element;
+
+    export function scryRenderedComponentsWithType<T extends Component<{}, {}>, C extends ComponentClass<{}>>(
+        root: Component<any, any>,
+        type: ClassType<any, T, C>): T[];
+
+    export function findRenderedComponentWithType<T extends Component<{}, {}>, C extends ComponentClass<{}>>(
+        root: Component<any, any>,
+        type: ClassType<any, T, C>): T;
+
+    export function createRenderer(): ShallowRenderer;
+}

react-addons-test-utils/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-transition-group/index.d.ts

@@ -3,25 +3,14 @@
 // Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+import { ReactElement, ComponentClass, ReactType } from 'react';
 
-
-declare namespace __React {
-
-    interface TransitionGroupProps {
+declare namespace ReactCSSTransitionGroup {
+    export interface TransitionGroupProps {
         component?: ReactType;
         className?: string;
         childFactory?: (child: ReactElement<any>) => ReactElement<any>;
     }
-
-    type TransitionGroup = ComponentClass<TransitionGroupProps>;
-
-    namespace __Addons {
-        export var TransitionGroup: __React.TransitionGroup;
-    }
-}
-
-declare module "react-addons-transition-group" {
-    var TransitionGroup: __React.TransitionGroup;
-    type TransitionGroup = __React.TransitionGroup;
-    export = TransitionGroup;
 }
+declare var ReactCSSTransitionGroup : ComponentClass<ReactCSSTransitionGroup.TransitionGroupProps>;
+export = ReactCSSTransitionGroup;

react-addons-transition-group/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-addons-update/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "files": [
+        "index.d.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-dom/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "files": [
+        "index.d.ts",
+        "react-dom-tests.ts"
+    ],
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "strictNullChecks": false,
+        "baseUrl": "../",
+        "typesSearchPaths": [
+            "../"
+        ],
+        "noEmit": true
+    }
+}

react-router/tsconfig.json

@@ -1,7 +1,7 @@
 {
     "files": [
         "index.d.ts",
-        "history-tests.ts"
+        "react-router-tests.tsx"
     ],
     "compilerOptions": {
         "module": "commonjs",

react/react-addons-css-transition-group.d.ts

@@ -1,40 +0,0 @@
-// Type definitions for React v0.14 (react-addons-css-transition-group)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-
-declare namespace __React {
-    interface CSSTransitionGroupTransitionName {
-        enter: string;
-        enterActive?: string;
-        leave: string;
-        leaveActive?: string;
-        appear?: string;
-        appearActive?: string;
-    }
-
-    interface CSSTransitionGroupProps extends TransitionGroupProps {
-        transitionName: string | CSSTransitionGroupTransitionName;
-        transitionAppear?: boolean;
-        transitionAppearTimeout?: number;
-        transitionEnter?: boolean;
-        transitionEnterTimeout?: number;
-        transitionLeave?: boolean;
-        transitionLeaveTimeout?: number;
-    }
-
-    type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
-
-    namespace __Addons {
-        export var CSSTransitionGroup: __React.CSSTransitionGroup;
-    }
-}
-
-declare module "react-addons-css-transition-group" {
-    var CSSTransitionGroup: __React.CSSTransitionGroup;
-    type CSSTransitionGroup = __React.CSSTransitionGroup;
-    export = CSSTransitionGroup;
-}

react/react-addons-linked-state-mixin.d.ts

@@ -1,32 +0,0 @@
-// Type definitions for React v0.14 (react-addons-linked-state-mixin)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-declare namespace __React {
-    interface ReactLink<T> {
-        value: T;
-        requestChange(newValue: T): void;
-    }
-
-    interface LinkedStateMixin extends Mixin<any, any> {
-        linkState<T>(key: string): ReactLink<T>;
-    }
-
-    interface HTMLAttributes {
-        checkedLink?: ReactLink<boolean>;
-        valueLink?: ReactLink<boolean | string | number>;
-    }
-
-    namespace __Addons {
-        export var LinkedStateMixin: LinkedStateMixin;
-    }
-}
-
-declare module "react-addons-linked-state-mixin" {
-    var LinkedStateMixin: __React.LinkedStateMixin;
-    type LinkedStateMixin = __React.LinkedStateMixin;
-    export = LinkedStateMixin;
-}

react/react-addons-perf.d.ts

@@ -1,46 +0,0 @@
-// Type definitions for React v0.14 (react-addons-perf)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-declare namespace __React {
-    interface ComponentPerfContext {
-        current: string;
-        owner: string;
-    }
-
-    interface NumericPerfContext {
-        [key: string]: number;
-    }
-
-    interface Measurements {
-        exclusive: NumericPerfContext;
-        inclusive: NumericPerfContext;
-        render: NumericPerfContext;
-        counts: NumericPerfContext;
-        writes: NumericPerfContext;
-        displayNames: {
-            [key: string]: ComponentPerfContext;
-        };
-        totalTime: number;
-    }
-
-    namespace __Addons {
-        namespace Perf {
-            export function start(): void;
-            export function stop(): void;
-            export function printInclusive(measurements: Measurements[]): void;
-            export function printExclusive(measurements: Measurements[]): void;
-            export function printWasted(measurements: Measurements[]): void;
-            export function printDOM(measurements: Measurements[]): void;
-            export function getLastMeasurements(): Measurements[];
-        }
-    }
-}
-
-declare module "react-addons-perf" {
-    import Perf = __React.__Addons.Perf;
-    export = Perf;
-}

react/react-addons-pure-render-mixin.d.ts

@@ -1,20 +0,0 @@
-// Type definitions for React v0.14 (react-addons-pure-render-mixin)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-declare namespace __React {
-    interface PureRenderMixin extends Mixin<any, any> {}
-
-    namespace __Addons {
-        export var PureRenderMixin: PureRenderMixin;
-    }
-}
-
-declare module "react-addons-pure-render-mixin" {
-    var PureRenderMixin: __React.PureRenderMixin;
-    type PureRenderMixin = __React.PureRenderMixin;
-    export = PureRenderMixin;
-}

react/react-addons-shallow-compare.d.ts

@@ -1,19 +0,0 @@
-// Type definitions for React v0.14 (react-addons-css-transition-group)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-declare namespace __React {
-    namespace __Addons {
-        export function shallowCompare<P, S>(
-            component: __React.Component<P, S>,
-            nextProps: P,
-            nextState: S): boolean;
-    }
-}
-
-declare module "react-addons-shallow-compare" {
-    export = __React.__Addons.shallowCompare;
-}

react/react-addons-test-utils.d.ts

@@ -1,172 +0,0 @@
-// Type definitions for React v0.14 (react-addons-test-utils)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-declare namespace __React {
-    interface OptionalEventProperties {
-        bubbles?: boolean;
-        cancelable?: boolean;
-        currentTarget?: EventTarget;
-        defaultPrevented?: boolean;
-        eventPhase?: number;
-        isTrusted?: boolean;
-        nativeEvent?: Event;
-        preventDefault?(): void;
-        stopPropagation?(): void;
-        target?: EventTarget;
-        timeStamp?: Date;
-        type?: string;
-    }
-
-    interface SyntheticEventData extends OptionalEventProperties {
-        altKey?: boolean;
-        button?: number;
-        buttons?: number;
-        clientX?: number;
-        clientY?: number;
-        changedTouches?: TouchList;
-        charCode?: boolean;
-        clipboardData?: DataTransfer;
-        ctrlKey?: boolean;
-        deltaMode?: number;
-        deltaX?: number;
-        deltaY?: number;
-        deltaZ?: number;
-        detail?: number;
-        getModifierState?(key: string): boolean;
-        key?: string;
-        keyCode?: number;
-        locale?: string;
-        location?: number;
-        metaKey?: boolean;
-        pageX?: number;
-        pageY?: number;
-        relatedTarget?: EventTarget;
-        repeat?: boolean;
-        screenX?: number;
-        screenY?: number;
-        shiftKey?: boolean;
-        targetTouches?: TouchList;
-        touches?: TouchList;
-        view?: AbstractView;
-        which?: number;
-    }
-
-    interface EventSimulator {
-        (element: Element | Component<any, any>, eventData?: SyntheticEventData): void;
-    }
-
-    interface MockedComponentClass {
-        new(): any;
-    }
-
-    class ShallowRenderer {
-        getRenderOutput<E extends ReactElement<any>>(): E;
-        getRenderOutput(): ReactElement<any>;
-        render(element: ReactElement<any>, context?: any): void;
-        unmount(): void;
-    }
-
-    namespace __Addons {
-        namespace TestUtils {
-            namespace Simulate {
-                export var blur: EventSimulator;
-                export var change: EventSimulator;
-                export var click: EventSimulator;
-                export var copy: EventSimulator;
-                export var cut: EventSimulator;
-                export var doubleClick: EventSimulator;
-                export var drag: EventSimulator;
-                export var dragEnd: EventSimulator;
-                export var dragEnter: EventSimulator;
-                export var dragExit: EventSimulator;
-                export var dragLeave: EventSimulator;
-                export var dragOver: EventSimulator;
-                export var dragStart: EventSimulator;
-                export var drop: EventSimulator;
-                export var focus: EventSimulator;
-                export var input: EventSimulator;
-                export var keyDown: EventSimulator;
-                export var keyPress: EventSimulator;
-                export var keyUp: EventSimulator;
-                export var mouseDown: EventSimulator;
-                export var mouseEnter: EventSimulator;
-                export var mouseLeave: EventSimulator;
-                export var mouseMove: EventSimulator;
-                export var mouseOut: EventSimulator;
-                export var mouseOver: EventSimulator;
-                export var mouseUp: EventSimulator;
-                export var paste: EventSimulator;
-                export var scroll: EventSimulator;
-                export var submit: EventSimulator;
-                export var touchCancel: EventSimulator;
-                export var touchEnd: EventSimulator;
-                export var touchMove: EventSimulator;
-                export var touchStart: EventSimulator;
-                export var wheel: EventSimulator;
-            }
-
-            export function renderIntoDocument<T extends Element>(
-                element: DOMElement<any, T>): T;
-            export function renderIntoDocument(
-                element: SFCElement<any>): void;
-            export function renderIntoDocument<T extends Component<any, any>>(
-                element: CElement<any, T>): T;
-            export function renderIntoDocument<P>(
-                element: ReactElement<P>): Component<P, {}> | Element | void;
-
-            export function mockComponent(
-                mocked: MockedComponentClass, mockTagName?: string): typeof TestUtils;
-
-            export function isElementOfType<T extends HTMLElement>(
-                element: ReactElement<any>, type: string): element is ReactHTMLElement<T>;
-            export function isElementOfType<P extends DOMAttributes, T extends Element>(
-                element: ReactElement<any>, type: string): element is DOMElement<P, T>;
-            export function isElementOfType<P>(
-                element: ReactElement<any>, type: SFC<P>): element is SFCElement<P>;
-            export function isElementOfType<P, T extends Component<P, {}>, C extends ComponentClass<P>>(
-                element: ReactElement<any>, type: ClassType<P, T, C>): element is CElement<P, T>;
-
-            export function isDOMComponent(instance: ReactInstance): instance is Element;
-            export function isCompositeComponent(instance: ReactInstance): instance is Component<any, any>;
-            export function isCompositeComponentWithType<T extends Component<any, any>, C extends ComponentClass<any>>(
-                instance: ReactInstance, type: ClassType<any, T, C>): T;
-
-            export function findAllInRenderedTree(
-                root: Component<any, any>,
-                fn: (i: ReactInstance) => boolean): ReactInstance[];
-
-            export function scryRenderedDOMComponentsWithClass(
-                root: Component<any, any>,
-                className: string): Element[];
-            export function findRenderedDOMComponentWithClass(
-                root: Component<any, any>,
-                className: string): Element;
-
-            export function scryRenderedDOMComponentsWithTag(
-                root: Component<any, any>,
-                tagName: string): Element[];
-            export function findRenderedDOMComponentWithTag(
-                root: Component<any, any>,
-                tagName: string): Element;
-
-            export function scryRenderedComponentsWithType<T extends Component<{}, {}>, C extends ComponentClass<{}>>(
-                root: Component<any, any>,
-                type: ClassType<any, T, C>): T[];
-
-            export function findRenderedComponentWithType<T extends Component<{}, {}>, C extends ComponentClass<{}>>(
-                root: Component<any, any>,
-                type: ClassType<any, T, C>): T;
-
-            export function createRenderer(): ShallowRenderer;
-        }
-    }
-}
-
-declare module "react-addons-test-utils" {
-    import TestUtils = __React.__Addons.TestUtils;
-    export = TestUtils;
-}

react/react-dom.d.ts

@@ -1,75 +0,0 @@
-// Type definitions for React v0.14 (react-dom)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-declare namespace __React {
-    namespace __DOM {
-        function findDOMNode<E extends Element>(instance: ReactInstance): E;
-        function findDOMNode(instance: ReactInstance): Element;
-
-        function render<P extends DOMAttributes, T extends Element>(
-            element: DOMElement<P, T>,
-            container: Element,
-            callback?: (element: T) => any): T;
-        function render<P>(
-            element: SFCElement<P>,
-            container: Element,
-            callback?: () => any): void;
-        function render<P, T extends Component<P, ComponentState>>(
-            element: CElement<P, T>,
-            container: Element,
-            callback?: (component: T) => any): T;
-        function render<P>(
-            element: ReactElement<P>,
-            container: Element,
-            callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
-
-        function unmountComponentAtNode(container: Element): boolean;
-
-        var version: string;
-
-        function unstable_batchedUpdates<A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
-        function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
-        function unstable_batchedUpdates(callback: () => any): void;
-
-        function unstable_renderSubtreeIntoContainer<P extends DOMAttributes, T extends Element>(
-            parentComponent: Component<any, any>,
-            element: DOMElement<P, T>,
-            container: Element,
-            callback?: (element: T) => any): T;
-        function unstable_renderSubtreeIntoContainer<P, T extends Component<P, ComponentState>>(
-            parentComponent: Component<any, any>,
-            element: CElement<P, T>,
-            container: Element,
-            callback?: (component: T) => any): T;
-        function render<P>(
-            parentComponent: Component<any, any>,
-            element: SFCElement<P>,
-            container: Element,
-            callback?: () => any): void;
-        function unstable_renderSubtreeIntoContainer<P>(
-            parentComponent: Component<any, any>,
-            element: ReactElement<P>,
-            container: Element,
-            callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
-    }
-
-    namespace __DOMServer {
-        function renderToString(element: ReactElement<any>): string;
-        function renderToStaticMarkup(element: ReactElement<any>): string;
-        var version: string;
-    }
-}
-
-declare module "react-dom" {
-    import DOM = __React.__DOM;
-    export = DOM;
-}
-
-declare module "react-dom/server" {
-    import DOMServer = __React.__DOMServer;
-    export = DOMServer;
-}

react/react-global-0.13.3.d.ts

@@ -1,285 +0,0 @@
-// Type definitions for React v0.13.3 (namespace)
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>, AssureSign <http://www.assuresign.com>, Microsoft <https://microsoft.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-
-
-import React = __React;
-
-declare namespace __React {
-    //
-    // React.addons
-    // ----------------------------------------------------------------------
-
-    export module addons {
-        export var CSSTransitionGroup: CSSTransitionGroup;
-        export var TransitionGroup: TransitionGroup;
-
-        export var LinkedStateMixin: LinkedStateMixin;
-        export var PureRenderMixin: PureRenderMixin;
-
-        export function batchedUpdates<A, B>(
-            callback: (a: A, b: B) => any, a: A, b: B): void;
-        export function batchedUpdates<A>(callback: (a: A) => any, a: A): void;
-        export function batchedUpdates(callback: () => any): void;
-
-        // deprecated: use petehunt/react-classset or JedWatson/classnames
-        export function classSet(cx: { [key: string]: boolean }): string;
-        export function classSet(...classList: string[]): string;
-
-        export function cloneWithProps<P>(
-            element: DOMElement<P>, props: P): DOMElement<P>;
-        export function cloneWithProps<P>(
-            element: ClassicElement<P>, props: P): ClassicElement<P>;
-        export function cloneWithProps<P>(
-            element: ReactElement<P>, props: P): ReactElement<P>;
-
-        export function createFragment(
-            object: { [key: string]: ReactNode }): ReactFragment;
-
-        export function update(value: any[], spec: UpdateArraySpec): any[];
-        export function update(value: {}, spec: UpdateSpec): any;
-
-        // Development tools
-        export import Perf = ReactPerf;
-        export import TestUtils = ReactTestUtils;
-    }
-
-    //
-    // React.addons (Transitions)
-    // ----------------------------------------------------------------------
-
-    interface TransitionGroupProps {
-        component?: ReactType;
-        childFactory?: (child: ReactElement<any>) => ReactElement<any>;
-    }
-
-    interface CSSTransitionGroupProps extends TransitionGroupProps {
-        transitionName: string;
-        transitionAppear?: boolean;
-        transitionEnter?: boolean;
-        transitionLeave?: boolean;
-    }
-
-    type CSSTransitionGroup = ComponentClass<CSSTransitionGroupProps>;
-    type TransitionGroup = ComponentClass<TransitionGroupProps>;
-
-    //
-    // React.addons (Mixins)
-    // ----------------------------------------------------------------------
-
-    interface ReactLink<T> {
-        value: T;
-        requestChange(newValue: T): void;
-    }
-
-    interface LinkedStateMixin extends Mixin<any, any> {
-        linkState<T>(key: string): ReactLink<T>;
-    }
-
-    interface PureRenderMixin extends Mixin<any, any> {
-    }
-
-    //
-    // Reat.addons.update
-    // ----------------------------------------------------------------------
-
-    interface UpdateSpecCommand {
-        $set?: any;
-        $merge?: {};
-        $apply?(value: any): any;
-    }
-
-    interface UpdateSpecPath {
-        [key: string]: UpdateSpec;
-    }
-
-    type UpdateSpec = UpdateSpecCommand | UpdateSpecPath;
-
-    interface UpdateArraySpec extends UpdateSpecCommand {
-        $push?: any[];
-        $unshift?: any[];
-        $splice?: any[][];
-    }
-
-    //
-    // React.addons.Perf
-    // ----------------------------------------------------------------------
-
-    interface ComponentPerfContext {
-        current: string;
-        owner: string;
-    }
-
-    interface NumericPerfContext {
-        [key: string]: number;
-    }
-
-    interface Measurements {
-        exclusive: NumericPerfContext;
-        inclusive: NumericPerfContext;
-        render: NumericPerfContext;
-        counts: NumericPerfContext;
-        writes: NumericPerfContext;
-        displayNames: {
-            [key: string]: ComponentPerfContext;
-        };
-        totalTime: number;
-    }
-
-    namespace ReactPerf {
-        export function start(): void;
-        export function stop(): void;
-        export function printInclusive(measurements: Measurements[]): void;
-        export function printExclusive(measurements: Measurements[]): void;
-        export function printWasted(measurements: Measurements[]): void;
-        export function printDOM(measurements: Measurements[]): void;
-        export function getLastMeasurements(): Measurements[];
-    }
-
-    //
-    // React.addons.TestUtils
-    // ----------------------------------------------------------------------
-
-    interface MockedComponentClass {
-        new(): any;
-    }
-
-    namespace ReactTestUtils {
-        export import Simulate = ReactSimulate;
-
-        export function renderIntoDocument<P>(
-            element: ReactElement<P>): Component<P, any>;
-        export function renderIntoDocument<C extends Component<any, any>>(
-            element: ReactElement<any>): C;
-
-        export function mockComponent(
-            mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
-
-        export function isElementOfType(
-            element: ReactElement<any>, type: ReactType): boolean;
-        export function isTextComponent(instance: Component<any, any>): boolean;
-        export function isDOMComponent(instance: Component<any, any>): boolean;
-        export function isCompositeComponent(instance: Component<any, any>): boolean;
-        export function isCompositeComponentWithType(
-            instance: Component<any, any>,
-            type: ComponentClass<any>): boolean;
-
-        export function findAllInRenderedTree(
-            tree: Component<any, any>,
-            fn: (i: Component<any, any>) => boolean): Component<any, any>;
-
-        export function scryRenderedDOMComponentsWithClass(
-            tree: Component<any, any>,
-            className: string): DOMComponent<any>[];
-        export function findRenderedDOMComponentWithClass(
-            tree: Component<any, any>,
-            className: string): DOMComponent<any>;
-
-        export function scryRenderedDOMComponentsWithTag(
-            tree: Component<any, any>,
-            tagName: string): DOMComponent<any>[];
-        export function findRenderedDOMComponentWithTag(
-            tree: Component<any, any>,
-            tagName: string): DOMComponent<any>;
-
-        export function scryRenderedComponentsWithType<P>(
-            tree: Component<any, any>,
-            type: ComponentClass<P>): Component<P, {}>[];
-        export function scryRenderedComponentsWithType<C extends Component<any, any>>(
-            tree: Component<any, any>,
-            type: ComponentClass<any>): C[];
-
-        export function findRenderedComponentWithType<P>(
-            tree: Component<any, any>,
-            type: ComponentClass<P>): Component<P, {}>;
-        export function findRenderedComponentWithType<C extends Component<any, any>>(
-            tree: Component<any, any>,
-            type: ComponentClass<any>): C;
-
-        export function createRenderer(): ShallowRenderer;
-    }
-
-    interface SyntheticEventData {
-        altKey?: boolean;
-        button?: number;
-        buttons?: number;
-        clientX?: number;
-        clientY?: number;
-        changedTouches?: TouchList;
-        charCode?: boolean;
-        clipboardData?: DataTransfer;
-        ctrlKey?: boolean;
-        deltaMode?: number;
-        deltaX?: number;
-        deltaY?: number;
-        deltaZ?: number;
-        detail?: number;
-        getModifierState?(key: string): boolean;
-        key?: string;
-        keyCode?: number;
-        locale?: string;
-        location?: number;
-        metaKey?: boolean;
-        pageX?: number;
-        pageY?: number;
-        relatedTarget?: EventTarget;
-        repeat?: boolean;
-        screenX?: number;
-        screenY?: number;
-        shiftKey?: boolean;
-        targetTouches?: TouchList;
-        touches?: TouchList;
-        view?: AbstractView;
-        which?: number;
-    }
-
-    interface EventSimulator {
-        (element: Element, eventData?: SyntheticEventData): void;
-        (component: Component<any, any>, eventData?: SyntheticEventData): void;
-    }
-
-    namespace ReactSimulate {
-        export var blur: EventSimulator;
-        export var change: EventSimulator;
-        export var click: EventSimulator;
-        export var cut: EventSimulator;
-        export var doubleClick: EventSimulator;
-        export var drag: EventSimulator;
-        export var dragEnd: EventSimulator;
-        export var dragEnter: EventSimulator;
-        export var dragExit: EventSimulator;
-        export var dragLeave: EventSimulator;
-        export var dragOver: EventSimulator;
-        export var dragStart: EventSimulator;
-        export var drop: EventSimulator;
-        export var focus: EventSimulator;
-        export var input: EventSimulator;
-        export var keyDown: EventSimulator;
-        export var keyPress: EventSimulator;
-        export var keyUp: EventSimulator;
-        export var mouseDown: EventSimulator;
-        export var mouseEnter: EventSimulator;
-        export var mouseLeave: EventSimulator;
-        export var mouseMove: EventSimulator;
-        export var mouseOut: EventSimulator;
-        export var mouseOver: EventSimulator;
-        export var mouseUp: EventSimulator;
-        export var paste: EventSimulator;
-        export var scroll: EventSimulator;
-        export var submit: EventSimulator;
-        export var touchCancel: EventSimulator;
-        export var touchEnd: EventSimulator;
-        export var touchMove: EventSimulator;
-        export var touchStart: EventSimulator;
-        export var wheel: EventSimulator;
-    }
-
-    class ShallowRenderer {
-        getRenderOutput<E extends ReactElement<any>>(): E;
-        getRenderOutput(): ReactElement<any>;
-        render(element: ReactElement<any>, context?: any): void;
-        unmount(): void;
-    }
-}

react/react-global-tests.ts

@@ -1,456 +0,0 @@
-
-
-interface Props {
-    hello: string;
-    world?: string;
-    foo: number;
-    bar: boolean;
-}
-
-interface State {
-    inputValue?: string;
-    seconds?: number;
-}
-
-interface Context {
-    someValue?: string;
-}
-
-interface ChildContext {
-    someOtherValue: string;
-}
-
-interface MyComponent extends React.Component<Props, State> {
-    reset(): void;
-}
-
-var props: Props & React.ClassAttributes<{}> = {
-    key: 42,
-    ref: "myComponent42",
-    hello: "world",
-    foo: 42,
-    bar: true
-};
-
-var container: Element;
-
-//
-// Top-Level API
-// --------------------------------------------------------------------------
-
-var ClassicComponent: React.ClassicComponentClass<Props> =
-    React.createClass<Props, State>({
-        getDefaultProps() {
-            return <Props>{
-                hello: undefined,
-                world: "peace",
-                foo: undefined,
-                bar: undefined,
-            };
-        },
-        getInitialState() {
-            return {
-                inputValue: this.context.someValue,
-                seconds: this.props.foo
-            };
-        },
-        reset() {
-            this.replaceState(this.getInitialState());
-        },
-        render() {
-            return React.DOM.div(null,
-                React.DOM.input({
-                    ref: input => this._input = input,
-                    value: this.state.inputValue
-                }));
-        }
-    });
-
-class ModernComponent extends React.Component<Props, State>
-    implements React.ChildContextProvider<ChildContext> {
-
-    static propTypes: React.ValidationMap<Props> = {
-        foo: React.PropTypes.number
-    };
-
-    static contextTypes: React.ValidationMap<Context> = {
-        someValue: React.PropTypes.string
-    };
-
-    static childContextTypes: React.ValidationMap<ChildContext> = {
-        someOtherValue: React.PropTypes.string
-    };
-
-    static defaultProps: Props;
-
-    context: Context;
-
-    getChildContext() {
-        return {
-            someOtherValue: "foo"
-        };
-    }
-
-    state = {
-        inputValue: this.context.someValue,
-        seconds: this.props.foo
-    };
-
-    reset() {
-        this.setState({
-            inputValue: this.context.someValue,
-            seconds: this.props.foo
-        });
-    }
-
-    private _input: HTMLInputElement;
-
-    render() {
-        return React.DOM.div(null,
-            React.DOM.input({
-                ref: input => this._input = <HTMLInputElement>input,
-                value: this.state.inputValue
-            }));
-    }
-}
-
-// React.createFactory
-var factory: React.CFactory<Props, ModernComponent> =
-    React.createFactory(ModernComponent);
-var factoryElement: React.CElement<Props, ModernComponent> =
-    factory(props);
-
-var classicFactory: React.ClassicFactory<Props> =
-    React.createFactory(ClassicComponent);
-var classicFactoryElement: React.ClassicElement<Props> =
-    classicFactory(props);
-
-var domFactory: React.DOMFactory<React.DOMAttributes, Element> =
-    React.createFactory("foo");
-var domFactoryElement: React.DOMElement<React.DOMAttributes, Element> =
-    domFactory();
-
-// React.createElement
-var element: React.CElement<Props, ModernComponent> =
-    React.createElement(ModernComponent, props);
-var classicElement: React.ClassicElement<Props> =
-    React.createElement(ClassicComponent, props);
-var domElement: React.ReactHTMLElement<HTMLDivElement> =
-    React.createElement("div");
-
-// React.cloneElement
-var clonedElement: React.CElement<Props, ModernComponent> =
-    React.cloneElement(element, props);
-var clonedClassicElement: React.ClassicElement<Props> =
-    React.cloneElement(classicElement, props);
-var clonedDOMElement: React.ReactHTMLElement<HTMLDivElement> =
-    React.cloneElement(domElement);
-
-// React.render
-var component: React.Component<Props, any> =
-    ReactDOM.render(element, container);
-var classicComponent: React.ClassicComponent<Props, any> =
-    ReactDOM.render(classicElement, container);
-var domComponent: Element =
-    ReactDOM.render(domElement, container);
-
-// Other Top-Level API
-var unmounted: boolean = ReactDOM.unmountComponentAtNode(container);
-
-// ReactDOMServer is not supported in global version
-// var str: string = ReactDOMServer.renderToString(element);
-// var markup: string = ReactDOMServer.renderToStaticMarkup(element);
-var notValid: boolean = React.isValidElement(props); // false
-var isValid = React.isValidElement(element); // true
-var domNode: Element = ReactDOM.findDOMNode(component);
-domNode = ReactDOM.findDOMNode(domNode);
-
-//
-// React Elements
-// --------------------------------------------------------------------------
-
-var type = element.type;
-var elementProps: Props = element.props;
-var key = element.key;
-
-//
-// React Components
-// --------------------------------------------------------------------------
-
-var displayName: string = ClassicComponent.displayName;
-var defaultProps: Props = ClassicComponent.getDefaultProps();
-var propTypes: React.ValidationMap<Props> = ClassicComponent.propTypes;
-
-//
-// Component API
-// --------------------------------------------------------------------------
-
-// modern
-var componentState: State = component.state;
-component.setState({ inputValue: "!!!" });
-component.forceUpdate();
-
-// classic
-var isMounted: boolean = classicComponent.isMounted();
-classicComponent.replaceState({ inputValue: "???", seconds: 60 });
-
-var myComponent = <MyComponent>component;
-myComponent.reset();
-
-//
-// Attributes
-// --------------------------------------------------------------------------
-
-var children: any[] = ["Hello world", [null], React.DOM.span(null)];
-var divStyle: React.CSSProperties = { // CSSProperties
-    flex: "1 1 main-size",
-    backgroundImage: "url('hello.png')"
-};
-var htmlAttr: React.HTMLProps<any> = {
-    key: 36,
-    ref: "htmlComponent",
-    children: children,
-    className: "test-attr",
-    style: divStyle,
-    onClick: (event: React.MouseEvent) => {
-        event.preventDefault();
-        event.stopPropagation();
-    },
-    dangerouslySetInnerHTML: {
-        __html: "<strong>STRONG</strong>"
-    }
-};
-React.DOM.div(htmlAttr);
-React.DOM.span(htmlAttr);
-React.DOM.input(htmlAttr);
-
-React.DOM.svg({ viewBox: "0 0 48 48" },
-    React.DOM.rect({
-      x: 22,
-      y: 10,
-      width: 4,
-      height: 28
-    }),
-    React.DOM.rect({
-      x: 10,
-      y: 22,
-      width: 28,
-      height: 4
-    }));
-
-
-//
-// React.PropTypes
-// --------------------------------------------------------------------------
-
-var PropTypesSpecification: React.ComponentSpec<any, any> = {
-    propTypes: {
-        optionalArray: React.PropTypes.array,
-        optionalBool: React.PropTypes.bool,
-        optionalFunc: React.PropTypes.func,
-        optionalNumber: React.PropTypes.number,
-        optionalObject: React.PropTypes.object,
-        optionalString: React.PropTypes.string,
-        optionalNode: React.PropTypes.node,
-        optionalElement: React.PropTypes.element,
-        optionalMessage: React.PropTypes.instanceOf(Date),
-        optionalEnum: React.PropTypes.oneOf(["News", "Photos"]),
-        optionalUnion: React.PropTypes.oneOfType([
-            React.PropTypes.string,
-            React.PropTypes.number,
-            React.PropTypes.instanceOf(Date)
-        ]),
-        optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-        optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-        optionalObjectWithShape: React.PropTypes.shape({
-            color: React.PropTypes.string,
-            fontSize: React.PropTypes.number
-        }),
-        requiredFunc: React.PropTypes.func.isRequired,
-        requiredAny: React.PropTypes.any.isRequired,
-        customProp: function(props: any, propName: string, componentName: string) {
-            if (!/matchme/.test(props[propName])) {
-                return new Error("Validation failed!");
-            }
-            return null;
-        }
-    },
-    render: (): React.ReactElement<any> => {
-        return null;
-    }
-};
-
-//
-// ContextTypes
-// --------------------------------------------------------------------------
-
-var ContextTypesSpecification: React.ComponentSpec<any, any> = {
-    contextTypes: {
-        optionalArray: React.PropTypes.array,
-        optionalBool: React.PropTypes.bool,
-        optionalFunc: React.PropTypes.func,
-        optionalNumber: React.PropTypes.number,
-        optionalObject: React.PropTypes.object,
-        optionalString: React.PropTypes.string,
-        optionalNode: React.PropTypes.node,
-        optionalElement: React.PropTypes.element,
-        optionalMessage: React.PropTypes.instanceOf(Date),
-        optionalEnum: React.PropTypes.oneOf(["News", "Photos"]),
-        optionalUnion: React.PropTypes.oneOfType([
-            React.PropTypes.string,
-            React.PropTypes.number,
-            React.PropTypes.instanceOf(Date)
-        ]),
-        optionalArrayOf: React.PropTypes.arrayOf(React.PropTypes.number),
-        optionalObjectOf: React.PropTypes.objectOf(React.PropTypes.number),
-        optionalObjectWithShape: React.PropTypes.shape({
-            color: React.PropTypes.string,
-            fontSize: React.PropTypes.number
-        }),
-        requiredFunc: React.PropTypes.func.isRequired,
-        requiredAny: React.PropTypes.any.isRequired,
-        customProp: function(props: any, propName: string, componentName: string) {
-            if (!/matchme/.test(props[propName])) {
-                return new Error("Validation failed!");
-            }
-            return null;
-        }
-    },
-    render: (): React.ReactElement<any> => {
-        return null;
-    }
-};
-
-//
-// React.Children
-// --------------------------------------------------------------------------
-
-var mappedChildrenArray: number[] =
-    React.Children.map<number>(children, (child) => { return 42; });
-React.Children.forEach(children, (child) => {});
-var nChildren: number = React.Children.count(children);
-var onlyChild = React.Children.only([null, [[["Hallo"], true]], false]);
-var childrenToArray: React.ReactChild[] = React.Children.toArray(children);
-
-//
-// Example from http://facebook.github.io/react/
-// --------------------------------------------------------------------------
-
-interface TimerState {
-    secondsElapsed: number;
-}
-class Timer extends React.Component<{}, TimerState> {
-    state = {
-        secondsElapsed: 0
-    };
-    private _interval: number;
-    tick() {
-        this.setState((prevState, props) => ({
-            secondsElapsed: prevState.secondsElapsed + 1
-        }));
-    }
-    componentDidMount() {
-        this._interval = setInterval(() => this.tick(), 1000);
-    }
-    componentWillUnmount() {
-        clearInterval(this._interval);
-    }
-    render() {
-        return React.DOM.div(
-            null,
-            "Seconds Elapsed: ",
-            this.state.secondsElapsed
-        );
-    }
-}
-ReactDOM.render(React.createElement(Timer), container);
-
-//
-// createFragment addon
-// --------------------------------------------------------------------------
-React.addons.createFragment({
-    a: React.DOM.div(),
-    b: ["a", false, React.createElement("span")]
-});
-
-//
-// CSSTransitionGroup addon
-// --------------------------------------------------------------------------
-React.createFactory(React.addons.CSSTransitionGroup)({
-    component: React.createClass({
-        render: (): React.ReactElement<any> => null
-    }),
-    childFactory: (c) => c,
-    transitionName: "transition",
-    transitionAppear: false,
-    transitionEnter: true,
-    transitionLeave: true
-});
-
-//
-// LinkedStateMixin addon
-// --------------------------------------------------------------------------
-React.createClass({
-  mixins: [React.addons.LinkedStateMixin],
-  render: function() { return React.DOM.div(null); }
-});
-
-//
-// Perf addon
-// --------------------------------------------------------------------------
-React.addons.Perf.start();
-React.addons.Perf.stop();
-var measurements = React.addons.Perf.getLastMeasurements();
-React.addons.Perf.printInclusive(measurements);
-React.addons.Perf.printExclusive(measurements);
-React.addons.Perf.printWasted(measurements);
-React.addons.Perf.printDOM(measurements);
-
-//
-// PureRenderMixin addon
-// --------------------------------------------------------------------------
-React.createClass({
-  mixins: [React.addons.PureRenderMixin],
-  render: function() { return React.DOM.div(null); }
-});
-
-//
-// TestUtils addon
-// --------------------------------------------------------------------------
-var node: Element;
-
-React.addons.TestUtils.Simulate.click(node);
-React.addons.TestUtils.Simulate.change(node);
-React.addons.TestUtils.Simulate.keyDown(node, { key: "Enter", cancelable: false });
-
-var renderer: React.ShallowRenderer =
-    React.addons.TestUtils.createRenderer();
-renderer.render(React.createElement(Timer));
-var output: React.ReactElement<React.Props<Timer>> =
-    renderer.getRenderOutput();
-
-//
-// TransitionGroup addon
-// --------------------------------------------------------------------------
-React.createFactory(React.addons.TransitionGroup)({ component: "div" });
-
-//
-// update addon
-// --------------------------------------------------------------------------
-{
-// These are copied from https://facebook.github.io/react/docs/update.html
-let initialArray = [1, 2, 3];
-let newArray = React.addons.update(initialArray, {$push: [4]}); // => [1, 2, 3, 4]
-
-let collection = [1, 2, {a: [12, 17, 15]}];
-let newCollection = React.addons.update(collection, {2: {a: {$splice: [[1, 1, 13, 14]]}}});
-// => [1, 2, {a: [12, 13, 14, 15]}]
-
-let obj = {a: 5, b: 3};
-let newObj = React.addons.update(obj, {b: {$apply: function(x) {return x * 2;}}});
-// => {a: 5, b: 6}
-let newObj2 = React.addons.update(obj, {b: {$set: obj.b * 2}});
-
-let objShallow = {a: 5, b: 3};
-let newObjShallow = React.addons.update(obj, {$merge: {b: 6, c: 7}}); // => {a: 5, b: 6, c: 7}
-}