diff --git a/docs/api-async.md b/docs/api-async.md
index c725a72..e49bf9f 100644
--- a/docs/api-async.md
+++ b/docs/api-async.md
@@ -1,7 +1,7 @@
 ---
 id: api-async
-title: Async
-sidebar_label: Async
+title: Async Utilities
+sidebar_label: Async Utilities
 ---
 
 Several utilities are provided for dealing with asynchronous code. These can be useful to wait for
@@ -26,8 +26,8 @@ expectations to pass. The `wait` function is a small wrapper around the
 example:
 
 ```javascript
-await wait(() => getByLabelText(container, 'username'));
-getByLabelText(container, 'username').value = 'chucknorris';
+await wait(() => getByLabelText('username'));
+getByLabelText('username').value = 'chucknorris';
 ```
 
 This can be useful if you have a unit test that mocks API calls and you need to wait for your mock
@@ -49,38 +49,60 @@ the event loop (in a `setTimeout`) before starting the intervals.
 function waitForElement<T>(
   callback: () => T,
   options?: {
-    container?: ReactTestInstance;
     timeout?: number;
     interval?: number;
   },
 ): Promise<T>;
 ```
 
-When in need to wait for DOM elements to appear, disappear, or change you can use `waitForElement`.
-The `waitForElement` function is a similar to `wait`, but is a helper specifically intended to wait
-for an element.
+When you need to wait for elements to appear, you can use `waitForElement`. The `waitForElement`
+function is a similar to `wait`, but is specifically intended to wait for an element to appear.
+Additionally, the result is returned for you to use.
 
 Here's a simple example:
 
 ```javascript
-const usernameElement = await waitForElement(() => getByA11yLabel(container, 'username'), {
-  container,
-});
-expect(usernameElement.props.children).toBe('chucknorris');
+const usernameElement = await waitForElement(() => getByLabelText('username'));
+expect(usernameElement).toHaveTextContent('chucknorris');
 ```
 
 You can also wait for multiple elements at once:
 
 ```javascript
-const [usernameElement, passwordElement] = await waitForElement(
-  () => [getByA11yLabel(container, 'username'), getByA11yLabel(container, 'password')],
-  { container },
-);
+const [usernameElement, passwordElement] = await waitForElement(() => [
+  getByLabelText('username'),
+  getByLabelText('password'),
+]);
 ```
 
-The default `container` is the root `ReactTestInstance` that is the result of `render`. Make sure
-the elements you wait for will be attached to it, or set a different `ReactTestInstance` as a
-container.
+The default `timeout` is `4500ms` which will keep you under
+[Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
+
+The default `interval` is `50ms`. However it will run your callback immediately on the next tick of
+the event loop (in a `setTimeout`) before starting the intervals.
+
+## `waitForElementToBeRemoved`
+
+```typescript
+function waitForElementToBeRemoved<T>(
+  callback: () => T,
+  options?: {
+    timeout?: number;
+    interval?: number;
+  },
+): Promise<T>;
+```
+
+When you need to wait for elements to be removed, or you can use `waitForElementToBeRemoved`. The
+`waitForElementToBeRemoved` function is a similar to `wait`, but is a helper specifically intended
+to wait for an element to be removed from the tree. Similarly to `waitForElement` the result of the
+callback is returned as a Promise, but in most cases you won't need it.
+
+Here's a simple example:
+
+```javascript
+await waitForElementToBeRemoved(() => queryAllByLabelText('list-item'));
+```
 
 The default `timeout` is `4500ms` which will keep you under
 [Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
diff --git a/docs/api-events.md b/docs/api-events.md
index bc7d996..187768e 100644
--- a/docs/api-events.md
+++ b/docs/api-events.md
@@ -7,21 +7,21 @@ sidebar_label: Firing Events
 ## Basic example
 
 ```javascript
-import { fireEvent, NativeEvent, render } from 'native-testing-library';
+import { fireEvent, NativeTestEvent, render } from 'native-testing-library';
 
 const { getByText } = render(<Button title="Submit" />);
-fireEvent(getByText(container, 'Submit'), new NativeEvent('press'));
+fireEvent(getByText(container, 'Submit'), new NativeTestEvent('press'));
 ```
 
 ## `fireEvent[eventName]`
 
 ```typescript
-fireEvent[eventName](node: FiberRoot, eventProperties: NativeEvent)
+fireEvent[eventName](node: FiberRoot, eventProperties: NativeTestEvent)
 ```
 
 Convenience methods for firing events. Check out
-[src/events.js](https://github.com/testing-library/native-testing-library/blob/master/src/events.js) for
-a full list as well as `validTargets` for every event type.
+[src/events.js](https://github.com/testing-library/native-testing-library/blob/master/src/events.js)
+for a full list as well as `validTargets` for every event type.
 
 ```javascript
 import { fireEvent, render } from 'native-testing-library';
@@ -35,19 +35,22 @@ called nativeEvent. When you fire an event using this library, you will have to
 config. You will use this particularly for events like a change event:
 
 ```javascript
-fireEvent.change(getByA11yLabel(/username/i), { nativeEvent: { text: 'a' } });
+fireEvent.change(getByLabelText(/username/i), { nativeEvent: { text: 'a' } });
 ```
 
 **changeText**: `Text` has a method for value updating called `onChangeText`. Since this is such a
 commonly used method, there is a special case in the library for this method.
 
 ```javascript
-fireEvent.changeText(getByA11yLabel(/username/i), 'a');
+fireEvent.changeText(getByLabelText(/username/i), 'a');
 ```
 
 **customEvent**: You may be using a library that has custom event listeners that you want to be able
 to fire. This is how you would fire one of these events:
 
 ```javascript
-fireEvent(getByTestId('swiper'), new NativeEvent('myEvent', { nativeEvent: { value: 'testing' } }));
+fireEvent(
+  getByTestId('swiper'),
+  new NativeTestEvent('myEvent', { nativeEvent: { value: 'testing' } }),
+);
 ```
diff --git a/docs/api-helpers.md b/docs/api-helpers.md
index a69e38c..e3e60d2 100644
--- a/docs/api-helpers.md
+++ b/docs/api-helpers.md
@@ -6,13 +6,13 @@ sidebar_label: Helpers
 
 ## Custom Queries
 
-`native-testing-library` exposes many of the helper functions that are used to implement the default
+`native-testing-library` exposes some of the helper functions that are used to implement the default
 queries. You can use the helpers to build custom queries. For example, the code below shows a way to
 query your TestInstance by a `style` prop. Note: test files would need to now import `test-utils.js`
 instead of using `native-testing-library` directly. Also note, please never actually implement this
 helper, it's just an example of what's possible.
 
-```js
+```javascript
 // test-utils.js
 import * as nativeTestingLib from 'native-testing-library';
 
