diff --git a/enzyme/enzyme-1.2.0-tests.tsx b/enzyme/enzyme-1.2.0-tests.tsx
new file mode 100644
index 0000000000..44db5705bc
--- /dev/null
+++ b/enzyme/enzyme-1.2.0-tests.tsx
@@ -0,0 +1,605 @@
+/// <reference path="enzyme-1.2.0.d.ts" />
+/// <reference path="../react/react.d.ts"/>
+
+import { shallow, mount, render, describeWithDOM, spyLifecycle } from "enzyme";
+import * as React from "react";
+import {Component, ReactElement, HTMLAttributes} from "react";
+import {ShallowWrapper, ReactWrapper, CheerioWrapper} from "enzyme";
+
+
+// Help classes/interfaces
+interface MyComponentProps {
+    propsProperty: any;
+    numberProp?: number;
+}
+
+interface StatelessProps {
+    stateless: any;
+}
+
+interface MyComponentState {
+    stateProperty: any;
+}
+
+class MyComponent extends Component<MyComponentProps, MyComponentState> {
+    setState(...args: any[]) {
+    }
+}
+
+const MyStatelessComponent = (props: StatelessProps) => <span />;
+
+// API
+namespace SpyLifecycleTest {
+    spyLifecycle(MyComponent);
+}
+
+// ShallowWrapper
+namespace ShallowWrapperTest {
+    var shallowWrapper: ShallowWrapper<MyComponentProps, MyComponentState> =
+        shallow<MyComponentProps, MyComponentState>(<MyComponent propsProperty="value"/>);
+
+    var reactElement: ReactElement<any>,
+        objectVal: Object,
+        boolVal: Boolean,
+        stringVal: String,
+        elementWrapper: ShallowWrapper<HTMLAttributes, {}>
+
+    function test_find() {
+        elementWrapper = shallowWrapper.find('.selector');
+        shallowWrapper = shallowWrapper.find(MyComponent);
+        shallowWrapper.find(MyStatelessComponent).props().stateless;
+        shallowWrapper.find(MyStatelessComponent).shallow();
+    }
+
+    function test_findWhere() {
+        shallowWrapper =
+            shallowWrapper.findWhere((aShallowWrapper: ShallowWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+
+    function test_filter() {
+        elementWrapper = shallowWrapper.filter('.selector');
+        shallowWrapper = shallowWrapper.filter(MyComponent).shallow();
+    }
+
+    function test_filterWhere() {
+        shallowWrapper =
+            shallowWrapper.filterWhere(wrapper => {
+                wrapper.props().propsProperty;
+                return true;
+            });
+    }
+
+    function test_contains() {
+        boolVal = shallowWrapper.contains(<div className="foo bar"/>);
+    }
+
+    function test_hasClass() {
+        boolVal = shallowWrapper.find('.my-button').hasClass('disabled');
+    }
+
+    function test_is() {
+        boolVal = shallowWrapper.is('.some-class');
+    }
+
+    function test_not() {
+        elementWrapper = shallowWrapper.find('.foo').not('.bar');
+    }
+
+    function test_children() {
+        shallowWrapper = shallowWrapper.children();
+        shallowWrapper.children(MyStatelessComponent).props().stateless;
+    }
+
+    function test_parents() {
+        shallowWrapper = shallowWrapper.parents();
+    }
+
+    function test_parent() {
+        shallowWrapper = shallowWrapper.parent();
+    }
+
+    function test_closest() {
+        elementWrapper = shallowWrapper.closest('.selector');
+        shallowWrapper = shallowWrapper.closest(MyComponent);
+    }
+
+    function test_shallow() {
+        shallowWrapper = shallowWrapper.shallow();
+    }
+
+    function test_unmount() {
+        shallowWrapper = shallowWrapper.unmount();
+    }
+
+    function test_render() {
+        var cheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState> = shallowWrapper.render();
+    }
+
+    function test_text() {
+        stringVal = shallowWrapper.text();
+    }
+
+
+    function test_html() {
+        stringVal = shallowWrapper.html();
+    }
+
+    function test_get() {
+        reactElement = shallowWrapper.get(1);
+    }
+
+    function test_at() {
+        shallowWrapper = shallowWrapper.at(1);
+    }
+
+    function test_first() {
+        shallowWrapper = shallowWrapper.first();
+    }
+
+    function test_last() {
+        shallowWrapper = shallowWrapper.last();
+    }
+
+    function test_state() {
+        shallowWrapper.state();
+        shallowWrapper.state('key');
+    }
+
+    function test_props() {
+        objectVal = shallowWrapper.props();
+    }
+
+    function test_prop() {
+        shallowWrapper.prop('key');
+    }
+
+
+    function test_simulate(...args: any[]) {
+        shallowWrapper.simulate('click');
+        shallowWrapper.simulate('click', args);
+    }
+
+    function test_setState() {
+        shallowWrapper = shallowWrapper.setState({stateProperty: 'state'});
+    }
+
+    function test_setProps() {
+        shallowWrapper = shallowWrapper.setProps({propsProperty: 'foo'});
+    }
+
+    function test_setContext() {
+        shallowWrapper = shallowWrapper.setContext({name: 'baz'});
+    }
+
+    function test_instance() {
+        var myComponent: MyComponent = shallowWrapper.instance();
+    }
+
+    function test_update() {
+        shallowWrapper = shallowWrapper.update();
+    }
+
+    function test_debug() {
+        stringVal = shallowWrapper.debug();
+    }
+
+    function test_type() {
+        var stringOrFunction: String|Function = shallowWrapper.type();
+    }
+
+    function test_forEach() {
+        shallowWrapper =
+            shallowWrapper.forEach(wrapper => wrapper.shallow().props().propsProperty);
+    }
+
+    function test_map() {
+        var arrayNumbers: Array<Number> =
+            shallowWrapper.map(wrapper => wrapper.props().numberProp);
+    }
+
+    function test_reduce() {
+        const total: number[] =
+            shallowWrapper.reduce(
+                (amount: number, n: ShallowWrapper<MyComponentProps, MyComponentState>) => amount + n.props().numberProp
+            );
+    }
+
+    function test_reduceRight() {
+        const total: number[] =
+            shallowWrapper.reduceRight<number>(
+                (amount: number, n: ShallowWrapper<MyComponentProps, MyComponentState>) => amount + n.prop('amount')
+            );
+    }
+
+    function test_some() {
+        boolVal = shallowWrapper.some('.selector');
+        boolVal = shallowWrapper.some(MyComponent);
+    }
+
+    function test_someWhere() {
+        boolVal = shallowWrapper.someWhere((aShallowWrapper: ShallowWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+
+    function test_every() {
+        boolVal = shallowWrapper.every('.selector');
+        boolVal = shallowWrapper.every(MyComponent);
+    }
+
+    function test_everyWhere() {
+        boolVal = shallowWrapper.everyWhere((aShallowWrapper: ShallowWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+}
+
+
+// ReactWrapper
+namespace ReactWrapperTest {
+    var reactWrapper: ReactWrapper<MyComponentProps, MyComponentState> =
+        mount<MyComponentProps, MyComponentState>(<MyComponent propsProperty="value"/>);
+
+    var reactElement: ReactElement<any>,
+        objectVal: Object,
+        boolVal: Boolean,
+        stringVal: String,
+        elementWrapper: ReactWrapper<HTMLAttributes, {}>
+
+    function test_unmount() {
+        reactWrapper = reactWrapper.unmount();
+    }
+
+    function test_mount() {
+        reactWrapper = reactWrapper.mount();
+    }
+
+    function test_find() {
+        elementWrapper = reactWrapper.find('.selector');
+        reactWrapper = reactWrapper.find(MyComponent);
+        reactWrapper.find(MyStatelessComponent).props().stateless;
+    }
+
+    function test_findWhere() {
+        reactWrapper =
+            reactWrapper.findWhere((aReactWrapper: ReactWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+
+    function test_filter() {
+        elementWrapper = reactWrapper.filter('.selector');
+        reactWrapper = reactWrapper.filter(MyComponent);
+    }
+
+    function test_filterWhere() {
+        reactWrapper =
+            reactWrapper.filterWhere(wrapper => {
+                wrapper.props().propsProperty;
+                return true;
+            });
+    }
+
+    function test_contains() {
+        boolVal = reactWrapper.contains(<div className="foo bar"/>);
+    }
+
+    function test_hasClass() {
+        boolVal = reactWrapper.find('.my-button').hasClass('disabled');
+    }
+
+    function test_is() {
+        boolVal = reactWrapper.is('.some-class');
+    }
+
+    function test_not() {
+        elementWrapper = reactWrapper.find('.foo').not('.bar');
+    }
+
+    function test_children() {
+        reactWrapper = reactWrapper.children();
+    }
+
+    function test_parents() {
+        reactWrapper = reactWrapper.parents();
+    }
+
+    function test_parent() {
+        reactWrapper = reactWrapper.parent();
+    }
+
+    function test_closest() {
+        elementWrapper = reactWrapper.closest('.selector');
+        reactWrapper = reactWrapper.closest(MyComponent);
+    }
+
+    function test_text() {
+        stringVal = reactWrapper.text();
+    }
+
+    function test_html() {
+        stringVal = reactWrapper.html();
+    }
+
+    function test_get() {
+        reactElement = reactWrapper.get(1);
+    }
+
+    function test_at() {
+        reactWrapper = reactWrapper.at(1);
+    }
+
+    function test_first() {
+        reactWrapper = reactWrapper.first();
+    }
+
+    function test_last() {
+        reactWrapper = reactWrapper.last();
+    }
+
+    function test_state() {
+        reactWrapper.state();
+        reactWrapper.state('key');
+    }
+
+    function test_props() {
+        objectVal = reactWrapper.props();
+    }
+
+    function test_prop() {
+        reactWrapper.prop('key');
+    }
+
+
+    function test_simulate(...args: any[]) {
+        reactWrapper.simulate('click');
+        reactWrapper.simulate('click', args);
+    }
+
+    function test_setState() {
+        reactWrapper = reactWrapper.setState({stateProperty: 'state'});
+    }
+
+    function test_setProps() {
+        reactWrapper = reactWrapper.setProps({propsProperty: 'foo'});
+    }
+
+    function test_setContext() {
+        reactWrapper = reactWrapper.setContext({name: 'baz'});
+    }
+
+    function test_instance() {
+        var myComponent: MyComponent = reactWrapper.instance();
+    }
+
+    function test_update() {
+        reactWrapper = reactWrapper.update();
+    }
+
+    function test_debug() {
+        stringVal = reactWrapper.debug();
+    }
+
+    function test_type() {
+        var stringOrFunction: String|Function = reactWrapper.type();
+    }
+
+    function test_forEach() {
+        reactWrapper =
+            reactWrapper.forEach(wrapper => wrapper.props().propsProperty);
+    }
+
+    function test_map() {
+        var arrayNumbers: Array<Number> =
+            reactWrapper.map(wrapper => wrapper.props().numberProp);
+    }
+
+    function test_reduce() {
+        const total: number[] =
+            reactWrapper.reduce<number>(
+                (amount: number, n: ReactWrapper<MyComponentProps, MyComponentState>) => amount + n.prop('amount')
+            );
+    }
+
+    function test_reduceRight() {
+        const total: number[] =
+            reactWrapper.reduceRight<number>(
+                (amount: number, n: ReactWrapper<MyComponentProps, MyComponentState>) => amount + n.prop('amount')
+            );
+    }
+
+    function test_some() {
+        boolVal = reactWrapper.some('.selector');
+        boolVal = reactWrapper.some(MyComponent);
+    }
+
+    function test_someWhere() {
+        boolVal = reactWrapper.someWhere((aReactWrapper: ReactWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+
+    function test_every() {
+        boolVal = reactWrapper.every('.selector');
+        boolVal = reactWrapper.every(MyComponent);
+    }
+
+    function test_everyWhere() {
+        boolVal = reactWrapper.everyWhere((aReactWrapper: ReactWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+}
+
+// CheerioWrapper
+namespace CheerioWrapperTest {
+    var cheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState> =
+        render<MyComponentProps, MyComponentState>(<MyComponent propsProperty="value"/>);
+
+    var reactElement: ReactElement<any>,
+        objectVal: Object,
+        boolVal: Boolean,
+        stringVal: String,
+        elementWrapper: CheerioWrapper<HTMLAttributes, {}>
+
+    function test_find() {
+        elementWrapper = cheerioWrapper.find('.selector');
+        cheerioWrapper = cheerioWrapper.find(MyComponent);
+        cheerioWrapper.find(MyStatelessComponent).props().stateless;
+    }
+
+    function test_findWhere() {
+        cheerioWrapper =
+            cheerioWrapper.findWhere((aCheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+
+    function test_filter() {
+        elementWrapper = cheerioWrapper.filter('.selector');
+        cheerioWrapper = cheerioWrapper.filter(MyComponent);
+    }
+
+    function test_filterWhere() {
+        cheerioWrapper =
+            cheerioWrapper.filterWhere(wrapper => {
+                wrapper.props().propsProperty;
+                return true;
+            });
+    }
+
+    function test_contains() {
+        boolVal = cheerioWrapper.contains(<div className="foo bar"/>);
+    }
+
+    function test_hasClass() {
+        boolVal = cheerioWrapper.find('.my-button').hasClass('disabled');
+    }
+
+    function test_is() {
+        boolVal = cheerioWrapper.is('.some-class');
+    }
+
+    function test_not() {
+        elementWrapper = cheerioWrapper.find('.foo').not('.bar');
+    }
+
+    function test_children() {
+        cheerioWrapper = cheerioWrapper.children();
+    }
+
+    function test_parents() {
+        cheerioWrapper = cheerioWrapper.parents();
+    }
+
+    function test_parent() {
+        cheerioWrapper = cheerioWrapper.parent();
+    }
+
+    function test_closest() {
+        elementWrapper = cheerioWrapper.closest('.selector');
+        cheerioWrapper = cheerioWrapper.closest(MyComponent);
+    }
+
+    function test_text() {
+        stringVal = cheerioWrapper.text();
+    }
+
+    function test_html() {
+        stringVal = cheerioWrapper.html();
+    }
+
+    function test_get() {
+        reactElement = cheerioWrapper.get(1);
+    }
+
+    function test_at() {
+        cheerioWrapper = cheerioWrapper.at(1);
+    }
+
+    function test_first() {
+        cheerioWrapper = cheerioWrapper.first();
+    }
+
+    function test_last() {
+        cheerioWrapper = cheerioWrapper.last();
+    }
+
+    function test_state() {
+        cheerioWrapper.state();
+        cheerioWrapper.state('key');
+    }
+
+    function test_props() {
+        objectVal = cheerioWrapper.props();
+    }
+
+    function test_prop() {
+        cheerioWrapper.prop('key');
+    }
+
+
+    function test_simulate(...args: any[]) {
+        cheerioWrapper.simulate('click');
+        cheerioWrapper.simulate('click', args);
+    }
+
+    function test_setState() {
+        cheerioWrapper = cheerioWrapper.setState({stateProperty: 'state'});
+    }
+
+    function test_setProps() {
+        cheerioWrapper = cheerioWrapper.setProps({propsProperty: 'foo'});
+    }
+
+    function test_setContext() {
+        cheerioWrapper = cheerioWrapper.setContext({name: 'baz'});
+    }
+
+    function test_instance() {
+        var myComponent: MyComponent = cheerioWrapper.instance();
+    }
+
+    function test_update() {
+        cheerioWrapper = cheerioWrapper.update();
+    }
+
+    function test_debug() {
+        stringVal = cheerioWrapper.debug();
+    }
+
+    function test_type() {
+        var stringOrFunction: String|Function = cheerioWrapper.type();
+    }
+
+    function test_forEach() {
+        cheerioWrapper =
+            cheerioWrapper.forEach((aCheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState>)=> {
+            });
+    }
+
+    function test_map() {
+        var arrayNumbers: Array<Number> =
+            cheerioWrapper.map(wrapper => wrapper.props().numberProp);
+    }
+
+    function test_reduce() {
+        const total: number[] =
+            cheerioWrapper.reduce<number>(
+                (amount: number, n: CheerioWrapper<MyComponentProps, MyComponentState>) => amount + n.prop('amount')
+            );
+    }
+
+    function test_reduceRight() {
+        const total: number[] =
+            cheerioWrapper.reduceRight<number>(
+                (amount: number, n: CheerioWrapper<MyComponentProps, MyComponentState>) => amount + n.prop('amount')
+            );
+    }
+
+    function test_some() {
+        boolVal = cheerioWrapper.some('.selector');
+        boolVal = cheerioWrapper.some(MyComponent);
+    }
+
+    function test_someWhere() {
+        boolVal = cheerioWrapper.someWhere((aCheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+
+    function test_every() {
+        boolVal = cheerioWrapper.every('.selector');
+        boolVal = cheerioWrapper.every(MyComponent);
+    }
+
+    function test_everyWhere() {
+        boolVal = cheerioWrapper.everyWhere((aCheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState>) => true);
+    }
+}
diff --git a/enzyme/enzyme-1.2.0.d.ts b/enzyme/enzyme-1.2.0.d.ts
new file mode 100644
index 0000000000..13c00041a5
--- /dev/null
+++ b/enzyme/enzyme-1.2.0.d.ts
@@ -0,0 +1,473 @@
+// Type definitions for Enzyme v1.2.0
+// Project: https://github.com/airbnb/enzyme
+// Definitions by: Marian Palkus <https://github.com/MarianPalkus>, Cap3 <http://www.cap3.de>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+///<reference path="../react/react.d.ts" />
+
+declare module "enzyme" {
+
+    import {ReactElement, Component, StatelessComponent, ComponentClass, HTMLAttributes} from "react";
+
+    export class ElementClass extends Component<any, any> {
+    }
+
+    /**
+     * Many methods in Enzyme's API accept a selector as an argument. Selectors in Enzyme can fall into one of the
+     * following three categories:
+     *
+     *  1. A Valid CSS Selector
+     *  2. A React Component Constructor
+     *  3. A React Component's displayName
+     */
+    export type EnzymeSelector = String | typeof ElementClass;
+
+    interface CommonWrapper<P, S> {
+        /**
+         * Find every node in the render tree that matches the provided selector.
+         * @param selector The selector to match.
+         */
+        find<P2>(component: ComponentClass<P2>): CommonWrapper<P2, any>;
+        find<P2>(statelessComponent: StatelessComponent<P2>): CommonWrapper<P2, {}>;
+        find(selector: string): CommonWrapper<HTMLAttributes, any>;
+
+        /**
+         * Finds every node in the render tree that returns true for the provided predicate function.
+         * @param predicate
+         */
+        findWhere(predicate: (wrapper: CommonWrapper<any, any>) => Boolean): CommonWrapper<any, any>;
+
+        /**
+         * Removes nodes in the current wrapper that do not match the provided selector.
+         * @param selector The selector to match.
+         */
+        filter<P2>(component: ComponentClass<P2>): CommonWrapper<P2, any>;
+        filter<P2>(statelessComponent: StatelessComponent<P2>): CommonWrapper<P2, {}>;
+        filter(selector: string): CommonWrapper<HTMLAttributes, any>;
+
+        /**
+         * Returns a new wrapper with only the nodes of the current wrapper that, when passed into the provided predicate function, return true.
+         * @param predicate
+         */
+        filterWhere(predicate: (wrapper: this) => Boolean): this;
+
+        /**
+         * Returns whether or not the current wrapper has a node anywhere in it's render tree that looks like the one passed in.
+         * @param node
+         */
+        contains(node: ReactElement<any>): Boolean;
+
+        /**
+         * Returns whether or not the current node has a className prop including the passed in class name.
+         * @param className
+         */
+        hasClass(className: String): Boolean;
+
+        /**
+         * Returns whether or not the current node matches a provided selector.
+         * @param selector
+         */
+        is(selector: EnzymeSelector): Boolean;
+
+        /**
+         * Returns a new wrapper with only the nodes of the current wrapper that don't match the provided selector.
+         * This method is effectively the negation or inverse of filter.
+         * @param selector
+         */
+        not(selector: EnzymeSelector): this;
+
+        /**
+         * Returns a new wrapper with all of the children of the node(s) in the current wrapper. Optionally, a selector
+         * can be provided and it will filter the children by this selector.
+         * @param [selector]
+         */
+        children<P2>(component: ComponentClass<P2>): CommonWrapper<P2, any>;
+        children<P2>(statelessComponent: StatelessComponent<P2>): CommonWrapper<P2, {}>;
+        children(selector: string): CommonWrapper<HTMLAttributes, any>;
+        children(): CommonWrapper<any, any>;
+
+        /**
+         * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node in the
+         * current wrapper. Optionally, a selector can be provided and it will filter the parents by this selector.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         * @param [selector]
+         */
+        parents<P2>(component: ComponentClass<P2>): CommonWrapper<P2, any>;
+        parents<P2>(statelessComponent: StatelessComponent<P2>): CommonWrapper<P2, {}>;
+        parents(selector: string): CommonWrapper<HTMLAttributes, any>;
+        parents(): CommonWrapper<any, any>;
+
+        /**
+         * Returns a wrapper with the direct parent of the node in the current wrapper.
+         */
+        parent(): CommonWrapper<any, any>;
+
+        /**
+         * Returns a wrapper of the first element that matches the selector by traversing up through the current node's
+         * ancestors in the tree, starting with itself.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         * @param selector
+         */
+        closest<P2>(component: ComponentClass<P2>): CommonWrapper<P2, any>;
+        closest<P2>(statelessComponent: StatelessComponent<P2>): CommonWrapper<P2, {}>;
+        closest(selector: string): CommonWrapper<HTMLAttributes, any>;
+
+        /**
+         * Returns a string of the rendered text of the current render tree. This function should be looked at with
+         * skepticism if being used to test what the actual HTML output of the component will be. If that is what you
+         * would like to test, use enzyme's render function instead.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         */
+        text(): String;
+
+        /**
+         * Returns a string of the rendered HTML markup of the current render tree.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         */
+        html(): String;
+
+        /**
+         * Returns the node at a given index of the current wrapper.
+         * @param index
+         */
+        get(index: number): ReactElement<any>;
+
+        /**
+         * Returns a wrapper around the node at a given index of the current wrapper.
+         * @param index
+         */
+        at(index: number): this;
+
+        /**
+         * Reduce the set of matched nodes to the first in the set.
+         */
+        first(): this;
+
+        /**
+         * Reduce the set of matched nodes to the last in the set.
+         */
+        last(): this;
+
+        /**
+         * Returns the state hash for the root node of the wrapper. Optionally pass in a prop name and it will return just that value.
+         * @param [key]
+         */
+        state(key?: String): any;
+
+        /**
+         * Returns the props hash for the current node of the wrapper.
+         *
+         * NOTE: can only be called on a wrapper of a single node.
+         */
+        props(): P;
+
+        /**
+         * Returns the prop value for the node of the current wrapper with the provided key.
+         *
+         * NOTE: can only be called on a wrapper of a single node.
+         * @param key
+         */
+        prop(key: String): any;
+
+        /**
+         * Simulate events.
+         * Returns itself.
+         * @param event
+         * @param args?
+         */
+        simulate(event: string, ...args: any[]): this;
+
+        /**
+         * A method to invoke setState() on the root component instance similar to how you might in the definition of
+         * the component, and re-renders. This method is useful for testing your component in hard to achieve states,
+         * however should be used sparingly. If possible, you should utilize your component's external API in order to
+         * get it into whatever state you want to test, in order to be as accurate of a test as possible. This is not
+         * always practical, however.
+         * Returns itself.
+         *
+         * NOTE: can only be called on a wrapper instance that is also the root instance.
+         * @param state
+         */
+        setState(state: S): this;
+
+        /**
+         * A method that sets the props of the root component, and re-renders. Useful for when you are wanting to test
+         * how the component behaves over time with changing props. Calling this, for instance, will call the
+         * componentWillReceiveProps lifecycle method.
+         *
+         * Similar to setState, this method accepts a props object and will merge it in with the already existing props.
+         * Returns itself.
+         *
+         * NOTE: can only be called on a wrapper instance that is also the root instance.
+         * @param state
+         */
+        setProps(props: P): this;
+
+        /**
+         * A method that sets the context of the root component, and re-renders. Useful for when you are wanting to
+         * test how the component behaves over time with changing contexts.
+         * Returns itself.
+         *
+         * NOTE: can only be called on a wrapper instance that is also the root instance.
+         * @param state
+         */
+        setContext(context: Object): this;
+
+        /**
+         * Gets the instance of the component being rendered as the root node passed into shallow().
+         *
+         * NOTE: can only be called on a wrapper instance that is also the root instance.
+         */
+        instance(): Component<P, S>;
+
+        /**
+         * Forces a re-render. Useful to run before checking the render output if something external may be updating
+         * the state of the component somewhere.
+         * Returns itself.
+         *
+         * NOTE: can only be called on a wrapper instance that is also the root instance.
+         */
+        update(): this;
+
+        /**
+         * Returns an html-like string of the wrapper for debugging purposes. Useful to print out to the console when
+         * tests are not passing when you expect them to.
+         */
+        debug(): String;
+
+        /**
+         * Returns the type of the current node of this wrapper. If it's a composite component, this will be the
+         * component constructor. If it's native DOM node, it will be a string of the tag name.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         */
+        type(): String | Function;
+
+        /**
+         * Iterates through each node of the current wrapper and executes the provided function with a wrapper around
+         * the corresponding node passed in as the first argument.
+         *
+         * Returns itself.
+         * @param fn A callback to be run for every node in the collection. Should expect a ShallowWrapper as the first
+         *              argument, and will be run with a context of the original instance.
+         */
+        forEach(fn: (wrapper: this) => any): this;
+
+        /**
+         * Maps the current array of nodes to another array. Each node is passed in as a ShallowWrapper to the map
+         * function.
+         * Returns an array of the returned values from the mapping function..
+         * @param fn A mapping function to be run for every node in the collection, the results of which will be mapped
+         *              to the returned array. Should expect a ShallowWrapper as the first argument, and will be run
+         *              with a context of the original instance.
+         */
+        map<V>(fn: (wrapper: this) => V): V[];
+
+        /**
+         * Applies the provided reducing function to every node in the wrapper to reduce to a single value. Each node
+         * is passed in as a ShallowWrapper, and is processed from left to right.
+         * @param fn
+         * @param initialValue
+         */
+        reduce<R>(fn: (prevVal: R, wrapper: this, index: number) => R, initialValue?: R): R[];
+
+        /**
+         * Applies the provided reducing function to every node in the wrapper to reduce to a single value.
+         * Each node is passed in as a ShallowWrapper, and is processed from right to left.
+         * @param fn
+         * @param initialValue
+         */
+        reduceRight<R>(fn: (prevVal: R, wrapper: this, index: number) => R, initialValue?: R): R[];
+
+        /**
+         * Returns whether or not any of the nodes in the wrapper match the provided selector.
+         * @param selector
+         */
+        some(selector: EnzymeSelector): Boolean;
+
+        /**
+         * Returns whether or not any of the nodes in the wrapper pass the provided predicate function.
+         * @param fn
+         */
+        someWhere(fn: (wrapper: this) => Boolean): Boolean;
+
+        /**
+         * Returns whether or not all of the nodes in the wrapper match the provided selector.
+         * @param selector
+         */
+        every(selector: EnzymeSelector): Boolean;
+
+        /**
+         * Returns whether or not any of the nodes in the wrapper pass the provided predicate function.
+         * @param fn
+         */
+        everyWhere(fn: (wrapper: this) => Boolean): Boolean;
+
+        length: number;
+    }
+
+    export interface ShallowWrapper<P, S> extends CommonWrapper<P, S> {
+        shallow(): ShallowWrapper<P, S>;
+        render(): CheerioWrapper<P, S>;
+        unmount(): ShallowWrapper<any, any>;
+
+        /**
+         * Find every node in the render tree that matches the provided selector.
+         * @param selector The selector to match.
+         */
+        find<P2>(component: ComponentClass<P2>): ShallowWrapper<P2, any>;
+        find<P2>(statelessComponent: (props: P2) => JSX.Element): ShallowWrapper<P2, {}>;
+        find(selector: string): ShallowWrapper<HTMLAttributes, any>;
+
+        /**
+         * Removes nodes in the current wrapper that do not match the provided selector.
+         * @param selector The selector to match.
+         */
+        filter<P2>(component: ComponentClass<P2>): ShallowWrapper<P2, any>;
+        filter<P2>(statelessComponent: StatelessComponent<P2>): ShallowWrapper<P2, {}>;
+        filter(selector: string): ShallowWrapper<HTMLAttributes, any>;
+
+        /**
+         * Finds every node in the render tree that returns true for the provided predicate function.
+         * @param predicate
+         */
+        findWhere(predicate: (wrapper: CommonWrapper<any, any>) => Boolean): ShallowWrapper<any, any>;
+
+        /**
+         * Returns a new wrapper with all of the children of the node(s) in the current wrapper. Optionally, a selector
+         * can be provided and it will filter the children by this selector.
+         * @param [selector]
+         */
+        children<P2>(component: ComponentClass<P2>): ShallowWrapper<P2, any>;
+        children<P2>(statelessComponent: StatelessComponent<P2>): ShallowWrapper<P2, {}>;
+        children(selector: string): ShallowWrapper<HTMLAttributes, any>;
+        children(): ShallowWrapper<any, any>;
+
+        /**
+         * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node in the
+         * current wrapper. Optionally, a selector can be provided and it will filter the parents by this selector.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         * @param [selector]
+         */
+        parents<P2>(component: ComponentClass<P2>): ShallowWrapper<P2, any>;
+        parents<P2>(statelessComponent: StatelessComponent<P2>): ShallowWrapper<P2, {}>;
+        parents(selector: string): ShallowWrapper<HTMLAttributes, any>;
+        parents(): ShallowWrapper<any, any>;
+
+        /**
+         * Returns a wrapper of the first element that matches the selector by traversing up through the current node's
+         * ancestors in the tree, starting with itself.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         * @param selector
+         */
+        closest<P2>(component: ComponentClass<P2>): ShallowWrapper<P2, any>;
+        closest<P2>(statelessComponent: StatelessComponent<P2>): ShallowWrapper<P2, {}>;
+        closest(selector: string): ShallowWrapper<HTMLAttributes, any>;
+
+        /**
+         * Returns a wrapper with the direct parent of the node in the current wrapper.
+         */
+        parent(): ShallowWrapper<any, any>;
+    }
+
+    export interface ReactWrapper<P, S> extends CommonWrapper<P, S> {
+        unmount(): ReactWrapper<any, any>;
+        mount(): ReactWrapper<any, any>;
+
+        /**
+         * Find every node in the render tree that matches the provided selector.
+         * @param selector The selector to match.
+         */
+        find<P2>(component: ComponentClass<P2>): ReactWrapper<P2, any>;
+        find<P2>(statelessComponent: (props: P2) => JSX.Element): ReactWrapper<P2, {}>;
+        find(selector: string): ReactWrapper<HTMLAttributes, any>;
+
+        /**
+         * Finds every node in the render tree that returns true for the provided predicate function.
+         * @param predicate
+         */
+        findWhere(predicate: (wrapper: CommonWrapper<any, any>) => Boolean): ReactWrapper<any, any>;
+
+        /**
+         * Removes nodes in the current wrapper that do not match the provided selector.
+         * @param selector The selector to match.
+         */
+        filter<P2>(component: ComponentClass<P2>): ReactWrapper<P2, any>;
+        filter<P2>(statelessComponent: StatelessComponent<P2>): ReactWrapper<P2, {}>;
+        filter(selector: string): ReactWrapper<HTMLAttributes, any>;
+
+        /**
+         * Returns a new wrapper with all of the children of the node(s) in the current wrapper. Optionally, a selector
+         * can be provided and it will filter the children by this selector.
+         * @param [selector]
+         */
+        children<P2>(component: ComponentClass<P2>): ReactWrapper<P2, any>;
+        children<P2>(statelessComponent: StatelessComponent<P2>): ReactWrapper<P2, {}>;
+        children(selector: string): ReactWrapper<HTMLAttributes, any>;
+        children(): ReactWrapper<any, any>;
+
+        /**
+         * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node in the
+         * current wrapper. Optionally, a selector can be provided and it will filter the parents by this selector.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         * @param [selector]
+         */
+        parents<P2>(component: ComponentClass<P2>): ReactWrapper<P2, any>;
+        parents<P2>(statelessComponent: StatelessComponent<P2>): ReactWrapper<P2, {}>;
+        parents(selector: string): ReactWrapper<HTMLAttributes, any>;
+        parents(): ReactWrapper<any, any>;
+
+        /**
+         * Returns a wrapper of the first element that matches the selector by traversing up through the current node's
+         * ancestors in the tree, starting with itself.
+         *
+         * Note: can only be called on a wrapper of a single node.
+         * @param selector
+         */
+        closest<P2>(component: ComponentClass<P2>): ReactWrapper<P2, any>;
+        closest<P2>(statelessComponent: StatelessComponent<P2>): ReactWrapper<P2, {}>;
+        closest(selector: string): ReactWrapper<HTMLAttributes, any>;
+
+        /**
+         * Returns a wrapper with the direct parent of the node in the current wrapper.
+         */
+        parent(): ReactWrapper<any, any>;
+    }
+
+    export interface CheerioWrapper<P, S> extends CommonWrapper<P, S> {
+
+    }
+
+    /**
+     * Shallow rendering is useful to constrain yourself to testing a component as a unit, and to ensure that
+     * your tests aren't indirectly asserting on behavior of child components.
+     * @param node
+     * @param [options]
+     */
+    export function shallow<P, S>(node: ReactElement<P>, options?: any): ShallowWrapper<P, S>;
+
+    /**
+     * Mounts and renders a react component into the document and provides a testing wrapper around it.
+     * @param node
+     * @param [options]
+     */
+    export function mount<P, S>(node: ReactElement<P>, options?: any): ReactWrapper<P, S>;
+
+    /**
+     * Render react components to static HTML and analyze the resulting HTML structure.
+     * @param node
+     * @param [options]
+     */
+    export function render<P, S>(node: ReactElement<P>, options?: any): CheerioWrapper<P, S>;
+
+    export function describeWithDOM(description: String, fn: Function): void;
+
+    export function spyLifecycle(component: typeof Component): void;
+}
\ No newline at end of file
diff --git a/enzyme/enzyme-tests.tsx b/enzyme/enzyme-tests.tsx
index 4cc45e9fd4..805201e53a 100644
--- a/enzyme/enzyme-tests.tsx
+++ b/enzyme/enzyme-tests.tsx
@@ -73,6 +73,26 @@ namespace ShallowWrapperTest {
         boolVal = shallowWrapper.contains(<div className="foo bar"/>);
     }
 
+    function test_containsMatchingElement() {
+        boolVal = shallowWrapper.contains(<div className="foo bar"/>);
+    }
+
+    function test_containsAllMatchingElements() {
+        boolVal = shallowWrapper.containsAllMatchingElements([<div className="foo bar"/>]);
+    }
+
+    function test_containsAnyMatchingElement() {
+        boolVal = shallowWrapper.containsAnyMatchingElements([<div className="foo bar"/>]);
+    }
+
+    function test_equals() {
+        boolVal = shallowWrapper.equals(<div className="foo bar"/>);
+    }
+
+    function test_matchesElement() {
+        boolVal = shallowWrapper.matchesElement(<div className="foo bar"/>);
+    }
+
     function test_hasClass() {
         boolVal = shallowWrapper.find('.my-button').hasClass('disabled');
     }
@@ -90,6 +110,20 @@ namespace ShallowWrapperTest {
         shallowWrapper.children(MyStatelessComponent).props().stateless;
     }
 
+    function test_childAt() {
+        const childWrapper: ShallowWrapper<any, any> = shallowWrapper.childAt(0);
+
+        interface TmpType1 {
+            foo: any
+        }
+
+        interface TmpType2 {
+            bar: any
+        }
+
+        const childWrapper2: ShallowWrapper<TmpType1, TmpType2> = shallowWrapper.childAt<TmpType1, TmpType2>(0);
+    }
+
     function test_parents() {
         shallowWrapper = shallowWrapper.parents();
     }
@@ -143,6 +177,13 @@ namespace ShallowWrapperTest {
     function test_state() {
         shallowWrapper.state();
         shallowWrapper.state('key');
+        const tmp: String = shallowWrapper.state<String>('key');
+    }
+
+    function test_context() {
+        shallowWrapper.context();
+        shallowWrapper.context('key');
+        const tmp: String = shallowWrapper.context<String>('key');
     }
 
     function test_props() {
@@ -151,8 +192,12 @@ namespace ShallowWrapperTest {
 
     function test_prop() {
         shallowWrapper.prop('key');
+        const tmp: String = shallowWrapper.prop<String>('key');
     }
 
+    function test_key() {
+        stringVal = shallowWrapper.key();
+    }
 
     function test_simulate(...args: any[]) {
         shallowWrapper.simulate('click');
@@ -160,15 +205,15 @@ namespace ShallowWrapperTest {
     }
 
     function test_setState() {
-        shallowWrapper = shallowWrapper.setState({stateProperty: 'state'});
+        shallowWrapper = shallowWrapper.setState({ stateProperty: 'state' });
     }
 
     function test_setProps() {
-        shallowWrapper = shallowWrapper.setProps({propsProperty: 'foo'});
+        shallowWrapper = shallowWrapper.setProps({ propsProperty: 'foo' });
     }
 
     function test_setContext() {
-        shallowWrapper = shallowWrapper.setContext({name: 'baz'});
+        shallowWrapper = shallowWrapper.setContext({ name: 'baz' });
     }
 
     function test_instance() {
@@ -184,7 +229,11 @@ namespace ShallowWrapperTest {
     }
 
     function test_type() {
-        var stringOrFunction: String|Function = shallowWrapper.type();
+        var stringOrFunction: String | Function = shallowWrapper.type();
+    }
+
+    function test_name() {
+        var str: String = shallowWrapper.name();
     }
 
     function test_forEach() {
@@ -250,6 +299,24 @@ namespace ReactWrapperTest {
         reactWrapper = reactWrapper.mount();
     }
 
+    function test_ref() {
+        reactWrapper = reactWrapper.ref('refName');
+        
+        interface TmpType1 {
+            foo: string
+        }
+        
+        interface TmpType2 {
+            bar: string
+        }
+        
+        const tmp: ReactWrapper<TmpType1, TmpType2> = reactWrapper.ref<TmpType1, TmpType2>('refName');
+    }
+    
+    function test_detach() {
+        reactWrapper.detach();
+    }
+    
     function test_find() {
         elementWrapper = reactWrapper.find('.selector');
         reactWrapper = reactWrapper.find(MyComponent);
@@ -278,6 +345,26 @@ namespace ReactWrapperTest {
         boolVal = reactWrapper.contains(<div className="foo bar"/>);
     }
 
+    function test_containsMatchingElement() {
+        boolVal = reactWrapper.contains(<div className="foo bar"/>);
+    }
+
+    function test_containsAllMatchingElements() {
+        boolVal = reactWrapper.containsAllMatchingElements([<div className="foo bar"/>]);
+    }
+
+    function test_containsAnyMatchingElement() {
+        boolVal = reactWrapper.containsAnyMatchingElements([<div className="foo bar"/>]);
+    }
+
+    function test_equals() {
+        boolVal = reactWrapper.equals(<div className="foo bar"/>);
+    }
+
+    function test_matchesElement() {
+        boolVal = reactWrapper.matchesElement(<div className="foo bar"/>);
+    }
+
     function test_hasClass() {
         boolVal = reactWrapper.find('.my-button').hasClass('disabled');
     }
@@ -294,6 +381,20 @@ namespace ReactWrapperTest {
         reactWrapper = reactWrapper.children();
     }
 
+    function test_childAt() {
+        const childWrapper: ReactWrapper<any, any> = reactWrapper.childAt(0);
+
+        interface TmpType1 {
+            foo: any
+        }
+
+        interface TmpType2 {
+            bar: any
+        }
+
+        const childWrapper2: ReactWrapper<TmpType1, TmpType2> = reactWrapper.childAt<TmpType1, TmpType2>(0);
+    }
+
     function test_parents() {
         reactWrapper = reactWrapper.parents();
     }
@@ -334,6 +435,13 @@ namespace ReactWrapperTest {
     function test_state() {
         reactWrapper.state();
         reactWrapper.state('key');
+        const tmp: String = reactWrapper.state<String>('key');
+    }
+
+    function test_context() {
+        reactWrapper.context();
+        reactWrapper.context('key');
+        const tmp: String = reactWrapper.context<String>('key');
     }
 
     function test_props() {
@@ -342,8 +450,12 @@ namespace ReactWrapperTest {
 
     function test_prop() {
         reactWrapper.prop('key');
+        const tmp: String = reactWrapper.prop<String>('key');
     }
 
+    function test_key() {
+        stringVal = reactWrapper.key();
+    }
 
     function test_simulate(...args: any[]) {
         reactWrapper.simulate('click');
@@ -351,15 +463,15 @@ namespace ReactWrapperTest {
     }
 
     function test_setState() {
-        reactWrapper = reactWrapper.setState({stateProperty: 'state'});
+        reactWrapper = reactWrapper.setState({ stateProperty: 'state' });
     }
 
     function test_setProps() {
-        reactWrapper = reactWrapper.setProps({propsProperty: 'foo'});
+        reactWrapper = reactWrapper.setProps({ propsProperty: 'foo' });
     }
 
     function test_setContext() {
-        reactWrapper = reactWrapper.setContext({name: 'baz'});
+        reactWrapper = reactWrapper.setContext({ name: 'baz' });
     }
 
     function test_instance() {
@@ -375,7 +487,11 @@ namespace ReactWrapperTest {
     }
 
     function test_type() {
-        var stringOrFunction: String|Function = reactWrapper.type();
+        var stringOrFunction: String | Function = reactWrapper.type();
+    }
+
+    function test_name() {
+        var str: String = reactWrapper.name();
     }
 
     function test_forEach() {
@@ -460,6 +576,26 @@ namespace CheerioWrapperTest {
         boolVal = cheerioWrapper.contains(<div className="foo bar"/>);
     }
 
+    function test_containsMatchingElement() {
+        boolVal = cheerioWrapper.contains(<div className="foo bar"/>);
+    }
+
+    function test_containsAllMatchingElements() {
+        boolVal = cheerioWrapper.containsAllMatchingElements([<div className="foo bar"/>]);
+    }
+
+    function test_containsAnyMatchingElement() {
+        boolVal = cheerioWrapper.containsAnyMatchingElements([<div className="foo bar"/>]);
+    }
+
+    function test_equals() {
+        boolVal = cheerioWrapper.equals(<div className="foo bar"/>);
+    }
+
+    function test_matchesElement() {
+        boolVal = cheerioWrapper.matchesElement(<div className="foo bar"/>);
+    }
+
     function test_hasClass() {
         boolVal = cheerioWrapper.find('.my-button').hasClass('disabled');
     }
@@ -476,6 +612,20 @@ namespace CheerioWrapperTest {
         cheerioWrapper = cheerioWrapper.children();
     }
 
+    function test_childAt() {
+        const childWrapper: CheerioWrapper<any, any> = cheerioWrapper.childAt(0);
+
+        interface TmpType1 {
+            foo: any
+        }
+
+        interface TmpType2 {
+            bar: any
+        }
+
+        const childWrapper2: CheerioWrapper<TmpType1, TmpType2> = cheerioWrapper.childAt<TmpType1, TmpType2>(0);
+    }
+
     function test_parents() {
         cheerioWrapper = cheerioWrapper.parents();
     }
@@ -516,6 +666,13 @@ namespace CheerioWrapperTest {
     function test_state() {
         cheerioWrapper.state();
         cheerioWrapper.state('key');
+        const tmp: String = cheerioWrapper.state<String>('key');
+    }
+
+    function test_context() {
+        cheerioWrapper.context();
+        cheerioWrapper.context('key');
+        const tmp: String = cheerioWrapper.context<String>('key');
     }
 
     function test_props() {
@@ -524,8 +681,12 @@ namespace CheerioWrapperTest {
 
     function test_prop() {
         cheerioWrapper.prop('key');
+        const tmp: String = cheerioWrapper.prop<String>('key');
     }
 
+    function test_key() {
+        stringVal = cheerioWrapper.key();
+    }
 
     function test_simulate(...args: any[]) {
         cheerioWrapper.simulate('click');
@@ -533,15 +694,15 @@ namespace CheerioWrapperTest {
     }
 
     function test_setState() {
-        cheerioWrapper = cheerioWrapper.setState({stateProperty: 'state'});
+        cheerioWrapper = cheerioWrapper.setState({ stateProperty: 'state' });
     }
 
     function test_setProps() {
-        cheerioWrapper = cheerioWrapper.setProps({propsProperty: 'foo'});
+        cheerioWrapper = cheerioWrapper.setProps({ propsProperty: 'foo' });
     }
 
     function test_setContext() {
-        cheerioWrapper = cheerioWrapper.setContext({name: 'baz'});
+        cheerioWrapper = cheerioWrapper.setContext({ name: 'baz' });
     }
 
     function test_instance() {
@@ -557,12 +718,16 @@ namespace CheerioWrapperTest {
     }
 
     function test_type() {
-        var stringOrFunction: String|Function = cheerioWrapper.type();
+        var stringOrFunction: String | Function = cheerioWrapper.type();
+    }
+
+    function test_name() {
+        var str: String = cheerioWrapper.name();
     }
 
     function test_forEach() {
         cheerioWrapper =
-            cheerioWrapper.forEach((aCheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState>)=> {
+            cheerioWrapper.forEach((aCheerioWrapper: CheerioWrapper<MyComponentProps, MyComponentState>) => {
             });
     }
 
diff --git a/enzyme/enzyme.d.ts b/enzyme/enzyme.d.ts
index 13c00041a5..2698fd366b 100644
--- a/enzyme/enzyme.d.ts
+++ b/enzyme/enzyme.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Enzyme v1.2.0
+// Type definitions for Enzyme v2.3.0
 // Project: https://github.com/airbnb/enzyme
 // Definitions by: Marian Palkus <https://github.com/MarianPalkus>, Cap3 <http://www.cap3.de>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -57,6 +57,34 @@ declare module "enzyme" {
          */
         contains(node: ReactElement<any>): Boolean;
 
+        /**
+         * Returns whether or not a given react element exists in the shallow render tree.
+         * @param node
+         */
+        containsMatchingElement(node: ReactElement<any>): Boolean;
+
+        /**
+         * Returns whether or not all the given react elements exists in the shallow render tree
+         * @param nodes
+         */
+        containsAllMatchingElements(nodes: ReactElement<any>[]): Boolean;
+
+        /**
+         * Returns whether or not one of the given react elements exists in the shallow render tree.
+         * @param nodes
+         */
+        containsAnyMatchingElements(nodes: ReactElement<any>[]): Boolean;
+
+        /**
+         * Returns whether or not the current render tree is equal to the given node, based on the expected value.
+         */
+        equals(node: ReactElement<any>): Boolean;
+
+        /**
+         * Returns whether or not a given react element matches the shallow render tree.
+         */
+        matchesElement(node: ReactElement<any>): Boolean;
+
         /**
          * Returns whether or not the current node has a className prop including the passed in class name.
          * @param className
@@ -86,6 +114,13 @@ declare module "enzyme" {
         children(selector: string): CommonWrapper<HTMLAttributes, any>;
         children(): CommonWrapper<any, any>;
 
+        /**
+         * Returns a new wrapper with child at the specified index.
+         * @param index
+         */
+        childAt(index: Number): CommonWrapper<any, any>;
+        childAt<P2, S2>(index: Number): CommonWrapper<P2, S2>;
+
         /**
          * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node in the
          * current wrapper. Optionally, a selector can be provided and it will filter the parents by this selector.
@@ -157,6 +192,13 @@ declare module "enzyme" {
          * @param [key]
          */
         state(key?: String): any;
+        state<T>(key?: String): T;
+
+        /**
+         * Returns the context hash for the root node of the wrapper. Optionally pass in a prop name and it will return just that value.
+         */
+        context(key?: String): any;
+        context<T>(key?: String): T;
 
         /**
          * Returns the props hash for the current node of the wrapper.
@@ -172,6 +214,13 @@ declare module "enzyme" {
          * @param key
          */
         prop(key: String): any;
+        prop<T>(key: String): T;
+
+        /**
+         * Returns the key value for the node of the current wrapper.
+         * NOTE: can only be called on a wrapper of a single node.
+         */
+        key(): String;
 
         /**
          * Simulate events.
@@ -247,6 +296,11 @@ declare module "enzyme" {
          */
         type(): String | Function;
 
+        /**
+         * Returns the name of the current node of the wrapper.
+         */
+        name(): String;
+
         /**
          * Iterates through each node of the current wrapper and executes the provided function with a wrapper around
          * the corresponding node passed in as the first argument.
@@ -347,6 +401,13 @@ declare module "enzyme" {
         children(selector: string): ShallowWrapper<HTMLAttributes, any>;
         children(): ShallowWrapper<any, any>;
 
+        /**
+         * Returns a new wrapper with child at the specified index.
+         * @param index
+         */
+        childAt(index: Number): ShallowWrapper<any, any>;
+        childAt<P2, S2>(index: Number): ShallowWrapper<P2, S2>;
+
         /**
          * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node in the
          * current wrapper. Optionally, a selector can be provided and it will filter the parents by this selector.
@@ -380,6 +441,25 @@ declare module "enzyme" {
         unmount(): ReactWrapper<any, any>;
         mount(): ReactWrapper<any, any>;
 
+        /**
+         * Returns a wrapper of the node that matches the provided reference name.
+         * 
+         * NOTE: can only be called on a wrapper instance that is also the root instance.
+         */
+        ref(refName: String): ReactWrapper<any, any>;
+        ref<P2, S2>(refName: String): ReactWrapper<P2, S2>;
+
+        /**
+         * Detaches the react tree from the DOM. Runs ReactDOM.unmountComponentAtNode() under the hood.
+         * 
+         * This method will most commonly be used as a "cleanup" method if you decide to use the attachTo option in mount(node, options).
+         * 
+         * The method is intentionally not "fluent" (in that it doesn't return this) because you should not be doing anything with this wrapper after this method is called.
+         * 
+         * Using the attachTo is not generally recommended unless it is absolutely necessary to test something. It is your responsibility to clean up after yourself at the end of the test if you do decide to use it, though.
+         */
+        detach() : void;
+
         /**
          * Find every node in the render tree that matches the provided selector.
          * @param selector The selector to match.
@@ -412,6 +492,13 @@ declare module "enzyme" {
         children(selector: string): ReactWrapper<HTMLAttributes, any>;
         children(): ReactWrapper<any, any>;
 
+        /**
+         * Returns a new wrapper with child at the specified index.
+         * @param index
+         */
+        childAt(index: Number): ReactWrapper<any, any>;
+        childAt<P2, S2>(index: Number): ReactWrapper<P2, S2>;
+
         /**
          * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node in the
          * current wrapper. Optionally, a selector can be provided and it will filter the parents by this selector.