,
+ element: DOMElement,
+ container: Element,
+ callback?: (element: T) => any): T;
+ function unstable_renderSubtreeIntoContainer
>(
+ parentComponent: Component,
+ element: CElement,
+ container: Element,
+ callback?: (component: T) => any): T;
+ function render
(
+ parentComponent: Component,
+ element: SFCElement,
+ container: Element,
+ callback?: () => any): void;
+ function unstable_renderSubtreeIntoContainer
(
+ parentComponent: Component,
+ element: ReactElement,
+ container: Element,
+ callback?: (component?: Component
| Element) => any): Component
| Element | void;
+ }
+
+ namespace __DOMServer {
+ function renderToString(element: ReactElement): string;
+ function renderToStaticMarkup(element: ReactElement): 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;
+}
diff --git a/examples/todo-app/typings/react/react.d.ts b/examples/todo-app/typings/react/react.d.ts
new file mode 100644
index 00000000000000..2d0d1f1136968e
--- /dev/null
+++ b/examples/todo-app/typings/react/react.d.ts
@@ -0,0 +1,2516 @@
+// Type definitions for React v0.14
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana , AssureSign , Microsoft
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare namespace __React {
+
+ //
+ // React Elements
+ // ----------------------------------------------------------------------
+
+ type ReactType = string | ComponentClass | StatelessComponent;
+
+ type Key = string | number;
+ type Ref = string | ((instance: T) => any);
+ type ComponentState = {} | void;
+
+ interface Attributes {
+ key?: Key;
+ }
+ interface ClassAttributes extends Attributes {
+ ref?: Ref;
+ }
+
+ interface ReactElement {
+ type: string | ComponentClass
| SFC
;
+ props: P;
+ key?: Key;
+ }
+
+ interface SFCElement
extends ReactElement
{
+ type: SFC
;
+ }
+
+ type CElement
> = ComponentElement
;
+ interface ComponentElement
> extends ReactElement
{
+ type: ComponentClass
;
+ ref?: Ref;
+ }
+
+ type ClassicElement = CElement
>;
+
+ interface DOMElement
extends ReactElement
{
+ type: string;
+ ref: Ref;
+ }
+
+ interface ReactHTMLElement extends DOMElement {
+ }
+
+ interface ReactSVGElement extends DOMElement {
+ }
+
+ //
+ // Factories
+ // ----------------------------------------------------------------------
+
+ interface Factory {
+ (props?: P & Attributes, ...children: ReactNode[]): ReactElement
;
+ }
+
+ interface SFCFactory
{
+ (props?: P & Attributes, ...children: ReactNode[]): SFCElement
;
+ }
+
+ interface ComponentFactory
> {
+ (props?: P & ClassAttributes, ...children: ReactNode[]): CElement;
+ }
+
+ type CFactory
> = ComponentFactory
;
+ type ClassicFactory
= CFactory
>;
+
+ interface DOMFactory
{
+ (props?: P & ClassAttributes, ...children: ReactNode[]): DOMElement;
+ }
+
+ interface HTMLFactory extends DOMFactory {
+ }
+
+ interface SVGFactory extends DOMFactory {
+ }
+
+ //
+ // React Nodes
+ // http://facebook.github.io/react/docs/glossary.html
+ // ----------------------------------------------------------------------
+
+ type ReactText = string | number;
+ type ReactChild = ReactElement | ReactText;
+
+ // Should be Array but type aliases cannot be recursive
+ type ReactFragment = {} | Array;
+ type ReactNode = ReactChild | ReactFragment | boolean;
+
+ //
+ // Top Level API
+ // ----------------------------------------------------------------------
+
+ function createClass(spec: ComponentSpec
): ClassicComponentClass
;
+
+ function createFactory
(
+ type: string): DOMFactory
;
+ function createFactory
(type: SFC
): SFCFactory
;
+ function createFactory
(
+ type: ClassType
, ClassicComponentClass
>): CFactory
>;
+ function createFactory
, C extends ComponentClass
>(
+ type: ClassType
): CFactory
;
+ function createFactory
(type: ComponentClass
| SFC
): Factory
;
+
+ function createElement
(
+ type: string,
+ props?: P & ClassAttributes,
+ ...children: ReactNode[]): DOMElement;
+ function createElement
(
+ type: SFC
,
+ props?: P & Attributes,
+ ...children: ReactNode[]): SFCElement
;
+ function createElement
(
+ type: ClassType
, ClassicComponentClass
>,
+ props?: P & ClassAttributes>,
+ ...children: ReactNode[]): CElement>;
+ function createElement
, C extends ComponentClass
>(
+ type: ClassType
,
+ props?: P & ClassAttributes,
+ ...children: ReactNode[]): CElement;
+ function createElement
(
+ type: ComponentClass
| SFC
,
+ props?: P & Attributes,
+ ...children: ReactNode[]): ReactElement
;
+
+ function cloneElement
(
+ element: DOMElement
,
+ props?: P & ClassAttributes,
+ ...children: ReactNode[]): DOMElement;
+ function cloneElement
(
+ element: SFCElement
,
+ props?: Q, // should be Q & Attributes, but then Q is inferred as {}
+ ...children: ReactNode[]): SFCElement
;
+ function cloneElement
>(
+ element: CElement
,
+ props?: Q, // should be Q & ClassAttributes
+ ...children: ReactNode[]): CElement;
+ function cloneElement
(
+ element: ReactElement
,
+ props?: Q, // should be Q & Attributes
+ ...children: ReactNode[]): ReactElement
;
+
+ function isValidElement
(object: {}): object is ReactElement
;
+
+ var DOM: ReactDOM;
+ var PropTypes: ReactPropTypes;
+ var Children: ReactChildren;
+ var version: string;
+
+ //
+ // Component API
+ // ----------------------------------------------------------------------
+
+ type ReactInstance = Component | Element;
+
+ // Base component for plain JS classes
+ class Component implements ComponentLifecycle
{
+ constructor(props?: P, context?: any);
+ setState(f: (prevState: S, props: P) => S, callback?: () => any): void;
+ setState(state: S, callback?: () => any): void;
+ forceUpdate(callback?: () => any): void;
+ render(): JSX.Element;
+
+ // React.Props is now deprecated, which means that the `children`
+ // property is not available on `P` by default, even though you can
+ // always pass children as variadic arguments to `createElement`.
+ // In the future, if we can define its call signature conditionally
+ // on the existence of `children` in `P`, then we should remove this.
+ props: P & { children?: ReactNode };
+ state: S;
+ context: {};
+ refs: {
+ [key: string]: ReactInstance
+ };
+ }
+
+ interface ClassicComponent extends Component
{
+ replaceState(nextState: S, callback?: () => any): void;
+ isMounted(): boolean;
+ getInitialState?(): S;
+ }
+
+ interface ChildContextProvider {
+ getChildContext(): CC;
+ }
+
+ //
+ // Class Interfaces
+ // ----------------------------------------------------------------------
+
+ type SFC = StatelessComponent
;
+ interface StatelessComponent
{
+ (props?: P, context?: any): ReactElement;
+ propTypes?: ValidationMap;
+ contextTypes?: ValidationMap;
+ defaultProps?: P;
+ displayName?: string;
+ }
+
+ interface ComponentClass {
+ new(props?: P, context?: any): Component
;
+ propTypes?: ValidationMap
;
+ contextTypes?: ValidationMap;
+ childContextTypes?: ValidationMap;
+ defaultProps?: P;
+ displayName?: string;
+ }
+
+ interface ClassicComponentClass extends ComponentClass
{
+ new(props?: P, context?: any): ClassicComponent
;
+ getDefaultProps?(): P;
+ }
+
+ /**
+ * We use an intersection type to infer multiple type parameters from
+ * a single argument, which is useful for many top-level API defs.
+ * See https://github.com/Microsoft/TypeScript/issues/7234 for more info.
+ */
+ type ClassType
, C extends ComponentClass
> =
+ C &
+ (new() => T) &
+ (new() => { props: P });
+
+ //
+ // Component Specs and Lifecycle
+ // ----------------------------------------------------------------------
+
+ interface ComponentLifecycle
{
+ componentWillMount?(): void;
+ componentDidMount?(): void;
+ componentWillReceiveProps?(nextProps: P, nextContext: any): void;
+ shouldComponentUpdate?(nextProps: P, nextState: S, nextContext: any): boolean;
+ componentWillUpdate?(nextProps: P, nextState: S, nextContext: any): void;
+ componentDidUpdate?(prevProps: P, prevState: S, prevContext: any): void;
+ componentWillUnmount?(): void;
+ }
+
+ interface Mixin
extends ComponentLifecycle
{
+ mixins?: Mixin
;
+ statics?: {
+ [key: string]: any;
+ };
+
+ displayName?: string;
+ propTypes?: ValidationMap;
+ contextTypes?: ValidationMap;
+ childContextTypes?: ValidationMap;
+
+ getDefaultProps?(): P;
+ getInitialState?(): S;
+ }
+
+ interface ComponentSpec extends Mixin
{
+ render(): ReactElement;
+
+ [propertyName: string]: any;
+ }
+
+ //
+ // Event System
+ // ----------------------------------------------------------------------
+
+ interface SyntheticEvent {
+ 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 ClipboardEvent extends SyntheticEvent {
+ clipboardData: DataTransfer;
+ }
+
+ interface CompositionEvent extends SyntheticEvent {
+ data: string;
+ }
+
+ interface DragEvent extends MouseEvent {
+ dataTransfer: DataTransfer;
+ }
+
+ interface FocusEvent extends SyntheticEvent {
+ relatedTarget: EventTarget;
+ }
+
+ interface FormEvent extends SyntheticEvent {
+ }
+
+ interface KeyboardEvent extends SyntheticEvent {
+ altKey: boolean;
+ charCode: number;
+ ctrlKey: boolean;
+ getModifierState(key: string): boolean;
+ key: string;
+ keyCode: number;
+ locale: string;
+ location: number;
+ metaKey: boolean;
+ repeat: boolean;
+ shiftKey: boolean;
+ which: number;
+ }
+
+ interface MouseEvent extends SyntheticEvent {
+ altKey: boolean;
+ button: number;
+ buttons: number;
+ clientX: number;
+ clientY: number;
+ ctrlKey: boolean;
+ getModifierState(key: string): boolean;
+ metaKey: boolean;
+ pageX: number;
+ pageY: number;
+ relatedTarget: EventTarget;
+ screenX: number;
+ screenY: number;
+ shiftKey: boolean;
+ }
+
+ interface TouchEvent extends SyntheticEvent {
+ altKey: boolean;
+ changedTouches: TouchList;
+ ctrlKey: boolean;
+ getModifierState(key: string): boolean;
+ metaKey: boolean;
+ shiftKey: boolean;
+ targetTouches: TouchList;
+ touches: TouchList;
+ }
+
+ interface UIEvent extends SyntheticEvent {
+ detail: number;
+ view: AbstractView;
+ }
+
+ interface WheelEvent extends MouseEvent {
+ deltaMode: number;
+ deltaX: number;
+ deltaY: number;
+ deltaZ: number;
+ }
+
+ interface AnimationEvent extends SyntheticEvent {
+ animationName: string;
+ pseudoElement: string;
+ elapsedTime: number;
+ }
+
+ interface TransitionEvent extends SyntheticEvent {
+ propertyName: string;
+ pseudoElement: string;
+ elapsedTime: number;
+ }
+
+ //
+ // Event Handler Types
+ // ----------------------------------------------------------------------
+
+ interface EventHandler {
+ (event: E): void;
+ }
+
+ type ReactEventHandler = EventHandler;
+
+ type ClipboardEventHandler = EventHandler;
+ type CompositionEventHandler = EventHandler;
+ type DragEventHandler = EventHandler;
+ type FocusEventHandler = EventHandler