@types/react-dom 16.0.3 → 16.0.7

react-dom/LICENSE

@@ -1,21 +1,21 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation. All rights reserved.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

react-dom/README.md

@@ -5,10 +5,10 @@
 This package contains type definitions for React (react-dom) (http://facebook.github.io/react/).
 
 # Details
-Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react-dom
 
 Additional Details
- * Last updated: Thu, 09 Nov 2017 09:57:15 GMT
+ * Last updated: Mon, 06 Aug 2018 21:55:26 GMT
  * Dependencies: react, node
  * Global values: ReactDOM, ReactDOMNodeStream, ReactDOMServer
 

react-dom/index.d.ts

@@ -1,100 +1,100 @@
-// Type definitions for React (react-dom) 16.0
-// Project: http://facebook.github.io/react/
-// Definitions by: Asana <https://asana.com>
-//                 AssureSign <http://www.assuresign.com>
-//                 Microsoft <https://microsoft.com>
-//                 MartynasZilinskas <https://github.com/MartynasZilinskas>
-//                 Josh Rutherford <https://github.com/theruther4d>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
-
-export as namespace ReactDOM;
-
-import {
-    ReactInstance, Component, ComponentState,
-    ReactElement, SFCElement, CElement,
-    DOMAttributes, DOMElement, ReactNode, ReactPortal
-} from 'react';
-
-export function findDOMNode(instance: ReactInstance): Element;
-export function unmountComponentAtNode(container: Element): boolean;
-
-export function createPortal(children: ReactNode, container: Element): ReactPortal;
-
-export const version: string;
-export const render: Renderer;
-export const hydrate: Renderer;
-
-export function unstable_batchedUpdates<A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
-export function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
-export function unstable_batchedUpdates(callback: () => any): void;
-
-export function unstable_renderSubtreeIntoContainer<T extends Element>(
-    parentComponent: Component<any>,
-    element: DOMElement<DOMAttributes<T>, T>,
-    container: Element,
-    callback?: (element: T) => any): T;
-export function unstable_renderSubtreeIntoContainer<P, T extends Component<P, ComponentState>>(
-    parentComponent: Component<any>,
-    element: CElement<P, T>,
-    container: Element,
-    callback?: (component: T) => any): T;
-export function unstable_renderSubtreeIntoContainer<P>(
-    parentComponent: Component<any>,
-    element: ReactElement<P>,
-    container: Element,
-    callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
-
-export interface Renderer {
-    // Deprecated(render): The return value is deprecated.
-    // In future releases the render function's return type will be void.
-
-    <T extends Element>(
-        element: DOMElement<DOMAttributes<T>, T>,
-        container: Element | null,
-        callback?: () => void
-    ): T;
-
-    (
-        element: Array<DOMElement<DOMAttributes<any>, any>>,
-        container: Element | null,
-        callback?: () => void
-    ): Element;
-
-    (
-        element: SFCElement<any> | Array<SFCElement<any>>,
-        container: Element | null,
-        callback?: () => void
-    ): void;
-
-    <P, T extends Component<P, ComponentState>>(
-        element: CElement<P, T>,
-        container: Element | null,
-        callback?: () => void
-    ): T;
-
-    (
-        element: Array<CElement<any, Component<any, ComponentState>>>,
-        container: Element | null,
-        callback?: () => void
-    ): Component<any, ComponentState>;
-
-    <P>(
-        element: ReactElement<P>,
-        container: Element | null,
-        callback?: () => void
-    ): Component<P, ComponentState> | Element | void;
-
-    (
-        element: Array<ReactElement<any>>,
-        container: Element | null,
-        callback?: () => void
-    ): Component<any, ComponentState> | Element | void;
-
-    (
-        parentComponent: Component<any> | Array<Component<any>>,
-        element: SFCElement<any>,
-        container: Element,
-        callback?: () => void
-    ): void;
-}
+// Type definitions for React (react-dom) 16.0
+// Project: http://facebook.github.io/react/
+// Definitions by: Asana <https://asana.com>
+//                 AssureSign <http://www.assuresign.com>
+//                 Microsoft <https://microsoft.com>
+//                 MartynasZilinskas <https://github.com/MartynasZilinskas>
+//                 Josh Rutherford <https://github.com/theruther4d>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+export as namespace ReactDOM;
+
+import {
+    ReactInstance, Component, ComponentState,
+    ReactElement, SFCElement, CElement,
+    DOMAttributes, DOMElement, ReactNode, ReactPortal
+} from 'react';
+
+export function findDOMNode(instance: ReactInstance): Element | null | Text;
+export function unmountComponentAtNode(container: Element): boolean;
+
+export function createPortal(children: ReactNode, container: Element, key?: null | string): ReactPortal;
+
+export const version: string;
+export const render: Renderer;
+export const hydrate: Renderer;
+
+export function unstable_batchedUpdates<A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
+export function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
+export function unstable_batchedUpdates(callback: () => any): void;
+
+export function unstable_renderSubtreeIntoContainer<T extends Element>(
+    parentComponent: Component<any>,
+    element: DOMElement<DOMAttributes<T>, T>,
+    container: Element,
+    callback?: (element: T) => any): T;
+export function unstable_renderSubtreeIntoContainer<P, T extends Component<P, ComponentState>>(
+    parentComponent: Component<any>,
+    element: CElement<P, T>,
+    container: Element,
+    callback?: (component: T) => any): T;
+export function unstable_renderSubtreeIntoContainer<P>(
+    parentComponent: Component<any>,
+    element: ReactElement<P>,
+    container: Element,
+    callback?: (component?: Component<P, ComponentState> | Element) => any): Component<P, ComponentState> | Element | void;
+
+export interface Renderer {
+    // Deprecated(render): The return value is deprecated.
+    // In future releases the render function's return type will be void.
+
+    <T extends Element>(
+        element: DOMElement<DOMAttributes<T>, T>,
+        container: Element | null,
+        callback?: () => void
+    ): T;
+
+    (
+        element: Array<DOMElement<DOMAttributes<any>, any>>,
+        container: Element | null,
+        callback?: () => void
+    ): Element;
+
+    (
+        element: SFCElement<any> | Array<SFCElement<any>>,
+        container: Element | null,
+        callback?: () => void
+    ): void;
+
+    <P, T extends Component<P, ComponentState>>(
+        element: CElement<P, T>,
+        container: Element | null,
+        callback?: () => void
+    ): T;
+
+    (
+        element: Array<CElement<any, Component<any, ComponentState>>>,
+        container: Element | null,
+        callback?: () => void
+    ): Component<any, ComponentState>;
+
+    <P>(
+        element: ReactElement<P>,
+        container: Element | null,
+        callback?: () => void
+    ): Component<P, ComponentState> | Element | void;
+
+    (
+        element: Array<ReactElement<any>>,
+        container: Element | null,
+        callback?: () => void
+    ): Component<any, ComponentState> | Element | void;
+
+    (
+        parentComponent: Component<any> | Array<Component<any>>,
+        element: SFCElement<any>,
+        container: Element,
+        callback?: () => void
+    ): void;
+}

react-dom/node-stream/index.d.ts

@@ -1,18 +1,18 @@
-import { ReactElement } from 'react';
-
-/**
- * Render a ReactElement to its initial HTML. This should only be used on the
- * server.
- * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostream
- */
-export function renderToStream(element: ReactElement<any>): any;
-
-/**
- * Similar to renderToStream, except this doesn't create extra DOM attributes
- * such as data-react-id that React uses internally.
- * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostaticstream
- */
-export function renderToStaticStream(element: ReactElement<any>): any;
-export const version: string;
-
-export as namespace ReactDOMNodeStream;
+import { ReactElement } from 'react';
+
+/**
+ * Render a ReactElement to its initial HTML. This should only be used on the
+ * server.
+ * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostream
+ */
+export function renderToStream(element: ReactElement<any>): any;
+
+/**
+ * Similar to renderToStream, except this doesn't create extra DOM attributes
+ * such as data-react-id that React uses internally.
+ * See https://facebook.github.io/react/docs/react-dom-stream.html#rendertostaticstream
+ */
+export function renderToStaticStream(element: ReactElement<any>): any;
+export const version: string;
+
+export as namespace ReactDOMNodeStream;

react-dom/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/react-dom",
-    "version": "16.0.3",
+    "version": "16.0.7",
     "description": "TypeScript definitions for React (react-dom)",
     "license": "MIT",
     "contributors": [
@@ -30,13 +30,13 @@
     "main": "",
     "repository": {
         "type": "git",
-        "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git"
     },
     "scripts": {},
     "dependencies": {
         "@types/react": "*",
         "@types/node": "*"
     },
-    "typesPublisherContentHash": "a1ecd70c2ef3dbfad1349e2130eeab861b8b53a24ba36a0721a3bd23b9504aeb",
-    "typeScriptVersion": "2.3"
+    "typesPublisherContentHash": "a72fcd94e060e36ee9396fe5c65569f1b87e6c64cce5d2d3461e86fa4b3a865d",
+    "typeScriptVersion": "2.8"
 }

react-dom/server/index.d.ts

@@ -1,41 +1,41 @@
-/// <reference types="node" />
-
-import { ReactElement } from 'react';
-
-/**
- * Render a React element to its initial HTML. This should only be used on the server.
- * React will return an HTML string. You can use this method to generate HTML on the server
- * and send the markup down on the initial request for faster page loads and to allow search
- * engines to crawl your pages for SEO purposes.
- *
- * If you call `ReactDOM.render()` on a node that already has this server-rendered markup,
- * React will preserve it and only attach event handlers, allowing you
- * to have a very performant first-load experience.
- */
-export function renderToString(element: ReactElement<any>): string;
-
-/**
- * Render a React element to its initial HTML. Returns a Readable stream that outputs
- * an HTML string. The HTML output by this stream is exactly equal to what
- * `ReactDOMServer.renderToString()` would return.
- */
-export function renderToNodeStream(element: ReactElement<any>): NodeJS.ReadableStream;
-
-/**
- * Similar to `renderToString`, except this doesn't create extra DOM attributes
- * such as `data-reactid`, that React uses internally. This is useful if you want
- * to use React as a simple static page generator, as stripping away the extra
- * attributes can save lots of bytes.
- */
-export function renderToStaticMarkup(element: ReactElement<any>): string;
-
-/**
- * Similar to `renderToNodeStream`, except this doesn't create extra DOM attributes
- * such as `data-reactid`, that React uses internally. The HTML output by this stream
- * is exactly equal to what `ReactDOMServer.renderToStaticMarkup()` would return.
- */
-export function renderToStaticNodeStream(element: ReactElement<any>): NodeJS.ReadableStream;
-
-export const version: string;
-
-export as namespace ReactDOMServer;
+/// <reference types="node" />
+
+import { ReactElement } from 'react';
+
+/**
+ * Render a React element to its initial HTML. This should only be used on the server.
+ * React will return an HTML string. You can use this method to generate HTML on the server
+ * and send the markup down on the initial request for faster page loads and to allow search
+ * engines to crawl your pages for SEO purposes.
+ *
+ * If you call `ReactDOM.render()` on a node that already has this server-rendered markup,
+ * React will preserve it and only attach event handlers, allowing you
+ * to have a very performant first-load experience.
+ */
+export function renderToString(element: ReactElement<any>): string;
+
+/**
+ * Render a React element to its initial HTML. Returns a Readable stream that outputs
+ * an HTML string. The HTML output by this stream is exactly equal to what
+ * `ReactDOMServer.renderToString()` would return.
+ */
+export function renderToNodeStream(element: ReactElement<any>): NodeJS.ReadableStream;
+
+/**
+ * Similar to `renderToString`, except this doesn't create extra DOM attributes
+ * such as `data-reactid`, that React uses internally. This is useful if you want
+ * to use React as a simple static page generator, as stripping away the extra
+ * attributes can save lots of bytes.
+ */
+export function renderToStaticMarkup(element: ReactElement<any>): string;
+
+/**
+ * Similar to `renderToNodeStream`, except this doesn't create extra DOM attributes
+ * such as `data-reactid`, that React uses internally. The HTML output by this stream
+ * is exactly equal to what `ReactDOMServer.renderToStaticMarkup()` would return.
+ */
+export function renderToStaticNodeStream(element: ReactElement<any>): NodeJS.ReadableStream;
+
+export const version: string;
+
+export as namespace ReactDOMServer;

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

@@ -1,276 +1,276 @@
-import {
-    AbstractView, Component, ComponentClass,
-    ReactElement, ReactInstance, ClassType,
-    DOMElement, SFCElement, CElement,
-    ReactHTMLElement, DOMAttributes, SFC
-} from 'react';
-
-import * as ReactTestUtils from ".";
-
-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 type EventSimulator = (element: Element | Component<any>, eventData?: SyntheticEventData) => void;
-
-export interface MockedComponentClass {
-    new (props: {}): any;
-}
-
-export interface ShallowRenderer {
-    /**
-     * After `shallowRenderer.render()` has been called, returns shallowly rendered output.
-     */
-    getRenderOutput<E extends ReactElement<any>>(): E;
-    /**
-     * After `shallowRenderer.render()` has been called, returns shallowly rendered output.
-     */
-    getRenderOutput(): ReactElement<any>;
-    /**
-     * Similar to `ReactDOM.render` but it doesn't require DOM and only renders a single level deep.
-     */
-    render(element: ReactElement<any>, context?: any): void;
-    unmount(): void;
-}
-
-/**
- * Simulate an event dispatch on a DOM node with optional `eventData` event data.
- * `Simulate` has a method for every event that React understands.
- */
-export namespace Simulate {
-    const abort: EventSimulator;
-    const animationEnd: EventSimulator;
-    const animationIteration: EventSimulator;
-    const animationStart: EventSimulator;
-    const blur: EventSimulator;
-    const canPlay: EventSimulator;
-    const canPlayThrough: EventSimulator;
-    const change: EventSimulator;
-    const click: EventSimulator;
-    const compositionEnd: EventSimulator;
-    const compositionStart: EventSimulator;
-    const compositionUpdate: EventSimulator;
-    const contextMenu: EventSimulator;
-    const copy: EventSimulator;
-    const cut: EventSimulator;
-    const doubleClick: EventSimulator;
-    const drag: EventSimulator;
-    const dragEnd: EventSimulator;
-    const dragEnter: EventSimulator;
-    const dragExit: EventSimulator;
-    const dragLeave: EventSimulator;
-    const dragOver: EventSimulator;
-    const dragStart: EventSimulator;
-    const drop: EventSimulator;
-    const durationChange: EventSimulator;
-    const emptied: EventSimulator;
-    const encrypted: EventSimulator;
-    const ended: EventSimulator;
-    const error: EventSimulator;
-    const focus: EventSimulator;
-    const input: EventSimulator;
-    const invalid: EventSimulator;
-    const keyDown: EventSimulator;
-    const keyPress: EventSimulator;
-    const keyUp: EventSimulator;
-    const load: EventSimulator;
-    const loadStart: EventSimulator;
-    const loadedData: EventSimulator;
-    const loadedMetadata: EventSimulator;
-    const mouseDown: EventSimulator;
-    const mouseEnter: EventSimulator;
-    const mouseLeave: EventSimulator;
-    const mouseMove: EventSimulator;
-    const mouseOut: EventSimulator;
-    const mouseOver: EventSimulator;
-    const mouseUp: EventSimulator;
-    const paste: EventSimulator;
-    const pause: EventSimulator;
-    const play: EventSimulator;
-    const playing: EventSimulator;
-    const progress: EventSimulator;
-    const rateChange: EventSimulator;
-    const scroll: EventSimulator;
-    const seeked: EventSimulator;
-    const seeking: EventSimulator;
-    const select: EventSimulator;
-    const stalled: EventSimulator;
-    const submit: EventSimulator;
-    const suspend: EventSimulator;
-    const timeUpdate: EventSimulator;
-    const touchCancel: EventSimulator;
-    const touchEnd: EventSimulator;
-    const touchMove: EventSimulator;
-    const touchStart: EventSimulator;
-    const transitionEnd: EventSimulator;
-    const volumeChange: EventSimulator;
-    const waiting: EventSimulator;
-    const wheel: EventSimulator;
-}
-
-/**
- * Render a React element into a detached DOM node in the document. __This function requires a DOM__.
- */
-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>>(
-    element: CElement<any, T>): T;
-export function renderIntoDocument<P>(
-    element: ReactElement<P>): Component<P> | Element | void;
-
-/**
- * Pass a mocked component module to this method to augment it with useful methods that allow it to
- * be used as a dummy React component. Instead of rendering as usual, the component will become
- * a simple `<div>` (or other tag if `mockTagName` is provided) containing any provided children.
- */
-export function mockComponent(
-    mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
-
-/**
- * Returns `true` if `element` is any React element.
- */
-export function isElement(element: any): boolean;
-
-/**
- * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
- */
-export function isElementOfType<T extends HTMLElement>(
-    element: ReactElement<any>, type: string): element is ReactHTMLElement<T>;
-/**
- * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
- */
-export function isElementOfType<P extends DOMAttributes<{}>, T extends Element>(
-    element: ReactElement<any>, type: string): element is DOMElement<P, T>;
-/**
- * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
- */
-export function isElementOfType<P>(
-    element: ReactElement<any>, type: SFC<P>): element is SFCElement<P>;
-/**
- * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
- */
-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>;
-
-/**
- * Returns `true` if `instance` is a DOM component (such as a `<div>` or `<span>`).
- */
-export function isDOMComponent(instance: ReactInstance): instance is Element;
-/**
- * Returns `true` if `instance` is a user-defined component, such as a class or a function.
- */
-export function isCompositeComponent(instance: ReactInstance): instance is Component<any>;
-/**
- * Returns `true` if `instance` is a component whose type is of a React `componentClass`.
- */
-export function isCompositeComponentWithType<T extends Component<any>, C extends ComponentClass<any>>(
-    instance: ReactInstance, type: ClassType<any, T, C>): boolean;
-
-/**
- * Traverse all components in `tree` and accumulate all components where
- * `test(component)` is `true`. This is not that useful on its own, but it's used
- * as a primitive for other test utils.
- */
-export function findAllInRenderedTree(
-    root: Component<any>,
-    fn: (i: ReactInstance) => boolean): ReactInstance[];
-
-/**
- * Finds all DOM elements of components in the rendered tree that are
- * DOM components with the class name matching `className`.
- */
-export function scryRenderedDOMComponentsWithClass(
-    root: Component<any>,
-    className: string): Element[];
-/**
- * Like `scryRenderedDOMComponentsWithClass()` but expects there to be one result,
- * and returns that one result, or throws exception if there is any other
- * number of matches besides one.
- */
-export function findRenderedDOMComponentWithClass(
-    root: Component<any>,
-    className: string): Element;
-
-/**
- * Finds all DOM elements of components in the rendered tree that are
- * DOM components with the tag name matching `tagName`.
- */
-export function scryRenderedDOMComponentsWithTag(
-    root: Component<any>,
-    tagName: string): Element[];
-/**
- * Like `scryRenderedDOMComponentsWithTag()` but expects there to be one result,
- * and returns that one result, or throws exception if there is any other
- * number of matches besides one.
- */
-export function findRenderedDOMComponentWithTag(
-    root: Component<any>,
-    tagName: string): Element;
-
-/**
- * Finds all instances of components with type equal to `componentClass`.
- */
-export function scryRenderedComponentsWithType<T extends Component, C extends ComponentClass>(
-    root: Component<any>,
-    type: ClassType<any, T, C>): T[];
-
-/**
- * Same as `scryRenderedComponentsWithType()` but expects there to be one result
- * and returns that one result, or throws exception if there is any other
- * number of matches besides one.
- */
-export function findRenderedComponentWithType<T extends Component, C extends ComponentClass>(
-    root: Component<any>,
-    type: ClassType<any, T, C>): T;
-
-/**
- * Call this in your tests to create a shallow renderer.
- */
-export function createRenderer(): ShallowRenderer;
+import {
+    AbstractView, Component, ComponentClass,
+    ReactElement, ReactInstance, ClassType,
+    DOMElement, SFCElement, CElement,
+    ReactHTMLElement, DOMAttributes, SFC
+} from 'react';
+
+import * as ReactTestUtils from ".";
+
+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 type EventSimulator = (element: Element | Component<any>, eventData?: SyntheticEventData) => void;
+
+export interface MockedComponentClass {
+    new (props: {}): any;
+}
+
+export interface ShallowRenderer {
+    /**
+     * After `shallowRenderer.render()` has been called, returns shallowly rendered output.
+     */
+    getRenderOutput<E extends ReactElement<any>>(): E;
+    /**
+     * After `shallowRenderer.render()` has been called, returns shallowly rendered output.
+     */
+    getRenderOutput(): ReactElement<any>;
+    /**
+     * Similar to `ReactDOM.render` but it doesn't require DOM and only renders a single level deep.
+     */
+    render(element: ReactElement<any>, context?: any): void;
+    unmount(): void;
+}
+
+/**
+ * Simulate an event dispatch on a DOM node with optional `eventData` event data.
+ * `Simulate` has a method for every event that React understands.
+ */
+export namespace Simulate {
+    const abort: EventSimulator;
+    const animationEnd: EventSimulator;
+    const animationIteration: EventSimulator;
+    const animationStart: EventSimulator;
+    const blur: EventSimulator;
+    const canPlay: EventSimulator;
+    const canPlayThrough: EventSimulator;
+    const change: EventSimulator;
+    const click: EventSimulator;
+    const compositionEnd: EventSimulator;
+    const compositionStart: EventSimulator;
+    const compositionUpdate: EventSimulator;
+    const contextMenu: EventSimulator;
+    const copy: EventSimulator;
+    const cut: EventSimulator;
+    const doubleClick: EventSimulator;
+    const drag: EventSimulator;
+    const dragEnd: EventSimulator;
+    const dragEnter: EventSimulator;
+    const dragExit: EventSimulator;
+    const dragLeave: EventSimulator;
+    const dragOver: EventSimulator;
+    const dragStart: EventSimulator;
+    const drop: EventSimulator;
+    const durationChange: EventSimulator;
+    const emptied: EventSimulator;
+    const encrypted: EventSimulator;
+    const ended: EventSimulator;
+    const error: EventSimulator;
+    const focus: EventSimulator;
+    const input: EventSimulator;
+    const invalid: EventSimulator;
+    const keyDown: EventSimulator;
+    const keyPress: EventSimulator;
+    const keyUp: EventSimulator;
+    const load: EventSimulator;
+    const loadStart: EventSimulator;
+    const loadedData: EventSimulator;
+    const loadedMetadata: EventSimulator;
+    const mouseDown: EventSimulator;
+    const mouseEnter: EventSimulator;
+    const mouseLeave: EventSimulator;
+    const mouseMove: EventSimulator;
+    const mouseOut: EventSimulator;
+    const mouseOver: EventSimulator;
+    const mouseUp: EventSimulator;
+    const paste: EventSimulator;
+    const pause: EventSimulator;
+    const play: EventSimulator;
+    const playing: EventSimulator;
+    const progress: EventSimulator;
+    const rateChange: EventSimulator;
+    const scroll: EventSimulator;
+    const seeked: EventSimulator;
+    const seeking: EventSimulator;
+    const select: EventSimulator;
+    const stalled: EventSimulator;
+    const submit: EventSimulator;
+    const suspend: EventSimulator;
+    const timeUpdate: EventSimulator;
+    const touchCancel: EventSimulator;
+    const touchEnd: EventSimulator;
+    const touchMove: EventSimulator;
+    const touchStart: EventSimulator;
+    const transitionEnd: EventSimulator;
+    const volumeChange: EventSimulator;
+    const waiting: EventSimulator;
+    const wheel: EventSimulator;
+}
+
+/**
+ * Render a React element into a detached DOM node in the document. __This function requires a DOM__.
+ */
+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>>(
+    element: CElement<any, T>): T;
+export function renderIntoDocument<P>(
+    element: ReactElement<P>): Component<P> | Element | void;
+
+/**
+ * Pass a mocked component module to this method to augment it with useful methods that allow it to
+ * be used as a dummy React component. Instead of rendering as usual, the component will become
+ * a simple `<div>` (or other tag if `mockTagName` is provided) containing any provided children.
+ */
+export function mockComponent(
+    mocked: MockedComponentClass, mockTagName?: string): typeof ReactTestUtils;
+
+/**
+ * Returns `true` if `element` is any React element.
+ */
+export function isElement(element: any): boolean;
+
+/**
+ * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
+ */
+export function isElementOfType<T extends HTMLElement>(
+    element: ReactElement<any>, type: string): element is ReactHTMLElement<T>;
+/**
+ * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
+ */
+export function isElementOfType<P extends DOMAttributes<{}>, T extends Element>(
+    element: ReactElement<any>, type: string): element is DOMElement<P, T>;
+/**
+ * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
+ */
+export function isElementOfType<P>(
+    element: ReactElement<any>, type: SFC<P>): element is SFCElement<P>;
+/**
+ * Returns `true` if `element` is a React element whose type is of a React `componentClass`.
+ */
+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>;
+
+/**
+ * Returns `true` if `instance` is a DOM component (such as a `<div>` or `<span>`).
+ */
+export function isDOMComponent(instance: ReactInstance): instance is Element;
+/**
+ * Returns `true` if `instance` is a user-defined component, such as a class or a function.
+ */
+export function isCompositeComponent(instance: ReactInstance): instance is Component<any>;
+/**
+ * Returns `true` if `instance` is a component whose type is of a React `componentClass`.
+ */
+export function isCompositeComponentWithType<T extends Component<any>, C extends ComponentClass<any>>(
+    instance: ReactInstance, type: ClassType<any, T, C>): boolean;
+
+/**
+ * Traverse all components in `tree` and accumulate all components where
+ * `test(component)` is `true`. This is not that useful on its own, but it's used
+ * as a primitive for other test utils.
+ */
+export function findAllInRenderedTree(
+    root: Component<any>,
+    fn: (i: ReactInstance) => boolean): ReactInstance[];
+
+/**
+ * Finds all DOM elements of components in the rendered tree that are
+ * DOM components with the class name matching `className`.
+ */
+export function scryRenderedDOMComponentsWithClass(
+    root: Component<any>,
+    className: string): Element[];
+/**
+ * Like `scryRenderedDOMComponentsWithClass()` but expects there to be one result,
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ */
+export function findRenderedDOMComponentWithClass(
+    root: Component<any>,
+    className: string): Element;
+
+/**
+ * Finds all DOM elements of components in the rendered tree that are
+ * DOM components with the tag name matching `tagName`.
+ */
+export function scryRenderedDOMComponentsWithTag(
+    root: Component<any>,
+    tagName: string): Element[];
+/**
+ * Like `scryRenderedDOMComponentsWithTag()` but expects there to be one result,
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ */
+export function findRenderedDOMComponentWithTag(
+    root: Component<any>,
+    tagName: string): Element;
+
+/**
+ * Finds all instances of components with type equal to `componentClass`.
+ */
+export function scryRenderedComponentsWithType<T extends Component, C extends ComponentClass>(
+    root: Component<any>,
+    type: ClassType<any, T, C>): T[];
+
+/**
+ * Same as `scryRenderedComponentsWithType()` but expects there to be one result
+ * and returns that one result, or throws exception if there is any other
+ * number of matches besides one.
+ */
+export function findRenderedComponentWithType<T extends Component, C extends ComponentClass>(
+    root: Component<any>,
+    type: ClassType<any, T, C>): T;
+
+/**
+ * Call this in your tests to create a shallow renderer.
+ */
+export function createRenderer(): ShallowRenderer;