@@ -54,61 +54,46 @@ export {
 getNodeText(node: React.ReactElement<any>)
 ```
 
-Returns the complete text content of a html element, removing any extra whitespace, and joining
-children that are an array. The intention is to treat text in nodes exactly as how it is perceived
-by users in a browser, where any extra whitespace within words in the html code is not meaningful
-when the text is rendered, and all text appears as one cohesive string regardless of the code.
+Returns the complete text content of an element, removing any extra whitespace, and joining children
+that are an array. The intention is to treat text in nodes exactly as how it is perceived by users
+in a browser, where any extra whitespace within words in the html code is not meaningful when the
+text is rendered, and all text appears as one cohesive string regardless of the code.
 
 ```javascript
-const inputNode = <TextInput value="words" />;
-const textNode = (
+getNodeText(
   <Text>
     {`
-  Hello
-    World  !
-  `}
-  </Text>
-);
-
-getNodeText(node); // "Hello World !"
-```
-
-This function is also used internally when querying nodes by their text content. This enables
-functions like `getByText` and `queryByText` to work as expected, finding elements in the tree
-similarly to how users would do.
-
-The function works for for input elements as well:
-
-```javascript
-const inputNode = <TextInput value="words" />;
-
-getNodeText(inputNode); // "words"
+    Hello
+      World  !
+    `}
+  </Text>,
+); // "Hello World !"
 ```
 
-## `getQueriesForElement` APIs
+## `within` and `getQueriesForElement` APIs
 
-`getQueriesForElement` takes a FiberRoot and binds it to the raw query functions, allowing them to
-be used without specifying a container.
+`within` (an alias to `getQueriesForElement`) takes a `NativeTestInstance` and binds it to the raw
+query functions, allowing them to be used without manually specifying a container.
 
 Example: To get the username input of a login form within a `<LoginModal />`, you could do:
 
 ```js
-import { render, getQueriesForElement } from 'react-testing-library';
+import { render, within } from 'native-testing-library';
 
-const { getByA11yLabel } = render(<LoginModal />);
-const loginForm = getByA11yLabel('login-form');
+const { getByLabelText } = render(<LoginModal />);
+const loginForm = getByLabelText('login-form');
 
-getQueriesForElement(loginForm).getByPlaceholder('Username');
+within(loginForm).getByPlaceholderText('Username');
 ```
 
 ## Debugging
 
-When you use any `get` calls in your test cases, the current state of the `container` (React tree)
-gets printed on the console. For example:
+When you use any `get` calls in your test cases, the current contents of the `baseElement` get
+printed on the console. For example:
 
 ```javascript
 // <Text>Hello world</Text>
-getByText(container, 'Goodbye world'); // will fail by throwing error
+getByText('Goodbye world'); // will fail by throwing error
 ```
 
 The above test case will fail, however it prints the state of your React tree being tested, so you
diff --git a/docs/api-main.md b/docs/api-main.md
new file mode 100644
index 0000000..638983e
--- /dev/null
+++ b/docs/api-main.md
@@ -0,0 +1,180 @@
+---
+id: api-main
+title: Main
+sidebar_label: Main
+---
+
+## `render`
+
+```typescript
+function render(
+  ui: React.ReactElement<any>,
+  options?: {
+    /* You won't often use this, expand below for docs on options */
+  },
+): RenderResult;
+```
+
+Create a `NativeTestInstance`.
+
+```jsx
+import { render } from 'native-testing-library';
+
+render(<View />);
+```
+
+```javascript
+import { render, toJSON } from 'native-testing-library';
+
+test('renders a message', () => {
+  const { container, getByText } = render(<Text>Hello, World!</Text>);
+  expect(getByText('Hello, world!')).toBeTruthy();
+  expect(toJSON(container)).toMatchInlineSnapshot(`
+<View
+  testID="ntl-container"
+>
+  <Text>Hello, World!</Text>
+</View>
+  `);
+});
+```
+
+## `render` Options
+
+Most of the time you won't need to pass any options to `render`, but when you do, you will pass them
+as the second parameter. There are some important key differences between this and
+`react-testing-library` that you will want to be aware of.
+
+### `wrapper`
+
+Pass a React Component as the `wrapper` option to have it rendered around the inner element. This is
+most useful for creating reusable custom render functions for common data providers. See
+[setup](setup.md#custom-render) for examples.
+
+### `queries`
+
+Queries to bind. Overrides the default set from `native-testing-library` unless merged.
+
+```js
+// Example, a function to traverse table contents
+import * as tableQueries from 'my-table-query-libary';
+import queries from 'native-testing-library';
+
+const { getByRowColumn, getByText } = render(<MyTable />, {
+  queries: { ...queries, ...tableQueries },
+});
+```
+
+See [helpers](api-helpers.md) for guidance on using utility functions to create custom queries.
+
+Custom queries can also be added globally by following the
+[custom render guide](setup.md#custom-render).
+
+## `render` Result
+
+The `render` method returns an object that has a few properties:
+
+### `...queries`
+
+The most important feature of `render` is that the [default queries](api-queries.md) are
+automatically returned with their first argument bound to the `baseElement`.
+
+**Example**
+
+```javascript
+const { getByText, getByTestId /* etc */ } = render(<Component />);
+```
+
+### `container`
+
+`native-testing-library` will create a View to wrap your react component passed to render. This
+ensures that there is always a single child passed to the `AppContainer` component.
+
+### `baseElement`
+
+This is the root element of your render result. This element is an `AppContainer` from
+`react-native`, and it appears as two nested `Views` at the root of your render.
+
+### `debug`
+
+This method is a shortcut for `console.log(prettyPrint(toJSON(baseElement)))`.
+
+```javascript
+import { render } from 'native-testing-library';
+
+const { debug } = render(
+  <View>
+    <Text>Hello World</Text>
+  </View>,
+);
+debug();
+// <View>
+//   <Text>
+//     Hello World
+//   </Text>
+// </View>
+// you can also pass an element: debug(getByText('Hello World'))
+```
+
+This is a simple wrapper around `prettyPrint` which is also exported.
+
+### `rerender`
+
+Although its likely better to test updating your props the way a user would (through events and
+interaction), this method will allow you to re-render your entire tree at the base with new props.
+
+```jsx
+import { render } from 'native-testing-library';
+
+const { rerender } = render(<NumberDisplay number={1} />);
+
+// re-render the same component with different props
+rerender(<NumberDisplay number={2} />);
+```
+
+[See the examples page](example-update-props.md)
+
+### `unmount`
+
+This will cause the rendered component to be unmounted. This is useful for testing what happens when
+your component is removed from the page (like testing that you don't leave event handlers hanging
+around causing memory leaks).
+
+> This method is a wrapper around ReactTestRenderer.unmount()
+
+```javascript
+import { render } from 'native-testing-library';
+
+const { unmount } = render(<Login />);
+unmount();
+```
+
+---
+
+## `cleanup`
+
+Unmounts React trees that were mounted with [render](#render).
+
+```jsx
+import { cleanup, render } from 'native-testing-library';
+
+afterEach(cleanup); // <-- add this
+
+test('renders into document', () => {
+  render(<View />);
+  // ...
+});
+
+// ... more tests ...
+```
+
+**If you don't want to add this to _every single test file_** then we recommend that you configure
+your test framework to run a file before your tests which does this automatically.
+
+---
+
+## `act`
+
+This is a light wrapper around the
+[`react-test-renderer` `act` function](https://reactjs.org/docs/test-renderer.html). All it does is
+forward all arguments to the act function if your version of react supports `act`.
diff --git a/docs/api-queries.md b/docs/api-queries.md
index 85d4b28..c8d2cab 100644
--- a/docs/api-queries.md
+++ b/docs/api-queries.md
@@ -55,22 +55,22 @@ See [TextMatch](#textmatch) for documentation on what can be passed to a query.
 
 ## Queries
 
-### `ByA11yHint`
+### `ByHintText`
 
-> getByA11yHint, queryByA11yHint, getAllByA11yHint, queryAllByA11yHint, findByA11yHint,
-> findAllByA11yHint
+> getByHintText, queryByHintText, getAllByHintText, queryAllByHintText, findByHintText,
+> findAllByHintText
 
 ```typescript
-getByA11yHint(
-  container: ReactTestInstance,
+getByHintText(
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
     exact?: boolean = true,
     trim?: boolean = true,
     collapseWhitespace?: boolean = true,
-    filter?: FilterFn,
+    selector?: SelectorFn,
     normalizer?: NormalizerFn,
-  }): FiberRoot
+  }): NativeTestInstance
 ```
 
 This will search for all elements with an `accessibilityHint` prop and find one that matches the
@@ -79,27 +79,27 @@ given [`TextMatch`](#textmatch).
 ```js
 import { render } from 'react-testing-library';
 
-const { getByA11yHint } = render(<View accessibilityHint="summary" />);
+const { getByHintText } = render(<View accessibilityHint="summary" />);
 
-getByA11yHint('summary'); // returns the View node
+getByHintText('summary'); // returns the View node
 ```
 
-### `ByA11yLabel`
+### `ByLabelText`
 
-> getByA11yLabel, queryByLabelText, getAllByLabelText, queryAllByLabelText findByLabelText,
+> getByLabelText, queryByLabelText, getAllByLabelText, queryAllByLabelText findByLabelText,
 > findAllByLabelText
 
 ```typescript
-getByA11yLabel(
-  container: ReactTestInstance,
+getByLabelText(
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
     exact?: boolean = true,
     trim?: boolean = true,
     collapseWhitespace?: boolean = true,
-    filter?: FilterFn,
+    selector?: SelectorFn,
     normalizer?: NormalizerFn,
-  }): FiberRoot
+  }): NativeTestInstance
 ```
 
 This will search for all elements with an `accessibilityLabel` prop and find one that matches the
@@ -119,27 +119,22 @@ function Login({ onPress }) {
 
 import { render } from 'native-testing-library';
 
-const { getByA11yLabel } = render(<Login onPress={jest.fn()} />);
+const { getByLabelText } = render(<Login onPress={jest.fn()} />);
 
-getByA11yLabel('username'); // returns the TextInput node
+getByLabelText('username'); // returns the TextInput node
 ```
 
-### `ByA11yRole`
+### `ByRole`
 
-> getByA11yRole, queryByA11yRole, getAllByA11yRole, queryAllByA11yRole, findByA11yRole,
-> findAllByA11yRole
+> getByRole, queryByRole, getAllByRole, queryAllByRole, findByRole, findAllByRole
 
 ```typescript
-getByA11yRole(
-  container: ReactTestInstance,
+getByRole(
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
-    exact?: boolean = true,
-    trim?: boolean = true,
-    collapseWhitespace?: boolean = true,
-    filter?: FilterFn,
-    normalizer?: NormalizerFn,
-  }): FiberRoot
+    selector?: SelectorFn,
+  }): NativeTestInstance
 ```
 
 This will search for all elements with an `accessibilityRole` prop and find one that matches the
@@ -148,140 +143,126 @@ given [`TextMatch`](#textmatch).
 ```js
 import { render } from 'react-testing-library';
 
-const { getByA11yRole } = render(<View accessibilityRole="summary" />);
-
-getByA11yRole('summary'); // returns the View node
-```
-
-### `ByA11yStates`
-
-> getByA11yStates, queryByA11yStates, getAllByA11yStates, queryAllByA11yStates, findByA11yStates,
-> findAllByA11yStates
+const { getByRole } = render(<View accessibilityRole="summary" />);
 
-```typescript
-getByA11yStates(
-  container: ReactTestInstance,
-  match: Array<string>
-): FiberRoot
+getByRole('summary'); // returns the View node
 ```
 
-This will search for all elements with an `accessibilityStates` prop and find one that matches the
-given `Array`.
+> `ByRole` queries will fall back to searching for elements with an `accessibilityTraits` match, but
+> they will log a warning on all matches that this prop is being deprecated by react-native.
 
-```js
-import { render } from 'react-testing-library';
+### `ByPlaceholderText`
 
-const { getByA11yStates } = render(<View accessibilityStates={['disabled']} />);
-
-getByA11yStates(['disabled']); // returns the View node
-```
-
-### `ByA11yTraits`
-
-> getByA11yTraits, queryByA11yTraits, getAllByA11yTraits, queryAllByA11yTraits, findByA11yTraits,
-> findAllByA11yTraits
+> getByPlaceholderText, queryByPlaceholderText, getAllByPlaceholderText, queryAllByPlaceholderText,
+> findByPlaceholderText, findAllByPlaceholderText
 
 ```typescript
-getByA11yTraits(
-  container: ReactTestInstance,
-  match: Array<string>,
-): FiberRoot
+getByPlaceholderText(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
 ```
 
-This will search for all elements with an `accessibilityTraits` prop and find one that matches the
-given `Array`.
+This will search for all elements with a `placeholder` prop and find one that matches the given
+[`TextMatch`](#textmatch).
 
-```js
-import { render } from 'react-testing-library';
+```javascript
+import { render } from 'native-testing-library';
 
-const { getByA11yTraits } = render(<View accessibilityTraits={['button']} />);
+const { getByPlaceholderText } = render(<TextInput placeholder="Username" />);
 
-getByA11yTraits(['button']); // returns the View node
+getByPlaceholderText('Username'); // returns the TextInput node
 ```
 
-### `ByPlaceholder`
+### `ByText`
 
-> getByPlaceholder, queryByPlaceholder, getAllByPlaceholder, queryAllByPlaceholder,
-> findByPlaceholder, findAllByPlaceholder
+> getByText, queryByText, getAllByText, queryAllByText, findByText, findAllByText
 
 ```typescript
-getByPlaceholder(
-  container: ReactTestInstance,
+getByText(
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
     exact?: boolean = true,
     trim?: boolean = true,
     collapseWhitespace?: boolean = true,
-    filter?: FilterFn,
+    selector?: SelectorFn,
     normalizer?: NormalizerFn,
-  }): FiberRoot
+  }): NativeTestInstance
 ```
 
-This will search for all elements with a `placeholder` prop and find one that matches the given
-[`TextMatch`](#textmatch).
+This will search for all elements of type `Text` with `props.children` matching the given. It will
+also search for `Button` elements by their `title` [`TextMatch`](#textmatch).
 
-```javascript
+```js
 import { render } from 'native-testing-library';
 
-const { getByPlaceholder } = render(<TextInput placeholder="Username" />);
+const { getByText } = render(<Text>About ℹ</Text>);
 
-getByPlaceholder('Username'); // returns the TextInput node
+getByText(/about/i); // returns the Text node
 ```
 
-### `ByText`
+### `ByTitle`
 
-> getByText, queryByText, getAllByText, queryAllByText, findByText, findAllByText
+> getByTitle, queryByTitle, getAllByTitle, queryAllByTitle, findByTitle, findAllByTitle
 
 ```typescript
-getByText(
-  container: ReactTestInstance,
+getByTitle(
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
-    types?: array = ['Text', 'TextInput'],
+    exact?: boolean = true,
     trim?: boolean = true,
     collapseWhitespace?: boolean = true,
-    exact?: boolean = true,
+    selector?: SelectorFn,
     normalizer?: NormalizerFn,
-  }): FiberRoot
+  }): NativeTestInstance
 ```
 
-This will search for all elements of type `Text` with `props.children` matching the given. It will
-also search `TextInput` elements by their value [`TextMatch`](#textmatch).
+This will search for all `Button` or `RefreshControl` elements with `props.title` matching the given
+by their value [`TextMatch`](#textmatch).
 
 ```js
 import { render } from 'native-testing-library';
 
-const { getByText } = render(<Text>About ℹ</Text>);
+const { getByTitle } = render(<Button title="About" />);
 
-getByText(/about/i); // returns the Text node
+getByTitle(/about/i); // returns the Button node
 ```
 
-### `ByValue`
+### `ByDisplayValue`
 
-> getByValue, queryByValue, getAllByValue, queryAllByValue, findByValue, findAllByValue
+> getByDisplayValue, queryByDisplayValue, getAllByDisplayValue, queryAllByDisplayValue,
+> findByDisplayValue, findAllByDisplayValue
 
 ```typescript
-getByValue(
-  container: ReactTestInstance,
+getByDisplayValue(
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
     exact?: boolean = true,
     trim?: boolean = true,
     collapseWhitespace?: boolean = true,
-    filter?: FilterFn,
+    selector?: SelectorFn,
     normalizer?: NormalizerFn,
   }): NormalizerOptions
 ```
 
-This will search for all elements with a `value` prop and find one that matches the given
-[`TextMatch`](#textmatch).
+This will search for all `TextInput` elements with a `value` prop and `Picker` or `Switch` elements
+with a `selectedValue` prop and find ones that matches the given [`TextMatch`](#textmatch).
 
 ```js
 import { render } from 'native-testing-library';
 
-const { getByValue } = render(<Input value="About ℹ" onChangeText={() => ({})} />);
+const { getByDisplayValue } = render(<Input value="About ℹ" onChangeText={() => ({})} />);
 
-getByValue(/about/i); // returns the Input node
+getByDisplayValue(/about/i); // returns the Input node
 ```
 
 ### `ByTestId`
@@ -290,15 +271,15 @@ getByValue(/about/i); // returns the Input node
 
 ```typescript
 getByTestId(
-  container: ReactTestInstance,
+  container: NativeTestInstance,
   match: TextMatch,
   options?: {
     trim?: boolean = true,
     collapseWhitespace?: boolean = true,
     exact?: boolean = true,
-    filter?: FilterFn,
+    selector?: SelectorFn,
     normalizer?: NormalizerFn,
-  }): FiberRoot
+  }): NativeTestInstance
 ```
 
 This will search for all elements with a `testID` and find one that matches the given
diff --git a/docs/api-test-instance.md b/docs/api-test-instance.md
new file mode 100644
index 0000000..b74e54f
--- /dev/null
+++ b/docs/api-test-instance.md
@@ -0,0 +1,105 @@
+---
+id: api-test-instance
+title: NativeTestInstance
+sidebar_label: NativeTestInstance
+---
+
+`NativeTestInstance` is a proxied react-test-renderer TestInstance. Not all properties are
+available, so you should only rely on the ones listed in this documentation.
+
+Properties are excluded or overridden in an effort to make it easier to follow the guiding
+principles of testing-library. If there are other assertions you'd like to make, that aren't
+supported by this library there should be no problem running other react-test-renderer tests in the
+same codebase.
+
+> Before assuming you need access to something not exposed, try to ask yourself what you would do if
+> you were using dom testing library.
+>
+> We believe all of the utilities provided by this package allow you to write tests the way you
+> would using that library, so if you're struggling to write a test, try to take a step back and
+> evaluate if you're trying to test implementation details or making an assertion that doesn't map
+> to something your users could do.
+
+## `getProp`
+
+This is simply a helper that allows you to get the value of a native node prop. It is meant to
+mirror the `getAttribute` API in the DOM. You should rarely need to use this method in your tests.
+
+```javascript
+const nativeNode = getByValue('hello world');
+const value = nativeNode.getProp('value');
+
+expect(value).toBe('hello world');
+```
+
+## `findAll`
+
+This method will return you all children nodes that are valid native nodes. **This will not find
+custom components, it will only return core components defined in the preset.** It is meant to be
+similar to `document.querySelectorAll`.
+
+```javascript
+const { container } = render(<MyComponent />);
+const textNodes = container.findAll(node => node.getProp('accessibilityLabel') === 'hello world');
+
+expect(textNodes).toHaveLength(2);
+```
+
+## `type`
+
+This will be the type of the native node. For all queries you can make in this library, this value
+will be a string.
+
+```javascript
+const { findByText } = render(<Text>hello world</Text>);
+
+expect(findByText(/hello world/i).type).toBe('hello world');
+```
+
+## `props`
+
+The props of the element you've queried for. These are meant to be the equivalent of a DOM
+"attribute". You should rarely need to make assertions on these values, so try not to rely heavily
+on using them directly.
+
+```javascript
+const { findByText } = render(<Text style={{}}>hello world</Text>);
+
+console.log(findByText(/hello world/i).props);
+```
+
+## `parentNode`
+
+This will return only valid native node parents. This differs from the react-test-renderer's
+`parent` property in that way. You will not be able to get your implementation components by
+traversing the parents of your tree.
+
+```javascript
+const { findByText } = render(
+  <View>
+    <CustomComponent>
+      <Text>hello world</Text>
+    </CustomComponent>
+  </View>,
+);
+
+expect(findByText(/hello world/i).parentNode.type).toBe('View'); // NOT CustomComponent
+```
+
+## `children`
+
+This will return only valid native node children. This differs from the react-test-renderer's
+children property in that way. You will not be able to get your implementation components by
+traversing the children of your tree.
+
+```javascript
+const { findByTestID } = render(
+  <View testID="my-wrapper">
+    <CustomComponent>
+      <Text>hello world</Text>
+    </CustomComponent>
+  </View>,
+);
+
+expect(findByTestID('my-wrapper').children[0].type).toBe('Text'); // NOT CustomComponent
+```
diff --git a/docs/cheat-sheet.md b/docs/cheat-sheet.md
index 45445b5..81866a9 100644
--- a/docs/cheat-sheet.md
+++ b/docs/cheat-sheet.md
@@ -10,4 +10,5 @@ copy of it on your desk to quickly take a peek at the most commonly used functio
 
 [Download the cheat sheet][cheatsheet]
 
-[cheatsheet]: https://github.com/testing-library/native-testing-library/raw/master/other/cheat-sheet.pdf
+[cheatsheet]:
+  https://github.com/testing-library/native-testing-library/raw/master/other/cheat-sheet.pdf
diff --git a/docs/ecosystem-jest-native.md b/docs/ecosystem-jest-native.md
index e7f6437..ea501c0 100644
--- a/docs/ecosystem-jest-native.md
+++ b/docs/ecosystem-jest-native.md
@@ -1,6 +1,6 @@
 ---
 id: ecosystem-jest-native
-title: jest-native
+title: Jest Matchers
 sidebar_label: Jest Matchers
 ---
 
@@ -27,7 +27,7 @@ expect(getByText(baseElement, 'Visible Example')).toBeVisible();
 > `queryByTestId`) rather than a get function (like `getByTestId`). Otherwise the `get*` function
 > could throw an error before your assertion.
 
-Check out [jest-native's documentation](https://github.com/testing-library/jest-native) for a full list
-of available matchers.
+Check out [jest-native's documentation](https://github.com/testing-library/jest-native) for a full
+list of available matchers.
 
 - [jest-native on GitHub](https://github.com/testing-library/jest-native)
diff --git a/docs/example-input-event.md b/docs/example-input-event.md
index 12f9cfa..4ac026c 100644
--- a/docs/example-input-event.md
+++ b/docs/example-input-event.md
@@ -36,7 +36,7 @@ class CostInput extends React.Component {
 
 const setup = () => {
   const utils = render(<CostInput />);
-  const input = utils.getByA11yLabel('cost-input');
+  const input = utils.getByLabelText('cost-input');
   return {
     input,
     ...utils,
diff --git a/docs/guide-disappearance.md b/docs/guide-disappearance.md
index 3b78f48..645ef21 100644
--- a/docs/guide-disappearance.md
+++ b/docs/guide-disappearance.md
@@ -60,7 +60,7 @@ expect(submitButton).toBeNull(); // it doesn't exist
 ```
 
 The `queryAll` APIs version return an array of matching nodes. The length of the array can be useful
-for assertions after elements are added or removed from the DOM.
+for assertions after elements are added or remove.
 
 ```javascript
 const submitButtons = queryAllByText(container, 'submit');
diff --git a/docs/guide-queries.md b/docs/guide-queries.md
index 94a664e..72de9df 100644
--- a/docs/guide-queries.md
+++ b/docs/guide-queries.md
@@ -9,106 +9,33 @@ Whatever you do, try to make your tests resemble real use cases. You'll only be
 tests if they work the way your users do. With that in mind, we recommend this order of priority:
 
 1. **Queries Users Can Interact With**
-   1. [`getByA11yLabel`](api-queries#bya11ylabel): Your disabled users are counting on you, so this
+   1. [`getByLabelText`](api-queries#bylabeltext): Your disabled users are counting on you, so this
       should likely be everywhere for their sake 😉 use it often, and if you aren't, maybe ask
       yourself why.
-   1. [`getByPlaceholder`](api-queries#byplaceholder): Great for targeting a `TextInput` element to
-      verify its content
-   1. [`getByText`](api-queries#bytext): Great for finding a `Button` or `Touchable` to fire an
-      event on
-   1. [`getByValue`](api-queries#byvalue): The user can see the value they type into a `TextInput`
-      or a checked `CheckBox` so this one is safe to use
+   1. [`getByHintText`](api-queries#byhinttext): You should probably have an accessibility label
+      that you can select by, but if for some reason you set this instead, it's safe to use.
+   1. [`getByPlaceholderText`](api-queries#byplaceholdertext): Great for targeting a `TextInput`
+      element to verify its content
+   1. [`getByText`](api-queries#bytext): Great for finding a `Text`, `Button`, or `Touchable` node.
+      You'll probably use this one a lot.
+   1. [`getByDisplayValue`](api-queries#bydisplayvalue): This is good because a user can see the
+      value they type into a `TextInput` or whether a `Switch` is on or off.
 1. **Queries Users Can Infer**
-   1. [`getByA11yRole`](api-queries#bya11yrole): If your app screens have good hierarchy and single
-      focus, this may be a good option for finding your elements
+   1. [`getByTitle`](api-queries#bytitle): This isn't available on many elements, and there's likely
+      a better way you can find the element you're looking for.
+   1. [`getByRole`](api-queries#byrole): If your app screens have good hierarchy, this may be a
+      decent option for finding your elements
 1. **Queries Users Don't Even Know About**
    1. [`getByTestId`](api-queries#bytestid): The user cannot see (or hear) these, so this is only
       recommended for cases where you can't match by text or it doesn't make sense
 
 ## Manual Queries
 
-If you absolutely can't figure out another way to test the element you need to test, there is a very
-highly discouraged, poorly documented way to likely get what you're looking for. We understand that
-there are times when you need to test things that aren't related to the native bridged views, and
-sometimes things that can't be "seen" in any way need to be validated.
+If you absolutely can't find a way to get the element you're looking for, you can use
+[`findAll`](api-test-instance#findall) as an escape hatch. Note that this is a bad practice and may
+introduce unpredictable behavior in your tests. It would likely be better to use a `testID` in most
+cases where you need to.
 
-Here is an example of such a case so that you're thinking in the right context. If you were to
-render a `<MaterialIcon />` from `react-native-vector-icons`, you provide a name prop which
-determines the icon to display to the user. Under the hood, `react-native-vector-icons` renders a
-`<Text />` component and passes a special symbol across the bridge, which a native counterpart
-module uses to translate to the vector icon you asked for by name. You can (and should) provide an
-`a11yLabel` and query by that, but for the sake of this example let's pretend like you can't. Here
-is what you can do in a case where you are **very** stuck and can't figure out what to do.
-
-```javascript
-// react-testing-library
-const { baseElement } = render(<MyComponent />);
-const icons = baseElement.findAll(node => node.props.name === 'menu');
-```
-
-We cannot stress enough that we _do not_ recommend that you do this. Your results will be
-unpredictable, and you will not be creating reliable tests. You're also wandering down the path of
-testing implementation details because your users do not, and won't ever, know about the shape of
-your props or care about whether or not those props are in the shape that only _you_ know about. You
-can use this API when you need it, but above all else please consider your users and remember the
-[guiding-principles](guiding-principles.md).
-
-### Addendum: why is this unpredictable?
-
-I'm so glad you asked! In the DOM, you don't "spread" props; you don't pass props to children at
-all. Attributes are "unique" to an element, and there's no concept of parent->child relationship in
-that regard. As we all know, that is not the case with React. Props are often spread or passed
-liberally without much consideration as to what gets "spread" or "passed" -- it's just so easy to
-do! We handled that problem in this library for you by only returning you the lowest level
-components that communicate to the native portion of the app -- spreading at that level tends to not
-be an issue.
-
-Let's look at a contrived example based on this idea of a `MaterialIcon`. Your rendered React tree
-might look like this:
-
-```javascript
-<MaterialIcon name="menu" accessibilityLabel="menu icon">
-  <Icon name="menu" accessibilityLabel="menu icon">
-    <Text accessibilityLabel="menu icon">???</Text>
-  </Icon>
-</MaterialIcon>
-```
-
-You can't know what a library does with their props, and it certainly doesn't matter to your users.
-All they care about is that they see a material design icon. So, if you do:
-
-```javascript
-baseElement.find(({ props }) => props.name === 'menu');
-
-// => [MaterialIcon, Icon]
-```
-
-This isn't right at all. Sure, you could do something like:
-
-```javascript
-const icon = baseElement.find(({ props }) => props.name === 'menu');
-
-icon[icon.length - 1];
-
-// => Icon
-```
-
-But I'm sure you can see now how wildly unpredictable and confusing this can turn out to be. If
-instead you do:
-
-```javascript
-queryAllByA11yLabel('menu icon');
-
-// => [Text]
-```
-
-This is the element your user will see, this is the element you should assert against. Do your best
-to always assert on this element. How can you know what components bridged to native?
-
-```javascript
-const { debug } = render(<MyComponent />);
-
-debug();
-```
-
-This is how ☺️ debug will always only show you the elements in the tree that bridge to native.
+Also note, this utility still won't be able to find your app's components, it will only search for
+React Native core components. This library provides you no reasonable way to make an assertion on
+your components.
diff --git a/docs/install.md b/docs/install.md
index 4cb38af..59de43f 100644
--- a/docs/install.md
+++ b/docs/install.md
@@ -4,6 +4,8 @@ title: Install
 sidebar_label: Install
 ---
 
+## Installation
+
 This module should be installed in your project's `devDependencies`:
 
 ```
@@ -12,6 +14,74 @@ npm install --save-dev native-testing-library
 
 You will need `react` and `react-native` installed as _dependencies_ in order to run this project.
 
+## Jest preset
+
+> It is **highly recommended** that you use the bundled Jest preset. You will likely experience
+> unexpected behavior and have a sub-optimal experience if you do not use the preset.
+
+`native-testing-library` includes an easy to adopt and reliable Jest preset to maximize the
+confidence you have in your tests. It extends the `react-native` preset, and was created order to
+more closely mimic behavior you would expect from any other member of the `testing-library` family.
+
+```diff
+// jest.config.js
+
++ preset: 'native-testing-library'
+- preset: 'react-native'
+```
+
+You can continue to add to your Jest config as you normally would, you'll just want to make sure
+that if you modify the `setupFiles` key that you include any additional files after the setup files
+provided by the preset. Here's how you might do that:
+
+```javascript
+const expoPreset = require('jest-expo/jest-preset.json');
+const jestPreset = require('native-testing-library/jest-preset');
+
+module.exports = Object.assign(expoPreset, jestPreset, {
+  setupFiles: [...expoPreset.setupFiles, ...jestPreset.setupFiles, './mySetup.js'],
+});
+```
+
+> If you use Expo, be sure to include the Expo setup files before the native-testing-library setup
+> files! If you're using React Native, there's no need to do anything extra.
+
+Generally speaking though, it's better to include any setup files you have in the
+`setupFilesAfterEnv` key of your Jest config.
+
+> Note: this preset will use the react-native jest preset included with your version of
+> react-native, so please be aware that some behaviors may not be totally as expected if you are
+> using an older version of the react-native library.
+
+Here is a list of all the components this preset supports:
+
+```json
+[
+  "ActivityIndicator",
+  "Button",
+  "DrawerLayoutAndroid",
+  "Image",
+  "Modal",
+  "Picker",
+  "RefreshControl",
+  "SafeAreaView",
+  "ScrollView",
+  "Switch",
+  "Text",
+  "TextInput",
+  "TouchableHighlight",
+  "TouchableNativeFeedback",
+  "TouchableOpacity",
+  "TouchableWithoutFeedback",
+  "View"
+]
+```
+
+You can still use components like `FlatList` and `SectionList`, you just won't be able to directly
+select them or see them in debug output. These components wrap other components, that's why we don't
+let you select them directly. If you're having trouble selecting what you need to inside of one of
+these components that isn't mocked, just `debug()` to see what your users are seeing ☺️
+
 ## Exports
 
 You will likely be able to import everything you'll need from the project entry point like this:
@@ -21,5 +91,5 @@ import { render } from 'native-testing-library';
 ```
 
 The library's tests run in Node 8-11 before all new versions are published, and all files are
-processed through Babel. Typings are not provided, although we would be happy to accept a PR to add
-them! ☺️
+processed using the `metro-react-native-babel-preset` preset. Typings are included, but may not be
+perfect, and we are happy to accept PRs to improve them! ☺️
diff --git a/docs/intro.md b/docs/intro.md
index 3c7c760..bd2ebda 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -1,7 +1,7 @@
 ---
 id: intro
 title: Introduction
-sidebar_label: Intro
+sidebar_label: Introduction
 ---
 
 ## The problem
@@ -21,10 +21,10 @@ of the differences between the two platforms. Although most framework implementa
 `react-testing-library` are thin layers over [dom-testing-library](https://testing-library.com),
 this library needed to have its own base implementation as well as a user-facing API. This library
 uses the [react-test-renderer](https://reactjs.org/docs/test-renderer.html), whereas
-`dom-testing-library` uses JSDOM. The main philosophy here is that you should find elements on the
-"screen" the way users would. This approach is meant to give you confidence that your app is working
-as a cohesive unit. Just like the `dom-testing-library`, `native-testing-library`'s primary guiding
-principle is:
+`dom-testing-library` uses ReactDOM to render to JSDOM. The main philosophy is that you should find
+elements the way your users would. This approach is meant to give you confidence that your app is
+working as a cohesive unit. Just like the `dom-testing-library`, `native-testing-library`'s primary
+guiding principle is:
 
 > [The more your tests resemble the way your software is used, the more confidence they can give you.](guiding-principles.md)
 
@@ -34,13 +34,11 @@ types of things your users can see. We also give you the ability to search for e
 but you should consider it a last resort because users can't see a testID and it can introduce
 unpredictable behavior in your tests.
 
-It will also encourage you to build more accessible apps. For example, your users can't see your
-icon touchable that doesn't have an accessibility label, so neither can your tests. We believe that
+It will also encourage you to build more accessible apps. For example, disabled users can't see a
+touchable icon that doesn't have an accessibility label, so neither can your tests. We believe that
 writing good tests using this library will force you to give more consideration to whether what
 you're doing is an accessible experience for all of your users.
 
-This library should, in theory, work with any any testing framework like Jest or Mocha, but we do
-recommend you use Jest with the `react-native` Jest preset. We have not tested it in any other
-environment, and likely won't be able to support usage with another library.
-
-[jest]: https://jestjs.io
+This library may work with any any testing framework like Jest or Mocha, but we do recommend you use
+Jest with the `react-native` Jest preset. We have not tested it in any other environment, and likely
+won't be able to support usage with another library.
diff --git a/docs/setup.md b/docs/setup.md
index 371ee67..501b36a 100644
--- a/docs/setup.md
+++ b/docs/setup.md
@@ -6,13 +6,14 @@ sidebar_label: Setup
 
 ## Setting up your project
 
-`native-testing-library` should work out of the box for simple tests. Most of the snippets you'll
-find throughout the website should work without any additional configuration assuming you're using
-Jest and a moderately recent version of React Native.
+The `native-testing-library` API should work out of the box for most tests. All of the snippets
+you'll find throughout the website work without any additional configuration assuming you use Jest
+and a moderately recent version of React Native.
 
-We do strongly encourage you to use Jest with the `react-native` preset. In addition, there may be
-some additional mocks you would want to provide to allow for a smoother testing experience, (for
-example mocks for `react-native-gesture-handler`).
+We strongly encourage you to use Jest with the `native-testing-library` preset. The `react-native`
+preset should also work, but you'll be getting the best experience when using our preset. There may
+be some additional mocks you need to provide to such as mocks for `react-native-gesture-handler`
+when using `react-navigation`.
 
 ## Custom Render
 
@@ -23,7 +24,7 @@ file that re-exports everything from `native-testing-library`. You can replace
 [below](#configuring-jest-with-test-utils) for a way to make your test util file accessible without
 using relative paths.
 
-The example below sets up data providers using the [`wrapper`](api-render.md#render-options) option to
+The example below sets up data providers using the [`wrapper`](api-main.md#render-options) option to
 `render`.
 
 ```diff
diff --git a/website/core/Footer.js b/website/core/Footer.js
index c12fbc3..e389011 100755
--- a/website/core/Footer.js
+++ b/website/core/Footer.js
@@ -41,7 +41,6 @@ class Footer extends React.Component {
           <div>
             <h5>Docs</h5>
             <a href={this.docUrl('intro')}>Getting Started</a>
-            <a href={this.docUrl('install')}>Install</a>
             <a href={this.docUrl('example')}>Example</a>
             <a href={this.docUrl('api-queries')}>API</a>
             <a
@@ -62,9 +61,10 @@ class Footer extends React.Component {
               Stack Overflow
             </a>
             <a href="https://reactiflux.com/">Reactiflux on Discord</a>
-            <a href="https://twitter.com/bcarroll22" target="_blank" rel="noreferrer noopener">
+            <a href="https://twitter.com/TestingLib" target="_blank" rel="noreferrer noopener">
               Follow on Twitter
             </a>
+            <a href="https://spectrum.chat/testing-library/help-react-native?tab=posts">Spectrum</a>
           </div>
           <div>
             <h5>More</h5>
@@ -80,7 +80,9 @@ class Footer extends React.Component {
               Star
             </a>
             <a href="https://github.com/testing-library/native-testing-library">GitHub</a>
-            <a href="https://github.com/testing-library/native-testing-library-docs">Edit the docs</a>
+            <a href="https://github.com/testing-library/native-testing-library-docs">
+              Edit the docs
+            </a>
           </div>
         </section>
         <section className="copyright">{this.props.config.copyright}</section>
diff --git a/website/package-lock.json b/website/package-lock.json
index 86614c7..3c87ed7 100644
--- a/website/package-lock.json
+++ b/website/package-lock.json
@@ -2774,6 +2774,8 @@
     },
     "docusaurus": {
       "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/docusaurus/-/docusaurus-1.8.0.tgz",
+      "integrity": "sha512-Hn+/simu3yiX+5ucqNvX6yTyXtH3BFu2UIeGiXcKiRG8Khos206SsQQ2B7DrBzeJ0duhPxi/I7zYMFyaF23UUQ==",
       "dev": true,
       "requires": {
         "@babel/core": "^7.0.0",
diff --git a/website/pages/en/versions.js b/website/pages/en/versions.js
new file mode 100755
index 0000000..c9e14ff
--- /dev/null
+++ b/website/pages/en/versions.js
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2017-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+const React = require('react');
+
+const CompLibrary = require('../../core/CompLibrary');
+
+const Container = CompLibrary.Container;
+
+const CWD = process.cwd();
+
+const versions = require(`${CWD}/versions.json`);
+
+function Versions(props) {
+  const { config: siteConfig } = props;
+  const latestVersion = versions[0];
+  const repoUrl = `https://github.com/testing-library/native-testing-library`;
+  return (
+    <div className="docMainWrapper wrapper">
+      <Container className="mainContainer versionsContainer">
+        <div className="post">
+          <header className="postHeader">
+            <h1>{siteConfig.title} Versions</h1>
+          </header>
+          <p>New versions of this project are released every so often.</p>
+          <h3 id="latest">Current version (Stable)</h3>
+          <table className="versions">
+            <tbody>
+              <tr>
+                <th>{latestVersion}</th>
+                <td>
+                  <a href="/docs/intro">Documentation</a>
+                </td>
+                <td>
+                  <a href="https://github.com/testing-library/native-testing-library/releases/latest">
+                    Changelog
+                  </a>
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <h3 id="latest">Next version</h3>
+          <table className="versions">
+            <tbody>
+              <tr>
+                <th>next</th>
+                <td>
+                  <a href="/docs/next/intro">Documentation</a>
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <h3 id="archive">Past Versions</h3>
+          <table className="versions">
+            <tbody>
+              {versions.map(
+                version =>
+                  version !== latestVersion && (
+                    <tr>
+                      <th>{version}</th>
+                      <td>
+                        {/* You are supposed to fill this href by yourself
+                        Example: href={`docs/${version}/doc.html`} */}
+                        <a href={`docs/${version}/intro`}>Documentation</a>
+                      </td>
+                      <td>
+                        <a href={`${repoUrl}/releases/tag/v${version}`}>Changelog</a>
+                      </td>
+                    </tr>
+                  ),
+              )}
+            </tbody>
+          </table>
+          <p>
+            You can find past versions of this project on <a href={repoUrl}>GitHub</a>.
+          </p>
+        </div>
+      </Container>
+    </div>
+  );
+}
+
+module.exports = Versions;
diff --git a/website/sidebars.json b/website/sidebars.json
index 5f7e953..6927bac 100755
--- a/website/sidebars.json
+++ b/website/sidebars.json
@@ -9,13 +9,12 @@
       "cheat-sheet"
     ],
     "API": [
+      "api-main",
+      "api-test-instance",
       "api-queries",
       "api-events",
       "api-async",
-      "api-helpers",
-      "api-render",
-      "api-render-hook",
-      "api-act"
+      "api-helpers"
     ],
     "Ecosystem": ["ecosystem-jest-native"]
   },
@@ -28,18 +27,6 @@
       "example-navigation",
       "example-redux",
       "example-update-props"
-    ],
-    "Hook Examples": [
-      "hook-example-async",
-      "hook-example-custom",
-      "hook-example-error",
-      "hook-example-test",
-      "hook-example-use-context",
-      "hook-example-use-effect",
-      "hook-example-use-memo",
-      "hook-example-use-reducer",
-      "hook-example-use-ref",
-      "hook-example-use-state"
     ]
   }
 }
diff --git a/website/siteConfig.js b/website/siteConfig.js
index 4dc02e1..5285bf8 100755
--- a/website/siteConfig.js
+++ b/website/siteConfig.js
@@ -21,7 +21,7 @@
 //];
 
 const siteConfig = {
-  title: 'React Native Testing Library', // Title for your website.
+  title: 'Native Testing Library', // Title for your website.
   tagline:
     'Simple and complete React Native testing utilities that encourage good testing practices.',
   url: 'https://native-testing-library.com', // Your website URL
diff --git a/website/versioned_docs/version-2.0.0/api-act.md b/website/versioned_docs/version-2.0.0/api-act.md
new file mode 100644
index 0000000..437b789
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/api-act.md
@@ -0,0 +1,12 @@
+---
+id: version-2.0.0-api-act
+title: Act
+sidebar_label: Act
+original_id: api-act
+---
+
+## `act`
+
+This is a light wrapper around the
+[`react-test-renderer` `act` function](https://reactjs.org/docs/test-renderer.html). All it does is
+forward all arguments to the act function if your version of react supports `act`.
diff --git a/website/versioned_docs/version-2.0.0/api-async.md b/website/versioned_docs/version-2.0.0/api-async.md
new file mode 100644
index 0000000..eafa2c8
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/api-async.md
@@ -0,0 +1,90 @@
+---
+id: version-2.0.0-api-async
+title: Async
+sidebar_label: Async
+original_id: api-async
+---
+
+Several utilities are provided for dealing with asynchronous code. These can be useful to wait for
+an element to appear or disappear in response to an action. (See the
+[guide to testing disappearance](guide-disappearance.md).)
+
+## `wait`
+
+```typescript
+function wait(
+  callback?: () => void,
+  options?: {
+    timeout?: number;
+    interval?: number;
+  },
+): Promise<void>;
+```
+
+When in need to wait for non-deterministic periods of time you can use `wait`, to wait for your
+expectations to pass. The `wait` function is a small wrapper around the
+[`wait-for-expect`](https://github.com/TheBrainFamily/wait-for-expect) module. Here's a simple
+example:
+
+```javascript
+await wait(() => getByLabelText(container, 'username'));
+getByLabelText(container, 'username').value = 'chucknorris';
+```
+
+This can be useful if you have a unit test that mocks API calls and you need to wait for your mock
+promises to all resolve.
+
+The default `callback` is a no-op function (used like `await wait()`). This can be helpful if you
+only need to wait for one tick of the event loop (in the case of mocked API calls with promises that
+resolve immediately).
+
+The default `timeout` is `4500ms` which will keep you under
+[Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
+
+The default `interval` is `50ms`. However it will run your callback immediately on the next tick of
+the event loop (in a `setTimeout`) before starting the intervals.
+
+## `waitForElement`
+
+```typescript
+function waitForElement<T>(
+  callback: () => T,
+  options?: {
+    container?: ReactTestInstance;
+    timeout?: number;
+    interval?: number;
+  },
+): Promise<T>;
+```
+
+When in need to wait for DOM elements to appear, disappear, or change you can use `waitForElement`.
+The `waitForElement` function is a similar to `wait`, but is a helper specifically intended to wait
+for an element.
+
+Here's a simple example:
+
+```javascript
+const usernameElement = await waitForElement(() => getByA11yLabel(container, 'username'), {
+  container,
+});
+expect(usernameElement.props.children).toBe('chucknorris');
+```
+
+You can also wait for multiple elements at once:
+
+```javascript
+const [usernameElement, passwordElement] = await waitForElement(
+  () => [getByA11yLabel(container, 'username'), getByA11yLabel(container, 'password')],
+  { container },
+);
+```
+
+The default `container` is the root `ReactTestInstance` that is the result of `render`. Make sure
+the elements you wait for will be attached to it, or set a different `ReactTestInstance` as a
+container.
+
+The default `timeout` is `4500ms` which will keep you under
+[Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
+
+The default `interval` is `50ms`. However it will run your callback immediately on the next tick of
+the event loop (in a `setTimeout`) before starting the intervals.
diff --git a/website/versioned_docs/version-2.0.0/api-events.md b/website/versioned_docs/version-2.0.0/api-events.md
new file mode 100644
index 0000000..ba19afe
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/api-events.md
@@ -0,0 +1,57 @@
+---
+id: version-2.0.0-api-events
+title: Firing Events
+sidebar_label: Firing Events
+original_id: api-events
+---
+
+## Basic example
+
+```javascript
+import { fireEvent, NativeTestEvent, render } from 'native-testing-library';
+
+const { getByText } = render(<Button title="Submit" />);
+fireEvent(getByText(container, 'Submit'), new NativeTestEvent('press'));
+```
+
+## `fireEvent[eventName]`
+
+```typescript
+fireEvent[eventName](node: FiberRoot, eventProperties: NativeTestEvent)
+```
+
+Convenience methods for firing events. Check out
+[src/events.js](https://github.com/testing-library/native-testing-library/blob/master/src/events.js)
+for a full list as well as `validTargets` for every event type.
+
+```javascript
+import { fireEvent, render } from 'native-testing-library';
+
+const { getByText } = render(<Button title="Submit" />);
+fireEvent.press(getByText('Submit'));
+```
+
+**nativeEvent**: React Native tends to put everything relevant to their built-in events on an object
+called nativeEvent. When you fire an event using this library, you will have to build a mock event
+config. You will use this particularly for events like a change event:
+
+```javascript
+fireEvent.change(getByA11yLabel(/username/i), { nativeEvent: { text: 'a' } });
+```
+
+**changeText**: `Text` has a method for value updating called `onChangeText`. Since this is such a
+commonly used method, there is a special case in the library for this method.
+
+```javascript
+fireEvent.changeText(getByA11yLabel(/username/i), 'a');
+```
+
+**customEvent**: You may be using a library that has custom event listeners that you want to be able
+to fire. This is how you would fire one of these events:
+
+```javascript
+fireEvent(
+  getByTestId('swiper'),
+  new NativeTestEvent('myEvent', { nativeEvent: { value: 'testing' } }),
+);
+```
diff --git a/website/versioned_docs/version-2.0.0/api-helpers.md b/website/versioned_docs/version-2.0.0/api-helpers.md
new file mode 100644
index 0000000..316eb99
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/api-helpers.md
@@ -0,0 +1,170 @@
+---
+id: version-2.0.0-api-helpers
+title: Helpers
+sidebar_label: Helpers
+original_id: api-helpers
+---
+
+## Custom Queries
+
+`native-testing-library` exposes many of the helper functions that are used to implement the default
+queries. You can use the helpers to build custom queries. For example, the code below shows a way to
+query your TestInstance by a `style` prop. Note: test files would need to now import `test-utils.js`
+instead of using `native-testing-library` directly. Also note, please never actually implement this
+helper, it's just an example of what's possible.
+
+```js
+// test-utils.js
+import * as nativeTestingLib from 'native-testing-library';
+
+const { queryHelpers } = nativeTestingLib;
+
+export const queryByStyle = queryHelpers.queryByProp.bind(null, 'style');
+export const queryAllByStyle = queryHelpers.queryByProp.bind(null, 'style');
+
+export function getAllByStyle(container, styles, ...rest) {
+  const els = queryAllByStyle(container, styles, ...rest);
+  if (!els.length) {
+    throw getElementError(`Unable to find an element by style="${styles}"`, container);
+  }
+  return els;
+}
+
+export function getByStyle(...args) {
+  return queryHelpers.firstResultOrNull(getAllByStyle, ...args);
+}
+
+// re-export with overrides
+export {
+  ...nativeTestingLib,
+  getByStyle,
+  getAllByStyle,
+  queryByStyle,
+  queryAllByStyle,
+};
+```
+
+> **Note**
+>
+> Custom queries can be added to the `render` method by adding `queries` to the options config
+> object. See the render [options](/docs/api-render#render-options).
+
+## `getNodeText`
+
+```typescript
+getNodeText(node: React.ReactElement<any>)
+```
+
+Returns the complete text content of a html element, removing any extra whitespace, and joining
+children that are an array. The intention is to treat text in nodes exactly as how it is perceived
+by users in a browser, where any extra whitespace within words in the html code is not meaningful
+when the text is rendered, and all text appears as one cohesive string regardless of the code.
+
+```javascript
+const inputNode = <TextInput value="words" />;
+const textNode = (
+  <Text>
+    {`
+  Hello
+    World  !
+  `}
+  </Text>
+);
+
+getNodeText(node); // "Hello World !"
+```
+
+This function is also used internally when querying nodes by their text content. This enables
+functions like `getByText` and `queryByText` to work as expected, finding elements in the tree
+similarly to how users would do.
+
+The function works for for input elements as well:
+
+```javascript
+const inputNode = <TextInput value="words" />;
+
+getNodeText(inputNode); // "words"
+```
+
+## `getQueriesForElement` APIs
+
+`getQueriesForElement` takes a FiberRoot and binds it to the raw query functions, allowing them to
+be used without specifying a container.
+
+Example: To get the username input of a login form within a `<LoginModal />`, you could do:
+
+```js
+import { render, getQueriesForElement } from 'react-testing-library';
+
+const { getByA11yLabel } = render(<LoginModal />);
+const loginForm = getByA11yLabel('login-form');
+
+getQueriesForElement(loginForm).getByPlaceholder('Username');
+```
+
+## Debugging
+
+When you use any `get` calls in your test cases, the current state of the `container` (React tree)
+gets printed on the console. For example:
+
+```javascript
+// <Text>Hello world</Text>
+getByText(container, 'Goodbye world'); // will fail by throwing error
+```
+
+The above test case will fail, however it prints the state of your React tree being tested, so you
+will get to see:
+
+```
+Unable to find an element with the text: Goodbye world. This could be because the text is broken up by multiple elements. In this case, you can provide a function for your text matcher to make your matcher more flexible.
+Here is the state of your container:
+<Text>
+  Hello World!
+</Text>
+```
+
+Note: Since the debug size can get really large, you can set the limit of debug content to be
+printed via environment variable `DEBUG_PRINT_LIMIT`. The default value is `7000`. You will see
+`...` in the console, when the debug content is stripped off, because of the length you have set or
+due to default size limit. Here's how you might increase this limit when running tests:
+
+```
+DEBUG_PRINT_LIMIT=10000 npm test
+```
+
+This works on macOS/linux, you'll need to do something else for windows. If you'd like a solution
+that works for both, see [`cross-env`](https://www.npmjs.com/package/cross-env)
+
+### `prettyPrint`
+
+This helper function can be used to print out readable representation of the React tree of a node.
+This can be helpful for instance when debugging tests.
+
+It is defined as:
+
+```typescript
+function prettyPrint(node: React.ReactElement<any>, maxLength?: number): string;
+```
+
+It receives the root node to print out, and an optional extra argument to limit the size of the
+resulting string, for cases when it becomes too large.
+
+This function is usually used alongside `console.log` to temporarily print out React trees during
+tests for debugging purposes:
+
+```javascript
+console.log(
+  prettyPrint(
+    <View>
+      <Text>hi</Text>
+    </View>,
+  ),
+);
+// <View>
+//   <Text>
+//     Hi
+//   </Text>
+// </View>
+```
+
+This function is what also powers [the automatic debugging output described above](#debugging).
diff --git a/website/versioned_docs/version-2.0.0/api-queries.md b/website/versioned_docs/version-2.0.0/api-queries.md
new file mode 100644
index 0000000..c38616e
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/api-queries.md
@@ -0,0 +1,413 @@
+---
+id: version-2.0.0-api-queries
+title: Queries
+sidebar_label: Queries
+original_id: api-queries
+---
+
+## Variants
+
+> `getBy` queries are shown by default in the [query documentation](#queries) below.
+
+### getBy
+
+`getBy*` queries returns the first matching node for a query, and throws an error if no elements
+match or if more than one match is found (use `getAllBy` instead).
+
+### getAllBy
+
+`getAllBy*` queries return an array of all matching nodes for a query, and throws an error if no
+elements match.
+
+### queryBy
+
+`queryBy*` queries returns the first matching node for a query, and return `null` if no elements
+match. This is useful for asserting an element is not present. This throws if more than one match is
+found (use `queryAllBy` instead)..
+
+### queryAllBy
+
+`queryAllBy*` queries return an array of all matching nodes for a query, and return an empty array
+(`[]`) if no elements match.
+
+### findBy
+
+`findBy*` queries return a promise which resolves when an element is found which matches the given
+query. The promise is rejected if no element is found or if more than one element is found after a
+default timeout of `4500`ms. If you need to find more than one element, then use `findAllBy`.
+
+> Note, this is a simple combination of `getBy*` queries and
+> [`waitForElement`](/docs/api-async#waitforelement). The `findBy*` queries accept the
+> `waitForElement` options as the last argument. (i.e.
+> `findByText(container, 'text', queryOptions, waitForElementOptions)`)
+
+### findAllBy
+
+`findAllBy*` queries return a promise which resolves to an array of elements when any elements are
+found which match the given query. The promise is rejected if no elements are found after a default
+timeout of `4500`ms.
+
+## Options
+
+The argument to a query can be a _string_, _regular expression_, or _function_. There are also
+options to adjust how node text is parsed.
+
+See [TextMatch](#textmatch) for documentation on what can be passed to a query.
+
+## Queries
+
+### `ByA11yHint`
+
+> getByA11yHint, queryByA11yHint, getAllByA11yHint, queryAllByA11yHint, findByA11yHint,
+> findAllByA11yHint
+
+```typescript
+getByA11yHint(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    filter?: FilterFn,
+    normalizer?: NormalizerFn,
+  }): FiberRoot
+```
+
+This will search for all elements with an `accessibilityHint` prop and find one that matches the
+given [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'react-testing-library';
+
+const { getByA11yHint } = render(<View accessibilityHint="summary" />);
+
+getByA11yHint('summary'); // returns the View node
+```
+
+### `ByA11yLabel`
+
+> getByA11yLabel, queryByLabelText, getAllByLabelText, queryAllByLabelText findByLabelText,
+> findAllByLabelText
+
+```typescript
+getByA11yLabel(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    filter?: FilterFn,
+    normalizer?: NormalizerFn,
+  }): FiberRoot
+```
+
+This will search for all elements with an `accessibilityLabel` prop and find one that matches the
+given [`TextMatch`](#textmatch).
+
+```js
+function Login({ onPress }) {
+  return (
+    <View accessibilityLabel="login-form">
+      <Text>Login</Text>
+      <TextInput accessibilityLabel="username" />
+      <TextInput accessibilityLabel="password" />
+      <Button title="Login" onPress={onPress} />
+    </View>
+  );
+}
+
+import { render } from 'native-testing-library';
+
+const { getByA11yLabel } = render(<Login onPress={jest.fn()} />);
+
+getByA11yLabel('username'); // returns the TextInput node
+```
+
+### `ByA11yRole`
+
+> getByA11yRole, queryByA11yRole, getAllByA11yRole, queryAllByA11yRole, findByA11yRole,
+> findAllByA11yRole
+
+```typescript
+getByA11yRole(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    filter?: FilterFn,
+    normalizer?: NormalizerFn,
+  }): FiberRoot
+```
+
+This will search for all elements with an `accessibilityRole` prop and find one that matches the
+given [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'react-testing-library';
+
+const { getByA11yRole } = render(<View accessibilityRole="summary" />);
+
+getByA11yRole('summary'); // returns the View node
+```
+
+### `ByA11yStates`
+
+> getByA11yStates, queryByA11yStates, getAllByA11yStates, queryAllByA11yStates, findByA11yStates,
+> findAllByA11yStates
+
+```typescript
+getByA11yStates(
+  container: ReactTestInstance,
+  match: Array<string>
+): FiberRoot
+```
+
+This will search for all elements with an `accessibilityStates` prop and find one that matches the
+given `Array`.
+
+```js
+import { render } from 'react-testing-library';
+
+const { getByA11yStates } = render(<View accessibilityStates={['disabled']} />);
+
+getByA11yStates(['disabled']); // returns the View node
+```
+
+### `ByA11yTraits`
+
+> getByA11yTraits, queryByA11yTraits, getAllByA11yTraits, queryAllByA11yTraits, findByA11yTraits,
+> findAllByA11yTraits
+
+```typescript
+getByA11yTraits(
+  container: ReactTestInstance,
+  match: Array<string>,
+): FiberRoot
+```
+
+This will search for all elements with an `accessibilityTraits` prop and find one that matches the
+given `Array`.
+
+```js
+import { render } from 'react-testing-library';
+
+const { getByA11yTraits } = render(<View accessibilityTraits={['button']} />);
+
+getByA11yTraits(['button']); // returns the View node
+```
+
+### `ByPlaceholder`
+
+> getByPlaceholder, queryByPlaceholder, getAllByPlaceholder, queryAllByPlaceholder,
+> findByPlaceholder, findAllByPlaceholder
+
+```typescript
+getByPlaceholder(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    filter?: FilterFn,
+    normalizer?: NormalizerFn,
+  }): FiberRoot
+```
+
+This will search for all elements with a `placeholder` prop and find one that matches the given
+[`TextMatch`](#textmatch).
+
+```javascript
+import { render } from 'native-testing-library';
+
+const { getByPlaceholder } = render(<TextInput placeholder="Username" />);
+
+getByPlaceholder('Username'); // returns the TextInput node
+```
+
+### `ByText`
+
+> getByText, queryByText, getAllByText, queryAllByText, findByText, findAllByText
+
+```typescript
+getByText(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    types?: array = ['Text', 'TextInput'],
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    exact?: boolean = true,
+    normalizer?: NormalizerFn,
+  }): FiberRoot
+```
+
+This will search for all elements of type `Text` with `props.children` matching the given. It will
+also search `TextInput` elements by their value [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByText } = render(<Text>About ℹ</Text>);
+
+getByText(/about/i); // returns the Text node
+```
+
+### `ByValue`
+
+> getByValue, queryByValue, getAllByValue, queryAllByValue, findByValue, findAllByValue
+
+```typescript
+getByValue(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    filter?: FilterFn,
+    normalizer?: NormalizerFn,
+  }): NormalizerOptions
+```
+
+This will search for all elements with a `value` prop and find one that matches the given
+[`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByValue } = render(<Input value="About ℹ" onChangeText={() => ({})} />);
+
+getByValue(/about/i); // returns the Input node
+```
+
+### `ByTestId`
+
+> getByTestId, queryByTestId, getAllByTestId, queryAllByTestId, findByTestId, findAllByTestId
+
+```typescript
+getByTestId(
+  container: ReactTestInstance,
+  match: TextMatch,
+  options?: {
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    exact?: boolean = true,
+    filter?: FilterFn,
+    normalizer?: NormalizerFn,
+  }): FiberRoot
+```
+
+This will search for all elements with a `testID` and find one that matches the given
+[`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByTestId } = render(<Text testID="test">hi there</Text>);
+
+getByTestId('test'); // returns the Text node
+```
+
+> Because your users can't see testIDs [the guiding principles](#guiding-principles), please only
+> use this as a last resort. Users don't interact with testIDs, and can lead to unpredictable
+> behavior. For example, internal React Native components sometimes spread testIds down to child
+> components. This means that if you query all by testId, you may get significantly more results
+> than you anticipate which will lead to unpredictable tests.
+
+## `TextMatch`
+
+Several APIs accept a `TextMatch` which can be a `string`, `regex` or a `function` which returns
+`true` for a match and `false` for a mismatch.
+
+### Precision
+
+Some APIs accept an object as the final argument that can contain options that affect the precision
+of string matching:
+
+- `exact`: Defaults to `true`; matches full strings, case-sensitive. When false, matches substrings
+  and is not case-sensitive.
+  - `exact` has no effect on `regex` or `function` arguments.
+  - In most cases using a regex instead of a string gives you more control over fuzzy matching and
+    should be preferred over `{ exact: false }`.
+- `normalizer`: An optional function which overrides normalization behavior. See
+  [`Normalization`](#normalization).
+
+### Normalization
+
+Before running any matching logic against text, `native-testing-library` automatically normalizes
+that text. By default, normalization consists of trimming whitespace from the start and end of text,
+and collapsing multiple adjacent whitespace characters into a single space.
+
+If you want to prevent that normalization, or provide alternative normalization (e.g. to remove
+Unicode control characters), you can provide a `normalizer` function in the options object. This
+function will be given a string and is expected to return a normalized version of that string.
+
+Note: Specifying a value for `normalizer` _replaces_ the built-in normalization, but you can call
+`getDefaultNormalizer` to obtain a built-in normalizer, either to adjust that normalization or to
+call it from your own normalizer.
+
+`getDefaultNormalizer` takes an options object which allows the selection of behaviour:
+
+- `trim`: Defaults to `true`. Trims leading and trailing whitespace
+- `collapseWhitespace`: Defaults to `true`. Collapses inner whitespace (newlines, tabs, repeated
+  spaces) into a single space.
+
+#### Normalization Examples
+
+To perform a match against text without trimming:
+
+```javascript
+getByText(node, 'text', {
+  normalizer: getDefaultNormalizer({ trim: false }),
+});
+```
+
+To override normalization to remove some Unicode characters whilst keeping some (but not all) of the
+built-in normalization behavior:
+
+```javascript
+getByText(node, 'text', {
+  normalizer: str => getDefaultNormalizer({ trim: false })(str).replace(/[\u200E-\u200F]*/g, ''),
+});
+```
+
+### TextMatch Examples
+
+Given the following render:
+
+```javascript
+const { baseElement } = render(<Text>Hello World</Text>);
+```
+
+**_Will_ find a match:**
+
+```javascript
+// Matching a string:
+getByText(baseElement, 'Hello World'); // full string match
+getByText(baseElement, 'llo Worl', { exact: false }); // substring match
+getByText(baseElement, 'hello world', { exact: false }); // ignore case
+
+// Matching a regex:
+getByText(baseElement, /World/); // substring match
+getByText(baseElement, /world/i); // substring match, ignore case
+getByText(baseElement, /^hello world$/i); // full string match, ignore case
+getByText(baseElement, /Hello W?oRlD/i); // advanced regex
+
+// Matching with a custom function:
+getByText(baseElement, content => content.startsWith('Hello'));
+```
+
+**_Will not_ find a match:**
+
+```javascript
+// full string does not match
+getByText(testElement, 'Goodbye World');
+
+// case-sensitive regex with different case
+getByText(testElement, /hello world/);
+```
diff --git a/docs/api-render-hook.md b/website/versioned_docs/version-2.0.0/api-render-hook.md
similarity index 96%
rename from docs/api-render-hook.md
rename to website/versioned_docs/version-2.0.0/api-render-hook.md
index 21d0bc1..8de49a1 100644
--- a/docs/api-render-hook.md
+++ b/website/versioned_docs/version-2.0.0/api-render-hook.md
@@ -1,7 +1,8 @@
 ---
-id: api-render-hook
+id: version-2.0.0-api-render-hook
 title: Render Hook
 sidebar_label: Render Hook
+original_id: api-render-hook
 ---
 
 ## `renderHook`
diff --git a/docs/api-render.md b/website/versioned_docs/version-2.0.0/api-render.md
similarity index 98%
rename from docs/api-render.md
rename to website/versioned_docs/version-2.0.0/api-render.md
index b74f418..568b188 100644
--- a/docs/api-render.md
+++ b/website/versioned_docs/version-2.0.0/api-render.md
@@ -1,7 +1,8 @@
 ---
-id: api-render
+id: version-2.0.0-api-render
 title: Render
 sidebar_label: Render
+original_id: api-render
 ---
 
 ## `render`
diff --git a/website/versioned_docs/version-2.0.0/cheat-sheet.md b/website/versioned_docs/version-2.0.0/cheat-sheet.md
new file mode 100644
index 0000000..6f5eb64
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/cheat-sheet.md
@@ -0,0 +1,15 @@
+---
+id: version-2.0.0-cheat-sheet
+title: Printable Cheat Sheet
+sidebar_label: Cheat Sheet
+original_id: cheat-sheet
+---
+
+There is a printable one-page cheat sheet available for you to download. It is intended to be a
+quick reference for `native-testing-library`, but is not a complete API glossary or guide. Keep a
+copy of it on your desk to quickly take a peek at the most commonly used functionality!
+
+[Download the cheat sheet][cheatsheet]
+
+[cheatsheet]:
+  https://github.com/testing-library/native-testing-library/raw/master/other/cheat-sheet.pdf
diff --git a/website/versioned_docs/version-2.0.0/ecosystem-jest-native.md b/website/versioned_docs/version-2.0.0/ecosystem-jest-native.md
new file mode 100644
index 0000000..447bc07
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/ecosystem-jest-native.md
@@ -0,0 +1,34 @@
+---
+id: version-2.0.0-ecosystem-jest-native
+title: jest-native
+sidebar_label: Jest Matchers
+original_id: ecosystem-jest-native
+---
+
+[`jest-native`](https://github.com/testing-library/jest-native) is a companion library for
+`native-testing-library` that provides custom element matchers for Jest.
+
+```
+npm install --save-dev jest-native
+```
+
+```javascript
+<View>
+  <View testID="not-empty">
+    <Text testID="empty" />
+  </View>
+  <Text testID="visible">Visible Example</Text>
+</View>;
+
+expect(queryByTestId(baseElement, 'not-empty')).not.toBeEmpty();
+expect(getByText(baseElement, 'Visible Example')).toBeVisible();
+```
+
+> Note: when using some of these matchers, you may need to make sure you use a query function (like
+> `queryByTestId`) rather than a get function (like `getByTestId`). Otherwise the `get*` function
+> could throw an error before your assertion.
+
+Check out [jest-native's documentation](https://github.com/testing-library/jest-native) for a full
+list of available matchers.
+
+- [jest-native on GitHub](https://github.com/testing-library/jest-native)
diff --git a/website/versioned_docs/version-2.0.0/example-context.md b/website/versioned_docs/version-2.0.0/example-context.md
new file mode 100644
index 0000000..1b13a97
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example-context.md
@@ -0,0 +1,49 @@
+---
+id: version-2.0.0-example-context
+title: Context
+sidebar_label: Context
+original_id: example-context
+---
+
+```javascript
+import React from 'react';
+import { Text } from 'react-native';
+
+import { render } from ' native-testing-library';
+import { NameContext, NameProvider, NameConsumer } from '../react-context';
+
+test('NameConsumer shows default value', () => {
+  const { getByText } = render(<NameConsumer />);
+  expect(getByText(/^My Name Is:/).props.children.join('')).toBe('My Name Is: Unknown');
+});
+
+test('NameConsumer shows value from provider', () => {
+  const tree = (
+    <NameContext.Provider value="C3P0">
+      <NameConsumer />
+    </NameContext.Provider>
+  );
+  const { getByText } = render(tree);
+  expect(getByText(/^My Name Is:/).props.children.join('')).toBe('My Name Is: C3P0');
+});
+
+test('NameProvider composes full name from first, last', () => {
+  const tree = (
+    <NameProvider first="Boba" last="Fett">
+      <NameContext.Consumer>{value => <Text>Received: {value}</Text>}</NameContext.Consumer>
+    </NameProvider>
+  );
+  const { getByText } = render(tree);
+  expect(getByText(/^Received:/).props.children.join('')).toBe('Received: Boba Fett');
+});
+
+test('NameProvider/Consumer shows name of character', () => {
+  const tree = (
+    <NameProvider first="Leia" last="Organa">
+      <NameConsumer />
+    </NameProvider>
+  );
+  const { getByText } = render(tree);
+  expect(getByText(/^My Name Is:/).props.children.join('')).toBe('My Name Is: Leia Organa');
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/example-input-event.md b/website/versioned_docs/version-2.0.0/example-input-event.md
new file mode 100644
index 0000000..ff8eb8c
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example-input-event.md
@@ -0,0 +1,73 @@
+---
+id: version-2.0.0-example-input-event
+title: Input Event
+sidebar_label: Input Event
+original_id: example-input-event
+---
+
+```javascript
+import React from 'react';
+import { Text, TextInput } from 'react-native';
+import { render, fireEvent } from ' native-testing-library';
+
+class CostInput extends React.Component {
+  state = {
+    value: '',
+  };
+
+  removeDollarSign = value => (value[0] === '$' ? value.slice(1) : value);
+  getReturnValue = value => (value === '' ? '' : `$${value}`);
+  handleChange = ({ nativeEvent }) => {
+    const text = nativeEvent.text;
+    const noDollarSign = this.removeDollarSign(text);
+    if (isNaN(noDollarSign)) return;
+    this.setState({ value: this.getReturnValue(noDollarSign) });
+  };
+
+  render() {
+    return (
+      <TextInput
+        value={this.state.value}
+        accessibilityLabel="cost-input"
+        onChange={this.handleChange}
+      />
+    );
+  }
+}
+
+const setup = () => {
+  const utils = render(<CostInput />);
+  const input = utils.getByA11yLabel('cost-input');
+  return {
+    input,
+    ...utils,
+  };
+};
+
+test('It should keep a $ in front of the input', () => {
+  const { input } = setup();
+
+  fireEvent.change(input, { nativeEvent: { text: 23 } });
+  expect(input.props.value).toBe('$23');
+});
+test('It should allow a $ to be in the input when the value is changed', () => {
+  const { input } = setup();
+  fireEvent.change(input, { nativeEvent: { text: '$23.0' } });
+  expect(input.props.value).toBe('$23.0');
+});
+
+test('It should not allow letters to be inputted', () => {
+  const { input } = setup();
+  expect(input.props.value).toBe('');
+  fireEvent.change(input, { nativeEvent: { text: 'Good Day' } });
+  expect(input.props.value).toBe('');
+});
+
+test('It should allow the $ to be deleted', () => {
+  const { input } = setup();
+  fireEvent.change(input, { nativeEvent: { text: '23' } });
+  expect(input.props.value).toBe('$23');
+  fireEvent.change(input, { nativeEvent: { text: '' } });
+  expect(input.props.value).toBe('');
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/example-intl.md b/website/versioned_docs/version-2.0.0/example-intl.md
new file mode 100644
index 0000000..23561dc
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example-intl.md
@@ -0,0 +1,54 @@
+---
+id: version-2.0.0-example-intl
+title: Intl
+sidebar_label: Intl
+original_id: example-intl
+---
+
+```javascript
+import React from 'react';
+import { View } from 'react-native';
+import { IntlProvider } from 'react-intl';
+import { FormattedDate } from 'react-intl-native';
+import IntlPolyfill from 'intl';
+import 'intl/locale-data/jsonp/pt';
+
+import { getByText, render } from ' native-testing-library';
+
+const setupTests = () => {
+  if (global.Intl) {
+    Intl.NumberFormat = IntlPolyfill.NumberFormat;
+    Intl.DateTimeFormat = IntlPolyfill.DateTimeFormat;
+  } else {
+    global.Intl = require('intl');
+  }
+};
+
+const FormatDateView = () => {
+  return (
+    <View testID="date-display">
+      <FormattedDate
+        value="2019-03-11"
+        timeZone="utc"
+        day="2-digit"
+        month="2-digit"
+        year="numeric"
+      />
+    </View>
+  );
+};
+
+const renderWithReactIntl = component => {
+  return {
+    ...render(<IntlProvider locale="pt">{component}</IntlProvider>),
+  };
+};
+
+setupTests();
+
+test('it should render FormattedDate and have a formatted pt date', () => {
+  const { container } = renderWithReactIntl(<FormatDateView />);
+
+  getByText(container, '11/03/2019');
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/example-navigation.md b/website/versioned_docs/version-2.0.0/example-navigation.md
new file mode 100644
index 0000000..727405f
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example-navigation.md
@@ -0,0 +1,94 @@
+---
+id: version-2.0.0-example-navigation
+title: Navigation
+sidebar_label: Navigation
+original_id: example-navigation
+---
+
+```javascript
+import React from 'react';
+import { Button, Text, View } from 'react-native';
+import { createStackNavigator, createAppContainer, withNavigation } from 'react-navigation';
+
+import { render, fireEvent } from ' native-testing-library';
+
+jest.mock('NativeAnimatedHelper').mock('react-native-gesture-handler', () => {
+  const View = require('react-native/Libraries/Components/View/View');
+  return {
+    State: {},
+    PanGestureHandler: View,
+    BaseButton: View,
+    Directions: {},
+  };
+});
+
+console.warn = arg => {
+  const warnings = [
+    'Calling .measureInWindow()',
+    'Calling .measureLayout()',
+    'Calling .setNativeProps()',
+    'Calling .focus()',
+    'Calling .blur()',
+  ];
+
+  const finalArgs = warnings.reduce((acc, curr) => (arg.includes(curr) ? [...acc, arg] : acc), []);
+
+  if (!finalArgs.length) {
+    console.warn(arg);
+  }
+};
+
+const Home = ({ navigation }) => (
+  <View>
+    <Text testID="title">Home page</Text>
+    <Button title="About page" onPress={() => navigation.navigate('About')} />
+  </View>
+);
+const About = ({ navigation }) => (
+  <View>
+    <Text testID="title">About page</Text>
+    <Button title="About page" onPress={() => navigation.navigate('Home')} />
+  </View>
+);
+const Location = () => (
+  <View>
+    <Text testID="title">Location page</Text>
+    <LocationDisplay />
+  </View>
+);
+
+const LocationDisplay = withNavigation(({ navigation }) => (
+  <Text testID="location-display">{navigation.state.routeName}</Text>
+));
+
+function renderWithNavigation({ screens = {}, navigatorConfig = {} } = {}) {
+  const AppNavigator = createStackNavigator(
+    {
+      Home,
+      About,
+      Location,
+      ...screens,
+    },
+    { initialRouteName: 'Home', ...navigatorConfig },
+  );
+
+  const App = createAppContainer(AppNavigator);
+
+  return { ...render(<App />), navigationContainer: App };
+}
+
+test('full app rendering/navigating', async () => {
+  const { findByText, getByTestId, getByText } = renderWithNavigation();
+  expect(getByTestId('title').props.children).toMatch('Home page');
+  fireEvent.press(getByText(/About page/i));
+  await expect(findByText('About page')).toBeTruthy();
+});
+
+test('rendering a component that uses withNavigation', () => {
+  const initialRouteName = 'Location';
+  const { getByTestId } = renderWithNavigation({
+    navigatorConfig: { initialRouteName },
+  });
+  expect(getByTestId('location-display').props.children).toBe(initialRouteName);
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/example-redux.md b/website/versioned_docs/version-2.0.0/example-redux.md
new file mode 100644
index 0000000..c470804
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example-redux.md
@@ -0,0 +1,86 @@
+---
+id: version-2.0.0-example-redux
+title: Redux
+sidebar_label: Redux
+original_id: example-redux
+---
+
+```javascript
+import React from 'react';
+import { Button, Text, View } from 'react-native';
+import { createStore } from 'redux';
+import { Provider, connect } from 'react-redux';
+import { render, fireEvent } from ' native-testing-library';
+
+class Counter extends React.Component {
+  increment = () => {
+    this.props.dispatch({ type: 'INCREMENT' });
+  };
+
+  decrement = () => {
+    this.props.dispatch({ type: 'DECREMENT' });
+  };
+
+  render() {
+    return (
+      <View>
+        <Text>Counter</Text>
+        <View>
+          <Button onPress={this.decrement} title="-" />
+          <Text testID="count-value">{this.props.count}</Text>
+          <Button onPress={this.increment} title="+" />
+        </View>
+      </View>
+    );
+  }
+}
+
+const ConnectedCounter = connect(state => ({ count: state.count }))(Counter);
+
+function reducer(state = { count: 0 }, action) {
+  switch (action.type) {
+    case 'INCREMENT':
+      return {
+        count: state.count + 1,
+      };
+    case 'DECREMENT':
+      return {
+        count: state.count - 1,
+      };
+    default:
+      return state;
+  }
+}
+
+function renderWithRedux(ui, { initialState, store = createStore(reducer, initialState) } = {}) {
+  return {
+    ...render(<Provider store={store}>{ui}</Provider>),
+    store,
+  };
+}
+
+test('can render with redux with defaults', () => {
+  const { getByTestId, getByText } = renderWithRedux(<ConnectedCounter />);
+  fireEvent.press(getByText('+'));
+  expect(getByTestId('count-value').props.children).toBe(1);
+});
+
+test('can render with redux with custom initial state', () => {
+  const { getByTestId, getByText } = renderWithRedux(<ConnectedCounter />, {
+    initialState: { count: 3 },
+  });
+  fireEvent.press(getByText('-'));
+  expect(getByTestId('count-value').props.children).toBe(2);
+});
+
+test('can render with redux with custom store', () => {
+  const store = createStore(() => ({ count: 1000 }));
+  const { getByTestId, getByText } = renderWithRedux(<ConnectedCounter />, {
+    store,
+  });
+  fireEvent.press(getByText('+'));
+  expect(getByTestId('count-value').props.children).toBe(1000);
+  fireEvent.press(getByText('-'));
+  expect(getByTestId('count-value').props.children).toBe(1000);
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/example-update-props.md b/website/versioned_docs/version-2.0.0/example-update-props.md
new file mode 100644
index 0000000..d4f373f
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example-update-props.md
@@ -0,0 +1,36 @@
+---
+id: version-2.0.0-example-update-props
+title: Update Props
+sidebar_label: Update Props
+original_id: example-update-props
+---
+
+```javascript
+import React from 'react';
+import { Text, View } from 'react-native';
+import { render } from ' native-testing-library';
+
+let idCounter = 1;
+
+class NumberDisplay extends React.Component {
+  id = idCounter++;
+  render() {
+    return (
+      <View>
+        <Text testID="number-display">{this.props.number}</Text>
+        <Text testID="instance-id">{this.id}</Text>
+      </View>
+    );
+  }
+}
+
+test('calling render with the same component on the same container does not remount', () => {
+  const { getByTestId, rerender } = render(<NumberDisplay number={1} />);
+  expect(getByTestId('number-display').props.children).toEqual(1);
+
+  rerender(<NumberDisplay number={2} />);
+  expect(getByTestId('number-display').props.children).toEqual(2);
+
+  expect(getByTestId('instance-id').props.children).toEqual(1);
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/example.md b/website/versioned_docs/version-2.0.0/example.md
new file mode 100644
index 0000000..442b4f9
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/example.md
@@ -0,0 +1,50 @@
+---
+id: version-2.0.0-example
+title: Example
+sidebar_label: Example
+original_id: example
+---
+
+```javascript
+import React from 'react';
+import { Button, Text, TextInput, View } from 'react-native';
+import { fireEvent, render, wait } from 'native-testing-library';
+
+function Example() {
+  const [name, setUser] = React.useState('');
+  const [show, setShow] = React.useState(false);
+
+  return (
+    <View>
+      <TextInput value={name} onChangeText={setUser} testID="input" />
+      <Button
+        title="Print Username"
+        onPress={() => {
+          // let's pretend this is making a server request, so it's async
+          // (you'd want to mock this imaginary request in your unit tests)...
+          setTimeout(() => {
+            setShow(!show);
+          }, Math.floor(Math.random() * 200));
+        }}
+      />
+      {show && <Text testID="printed-username">{name}</Text>}
+    </View>
+  );
+}
+
+test('examples of some things', async () => {
+  const { getByTestId, getByText, queryByTestId, baseElement } = render(<Example />);
+  const famousWomanInHistory = 'Ada Lovelace';
+
+  const input = getByTestId('input');
+  fireEvent.changeText(input, famousWomanInHistory);
+
+  const button = getByText('Print Username');
+  fireEvent.press(button);
+
+  await wait(() => expect(queryByTestId('printed-username')).toBeTruthy());
+
+  expect(getByTestId('printed-username').props.children).toBe(famousWomanInHistory);
+  expect(baseElement).toMatchSnapshot();
+});
+```
diff --git a/website/versioned_docs/version-2.0.0/guide-disappearance.md b/website/versioned_docs/version-2.0.0/guide-disappearance.md
new file mode 100644
index 0000000..ce0f170
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/guide-disappearance.md
@@ -0,0 +1,69 @@
+---
+id: version-2.0.0-guide-disappearance
+title: Appearance and Disappearance
+original_id: guide-disappearance
+---
+
+`dom-testing-library` can utilize a fake DOM `MutationObserver` to look for changes, but we don't
+have that luxury in the native/test renderer environment. Since we don't have that, you should know
+that all `wait-*` utilities in this library offer roughly the same functionality, just with some
+added convenience.
+
+Since we can't "observe" a DOM, we just have to poll it at a given interval
+
+## Waiting for appearance
+
+If you need to wait for an element to appear, the [async wait utilities](api-async.md) allow you to
+wait for an assertion to be satisfied before proceeding. The wait utilities retry until the query
+passes or times out.
+
+```javascript
+test('movie title appears', async () => {
+  // element is initially not present...
+
+  // wait for appearance
+  await wait(() => {
+    // We don't have a handy assertion like they do in DOM land, so just check that it exists
+    expect(getByText('the lion king')).toBeTruthy();
+  });
+
+  // wait for appearance and return the element
+  const movie = await waitForElement(() => getByText('the lion king'));
+});
+```
+
+## Waiting for disappearance
+
+The `wait` [async helper](api-async.md) function retries until the wrapped function stops throwing
+an error. This can be used to assert that an element disappears from the page.
+
+```javascript
+test('movie title goes away', async () => {
+  // element is initially present...
+  // note use of queryBy instead of getBy to return null
+  // instead of throwing in the query itself
+  await wait(() => {
+    // We don't have a handy assertion like they do in DOM land, so just check that it doesn't exist
+    expect(queryByText('i, robot')).toBeFalsy();
+  });
+});
+```
+
+## Asserting elements are not present
+
+All `getBy` methods throw errors when they can't find their search, but `queryBy` methods don't. Any
+time you need to verify something isn't there, use `query`. Any time you need to verify something i
+there, use `get`.
+
+```javascript
+const submitButton = queryByText(testInstance, 'submit');
+expect(submitButton).toBeNull(); // it doesn't exist
+```
+
+The `queryAll` APIs version return an array of matching nodes. The length of the array can be useful
+for assertions after elements are added or removed from the DOM.
+
+```javascript
+const submitButtons = queryAllByText(container, 'submit');
+expect(submitButtons).toHaveLength(2); // expect 2 elements
+```
diff --git a/website/versioned_docs/version-2.0.0/guide-queries.md b/website/versioned_docs/version-2.0.0/guide-queries.md
new file mode 100644
index 0000000..b8e5d16
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/guide-queries.md
@@ -0,0 +1,115 @@
+---
+id: version-2.0.0-guide-queries
+title: How Should I Query?
+original_id: guide-queries
+---
+
+## Priority
+
+Whatever you do, try to make your tests resemble real use cases. You'll only be confident with your
+tests if they work the way your users do. With that in mind, we recommend this order of priority:
+
+1. **Queries Users Can Interact With**
+   1. [`getByA11yLabel`](api-queries#bya11ylabel): Your disabled users are counting on you, so this
+      should likely be everywhere for their sake 😉 use it often, and if you aren't, maybe ask
+      yourself why.
+   1. [`getByPlaceholder`](api-queries#byplaceholder): Great for targeting a `TextInput` element to
+      verify its content
+   1. [`getByText`](api-queries#bytext): Great for finding a `Button` or `Touchable` to fire an
+      event on
+   1. [`getByValue`](api-queries#byvalue): The user can see the value they type into a `TextInput`
+      or a checked `CheckBox` so this one is safe to use
+1. **Queries Users Can Infer**
+   1. [`getByA11yRole`](api-queries#bya11yrole): If your app screens have good hierarchy and single
+      focus, this may be a good option for finding your elements
+1. **Queries Users Don't Even Know About**
+   1. [`getByTestId`](api-queries#bytestid): The user cannot see (or hear) these, so this is only
+      recommended for cases where you can't match by text or it doesn't make sense
+
+## Manual Queries
+
+If you absolutely can't figure out another way to test the element you need to test, there is a very
+highly discouraged, poorly documented way to likely get what you're looking for. We understand that
+there are times when you need to test things that aren't related to the native bridged views, and
+sometimes things that can't be "seen" in any way need to be validated.
+
+Here is an example of such a case so that you're thinking in the right context. If you were to
+render a `<MaterialIcon />` from `react-native-vector-icons`, you provide a name prop which
+determines the icon to display to the user. Under the hood, `react-native-vector-icons` renders a
+`<Text />` component and passes a special symbol across the bridge, which a native counterpart
+module uses to translate to the vector icon you asked for by name. You can (and should) provide an
+`a11yLabel` and query by that, but for the sake of this example let's pretend like you can't. Here
+is what you can do in a case where you are **very** stuck and can't figure out what to do.
+
+```javascript
+// react-testing-library
+const { baseElement } = render(<MyComponent />);
+const icons = baseElement.findAll(node => node.props.name === 'menu');
+```
+
+We cannot stress enough that we _do not_ recommend that you do this. Your results will be
+unpredictable, and you will not be creating reliable tests. You're also wandering down the path of
+testing implementation details because your users do not, and won't ever, know about the shape of
+your props or care about whether or not those props are in the shape that only _you_ know about. You
+can use this API when you need it, but above all else please consider your users and remember the
+[guiding-principles](guiding-principles.md).
+
+### Addendum: why is this unpredictable?
+
+I'm so glad you asked! In the DOM, you don't "spread" props; you don't pass props to children at
+all. Attributes are "unique" to an element, and there's no concept of parent->child relationship in
+that regard. As we all know, that is not the case with React. Props are often spread or passed
+liberally without much consideration as to what gets "spread" or "passed" -- it's just so easy to
+do! We handled that problem in this library for you by only returning you the lowest level
+components that communicate to the native portion of the app -- spreading at that level tends to not
+be an issue.
+
+Let's look at a contrived example based on this idea of a `MaterialIcon`. Your rendered React tree
+might look like this:
+
+```javascript
+<MaterialIcon name="menu" accessibilityLabel="menu icon">
+  <Icon name="menu" accessibilityLabel="menu icon">
+    <Text accessibilityLabel="menu icon">???</Text>
+  </Icon>
+</MaterialIcon>
+```
+
+You can't know what a library does with their props, and it certainly doesn't matter to your users.
+All they care about is that they see a material design icon. So, if you do:
+
+```javascript
+baseElement.find(({ props }) => props.name === 'menu');
+
+// => [MaterialIcon, Icon]
+```
+
+This isn't right at all. Sure, you could do something like:
+
+```javascript
+const icon = baseElement.find(({ props }) => props.name === 'menu');
+
+icon[icon.length - 1];
+
+// => Icon
+```
+
+But I'm sure you can see now how wildly unpredictable and confusing this can turn out to be. If
+instead you do:
+
+```javascript
+queryAllByA11yLabel('menu icon');
+
+// => [Text]
+```
+
+This is the element your user will see, this is the element you should assert against. Do your best
+to always assert on this element. How can you know what components bridged to native?
+
+```javascript
+const { debug } = render(<MyComponent />);
+
+debug();
+```
+
+This is how ☺️ debug will always only show you the elements in the tree that bridge to native.
diff --git a/website/versioned_docs/version-2.0.0/guiding-principles.md b/website/versioned_docs/version-2.0.0/guiding-principles.md
new file mode 100644
index 0000000..59078a0
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/guiding-principles.md
@@ -0,0 +1,25 @@
+---
+id: version-2.0.0-guiding-principles
+title: Guiding Principles
+sidebar_label: Guiding Principles
+original_id: guiding-principles
+---
+
+> [The more your tests resemble the way your software is used, the more confidence they can give you.](https://twitter.com/kentcdodds/status/977018512689455106)
+
+We try to only expose methods and utilities that encourage you to write tests that closely resemble
+how your apps are used.
+
+Utilities are included in this project based on the following guiding principles:
+
+1.  If it relates to rendering components, it deals with native views rather than component
+    instances, nor should it encourage dealing with component instances.
+2.  It should be generally useful for testing the application components in the way the user would
+    use it. We are making some trade-offs here because we're using a computer and often a simulated
+    environment, but in general, utilities should encourage tests that use the components the way
+    they're intended to be used.
+3.  Utility implementations and APIs should be simple and flexible.
+
+In summary, we believe in the principles of `testing-library`, and adhere to them as closely as
+possible. At the end of the day, what we want is for this library to be pretty light-weight, simple,
+and understandable.
diff --git a/docs/hook-example-async.md b/website/versioned_docs/version-2.0.0/hook-example-async.md
similarity index 95%
rename from docs/hook-example-async.md
rename to website/versioned_docs/version-2.0.0/hook-example-async.md
index 2706437..3d7e80b 100644
--- a/docs/hook-example-async.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-async.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-async
+id: version-2.0.0-hook-example-async
 title: Async Hook
 sidebar_label: Async Hook
+original_id: hook-example-async
 ---
 
 ```javascript
diff --git a/docs/hook-example-custom.md b/website/versioned_docs/version-2.0.0/hook-example-custom.md
similarity index 94%
rename from docs/hook-example-custom.md
rename to website/versioned_docs/version-2.0.0/hook-example-custom.md
index ae54824..3beea21 100644
--- a/docs/hook-example-custom.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-custom.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-async
+id: version-2.0.0-hook-example-async
 title: Custom Hook
 sidebar_label: Custom Hook
+original_id: hook-example-async
 ---
 
 ```javascript
diff --git a/docs/hook-example-error.md b/website/versioned_docs/version-2.0.0/hook-example-error.md
similarity index 97%
rename from docs/hook-example-error.md
rename to website/versioned_docs/version-2.0.0/hook-example-error.md
index ffba02a..790fb28 100644
--- a/docs/hook-example-error.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-error.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-error
+id: version-2.0.0-hook-example-error
 title: Error Hook
 sidebar_label: Error Hook
+original_id: hook-example-error
 ---
 
 ```javascript
diff --git a/docs/hook-example-test.md b/website/versioned_docs/version-2.0.0/hook-example-test.md
similarity index 96%
rename from docs/hook-example-test.md
rename to website/versioned_docs/version-2.0.0/hook-example-test.md
index 881c7f8..22f653e 100644
--- a/docs/hook-example-test.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-test.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-test
+id: version-2.0.0-hook-example-test
 title: Test Hook
 sidebar_label: Test Hook
+original_id: hook-example-test
 ---
 
 ```javascript
diff --git a/docs/hook-example-use-context.md b/website/versioned_docs/version-2.0.0/hook-example-use-context.md
similarity index 93%
rename from docs/hook-example-use-context.md
rename to website/versioned_docs/version-2.0.0/hook-example-use-context.md
index a1312ac..64b7a16 100644
--- a/docs/hook-example-use-context.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-use-context.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-use-context
+id: version-2.0.0-hook-example-use-context
 title: useContext Hook
 sidebar_label: useContext Hook
+original_id: hook-example-use-context
 ---
 
 ```javascript
diff --git a/docs/hook-example-use-effect.md b/website/versioned_docs/version-2.0.0/hook-example-use-effect.md
similarity index 94%
rename from docs/hook-example-use-effect.md
rename to website/versioned_docs/version-2.0.0/hook-example-use-effect.md
index f37ede5..e6bb842 100644
--- a/docs/hook-example-use-effect.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-use-effect.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-use-effect
+id: version-2.0.0-hook-example-use-effect
 title: useEffect Hook
 sidebar_label: useEffect Hook
+original_id: hook-example-use-effect
 ---
 
 ```javascript
diff --git a/docs/hook-example-use-memo.md b/website/versioned_docs/version-2.0.0/hook-example-use-memo.md
similarity index 94%
rename from docs/hook-example-use-memo.md
rename to website/versioned_docs/version-2.0.0/hook-example-use-memo.md
index ada1c32..b16ce36 100644
--- a/docs/hook-example-use-memo.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-use-memo.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-use-memo
+id: version-2.0.0-hook-example-use-memo
 title: useMemo Hook
 sidebar_label: useMemo Hook
+original_id: hook-example-use-memo
 ---
 
 ```javascript
diff --git a/docs/hook-example-use-reducer.md b/website/versioned_docs/version-2.0.0/hook-example-use-reducer.md
similarity index 86%
rename from docs/hook-example-use-reducer.md
rename to website/versioned_docs/version-2.0.0/hook-example-use-reducer.md
index be60e7c..0489e8f 100644
--- a/docs/hook-example-use-reducer.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-use-reducer.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-use-reducer
+id: version-2.0.0-hook-example-use-reducer
 title: useReducer Hook
 sidebar_label: useReducer Hook
+original_id: hook-example-use-reducer
 ---
 
 ```javascript
diff --git a/docs/hook-example-use-ref.md b/website/versioned_docs/version-2.0.0/hook-example-use-ref.md
similarity index 91%
rename from docs/hook-example-use-ref.md
rename to website/versioned_docs/version-2.0.0/hook-example-use-ref.md
index 06b1bb1..3a86b51 100644
--- a/docs/hook-example-use-ref.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-use-ref.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-use-ref
+id: version-2.0.0-hook-example-use-ref
 title: useRef Hook
 sidebar_label: useRef Hook
+original_id: hook-example-use-ref
 ---
 
 ```javascript
diff --git a/docs/hook-example-use-state.md b/website/versioned_docs/version-2.0.0/hook-example-use-state.md
similarity index 88%
rename from docs/hook-example-use-state.md
rename to website/versioned_docs/version-2.0.0/hook-example-use-state.md
index 72fb56f..6155c7f 100644
--- a/docs/hook-example-use-state.md
+++ b/website/versioned_docs/version-2.0.0/hook-example-use-state.md
@@ -1,7 +1,8 @@
 ---
-id: hook-example-useState
+id: version-2.0.0-hook-example-useState
 title: useState Hook
 sidebar_label: useState Hook
+original_id: hook-example-useState
 ---
 
 ```javascript
diff --git a/website/versioned_docs/version-2.0.0/install.md b/website/versioned_docs/version-2.0.0/install.md
new file mode 100644
index 0000000..c1efbd2
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/install.md
@@ -0,0 +1,26 @@
+---
+id: version-2.0.0-install
+title: Install
+sidebar_label: Install
+original_id: install
+---
+
+This module should be installed in your project's `devDependencies`:
+
+```
+npm install --save-dev native-testing-library
+```
+
+You will need `react` and `react-native` installed as _dependencies_ in order to run this project.
+
+## Exports
+
+You will likely be able to import everything you'll need from the project entry point like this:
+
+```js
+import { render } from 'native-testing-library';
+```
+
+The library's tests run in Node 8-11 before all new versions are published, and all files are
+processed through Babel. Typings are not provided, although we would be happy to accept a PR to add
+them! ☺️
diff --git a/website/versioned_docs/version-2.0.0/intro.md b/website/versioned_docs/version-2.0.0/intro.md
new file mode 100644
index 0000000..b4bfb71
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/intro.md
@@ -0,0 +1,47 @@
+---
+id: version-2.0.0-intro
+title: Introduction
+sidebar_label: Intro
+original_id: intro
+---
+
+## The problem
+
+You want to write maintainable tests for your React Native application. You love Kent Dodds'
+[testing library](https://testing-library.com), and you want to be able to write maintainable tests
+for your React Native application. You don't want to use a library that renders components to a fake
+DOM, and you've had a hard time finding what you need to write tests using that philosophy in React
+Native.
+
+## This solution
+
+`native-testing-library` is an implementation of the well-known `testing-library` API that works for
+React Native. The primary goal is to mimic the testing library API as closely as possible while
+still accounting for the differences in the platforms. Accomplishing this is no small feat because
+of the differences between the two platforms. Although most framework implementations like
+`react-testing-library` are thin layers over [dom-testing-library](https://testing-library.com),
+this library needed to have its own base implementation as well as a user-facing API. This library
+uses the [react-test-renderer](https://reactjs.org/docs/test-renderer.html), whereas
+`dom-testing-library` uses JSDOM. The main philosophy here is that you should find elements on the
+"screen" the way users would. This approach is meant to give you confidence that your app is working
+as a cohesive unit. Just like the `dom-testing-library`, `native-testing-library`'s primary guiding
+principle is:
+
+> [The more your tests resemble the way your software is used, the more confidence they can give you.](guiding-principles.md)
+
+This library gives you the tools you need to find things in your application the way your users
+would. You can do things like find elements by text, input value, and accessibility labels -- the
+types of things your users can see. We also give you the ability to search for elements by `testID`,
+but you should consider it a last resort because users can't see a testID and it can introduce
+unpredictable behavior in your tests.
+
+It will also encourage you to build more accessible apps. For example, your users can't see your
+icon touchable that doesn't have an accessibility label, so neither can your tests. We believe that
+writing good tests using this library will force you to give more consideration to whether what
+you're doing is an accessible experience for all of your users.
+
+This library should, in theory, work with any any testing framework like Jest or Mocha, but we do
+recommend you use Jest with the `react-native` Jest preset. We have not tested it in any other
+environment, and likely won't be able to support usage with another library.
+
+[jest]: https://jestjs.io
diff --git a/website/versioned_docs/version-2.0.0/setup.md b/website/versioned_docs/version-2.0.0/setup.md
new file mode 100644
index 0000000..86f9312
--- /dev/null
+++ b/website/versioned_docs/version-2.0.0/setup.md
@@ -0,0 +1,84 @@
+---
+id: version-2.0.0-setup
+title: Setup
+sidebar_label: Setup
+original_id: setup
+---
+
+## Setting up your project
+
+`native-testing-library` should work out of the box for simple tests. Most of the snippets you'll
+find throughout the website should work without any additional configuration assuming you're using
+Jest and a moderately recent version of React Native.
+
+We do strongly encourage you to use Jest with the `react-native` preset. In addition, there may be
+some additional mocks you would want to provide to allow for a smoother testing experience, (for
+example mocks for `react-native-gesture-handler`).
+
+## Custom Render
+
+It's often useful to define a custom render method that includes things like global context
+providers, data stores, etc. To make this available globally, one approach is to define a utility
+file that re-exports everything from `native-testing-library`. You can replace
+`native-testing-library` with this file in all your imports. See
+[below](#configuring-jest-with-test-utils) for a way to make your test util file accessible without
+using relative paths.
+
+The example below sets up data providers using the [`wrapper`](api-render.md#render-options) option
+to `render`.
+
+```diff
+// my-component.test.js
+- import { render, fireEvent } from 'native-testing-library';
++ import { render, fireEvent } from '../test-utils';
+```
+
+```js
+// test-utils.js
+import { render } from 'native-testing-library';
+import { ThemeProvider } from 'my-ui-lib';
+import { TranslationProvider } from 'my-i18n-lib';
+import defaultStrings from 'i18n/en-x-default';
+
+const AllTheProviders = ({ children }) => {
+  return (
+    <ThemeProvider theme="light">
+      <TranslationProvider messages={defaultStrings}>{children}</TranslationProvider>
+    </ThemeProvider>
+  );
+};
+
+const customRender = (ui, options) => render(ui, { wrapper: AllTheProviders, ...options });
+
+// re-export everything
+export * from 'native-testing-library';
+
+// override render method
+export { customRender as render };
+```
+
+### Configuring Jest with Test Utils
+
+To make your custom test file accessible in your Jest test files without using relative imports
+(`../../test-utils`), add the folder containing the file to the Jest `moduleDirectories` option.
+
+This will make all the `.js` files in the test-utils directory importable without `../`.
+
+```diff
+// my-component.test.js
+- import { render, fireEvent } from '../test-utils';
++ import { render, fireEvent } from 'test-utils';
+```
+
+```diff
+// jest.config.js
+module.exports = {
+  moduleDirectories: [
+    'node_modules',
++   // add the directory with the test-utils.js file, for example:
++   'utils', // a utility folder
++    __dirname, // the root directory
+  ],
+  // ... other options ...
+}
+```
diff --git a/website/versioned_docs/version-3.0.0/api-act.md b/website/versioned_docs/version-3.0.0/api-act.md
new file mode 100644
index 0000000..13ce9c8
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-act.md
@@ -0,0 +1,13 @@
+---
+id: version-3.0.0-api-act
+title: Act
+sidebar_label: Act
+original_id: api-act
+---
+
+## `act`
+
+This is a light wrapper around the
+[`react-test-renderer` `act` function](https://reactjs.org/docs/test-renderer.html).
+All it does is forward all arguments to the act function if your version of
+react supports `act`.
diff --git a/website/versioned_docs/version-3.0.0/api-async.md b/website/versioned_docs/version-3.0.0/api-async.md
new file mode 100644
index 0000000..7d69926
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-async.md
@@ -0,0 +1,112 @@
+---
+id: version-3.0.0-api-async
+title: Async Utilities
+sidebar_label: Async Utilities
+original_id: api-async
+---
+
+Several utilities are provided for dealing with asynchronous code. These can be useful to wait for
+an element to appear or disappear in response to an action. (See the
+[guide to testing disappearance](guide-disappearance.md).)
+
+## `wait`
+
+```typescript
+function wait(
+  callback?: () => void,
+  options?: {
+    timeout?: number;
+    interval?: number;
+  },
+): Promise<void>;
+```
+
+When in need to wait for non-deterministic periods of time you can use `wait`, to wait for your
+expectations to pass. The `wait` function is a small wrapper around the
+[`wait-for-expect`](https://github.com/TheBrainFamily/wait-for-expect) module. Here's a simple
+example:
+
+```javascript
+await wait(() => getByLabelText('username'));
+getByLabelText('username').value = 'chucknorris';
+```
+
+This can be useful if you have a unit test that mocks API calls and you need to wait for your mock
+promises to all resolve.
+
+The default `callback` is a no-op function (used like `await wait()`). This can be helpful if you
+only need to wait for one tick of the event loop (in the case of mocked API calls with promises that
+resolve immediately).
+
+The default `timeout` is `4500ms` which will keep you under
+[Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
+
+The default `interval` is `50ms`. However it will run your callback immediately on the next tick of
+the event loop (in a `setTimeout`) before starting the intervals.
+
+## `waitForElement`
+
+```typescript
+function waitForElement<T>(
+  callback: () => T,
+  options?: {
+    timeout?: number;
+    interval?: number;
+  },
+): Promise<T>;
+```
+
+When you need to wait for elements to appear, you can use `waitForElement`. The `waitForElement`
+function is a similar to `wait`, but is specifically intended to wait for an element to appear.
+Additionally, the result is returned for you to use.
+
+Here's a simple example:
+
+```javascript
+const usernameElement = await waitForElement(() => getByLabelText('username'));
+expect(usernameElement).toHaveTextContent('chucknorris');
+```
+
+You can also wait for multiple elements at once:
+
+```javascript
+const [usernameElement, passwordElement] = await waitForElement(() => [
+  getByLabelText('username'),
+  getByLabelText('password'),
+]);
+```
+
+The default `timeout` is `4500ms` which will keep you under
+[Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
+
+The default `interval` is `50ms`. However it will run your callback immediately on the next tick of
+the event loop (in a `setTimeout`) before starting the intervals.
+
+## `waitForElementToBeRemoved`
+
+```typescript
+function waitForElementToBeRemoved<T>(
+  callback: () => T,
+  options?: {
+    timeout?: number;
+    interval?: number;
+  },
+): Promise<T>;
+```
+
+When you need to wait for elements to be removed, or you can use `waitForElementToBeRemoved`. The
+`waitForElementToBeRemoved` function is a similar to `wait`, but is a helper specifically intended
+to wait for an element to be removed from the tree. Similarly to `waitForElement` the result of the
+callback is returned as a Promise, but in most cases you won't need it.
+
+Here's a simple example:
+
+```javascript
+await waitForElementToBeRemoved(() => queryAllByLabelText('list-item'));
+```
+
+The default `timeout` is `4500ms` which will keep you under
+[Jest's default timeout of `5000ms`](https://facebook.github.io/jest/docs/en/jest-object.html#jestsettimeouttimeout).
+
+The default `interval` is `50ms`. However it will run your callback immediately on the next tick of
+the event loop (in a `setTimeout`) before starting the intervals.
diff --git a/website/versioned_docs/version-3.0.0/api-events.md b/website/versioned_docs/version-3.0.0/api-events.md
new file mode 100644
index 0000000..13df3a7
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-events.md
@@ -0,0 +1,57 @@
+---
+id: version-3.0.0-api-events
+title: Firing Events
+sidebar_label: Firing Events
+original_id: api-events
+---
+
+## Basic example
+
+```javascript
+import { fireEvent, NativeTestEvent, render } from 'native-testing-library';
+
+const { getByText } = render(<Button title="Submit" />);
+fireEvent(getByText(container, 'Submit'), new NativeTestEvent('press'));
+```
+
+## `fireEvent[eventName]`
+
+```typescript
+fireEvent[eventName](node: FiberRoot, eventProperties: NativeTestEvent)
+```
+
+Convenience methods for firing events. Check out
+[src/events.js](https://github.com/testing-library/native-testing-library/blob/master/src/events.js)
+for a full list as well as `validTargets` for every event type.
+
+```javascript
+import { fireEvent, render } from 'native-testing-library';
+
+const { getByText } = render(<Button title="Submit" />);
+fireEvent.press(getByText('Submit'));
+```
+
+**nativeEvent**: React Native tends to put everything relevant to their built-in events on an object
+called nativeEvent. When you fire an event using this library, you will have to build a mock event
+config. You will use this particularly for events like a change event:
+
+```javascript
+fireEvent.change(getByLabelText(/username/i), { nativeEvent: { text: 'a' } });
+```
+
+**changeText**: `Text` has a method for value updating called `onChangeText`. Since this is such a
+commonly used method, there is a special case in the library for this method.
+
+```javascript
+fireEvent.changeText(getByLabelText(/username/i), 'a');
+```
+
+**customEvent**: You may be using a library that has custom event listeners that you want to be able
+to fire. This is how you would fire one of these events:
+
+```javascript
+fireEvent(
+  getByTestId('swiper'),
+  new NativeTestEvent('myEvent', { nativeEvent: { value: 'testing' } }),
+);
+```
diff --git a/website/versioned_docs/version-3.0.0/api-helpers.md b/website/versioned_docs/version-3.0.0/api-helpers.md
new file mode 100644
index 0000000..dacdbb4
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-helpers.md
@@ -0,0 +1,155 @@
+---
+id: version-3.0.0-api-helpers
+title: Helpers
+sidebar_label: Helpers
+original_id: api-helpers
+---
+
+## Custom Queries
+
+`native-testing-library` exposes some of the helper functions that are used to implement the default
+queries. You can use the helpers to build custom queries. For example, the code below shows a way to
+query your TestInstance by a `style` prop. Note: test files would need to now import `test-utils.js`
+instead of using `native-testing-library` directly. Also note, please never actually implement this
+helper, it's just an example of what's possible.
+
+```javascript
+// test-utils.js
+import * as nativeTestingLib from 'native-testing-library';
+
+const { queryHelpers } = nativeTestingLib;
+
+export const queryByStyle = queryHelpers.queryByProp.bind(null, 'style');
+export const queryAllByStyle = queryHelpers.queryByProp.bind(null, 'style');
+
+export function getAllByStyle(container, styles, ...rest) {
+  const els = queryAllByStyle(container, styles, ...rest);
+  if (!els.length) {
+    throw getElementError(`Unable to find an element by style="${styles}"`, container);
+  }
+  return els;
+}
+
+export function getByStyle(...args) {
+  return queryHelpers.firstResultOrNull(getAllByStyle, ...args);
+}
+
+// re-export with overrides
+export {
+  ...nativeTestingLib,
+  getByStyle,
+  getAllByStyle,
+  queryByStyle,
+  queryAllByStyle,
+};
+```
+
+> **Note**
+>
+> Custom queries can be added to the `render` method by adding `queries` to the options config
+> object. See the render [options](/docs/api-render#render-options).
+
+## `getNodeText`
+
+```typescript
+getNodeText(node: React.ReactElement<any>)
+```
+
+Returns the complete text content of an element, removing any extra whitespace, and joining children
+that are an array. The intention is to treat text in nodes exactly as how it is perceived by users
+in a browser, where any extra whitespace within words in the html code is not meaningful when the
+text is rendered, and all text appears as one cohesive string regardless of the code.
+
+```javascript
+getNodeText(
+  <Text>
+    {`
+    Hello
+      World  !
+    `}
+  </Text>,
+); // "Hello World !"
+```
+
+## `within` and `getQueriesForElement` APIs
+
+`within` (an alias to `getQueriesForElement`) takes a `NativeTestInstance` and binds it to the raw
+query functions, allowing them to be used without manually specifying a container.
+
+Example: To get the username input of a login form within a `<LoginModal />`, you could do:
+
+```js
+import { render, within } from 'native-testing-library';
+
+const { getByLabelText } = render(<LoginModal />);
+const loginForm = getByLabelText('login-form');
+
+within(loginForm).getByPlaceholderText('Username');
+```
+
+## Debugging
+
+When you use any `get` calls in your test cases, the current contents of the `baseElement` get
+printed on the console. For example:
+
+```javascript
+// <Text>Hello world</Text>
+getByText('Goodbye world'); // will fail by throwing error
+```
+
+The above test case will fail, however it prints the state of your React tree being tested, so you
+will get to see:
+
+```
+Unable to find an element with the text: Goodbye world. This could be because the text is broken up by multiple elements. In this case, you can provide a function for your text matcher to make your matcher more flexible.
+Here is the state of your container:
+<Text>
+  Hello World!
+</Text>
+```
+
+Note: Since the debug size can get really large, you can set the limit of debug content to be
+printed via environment variable `DEBUG_PRINT_LIMIT`. The default value is `7000`. You will see
+`...` in the console, when the debug content is stripped off, because of the length you have set or
+due to default size limit. Here's how you might increase this limit when running tests:
+
+```
+DEBUG_PRINT_LIMIT=10000 npm test
+```
+
+This works on macOS/linux, you'll need to do something else for windows. If you'd like a solution
+that works for both, see [`cross-env`](https://www.npmjs.com/package/cross-env)
+
+### `prettyPrint`
+
+This helper function can be used to print out readable representation of the React tree of a node.
+This can be helpful for instance when debugging tests.
+
+It is defined as:
+
+```typescript
+function prettyPrint(node: React.ReactElement<any>, maxLength?: number): string;
+```
+
+It receives the root node to print out, and an optional extra argument to limit the size of the
+resulting string, for cases when it becomes too large.
+
+This function is usually used alongside `console.log` to temporarily print out React trees during
+tests for debugging purposes:
+
+```javascript
+console.log(
+  prettyPrint(
+    <View>
+      <Text>hi</Text>
+    </View>,
+  ),
+);
+// <View>
+//   <Text>
+//     Hi
+//   </Text>
+// </View>
+```
+
+This function is what also powers [the automatic debugging output described above](#debugging).
diff --git a/website/versioned_docs/version-3.0.0/api-main.md b/website/versioned_docs/version-3.0.0/api-main.md
new file mode 100644
index 0000000..93ee4bc
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-main.md
@@ -0,0 +1,181 @@
+---
+id: version-3.0.0-api-main
+title: Main
+sidebar_label: Main
+original_id: api-main
+---
+
+## `render`
+
+```typescript
+function render(
+  ui: React.ReactElement<any>,
+  options?: {
+    /* You won't often use this, expand below for docs on options */
+  },
+): RenderResult;
+```
+
+Create a `NativeTestInstance`.
+
+```jsx
+import { render } from 'native-testing-library';
+
+render(<View />);
+```
+
+```javascript
+import { render, toJSON } from 'native-testing-library';
+
+test('renders a message', () => {
+  const { container, getByText } = render(<Text>Hello, World!</Text>);
+  expect(getByText('Hello, world!')).toBeTruthy();
+  expect(toJSON(container)).toMatchInlineSnapshot(`
+<View
+  testID="ntl-container"
+>
+  <Text>Hello, World!</Text>
+</View>
+  `);
+});
+```
+
+## `render` Options
+
+Most of the time you won't need to pass any options to `render`, but when you do, you will pass them
+as the second parameter. There are some important key differences between this and
+`react-testing-library` that you will want to be aware of.
+
+### `wrapper`
+
+Pass a React Component as the `wrapper` option to have it rendered around the inner element. This is
+most useful for creating reusable custom render functions for common data providers. See
+[setup](setup.md#custom-render) for examples.
+
+### `queries`
+
+Queries to bind. Overrides the default set from `native-testing-library` unless merged.
+
+```js
+// Example, a function to traverse table contents
+import * as tableQueries from 'my-table-query-libary';
+import queries from 'native-testing-library';
+
+const { getByRowColumn, getByText } = render(<MyTable />, {
+  queries: { ...queries, ...tableQueries },
+});
+```
+
+See [helpers](api-helpers.md) for guidance on using utility functions to create custom queries.
+
+Custom queries can also be added globally by following the
+[custom render guide](setup.md#custom-render).
+
+## `render` Result
+
+The `render` method returns an object that has a few properties:
+
+### `...queries`
+
+The most important feature of `render` is that the [default queries](api-queries.md) are
+automatically returned with their first argument bound to the `baseElement`.
+
+**Example**
+
+```javascript
+const { getByText, getByTestId /* etc */ } = render(<Component />);
+```
+
+### `container`
+
+`native-testing-library` will create a View to wrap your react component passed to render. This
+ensures that there is always a single child passed to the `AppContainer` component.
+
+### `baseElement`
+
+This is the root element of your render result. This element is an `AppContainer` from
+`react-native`, and it appears as two nested `Views` at the root of your render.
+
+### `debug`
+
+This method is a shortcut for `console.log(prettyPrint(toJSON(baseElement)))`.
+
+```javascript
+import { render } from 'native-testing-library';
+
+const { debug } = render(
+  <View>
+    <Text>Hello World</Text>
+  </View>,
+);
+debug();
+// <View>
+//   <Text>
+//     Hello World
+//   </Text>
+// </View>
+// you can also pass an element: debug(getByText('Hello World'))
+```
+
+This is a simple wrapper around `prettyPrint` which is also exported.
+
+### `rerender`
+
+Although its likely better to test updating your props the way a user would (through events and
+interaction), this method will allow you to re-render your entire tree at the base with new props.
+
+```jsx
+import { render } from 'native-testing-library';
+
+const { rerender } = render(<NumberDisplay number={1} />);
+
+// re-render the same component with different props
+rerender(<NumberDisplay number={2} />);
+```
+
+[See the examples page](example-update-props.md)
+
+### `unmount`
+
+This will cause the rendered component to be unmounted. This is useful for testing what happens when
+your component is removed from the page (like testing that you don't leave event handlers hanging
+around causing memory leaks).
+
+> This method is a wrapper around ReactTestRenderer.unmount()
+
+```javascript
+import { render } from 'native-testing-library';
+
+const { unmount } = render(<Login />);
+unmount();
+```
+
+---
+
+## `cleanup`
+
+Unmounts React trees that were mounted with [render](#render).
+
+```jsx
+import { cleanup, render } from 'native-testing-library';
+
+afterEach(cleanup); // <-- add this
+
+test('renders into document', () => {
+  render(<View />);
+  // ...
+});
+
+// ... more tests ...
+```
+
+**If you don't want to add this to _every single test file_** then we recommend that you configure
+your test framework to run a file before your tests which does this automatically.
+
+---
+
+## `act`
+
+This is a light wrapper around the
+[`react-test-renderer` `act` function](https://reactjs.org/docs/test-renderer.html). All it does is
+forward all arguments to the act function if your version of react supports `act`.
diff --git a/website/versioned_docs/version-3.0.0/api-queries.md b/website/versioned_docs/version-3.0.0/api-queries.md
new file mode 100644
index 0000000..98319eb
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-queries.md
@@ -0,0 +1,394 @@
+---
+id: version-3.0.0-api-queries
+title: Queries
+sidebar_label: Queries
+original_id: api-queries
+---
+
+## Variants
+
+> `getBy` queries are shown by default in the [query documentation](#queries) below.
+
+### getBy
+
+`getBy*` queries returns the first matching node for a query, and throws an error if no elements
+match or if more than one match is found (use `getAllBy` instead).
+
+### getAllBy
+
+`getAllBy*` queries return an array of all matching nodes for a query, and throws an error if no
+elements match.
+
+### queryBy
+
+`queryBy*` queries returns the first matching node for a query, and return `null` if no elements
+match. This is useful for asserting an element is not present. This throws if more than one match is
+found (use `queryAllBy` instead)..
+
+### queryAllBy
+
+`queryAllBy*` queries return an array of all matching nodes for a query, and return an empty array
+(`[]`) if no elements match.
+
+### findBy
+
+`findBy*` queries return a promise which resolves when an element is found which matches the given
+query. The promise is rejected if no element is found or if more than one element is found after a
+default timeout of `4500`ms. If you need to find more than one element, then use `findAllBy`.
+
+> Note, this is a simple combination of `getBy*` queries and
+> [`waitForElement`](/docs/api-async#waitforelement). The `findBy*` queries accept the
+> `waitForElement` options as the last argument. (i.e.
+> `findByText(container, 'text', queryOptions, waitForElementOptions)`)
+
+### findAllBy
+
+`findAllBy*` queries return a promise which resolves to an array of elements when any elements are
+found which match the given query. The promise is rejected if no elements are found after a default
+timeout of `4500`ms.
+
+## Options
+
+The argument to a query can be a _string_, _regular expression_, or _function_. There are also
+options to adjust how node text is parsed.
+
+See [TextMatch](#textmatch) for documentation on what can be passed to a query.
+
+## Queries
+
+### `ByHintText`
+
+> getByHintText, queryByHintText, getAllByHintText, queryAllByHintText, findByHintText,
+> findAllByHintText
+
+```typescript
+getByHintText(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
+```
+
+This will search for all elements with an `accessibilityHint` prop and find one that matches the
+given [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'react-testing-library';
+
+const { getByHintText } = render(<View accessibilityHint="summary" />);
+
+getByHintText('summary'); // returns the View node
+```
+
+### `ByLabelText`
+
+> getByLabelText, queryByLabelText, getAllByLabelText, queryAllByLabelText findByLabelText,
+> findAllByLabelText
+
+```typescript
+getByLabelText(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
+```
+
+This will search for all elements with an `accessibilityLabel` prop and find one that matches the
+given [`TextMatch`](#textmatch).
+
+```js
+function Login({ onPress }) {
+  return (
+    <View accessibilityLabel="login-form">
+      <Text>Login</Text>
+      <TextInput accessibilityLabel="username" />
+      <TextInput accessibilityLabel="password" />
+      <Button title="Login" onPress={onPress} />
+    </View>
+  );
+}
+
+import { render } from 'native-testing-library';
+
+const { getByLabelText } = render(<Login onPress={jest.fn()} />);
+
+getByLabelText('username'); // returns the TextInput node
+```
+
+### `ByRole`
+
+> getByRole, queryByRole, getAllByRole, queryAllByRole, findByRole, findAllByRole
+
+```typescript
+getByRole(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    selector?: SelectorFn,
+  }): NativeTestInstance
+```
+
+This will search for all elements with an `accessibilityRole` prop and find one that matches the
+given [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'react-testing-library';
+
+const { getByRole } = render(<View accessibilityRole="summary" />);
+
+getByRole('summary'); // returns the View node
+```
+
+> `ByRole` queries will fall back to searching for elements with an `accessibilityTraits` match, but
+> they will log a warning on all matches that this prop is being deprecated by react-native.
+
+### `ByPlaceholderText`
+
+> getByPlaceholderText, queryByPlaceholderText, getAllByPlaceholderText, queryAllByPlaceholderText,
+> findByPlaceholderText, findAllByPlaceholderText
+
+```typescript
+getByPlaceholderText(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
+```
+
+This will search for all elements with a `placeholder` prop and find one that matches the given
+[`TextMatch`](#textmatch).
+
+```javascript
+import { render } from 'native-testing-library';
+
+const { getByPlaceholderText } = render(<TextInput placeholder="Username" />);
+
+getByPlaceholderText('Username'); // returns the TextInput node
+```
+
+### `ByText`
+
+> getByText, queryByText, getAllByText, queryAllByText, findByText, findAllByText
+
+```typescript
+getByText(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
+```
+
+This will search for all elements of type `Text` with `props.children` matching the given. It will
+also search for `Button` elements by their `title` [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByText } = render(<Text>About ℹ</Text>);
+
+getByText(/about/i); // returns the Text node
+```
+
+### `ByTitle`
+
+> getByTitle, queryByTitle, getAllByTitle, queryAllByTitle, findByTitle, findAllByTitle
+
+```typescript
+getByTitle(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
+```
+
+This will search for all `Button` or `RefreshControl` elements with `props.title` matching the given
+by their value [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByTitle } = render(<Button title="About" />);
+
+getByTitle(/about/i); // returns the Button node
+```
+
+### `ByDisplayValue`
+
+> getByDisplayValue, queryByDisplayValue, getAllByDisplayValue, queryAllByDisplayValue,
+> findByDisplayValue, findAllByDisplayValue
+
+```typescript
+getByDisplayValue(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    exact?: boolean = true,
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NormalizerOptions
+```
+
+This will search for all `TextInput` elements with a `value` prop and `Picker` or `Switch` elements
+with a `selectedValue` prop and find ones that matches the given [`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByDisplayValue } = render(<Input value="About ℹ" onChangeText={() => ({})} />);
+
+getByDisplayValue(/about/i); // returns the Input node
+```
+
+### `ByTestId`
+
+> getByTestId, queryByTestId, getAllByTestId, queryAllByTestId, findByTestId, findAllByTestId
+
+```typescript
+getByTestId(
+  container: NativeTestInstance,
+  match: TextMatch,
+  options?: {
+    trim?: boolean = true,
+    collapseWhitespace?: boolean = true,
+    exact?: boolean = true,
+    selector?: SelectorFn,
+    normalizer?: NormalizerFn,
+  }): NativeTestInstance
+```
+
+This will search for all elements with a `testID` and find one that matches the given
+[`TextMatch`](#textmatch).
+
+```js
+import { render } from 'native-testing-library';
+
+const { getByTestId } = render(<Text testID="test">hi there</Text>);
+
+getByTestId('test'); // returns the Text node
+```
+
+> Because your users can't see testIDs [the guiding principles](#guiding-principles), please only
+> use this as a last resort. Users don't interact with testIDs, and can lead to unpredictable
+> behavior. For example, internal React Native components sometimes spread testIds down to child
+> components. This means that if you query all by testId, you may get significantly more results
+> than you anticipate which will lead to unpredictable tests.
+
+## `TextMatch`
+
+Several APIs accept a `TextMatch` which can be a `string`, `regex` or a `function` which returns
+`true` for a match and `false` for a mismatch.
+
+### Precision
+
+Some APIs accept an object as the final argument that can contain options that affect the precision
+of string matching:
+
+- `exact`: Defaults to `true`; matches full strings, case-sensitive. When false, matches substrings
+  and is not case-sensitive.
+  - `exact` has no effect on `regex` or `function` arguments.
+  - In most cases using a regex instead of a string gives you more control over fuzzy matching and
+    should be preferred over `{ exact: false }`.
+- `normalizer`: An optional function which overrides normalization behavior. See
+  [`Normalization`](#normalization).
+
+### Normalization
+
+Before running any matching logic against text, `native-testing-library` automatically normalizes
+that text. By default, normalization consists of trimming whitespace from the start and end of text,
+and collapsing multiple adjacent whitespace characters into a single space.
+
+If you want to prevent that normalization, or provide alternative normalization (e.g. to remove
+Unicode control characters), you can provide a `normalizer` function in the options object. This
+function will be given a string and is expected to return a normalized version of that string.
+
+Note: Specifying a value for `normalizer` _replaces_ the built-in normalization, but you can call
+`getDefaultNormalizer` to obtain a built-in normalizer, either to adjust that normalization or to
+call it from your own normalizer.
+
+`getDefaultNormalizer` takes an options object which allows the selection of behaviour:
+
+- `trim`: Defaults to `true`. Trims leading and trailing whitespace
+- `collapseWhitespace`: Defaults to `true`. Collapses inner whitespace (newlines, tabs, repeated
+  spaces) into a single space.
+
+#### Normalization Examples
+
+To perform a match against text without trimming:
+
+```javascript
+getByText(node, 'text', {
+  normalizer: getDefaultNormalizer({ trim: false }),
+});
+```
+
+To override normalization to remove some Unicode characters whilst keeping some (but not all) of the
+built-in normalization behavior:
+
+```javascript
+getByText(node, 'text', {
+  normalizer: str => getDefaultNormalizer({ trim: false })(str).replace(/[\u200E-\u200F]*/g, ''),
+});
+```
+
+### TextMatch Examples
+
+Given the following render:
+
+```javascript
+const { baseElement } = render(<Text>Hello World</Text>);
+```
+
+**_Will_ find a match:**
+
+```javascript
+// Matching a string:
+getByText(baseElement, 'Hello World'); // full string match
+getByText(baseElement, 'llo Worl', { exact: false }); // substring match
+getByText(baseElement, 'hello world', { exact: false }); // ignore case
+
+// Matching a regex:
+getByText(baseElement, /World/); // substring match
+getByText(baseElement, /world/i); // substring match, ignore case
+getByText(baseElement, /^hello world$/i); // full string match, ignore case
+getByText(baseElement, /Hello W?oRlD/i); // advanced regex
+
+// Matching with a custom function:
+getByText(baseElement, content => content.startsWith('Hello'));
+```
+
+**_Will not_ find a match:**
+
+```javascript
+// full string does not match
+getByText(testElement, 'Goodbye World');
+
+// case-sensitive regex with different case
+getByText(testElement, /hello world/);
+```
diff --git a/website/versioned_docs/version-3.0.0/api-test-instance.md b/website/versioned_docs/version-3.0.0/api-test-instance.md
new file mode 100644
index 0000000..3661b8c
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/api-test-instance.md
@@ -0,0 +1,106 @@
+---
+id: version-3.0.0-api-test-instance
+title: NativeTestInstance
+sidebar_label: NativeTestInstance
+original_id: api-test-instance
+---
+
+`NativeTestInstance` is a proxied react-test-renderer TestInstance. Not all properties are
+available, so you should only rely on the ones listed in this documentation.
+
+Properties are excluded or overridden in an effort to make it easier to follow the guiding
+principles of testing-library. If there are other assertions you'd like to make, that aren't
+supported by this library there should be no problem running other react-test-renderer tests in the
+same codebase.
+
+> Before assuming you need access to something not exposed, try to ask yourself what you would do if
+> you were using dom testing library.
+>
+> We believe all of the utilities provided by this package allow you to write tests the way you
+> would using that library, so if you're struggling to write a test, try to take a step back and
+> evaluate if you're trying to test implementation details or making an assertion that doesn't map
+> to something your users could do.
+
+## `getProp`
+
+This is simply a helper that allows you to get the value of a native node prop. It is meant to
+mirror the `getAttribute` API in the DOM. You should rarely need to use this method in your tests.
+
+```javascript
+const nativeNode = getByValue('hello world');
+const value = nativeNode.getProp('value');
+
+expect(value).toBe('hello world');
+```
+
+## `findAll`
+
+This method will return you all children nodes that are valid native nodes. **This will not find
+custom components, it will only return core components defined in the preset.** It is meant to be
+similar to `document.querySelectorAll`.
+
+```javascript
+const { container } = render(<MyComponent />);
+const textNodes = container.findAll(node => node.getProp('accessibilityLabel') === 'hello world');
+
+expect(textNodes).toHaveLength(2);
+```
+
+## `type`
+
+This will be the type of the native node. For all queries you can make in this library, this value
+will be a string.
+
+```javascript
+const { findByText } = render(<Text>hello world</Text>);
+
+expect(findByText(/hello world/i).type).toBe('hello world');
+```
+
+## `props`
+
+The props of the element you've queried for. These are meant to be the equivalent of a DOM
+"attribute". You should rarely need to make assertions on these values, so try not to rely heavily
+on using them directly.
+
+```javascript
+const { findByText } = render(<Text style={{}}>hello world</Text>);
+
+console.log(findByText(/hello world/i).props);
+```
+
+## `parentNode`
+
+This will return only valid native node parents. This differs from the react-test-renderer's
+`parent` property in that way. You will not be able to get your implementation components by
+traversing the parents of your tree.
+
+```javascript
+const { findByText } = render(
+  <View>
+    <CustomComponent>
+      <Text>hello world</Text>
+    </CustomComponent>
+  </View>,
+);
+
+expect(findByText(/hello world/i).parentNode.type).toBe('View'); // NOT CustomComponent
+```
+
+## `children`
+
+This will return only valid native node children. This differs from the react-test-renderer's
+children property in that way. You will not be able to get your implementation components by
+traversing the children of your tree.
+
+```javascript
+const { findByTestID } = render(
+  <View testID="my-wrapper">
+    <CustomComponent>
+      <Text>hello world</Text>
+    </CustomComponent>
+  </View>,
+);
+
+expect(findByTestID('my-wrapper').children[0].type).toBe('Text'); // NOT CustomComponent
+```
diff --git a/website/versioned_docs/version-3.0.0/example-input-event.md b/website/versioned_docs/version-3.0.0/example-input-event.md
new file mode 100644
index 0000000..a04baf6
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/example-input-event.md
@@ -0,0 +1,73 @@
+---
+id: version-3.0.0-example-input-event
+title: Input Event
+sidebar_label: Input Event
+original_id: example-input-event
+---
+
+```javascript
+import React from 'react';
+import { Text, TextInput } from 'react-native';
+import { render, fireEvent } from ' native-testing-library';
+
+class CostInput extends React.Component {
+  state = {
+    value: '',
+  };
+
+  removeDollarSign = value => (value[0] === '$' ? value.slice(1) : value);
+  getReturnValue = value => (value === '' ? '' : `$${value}`);
+  handleChange = ({ nativeEvent }) => {
+    const text = nativeEvent.text;
+    const noDollarSign = this.removeDollarSign(text);
+    if (isNaN(noDollarSign)) return;
+    this.setState({ value: this.getReturnValue(noDollarSign) });
+  };
+
+  render() {
+    return (
+      <TextInput
+        value={this.state.value}
+        accessibilityLabel="cost-input"
+        onChange={this.handleChange}
+      />
+    );
+  }
+}
+
+const setup = () => {
+  const utils = render(<CostInput />);
+  const input = utils.getByLabelText('cost-input');
+  return {
+    input,
+    ...utils,
+  };
+};
+
+test('It should keep a $ in front of the input', () => {
+  const { input } = setup();
+
+  fireEvent.change(input, { nativeEvent: { text: 23 } });
+  expect(input.props.value).toBe('$23');
+});
+test('It should allow a $ to be in the input when the value is changed', () => {
+  const { input } = setup();
+  fireEvent.change(input, { nativeEvent: { text: '$23.0' } });
+  expect(input.props.value).toBe('$23.0');
+});
+
+test('It should not allow letters to be inputted', () => {
+  const { input } = setup();
+  expect(input.props.value).toBe('');
+  fireEvent.change(input, { nativeEvent: { text: 'Good Day' } });
+  expect(input.props.value).toBe('');
+});
+
+test('It should allow the $ to be deleted', () => {
+  const { input } = setup();
+  fireEvent.change(input, { nativeEvent: { text: '23' } });
+  expect(input.props.value).toBe('$23');
+  fireEvent.change(input, { nativeEvent: { text: '' } });
+  expect(input.props.value).toBe('');
+});
+```
diff --git a/website/versioned_docs/version-3.0.0/example-update-props.md b/website/versioned_docs/version-3.0.0/example-update-props.md
new file mode 100644
index 0000000..2c57054
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/example-update-props.md
@@ -0,0 +1,37 @@
+---
+id: version-3.0.0-example-update-props
+title: Update Props
+sidebar_label: Update Props
+original_id: example-update-props
+---
+
+```javascript
+import React from 'react';
+import { Text, View } from 'react-native';
+import { render } from ' native-testing-library';
+
+let idCounter = 1;
+
+class NumberDisplay extends React.Component {
+  id = idCounter++;
+  render() {
+    return (
+      <View>
+        <Text testID="number-display">{this.props.number}</Text>
+        <Text testID="instance-id">{this.id}</Text>
+      </View>
+    );
+  }
+}
+
+test('calling render with the same component on the same container does not remount', () => {
+  const { getByTestId, rerender } = render(<NumberDisplay number={1} />);
+  expect(getByTestId('number-display').props.children).toEqual(1);
+
+  rerender(<NumberDisplay number={2} />);
+  expect(getByTestId('number-display').props.children).toEqual(2);
+
+  expect(getByTestId('instance-id').props.children).toEqual(1);
+});
+
+```
diff --git a/website/versioned_docs/version-3.0.0/guide-disappearance.md b/website/versioned_docs/version-3.0.0/guide-disappearance.md
new file mode 100644
index 0000000..a5a965a
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/guide-disappearance.md
@@ -0,0 +1,69 @@
+---
+id: version-3.0.0-guide-disappearance
+title: Appearance and Disappearance
+original_id: guide-disappearance
+---
+
+`dom-testing-library` can utilize a fake DOM `MutationObserver` to look for changes, but we don't
+have that luxury in the native/test renderer environment. Since we don't have that, you should know
+that all `wait-*` utilities in this library offer roughly the same functionality, just with some
+added convenience.
+
+Since we can't "observe" a DOM, we just have to poll it at a given interval
+
+## Waiting for appearance
+
+If you need to wait for an element to appear, the [async wait utilities](api-async.md) allow you to
+wait for an assertion to be satisfied before proceeding. The wait utilities retry until the query
+passes or times out.
+
+```javascript
+test('movie title appears', async () => {
+  // element is initially not present...
+
+  // wait for appearance
+  await wait(() => {
+    // We don't have a handy assertion like they do in DOM land, so just check that it exists
+    expect(getByText('the lion king')).toBeTruthy();
+  });
+
+  // wait for appearance and return the element
+  const movie = await waitForElement(() => getByText('the lion king'));
+});
+```
+
+## Waiting for disappearance
+
+The `wait` [async helper](api-async.md) function retries until the wrapped function stops throwing
+an error. This can be used to assert that an element disappears from the page.
+
+```javascript
+test('movie title goes away', async () => {
+  // element is initially present...
+  // note use of queryBy instead of getBy to return null
+  // instead of throwing in the query itself
+  await wait(() => {
+    // We don't have a handy assertion like they do in DOM land, so just check that it doesn't exist
+    expect(queryByText('i, robot')).toBeFalsy();
+  });
+});
+```
+
+## Asserting elements are not present
+
+All `getBy` methods throw errors when they can't find their search, but `queryBy` methods don't. Any
+time you need to verify something isn't there, use `query`. Any time you need to verify something i
+there, use `get`.
+
+```javascript
+const submitButton = queryByText(testInstance, 'submit');
+expect(submitButton).toBeNull(); // it doesn't exist
+```
+
+The `queryAll` APIs version return an array of matching nodes. The length of the array can be useful
+for assertions after elements are added or remove.
+
+```javascript
+const submitButtons = queryAllByText(container, 'submit');
+expect(submitButtons).toHaveLength(2); // expect 2 elements
+```
diff --git a/website/versioned_docs/version-3.0.0/guide-queries.md b/website/versioned_docs/version-3.0.0/guide-queries.md
new file mode 100644
index 0000000..2a31a7b
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/guide-queries.md
@@ -0,0 +1,42 @@
+---
+id: version-3.0.0-guide-queries
+title: How Should I Query?
+original_id: guide-queries
+---
+
+## Priority
+
+Whatever you do, try to make your tests resemble real use cases. You'll only be confident with your
+tests if they work the way your users do. With that in mind, we recommend this order of priority:
+
+1. **Queries Users Can Interact With**
+   1. [`getByLabelText`](api-queries#bylabeltext): Your disabled users are counting on you, so this
+      should likely be everywhere for their sake 😉 use it often, and if you aren't, maybe ask
+      yourself why.
+   1. [`getByHintText`](api-queries#byhinttext): You should probably have an accessibility label
+      that you can select by, but if for some reason you set this instead, it's safe to use.
+   1. [`getByPlaceholderText`](api-queries#byplaceholdertext): Great for targeting a `TextInput`
+      element to verify its content
+   1. [`getByText`](api-queries#bytext): Great for finding a `Text`, `Button`, or `Touchable` node.
+      You'll probably use this one a lot.
+   1. [`getByDisplayValue`](api-queries#bydisplayvalue): This is good because a user can see the
+      value they type into a `TextInput` or whether a `Switch` is on or off.
+1. **Queries Users Can Infer**
+   1. [`getByTitle`](api-queries#bytitle): This isn't available on many elements, and there's likely
+      a better way you can find the element you're looking for.
+   1. [`getByRole`](api-queries#byrole): If your app screens have good hierarchy, this may be a
+      decent option for finding your elements
+1. **Queries Users Don't Even Know About**
+   1. [`getByTestId`](api-queries#bytestid): The user cannot see (or hear) these, so this is only
+      recommended for cases where you can't match by text or it doesn't make sense
+
+## Manual Queries
+
+If you absolutely can't find a way to get the element you're looking for, you can use
+[`findAll`](api-test-instance#findall) as an escape hatch. Note that this is a bad practice and may
+introduce unpredictable behavior in your tests. It would likely be better to use a `testID` in most
+cases where you need to.
+
+Also note, this utility still won't be able to find your app's components, it will only search for
+React Native core components. This library provides you no reasonable way to make an assertion on
+your components.
diff --git a/website/versioned_docs/version-3.0.0/install.md b/website/versioned_docs/version-3.0.0/install.md
new file mode 100644
index 0000000..4fcce46
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/install.md
@@ -0,0 +1,96 @@
+---
+id: version-3.0.0-install
+title: Install
+sidebar_label: Install
+original_id: install
+---
+
+## Installation
+
+This module should be installed in your project's `devDependencies`:
+
+```
+npm install --save-dev native-testing-library
+```
+
+You will need `react` and `react-native` installed as _dependencies_ in order to run this project.
+
+## Jest preset
+
+> It is **highly recommended** that you use the bundled Jest preset. You will likely experience
+> unexpected behavior and have a sub-optimal experience if you do not use the preset.
+
+`native-testing-library` includes an easy to adopt and reliable Jest preset to maximize the
+confidence you have in your tests. It extends the `react-native` preset, and was created order to
+more closely mimic behavior you would expect from any other member of the `testing-library` family.
+
+```diff
+// jest.config.js
+
++ preset: 'native-testing-library'
+- preset: 'react-native'
+```
+
+You can continue to add to your Jest config as you normally would, you'll just want to make sure
+that if you modify the `setupFiles` key that you include any additional files after the setup files
+provided by the preset. Here's how you might do that:
+
+```javascript
+const expoPreset = require('jest-expo/jest-preset.json');
+const jestPreset = require('native-testing-library/jest-preset');
+
+module.exports = Object.assign(expoPreset, jestPreset, {
+  setupFiles: [...expoPreset.setupFiles, ...jestPreset.setupFiles, './mySetup.js'],
+});
+```
+
+> If you use Expo, be sure to include the Expo setup files before the native-testing-library setup
+> files! If you're using React Native, there's no need to do anything extra.
+
+Generally speaking though, it's better to include any setup files you have in the
+`setupFilesAfterEnv` key of your Jest config.
+
+> Note: this preset will use the react-native jest preset included with your version of
+> react-native, so please be aware that some behaviors may not be totally as expected if you are
+> using an older version of the react-native library.
+
+Here is a list of all the components this preset supports:
+
+```json
+[
+  "ActivityIndicator",
+  "Button",
+  "DrawerLayoutAndroid",
+  "Image",
+  "Modal",
+  "Picker",
+  "RefreshControl",
+  "SafeAreaView",
+  "ScrollView",
+  "Switch",
+  "Text",
+  "TextInput",
+  "TouchableHighlight",
+  "TouchableNativeFeedback",
+  "TouchableOpacity",
+  "TouchableWithoutFeedback",
+  "View"
+]
+```
+
+You can still use components like `FlatList` and `SectionList`, you just won't be able to directly
+select them or see them in debug output. These components wrap other components, that's why we don't
+let you select them directly. If you're having trouble selecting what you need to inside of one of
+these components that isn't mocked, just `debug()` to see what your users are seeing ☺️
+
+## Exports
+
+You will likely be able to import everything you'll need from the project entry point like this:
+
+```js
+import { render } from 'native-testing-library';
+```
+
+The library's tests run in Node 8-11 before all new versions are published, and all files are
+processed using the `metro-react-native-babel-preset` preset. Typings are included, but may not be
+perfect, and we are happy to accept PRs to improve them! ☺️
diff --git a/website/versioned_docs/version-3.0.0/intro.md b/website/versioned_docs/version-3.0.0/intro.md
new file mode 100644
index 0000000..4997266
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/intro.md
@@ -0,0 +1,45 @@
+---
+id: version-3.0.0-intro
+title: Introduction
+sidebar_label: Introduction
+original_id: intro
+---
+
+## The problem
+
+You want to write maintainable tests for your React Native application. You love Kent Dodds'
+[testing library](https://testing-library.com), and you want to be able to write maintainable tests
+for your React Native application. You don't want to use a library that renders components to a fake
+DOM, and you've had a hard time finding what you need to write tests using that philosophy in React
+Native.
+
+## This solution
+
+`native-testing-library` is an implementation of the well-known `testing-library` API that works for
+React Native. The primary goal is to mimic the testing library API as closely as possible while
+still accounting for the differences in the platforms. Accomplishing this is no small feat because
+of the differences between the two platforms. Although most framework implementations like
+`react-testing-library` are thin layers over [dom-testing-library](https://testing-library.com),
+this library needed to have its own base implementation as well as a user-facing API. This library
+uses the [react-test-renderer](https://reactjs.org/docs/test-renderer.html), whereas
+`dom-testing-library` uses ReactDOM to render to JSDOM. The main philosophy is that you should find
+elements the way your users would. This approach is meant to give you confidence that your app is
+working as a cohesive unit. Just like the `dom-testing-library`, `native-testing-library`'s primary
+guiding principle is:
+
+> [The more your tests resemble the way your software is used, the more confidence they can give you.](guiding-principles.md)
+
+This library gives you the tools you need to find things in your application the way your users
+would. You can do things like find elements by text, input value, and accessibility labels -- the
+types of things your users can see. We also give you the ability to search for elements by `testID`,
+but you should consider it a last resort because users can't see a testID and it can introduce
+unpredictable behavior in your tests.
+
+It will also encourage you to build more accessible apps. For example, disabled users can't see a
+touchable icon that doesn't have an accessibility label, so neither can your tests. We believe that
+writing good tests using this library will force you to give more consideration to whether what
+you're doing is an accessible experience for all of your users.
+
+This library may work with any any testing framework like Jest or Mocha, but we do recommend you use
+Jest with the `react-native` Jest preset. We have not tested it in any other environment, and likely
+won't be able to support usage with another library.
diff --git a/website/versioned_docs/version-3.0.0/setup.md b/website/versioned_docs/version-3.0.0/setup.md
new file mode 100644
index 0000000..f89484f
--- /dev/null
+++ b/website/versioned_docs/version-3.0.0/setup.md
@@ -0,0 +1,85 @@
+---
+id: version-3.0.0-setup
+title: Setup
+sidebar_label: Setup
+original_id: setup
+---
+
+## Setting up your project
+
+The `native-testing-library` API should work out of the box for most tests. All of the snippets
+you'll find throughout the website work without any additional configuration assuming you use Jest
+and a moderately recent version of React Native.
+
+We strongly encourage you to use Jest with the `native-testing-library` preset. The `react-native`
+preset should also work, but you'll be getting the best experience when using our preset. There may
+be some additional mocks you need to provide to such as mocks for `react-native-gesture-handler`
+when using `react-navigation`.
+
+## Custom Render
+
+It's often useful to define a custom render method that includes things like global context
+providers, data stores, etc. To make this available globally, one approach is to define a utility
+file that re-exports everything from `native-testing-library`. You can replace
+`native-testing-library` with this file in all your imports. See
+[below](#configuring-jest-with-test-utils) for a way to make your test util file accessible without
+using relative paths.
+
+The example below sets up data providers using the [`wrapper`](api-main.md#render-options) option to
+`render`.
+
+```diff
+// my-component.test.js
+- import { render, fireEvent } from 'native-testing-library';
++ import { render, fireEvent } from '../test-utils';
+```
+
+```js
+// test-utils.js
+import { render } from 'native-testing-library';
+import { ThemeProvider } from 'my-ui-lib';
+import { TranslationProvider } from 'my-i18n-lib';
+import defaultStrings from 'i18n/en-x-default';
+
+const AllTheProviders = ({ children }) => {
+  return (
+    <ThemeProvider theme="light">
+      <TranslationProvider messages={defaultStrings}>{children}</TranslationProvider>
+    </ThemeProvider>
+  );
+};
+
+const customRender = (ui, options) => render(ui, { wrapper: AllTheProviders, ...options });
+
+// re-export everything
+export * from 'native-testing-library';
+
+// override render method
+export { customRender as render };
+```
+
+### Configuring Jest with Test Utils
+
+To make your custom test file accessible in your Jest test files without using relative imports
+(`../../test-utils`), add the folder containing the file to the Jest `moduleDirectories` option.
+
+This will make all the `.js` files in the test-utils directory importable without `../`.
+
+```diff
+// my-component.test.js
+- import { render, fireEvent } from '../test-utils';
++ import { render, fireEvent } from 'test-utils';
+```
+
+```diff
+// jest.config.js
+module.exports = {
+  moduleDirectories: [
+    'node_modules',
++   // add the directory with the test-utils.js file, for example:
++   'utils', // a utility folder
++    __dirname, // the root directory
+  ],
+  // ... other options ...
+}
+```
diff --git a/website/versioned_sidebars/version-2.0.0-sidebars.json b/website/versioned_sidebars/version-2.0.0-sidebars.json
new file mode 100644
index 0000000..4712465
--- /dev/null
+++ b/website/versioned_sidebars/version-2.0.0-sidebars.json
@@ -0,0 +1,50 @@
+{
+  "version-2.0.0-docs": {
+    "Getting started": [
+      "version-2.0.0-intro",
+      "version-2.0.0-install",
+      "version-2.0.0-example",
+      "version-2.0.0-setup",
+      "version-2.0.0-guiding-principles",
+      "version-2.0.0-cheat-sheet"
+    ],
+    "API": [
+      "version-2.0.0-api-queries",
+      "version-2.0.0-api-events",
+      "version-2.0.0-api-async",
+      "version-2.0.0-api-helpers",
+      "version-2.0.0-api-render",
+      "version-2.0.0-api-render-hook",
+      "version-2.0.0-api-act"
+    ],
+    "Ecosystem": [
+      "version-2.0.0-ecosystem-jest-native"
+    ]
+  },
+  "version-2.0.0-recipes": {
+    "Guides": [
+      "version-2.0.0-guide-queries",
+      "version-2.0.0-guide-disappearance"
+    ],
+    "Examples": [
+      "version-2.0.0-example-context",
+      "version-2.0.0-example-input-event",
+      "version-2.0.0-example-intl",
+      "version-2.0.0-example-navigation",
+      "version-2.0.0-example-redux",
+      "version-2.0.0-example-update-props"
+    ],
+    "Hook Examples": [
+      "version-2.0.0-hook-example-async",
+      "version-2.0.0-hook-example-custom",
+      "version-2.0.0-hook-example-error",
+      "version-2.0.0-hook-example-test",
+      "version-2.0.0-hook-example-use-context",
+      "version-2.0.0-hook-example-use-effect",
+      "version-2.0.0-hook-example-use-memo",
+      "version-2.0.0-hook-example-use-reducer",
+      "version-2.0.0-hook-example-use-ref",
+      "version-2.0.0-hook-example-use-state"
+    ]
+  }
+}
diff --git a/website/versioned_sidebars/version-3.0.0-sidebars.json b/website/versioned_sidebars/version-3.0.0-sidebars.json
new file mode 100644
index 0000000..8c08746
--- /dev/null
+++ b/website/versioned_sidebars/version-3.0.0-sidebars.json
@@ -0,0 +1,37 @@
+{
+  "version-3.0.0-docs": {
+    "Getting started": [
+      "version-3.0.0-intro",
+      "version-3.0.0-install",
+      "version-3.0.0-example",
+      "version-3.0.0-setup",
+      "version-3.0.0-guiding-principles",
+      "version-3.0.0-cheat-sheet"
+    ],
+    "API": [
+      "version-3.0.0-api-main",
+      "version-3.0.0-api-test-instance",
+      "version-3.0.0-api-queries",
+      "version-3.0.0-api-events",
+      "version-3.0.0-api-async",
+      "version-3.0.0-api-helpers"
+    ],
+    "Ecosystem": [
+      "version-3.0.0-ecosystem-jest-native"
+    ]
+  },
+  "version-3.0.0-recipes": {
+    "Guides": [
+      "version-3.0.0-guide-queries",
+      "version-3.0.0-guide-disappearance"
+    ],
+    "Examples": [
+      "version-3.0.0-example-context",
+      "version-3.0.0-example-input-event",
+      "version-3.0.0-example-intl",
+      "version-3.0.0-example-navigation",
+      "version-3.0.0-example-redux",
+      "version-3.0.0-example-update-props"
+    ]
+  }
+}
diff --git a/website/versions.json b/website/versions.json
new file mode 100644
index 0000000..ffe8f2d
--- /dev/null
+++ b/website/versions.json
@@ -0,0 +1,4 @@
+[
+  "3.0.0",
+  "2.0.0"
+]