update docs

Author: mdjastrzebski

website/docs/13.x/docs/api/events/fire-event.mdx

@@ -32,7 +32,7 @@ test('fire changeText event', () => {
 ```
 
 :::note
-Please note that from version `7.0` `fireEvent` performs checks that should prevent events firing on disabled elements.
+`fireEvent` performs checks that should prevent events firing on disabled elements.
 :::
 
 An example using `fireEvent` with native events that aren't already aliased by the `fireEvent` api.
@@ -156,3 +156,58 @@ fireEvent.scroll(screen.getByText('scroll-view'), eventData);
 Prefer using [`user.scrollTo`](docs/api/events/user-event#scrollto) over `fireEvent.scroll` for `ScrollView`, `FlatList`, and `SectionList` components. User Event provides a more realistic event simulation based on React Native runtime behavior.
 
 :::
+
+
+## `fireEventAsync`
+
+:::info RNTL minimal version
+
+This API requires RNTL v13.3.0 or later.
+
+:::
+
+
+```ts
+async function fireEventAsync(element: ReactTestInstance, eventName: string, ...data: unknown[]): Promise<unknown>;
+```
+
+The `fireEventAsync` function is the async version of `fireEvent` designed for working with React 19 and React Suspense. It wraps event handler execution in async `act()`, making it suitable for event handlers that trigger suspense boundaries or other async behavior.
+
+```jsx
+import { renderAsync, screen, fireEventAsync } from '@testing-library/react-native';
+
+test('async fire event test', async () => {
+  await renderAsync(<MyAsyncComponent />);
+  
+  // Use fireEventAsync when event handlers have async behavior
+  await fireEventAsync(screen.getByText('Async Button'), 'press');
+  
+  expect(screen.getByText('Async operation completed')).toBeOnTheScreen();
+});
+```
+
+Like `fireEvent`, `fireEventAsync` also provides convenience methods for common events: `fireEventAsync.press`, `fireEventAsync.changeText`, and `fireEventAsync.scroll`.
+
+### `fireEventAsync.press` {#async-press}
+
+```
+fireEventAsync.press: (element: ReactTestInstance, ...data: Array<any>) => Promise<unknown>
+```
+
+Async version of `fireEvent.press` designed for React 19 and React Suspense. Use when press event handlers trigger suspense boundaries or other async behavior.
+
+### `fireEventAsync.changeText` {#async-change-text}
+
+```
+fireEventAsync.changeText: (element: ReactTestInstance, ...data: Array<any>) => Promise<unknown>
+```
+
+Async version of `fireEvent.changeText` designed for React 19 and React Suspense. Use when changeText event handlers trigger suspense boundaries or other async behavior.
+
+### `fireEventAsync.scroll` {#async-scroll}
+
+```
+fireEventAsync.scroll: (element: ReactTestInstance, ...data: Array<any>) => Promise<unknown>
+```
+
+Async version of `fireEvent.scroll` designed for React 19 and React Suspense. Use when scroll event handlers trigger suspense boundaries or other async behavior.

website/docs/13.x/docs/api/render.mdx

@@ -64,3 +64,43 @@ React Test Renderer does not enforce this check; hence, by default, React Native
 The `render` function returns the same queries and utilities as the [`screen`](docs/api/screen) object. We recommended using the `screen` object as more developer-friendly way.
 
 See [this article](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library#not-using-screen) from Kent C. Dodds for more details.
+
+## `renderAsync` function
+
+:::info RNTL minimal version
+
+This API requires RNTL v13.3.0 or later.
+
+:::
+
+```jsx
+async function renderAsync(
+  component: React.Element<any>,
+  options?: RenderAsyncOptions
+): Promise<RenderAsyncResult>
+```
+
+The `renderAsync` function is the async version of `render` designed for working with React 19 and React Suspense. It allows components to be properly rendered when they contain suspense boundaries or async behavior that needs to complete before the render result is returned.
+
+```jsx
+import { renderAsync, screen } from '@testing-library/react-native';
+
+test('async component test', async () => {
+  await renderAsync(<MyAsyncApp />);
+  expect(screen.getAllByRole('button', { name: 'start' })).toBeOnTheScreen();
+});
+```
+
+### Options
+
+`renderAsync` accepts the same options as `render`.
+
+### Result
+
+The `renderAsync` function returns a promise that resolves to the same queries and utilities as the [`screen`](docs/api/screen) object. We recommend using the `screen` object for queries and the async lifecycle methods from the render result when needed.
+
+:::note Async lifecycle methods
+
+When using `renderAsync`, you have to use correspodning lifecycle methods: `updateAsync`/`rerenderAsync` and `unmountAsync` instead of their sync versions.
+
+::

website/docs/13.x/docs/api/screen.mdx

@@ -41,6 +41,35 @@ function rerender(element: React.Element<unknown>): void;
 
 Re-render the in-memory tree with a new root element. This simulates a React update render at the root. If the new element has the same type (and `key`) as the previous element, the tree will be updated; otherwise, it will re-mount a new tree, in both cases triggering the appropriate lifecycle events.
 
+### `rerenderAsync`
+
+_Also available under `updateAsync` alias_
+
+:::info RNTL minimal version
+
+This API requires RNTL v13.3.0 or later.
+
+:::
+
+```ts
+function rerenderAsync(element: React.Element<unknown>): Promise<void>;
+```
+
+Async versions of `rerender` designed for working with React 19 and React Suspense. These methods wait for async operations to complete during re-rendering, making them suitable for components that use suspense boundaries or other async behavior.
+
+```jsx
+import { renderAsync, screen } from '@testing-library/react-native';
+
+test('async rerender test', async () => {
+  await renderAsync(<MyComponent initialData="first" />);
+  
+  // Use async rerender when component has suspense or async behavior
+  await screen.rerenderAsync(<MyComponent initialData="updated" />);
+  
+  expect(screen.getByText('updated')).toBeOnTheScreen();
+});
+```
+
 ### `unmount`
 
 ```ts
@@ -50,7 +79,29 @@ function unmount(): void;
 Unmount the in-memory tree, triggering the appropriate lifecycle events.
 
 :::note
+
+Usually you should not need to call `unmount` as it is done automatically if your test runner supports `afterEach` hook (like Jest, mocha, Jasmine).
+
+:::
+
+### `unmountAsync`
+
+:::info RNTL minimal version
+
+This API requires RNTL v13.3.0 or later.
+
+:::
+
+```ts
+function unmountAsync(): Promise<void>;
+```
+
+Async version of `unmount` designed for working with React 19 and React Suspense. This method waits for async cleanup operations to complete during unmounting, making it suitable for components that have async cleanup behavior.
+
+:::note
+
 Usually you should not need to call `unmount` as it is done automatically if your test runner supports `afterEach` hook (like Jest, mocha, Jasmine).
+
 :::
 
 ### `debug`