diff --git a/content/chat/connect.textile b/content/chat/connect.textile
index 3c71c7650b..1ececdad1f 100644
--- a/content/chat/connect.textile
+++ b/content/chat/connect.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 When you "instantiate":/chat/setup#instantiate a client, a realtime connection is established and maintained with Ably. You can interact with the connection using the @ChatClient.connection@ object in order to monitor a client's connection status.
@@ -24,6 +25,9 @@ A connection can have any of the following statuses:
 blang[javascript].
   Use the "@current@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.ConnectionStatus.html#current property to check which status a connection is currently in:
 
+blang[swift].
+  Use the "@status@":https://sdk.ably.com/builds/ably/#status property to check which status a connection is currently in:
+
 blang[react].
   Use the "@currentStatus@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseChatConnectionResponse.html#currentStatus property returned in the response of the "@useChatConnection@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.useChatConnection.html hook to check which status a connection is currently in:
 
@@ -44,6 +48,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let status = await chatClient.connection.status
+```
+
 blang[react].
   Hooks related to chat features, such as @useMessages@ and @useTyping@, also return the current @connectionStatus@ in their response.
 
@@ -63,12 +71,17 @@ blang[react].
 
 blang[javascript].
 
+blang[swift].
+
 blang[javascript].
   Use the "@connection.status.onChange()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.ConnectionStatus.html#onChange method to register a listener for status change updates:
 
 blang[react].
   Listeners can also be registered to monitor the changes in connection status. Any hooks that take an optional listener to monitor their events, such as typing indicator events in the @useTyping@ hook, can also register a status change listener. Changing the value provided for a listener will cause the previously registered listener instance to stop receiving events. All messages will be received by exactly one listener.
 
+blang[swift].
+  Use the "@connection.onStatusChange(bufferingPolicy: .unbounded)@":https://sdk.ably.com/builds/ably/#onStatusChange method to create a subscription through which you can asynchronously iterate for the status updates:
+  
 ```[javascript]
 const { off } = chatClient.connection.status.onStatusChange((change) => console.log(change));
 ```
@@ -86,6 +99,13 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let subscription = chatClient.connection.onStatusChange(bufferingPolicy: .unbounded)
+for await statusChange in subscription {
+  print("Connection status changed to: \(statusChange.current)")
+}
+```
+  
 blang[javascript].
   To remove the connection status listener, call the @off()@ function returned in the @subscribe()@ response:
 
@@ -101,6 +121,13 @@ blang[javascript].
 
 blang[react].
 
+blang[swift].
+  To stop the subscription from firing new status events, call its @finish()@ function:
+
+  ```[swift]
+  subscription.finish()
+  ```
+
 h2(#discontinuity). Handle connection discontinuity
 
 If a client briefly loses connection to Ably, for example when driving through a tunnel, the SDK will attempt to recover the connection. If the disruption lasts for less than 2 minutes, then on reconnection the SDK will automatically reattach to any rooms and replay any missed messages.
@@ -112,6 +139,9 @@ blang[javascript].
 
 blang[react].
   Any hooks that take an optional listener to monitor their events, such as typing indicator events in the @useTyping@ hook, can also register a listener to be notified of, and handle, periods of discontinuity.
+  
+blang[swift].
+  Each feature of the Chat SDK provides an @subscribeToDiscontinuities()@ method to assist with this. This enables you to create a subscription that will fire an event when discontinuity occurs in that feature so that you can handle it, as needed. As mentioned above, to stop your subscription from firing new events call its @finish()@ method.
 
 For example, for messages:
 
@@ -136,6 +166,13 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let subscription = room.messages.subscribeToDiscontinuities()
+for await error in subscription {
+  print("Recovering from the error: \(error)")
+}
+```
+
 blang[react].
 
 blang[javascript].
diff --git a/content/chat/rooms/history.textile b/content/chat/rooms/history.textile
index 9ebffa2401..df0170c052 100644
--- a/content/chat/rooms/history.textile
+++ b/content/chat/rooms/history.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 The history feature enables users to retrieve messages that have been previously sent in a room. Ably stores chat messages for 24 hours by default. You can extend this up to 30 days by "contacting us":https://forms.gle/SmCLNFoRrYmkbZSf8.
@@ -50,13 +51,32 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let paginatedResult = try await room.messages.get(options: .init(orderBy: .newestFirst))
+print(paginatedResult.items)
+if paginatedResult.hasNext {
+    let next = try await paginatedResult.next!
+    print(next.items)
+} else {
+    print("End of messages")
+}
+```
+
 The following optional parameters can be passed when retrieving previously sent messages:
 
-|_. Parameter |_. Description |
-| start | Earliest time to retrieve messages from, as a unix timestamp in milliseconds. Messages with a timestamp equal to, or greater than, this value will be returned. |
-| end | Latest time to retrieve messages from, as a unix timestamp in milliseconds. Messages with a timestamp less than this value will be returned. |
-| direction | The direction in which to retrieve messages from; either @forwards@ or @backwards@. |
-| limit | Maximum number of messages to be retrieved, up to 1,000. |
+blang[javascript].
+  |_. Parameter |_. Description |
+  | start | Earliest time to retrieve messages from, as a unix timestamp in milliseconds. Messages with a timestamp equal to, or greater than, this value will be returned. |
+  | end | Latest time to retrieve messages from, as a unix timestamp in milliseconds. Messages with a timestamp less than this value will be returned. |
+  | direction | The direction in which to retrieve messages from; either @forwards@ or @backwards@. |
+  | limit | Maximum number of messages to be retrieved, up to 1,000. |
+
+blang[swift].
+  |_. Parameter |_. Description |
+  | start | Earliest time to retrieve messages from, as a unix timestamp in milliseconds. Messages with a timestamp equal to, or greater than, this value will be returned. |
+  | end | Latest time to retrieve messages from, as a unix timestamp in milliseconds. Messages with a timestamp less than this value will be returned. |
+  | orderBy | The direction in which to retrieve messages from; either @oldestFirst@ or @newestFirst@. |
+  | limit | Maximum number of messages to be retrieved, up to 1,000. |
 
 h2(#subscribe). Retrieve messages sent prior to subscribing
 
@@ -68,6 +88,9 @@ blang[javascript].
 blang[react].
   Use the "@getPrevious()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseMessagesResponse.html#getPreviousMessages method available from the response of the @useMessages@ hook to only retrieve messages that were received before the listener subscribed to the room. As long as a defined value is provided for the listener, and there are no message discontinuities, @getPreviousMessages()@ will return messages from the same point across component renders. If the listener becomes undefined, the subscription to messages will be removed. If you subsequently redefine the listener then @getPreviousMessages()@ will return messages from the new point of subscription.
 
+blang[swift].
+  Use the @getPreviousMessages()@ method from your messages subscription to only retrieve messages that were received before the subscription was created:
+
 ```[javascript]
 const { getPreviousMessages } = room.messages.subscribe(() => {
   console.log('New message received');
@@ -114,6 +137,18 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let messagesSubscription = try await room.messages.subscribe(bufferingPolicy: .unbounded)
+let paginatedResult = try await messagesSubscription.getPreviousMessages(params: .init(limit: 50)) // `orderBy` here is ignored and always `newestFirst`
+print(paginatedResult.items)
+if paginatedResult.hasNext {
+    let next = try await paginatedResult.next!
+    print(next.items)
+} else {
+    print("End of messages")
+}
+```
+
 The following parameters can be passed when retrieving previously sent messages:
 
 |_. Parameter |_. Description |
diff --git a/content/chat/rooms/index.textile b/content/chat/rooms/index.textile
index 438804e1b4..c56f8d8857 100644
--- a/content/chat/rooms/index.textile
+++ b/content/chat/rooms/index.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 Rooms are used to organize and logically separate your users and chat messages into 'rooms'. They are the entry object into using chat and provide access to all other chat features, such as messages, online status and typing indicators. A room can represent a 1:1 chat between an agent and a customer, a private message between two users in a chat application, a large group conversation, or the chat section of a livestream with thousands of users.
@@ -53,6 +54,10 @@ const App = () => {
 };
 ```
 
+```[swift]
+let room = try await chatClient.rooms.get(roomID: "basketball-stream", options: RoomOptions())
+```
+
 blang[react].
 
   <aside data-type='important'>
@@ -62,8 +67,11 @@ blang[react].
 
 blang[javascript].
 
+blang[swift].
+
+When you create or retrieve a room using @rooms.get()@, you need to choose which additional chat features you want enabled for that room. This is configured by passing a "@RoomOptions@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.RoomOptions.html object as the second argument. In addition to setting which features are enabled, @RoomOptions@ also configures the properties of the associated features, such as the timeout period for typing indicators.
+
 blang[javascript].
-  When you create or retrieve a room using @rooms.get()@, you need to choose which additional chat features you want enabled for that room. This is configured by passing a "@RoomOptions@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.RoomOptions.html object as the second argument. In addition to setting which features are enabled, @RoomOptions@ also configures the properties of the associated features, such as the timeout period for typing indicators.
 
   ```[javascript]
   const presence = {enter: false};
@@ -84,29 +92,42 @@ blang[javascript].
   ```[javascript]
   const room = chatClient.rooms.get('basketball-stream', {typing: {timeoutMs: 5000}});
   ```
+  
+  Enable each feature using its associated option. The details of the options available to each feature are documented on their respective pages:
+
+  | Feature | @RoomOption@ | Default settings |
+  | "Presence":/chat/rooms/presence | @presence@ | @RoomOptionsDefaults.presence@ |
+  | "Occupancy":/chat/rooms/occupancy | @occupancy@ | @RoomOptionsDefaults.occupancy@ |
+  | "Typing indicators":/chat/rooms/typing | @typing@ | @RoomOptionsDefaults.typing@ |
+  | "Room reactions":/chat/rooms/reactions | @reactions@ | @RoomOptionsDefaults.reactions@ |
 
 blang[react].
 
-Enable each feature using its associated option. The details of the options available to each feature are documented on their respective pages:
+blang[swift].
 
-| Feature | @RoomOption@ | Default settings |
-| "Presence":/chat/rooms/presence | @presence@ | @RoomOptionsDefaults.presence@ |
-| "Occupancy":/chat/rooms/occupancy | @occupancy@ | @RoomOptionsDefaults.occupancy@ |
-| "Typing indicators":/chat/rooms/typing | @typing@ | @RoomOptionsDefaults.typing@ |
-| "Room reactions":/chat/rooms/reactions | @reactions@ | @RoomOptionsDefaults.reactions@ |
+  ```[swift]
+  let presence = PresenceOptions(enter: false)
+  let typing = TypingOptions(timeout: 5.0) // seconds
+  let options = RoomOptions(presence: presence, typing: typing, reactions: nil, occupancy: nil)
+  let room = try await chatClient.rooms.get(roomID: "basketball-stream", options: options)
+  ```
 
 h3(#release). Release a room
 
 Releasing a room allows the underlying resources to be garbage collected or released.
 
 Releasing a room may be optional for many applications. If you have multiple transient rooms, such as in the case of a 1:1 support chat, then it is may be more beneficial.
+Once "@rooms.release()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Rooms.html#release has been called, the room will be unusable and a new instance will need to be created using "@rooms.get()@":#create if you want to reuse it.
 
 blang[javascript].
-  Once "@rooms.release()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Rooms.html#release has been called, the room will be unusable and a new instance will need to be created using "@rooms.get()@":#create if you want to reuse it.
 
   ```[javascript]
   await rooms.release('basketball-stream');
   ```
+  
+  ```[swift]
+  _ = try await rooms.release(roomID: "basketball-stream")
+  ```
 
 blang[react].
   By default the @ChatRoomProvider@ will automatically call "@release()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Room.html#release on the room when it unmounts. Set the "@release@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.ChatRoomProviderProps.html#release property to @false@ to change this behavior and have the room only "detach":#detach when the component unmounts. You can manually control this attachment behavior using the "@useRoom@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.useRoom.html hook.
@@ -142,6 +163,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+try await room.attach()
+```
+
 h3(#detach). Detach from a room
 
 blang[javascript].
@@ -150,6 +175,10 @@ blang[javascript].
   ```[javascript]
   await room.detach();
   ```
+  
+  ```[swift]
+  try await room.detach()
+  ```
 
 blang[react].
   By default the @ChatRoomProvider@ will automatically call "@release()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Room.html#release on the room when it unmounts. Set the "@release@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.ChatRoomProviderProps.html#release property to @false@ to change this behavior and have the room only "detach":#detach when the component unmounts. You can manually control this attachment behavior using the "@useRoom@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.useRoom.html hook.
@@ -180,6 +209,9 @@ blang[javascript].
 blang[react].
   Use the @roomStatus@ property to view the current "@Room@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Room.html status changes. The @roomError@ property is its associated error. Any hooks that take an optional listener have these properties available in their response, such as @useMessages@ or @useTyping@. It is more common that you will monitor the room status in the specific feature hooks rather than needing to use @useRoom@. These events are related to the room instance of the nearest "@ChatRoomProvider@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.ChatRoomProvider.html. For example, with the @useMessages@ hook:
 
+blang[swift].
+  Use the @status@ property to check which status a room is currently in:
+
 ```[javascript]
 const currentStatus = room.status.current
 ```
@@ -203,6 +235,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let status = try await room.status
+```
+
 blang[javascript].
   You can also subscribe to room status updates by registering a listener. An event will be emitted whenever the status of the room changes.
 
@@ -243,3 +279,19 @@ blang[react].
     return <div>Occupancy Component</div>;
   };
   ```
+
+blang[swift].
+  You can also create a subscribtion to the room status updates. An event will be emitted whenever the status of the room changes.
+
+  ```[swift]
+  let statusSubscription = try await room.onStatusChange(bufferingPolicy: .unbounded)
+  for await status in statusSubscription {
+    print("Room status: \(status)")
+  }
+  ```
+
+  To cancel the room status subscribtion, call the provided @finish()@ method:
+
+  ```[swift]
+  statusSubscription.finish()
+  ```
diff --git a/content/chat/rooms/messages.textile b/content/chat/rooms/messages.textile
index 9d87513e4b..eca2cd0d10 100644
--- a/content/chat/rooms/messages.textile
+++ b/content/chat/rooms/messages.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 You can send and receive messages in a chat room with any number of participants. These users subscribe to messages by registering a listener, and send messages to all users that are subscribed to receive them.
@@ -19,6 +20,9 @@ blang[react].
 
     Providing a listener will also enable you to retrieve messages that have been "previously sent to the room.":/chat/rooms/history
 
+blang[swift].
+  Subscribe to receive messages in a room by creating a subscription. Use the @messages.subscribe(bufferingPolicy: .unbounded)@ method in a room to receive all messages that are sent to it:
+
 ```[javascript]
 const {unsubscribe} = room.messages.subscribe((message) => {
   console.log(message);
@@ -40,6 +44,13 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let messagesSubscription = try await room.messages.subscribe(bufferingPolicy: .unbounded)
+for await message in messagesSubscription {
+    print("Message received: \(message)")
+}
+```
+
 h3(#structure). Message structure
 
 The following is the structure of a message:
@@ -97,6 +108,13 @@ blang[javascript].
 blang[react].
   When you unmount the component that is using the @useMessages@ hook, it will automatically handle unsubscribing any associated listeners registered to receive messages.
 
+blang[swift].
+  To cancel the room messages subscribtion, call the provided @finish()@ method:
+
+  ```[swift]
+  messagesSubscription.finish()
+  ```
+
 h2(#send). Send a message
 
 blang[javascript].
@@ -105,6 +123,9 @@ blang[javascript].
 blang[react].
   Use the "@send()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseMessagesResponse.html#send method available from the response of the @useMessages@ hook to to send a message to the room:
 
+blang[swift].
+  Use the @messages.send()@ method to send a message in a chat room. All users that are subscribed to messages on that room will receive it:
+
 ```[javascript]
 await room.messages.send({text: 'hello'});
 ```
@@ -126,3 +147,7 @@ const MyComponent = () => {
   );
 };
 ```
+
+```[swift]
+_ = try await room.messages.send(params: .init(text: "hello"))
+```
diff --git a/content/chat/rooms/occupancy.textile b/content/chat/rooms/occupancy.textile
index b4ac2dede0..4e54bb206e 100644
--- a/content/chat/rooms/occupancy.textile
+++ b/content/chat/rooms/occupancy.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 Occupancy enables you to view the number of users currently online in a room. This feature can be used to display user counts to highlight popular, or trending chat rooms.
@@ -21,12 +22,22 @@ blang[javascript].
 blang[react].
   Subscribe to a room's occupancy with the "@useOccupancy@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.useOccupancy.html hook.
 
+blang[swift].
+  Subscribe to a room's occupancy by creating a subscription. Use the @occupancy.subscribe(bufferingPolicy: .unbounded)@ method in a room to receive updates:
+
 ```[javascript]
 const {unsubscribe} = room.occupancy.subscribe((event) => {
   console.log(event);
 });
 ```
 
+```[swift]
+let occupancySubscription = try await room.occupancy.subscribe(bufferingPolicy: .unbounded)
+for await event in occupancySubscription {
+  occupancyInfo = "Connections: \(event.presenceMembers) (\(event.connections))"
+}
+```
+
 ```[react]
 import { useOccupancy } from '@ably/chat/react';
 
@@ -97,6 +108,13 @@ blang[javascript].
 blang[react].
   When you unmount the component that is using the @useOccupancy@ hook, it will automatically handle unsubscribing any associated listeners registered for room occupancy.
 
+blang[swift].
+  To cancel the room occupancy subscribtion, call the provided @finish()@ method:
+
+  ```[swift]
+  occupancySubscription.finish()
+  ```
+
 h2(#retrieve). Retrieve room occupancy
 
 blang[javascript].
@@ -107,6 +125,10 @@ blang[javascript].
   ```[javascript]
   const occupancy = await room.occupancy.get();
   ```
+  
+  ```[swift]
+  let occupancy = try await room.occupancy.get()
+  ```
 
 blang[react].
   Use the "@connections@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseOccupancyResponse.html#connections and "@presenceMembers@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseOccupancyResponse.html#presenceMembers properties available from the response of the @useOccupancy@ hook to view the occupancy of a room.
diff --git a/content/chat/rooms/presence.textile b/content/chat/rooms/presence.textile
index 8fdb0e7675..01106d0353 100644
--- a/content/chat/rooms/presence.textile
+++ b/content/chat/rooms/presence.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 Subscribe to the online status of room members using the presence feature. Presence enables you to show which members are currently online, indicate when a user goes offline, and have users optionally set additional information about their profile, or their current status within the application.
@@ -23,6 +24,9 @@ blang[react].
 
   To enter the presence set of a room, use the "@usePresence@":#set hook instead.
 
+blang[swift].
+  Subscribe to users' presence status by creating a subscription. Presence events are emitted whenever a member enters or leaves the presence set, or updates their user data. Use the @presence.subscribe()@ method in a room to receive updates:
+
 ```[javascript]
 const { unsubscribe } = room.presence.subscribe((event) => {
   console.log(`${event.clientId} entered with data: ${event.data}`);
@@ -57,6 +61,13 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let presenceSubscription = try await room.presence.subscribe(events: [.enter, .leave, .update])
+for await event in presenceSubscription {
+    print("Presence event `\(event.action)` from `\(event.clientId)` with data `\(event.data)`")
+}
+```
+
 blang[javascript].
   You can also subscribe to only specific presence events, or an array of presence events:
 
@@ -74,6 +85,8 @@ blang[javascript].
 
 blang[react].
 
+blang[swift].
+
 h3(#event-structure). Presence event structure
 
 The following is the structure of a presence event:
@@ -121,6 +134,13 @@ blang[javascript].
 blang[react].
   When you unmount the component that is using the @usePresenceListener@ hook, it will automatically handle unsubscribing any associated listeners registered for presence status updates.
 
+blang[swift].
+  To cancel the room presence subscribtion, call the provided @finish()@ method:
+
+  ```[swift]
+  presenceSubscription.finish()
+  ```
+
 h2(#set). Set user presence
 
 Users can enter and leave the presence set of a room to indicate when they are online or offline. They can also set user data when entering and leaving the set, such as their current status. Presence is also linked to a user's "connection status":/chat/connect. For example, if a user goes offline then a leave event will be emitted for them.
@@ -159,8 +179,12 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+try await room.presence.enter(data: .init(userCustomData: ["status": .string("Online")]))
+```
+
 blang[javascript].
-  Use the "@presence.update()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Presence.html#update method when a user wants to update their data, such as an update to their status, or to indicate that they're raising their hand. Updates will send a presence event ao all users subscribed to presence:
+  Use the "@presence.update()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Presence.html#update method when a user wants to update their data, such as an update to their status, or to indicate that they're raising their hand. Updates will send a presence event to all users subscribed to presence:
 
 blang[react].
   Use the "@update()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UsePresenceResponse.html#update property available from the response of the @usePresence@ hook to update a user's data, such as setting their status to 'Away from keyboard'.
@@ -191,6 +215,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+try await room.presence.update(data: .init(userCustomData: ["status": .string("Busy")]))
+```
+
 blang[javascript].
   Use the "@presence.leave()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Presence.html#leave method to explicitly remove a user from the presence set. This will send a presence event to all users subscribed to presence. You can also set an optional data field such as setting a status of 'Back later'.
 
@@ -218,6 +246,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+try await room.presence.leave(data: .init(userCustomData: ["status": .string("Away")]))
+```
+
 When a user goes offline or closes their "connection":/chat/connect, a leave event is also emitted and they are removed from the presence set.
 
 h2(#options). Presence options
@@ -250,15 +282,36 @@ blang[javascript].
   const presentMember = await room.presence.get({ clientId: 'clemons123' });
   ```
 
+  ```[swift]
+  // Retrieve all users entered into presence as an array:
+  let presentMembers = try await room.presence.get()
+
+  // Retrieve the status of specific users by their clientId:
+  let presentMember = try await room.presence.get(params: .init(clientID: "clemons123"))
+  ```
+
+blang[react].
+
+blang[javascript].
   Alternatively, use the "@presence.isUserPresent()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Presence.html#isUserPresent method and pass in a user's @clientId@ to check whether they are online or not. This will return a boolean:
 
   ```[javascript]
   const isPresent = await room.presence.isUserPresent('clemons123');
   ```
 
+  ```[swift]
+  let isPresent = try await room.presence.isUserPresent(clientID: "clemons123")
+  ```
+
+blang[react].
+
 blang[react].
   Use the "@presenceData@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UsePresenceListener.html#presenceData property available from the response of the @usePresence@ hook to view a list of all member's presence status in the room.
 
+blang[swift].
+
+blang[javascript].
+
 h3(#member-structure). Presence member structure
 
 The following is the structure of an individual presence member within the presence set:
diff --git a/content/chat/rooms/reactions.textile b/content/chat/rooms/reactions.textile
index e4c3dad798..1db088f509 100644
--- a/content/chat/rooms/reactions.textile
+++ b/content/chat/rooms/reactions.textile
@@ -5,6 +5,7 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
 Users can send reactions to the entire chat room to show their sentiment as to what is happening. For example, agreeing with the content in a livestream using a thumbs up, or sending a heart when their team scores in a sports game.
@@ -17,11 +18,16 @@ Room reactions are ephemeral and not stored or aggregated by Ably. The intention
 
 h2(#subscribe). Subscribe to room reactions
 
+Room reactions events are emitted whenever a user sends a reaction, such as by hitting a 'like' button or clicking a heart emoji.
+
 blang[javascript].
-  Subscribe to room reactions by registering a listener. These events are emitted whenever a user sends a reaction, such as by hitting a 'like' button or clicking a heart emoji. Use the "@reactions.subscribe()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.RoomReactions.html#subscribe method in a room to receive reactions:
+  Subscribe to room reactions by registering a listener. Use the "@reactions.subscribe()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.RoomReactions.html#subscribe method in a room to receive reactions:
 
 blang[react].
   Subscribe to room reactions with the "@useRoomReactions@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.useRoomReactions.html hook. Supply an optional listener to receive the room reactions.
+  
+blang[swift].
+  Subscribe to a room reactions by creating a subscription. Use the @occupancy.subscribe(bufferingPolicy: .unbounded)@ method in a room to receive reactions:
 
 ```[javascript]
 const {unsubscribe} = room.reactions.subscribe((reaction) => {
@@ -42,6 +48,13 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let reactionSubscription = try await room.reactions.subscribe(bufferingPolicy: .unbounded)
+for await reaction in reactionSubscription {
+  print("Received a reaction of type \(reaction.type), and metadata \(reaction.metadata)")
+}
+```
+
 h3(#structure). Room reaction event structure
 
 The following is the structure of a room reaction event:
@@ -95,6 +108,13 @@ blang[javascript].
 blang[react].
   When you unmount the component that is using the @useRoomReactions@ hook, it will automatically handle unsubscribing any associated listeners registered for room reactions.
 
+blang[swift].
+  To cancel the room reactions subscribtion, call the provided @finish()@ method:
+
+  ```[swift]
+  reactionSubscription.finish()
+  ```
+
 h2(#send). Send a room reaction
 
 blang[javascript].
@@ -126,3 +146,10 @@ const MyComponent = () => {
   );
 };
 ```
+
+```[swift]
+try await room.reactions.send(params: .init(type: "like"))
+
+try await room.reactions.send(params: .init(type: "🎉",
+                              metadata: ["effect": .string("fireworks")]))
+```
diff --git a/content/chat/rooms/typing.textile b/content/chat/rooms/typing.textile
index cb3f20077a..ce4a0953f1 100644
--- a/content/chat/rooms/typing.textile
+++ b/content/chat/rooms/typing.textile
@@ -5,9 +5,10 @@ product: chat
 languages:
   - javascript
   - react
+  - swift
 ---
 
-Typing indicators enable you to display which users are currently writing a message in a room. This feature can be used to display a message such as __Sandi is typing...__, or when a certain threshold is reached you could instead display __Multiple people are typing...__ or _12 people are typing..._.
+Typing indicators enable you to display which users are currently writing a message in a room. This feature can be used to display a message such as __Sandi is typing...__, or when a certain threshold is reached you could instead display __Multiple people are typing...__ or _12 people are typing..._. Typing events can be emitted when a user starts typing, and when they stop typing.
 
 <aside data-type='note'>
 <p>Typing indicators need to be "enabled":/chat/rooms#create when creating or retrieving a room.</p>
@@ -16,11 +17,14 @@ Typing indicators enable you to display which users are currently writing a mess
 h2(#subscribe). Subscribe to typing events
 
 blang[javascript].
-  Subscribe to typing events by registering a listener. Typing events can be emitted when a user starts typing, and when they stop typing. Use the "@typing.subscribe()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Typing.html#subscribe method in a room to subscribe to receive these updates:
+  Subscribe to typing events by registering a listener. Typing events can be emitted when a user starts typing, and when they stop typing. Use the "@typing.subscribe()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Typing.html#subscribe method in a room to receive these updates:
 
 blang[react].
   Subscribe to typing events with the "@useTyping@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/functions/chat_react.useTyping.html hook. Supply an optional listener to receive the typing events, or use the "@currentlyTyping@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseTypingResponse.html#currentlyTyping property returned by the hook to access the list of those users that are currently typing.
 
+blang[swift].
+  Subscribe to typing events by creating a subscription. Use the @typing.subscribe(bufferingPolicy: .unbounded)@ method in a room to receive these updates:
+
 ```[javascript]
 const {unsubscribe} = room.typing.subscribe((event) => {
   console.log(event);
@@ -46,6 +50,14 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+let typingSubscription = try await room.typing.subscribe(bufferingPolicy: .unbounded)
+for await typing in typingSubscription {
+  typingInfo = typing.currentlyTyping.isEmpty ? "" :
+                "Typing: \(typing.currentlyTyping.joined(separator: ", "))..."
+}
+```
+
 h3(#structure). Typing event structure
 
 The following is the structure of a typing event:
@@ -92,6 +104,13 @@ blang[javascript].
 blang[react].
   When you unmount the component that is using the @useTyping@ hook, it will automatically handle unsubscribing any associated listeners registered for typing events.
 
+blang[swift].
+  To cancel the room typing subscribtion, call the provided @finish()@ method:
+
+  ```[swift]
+  typingSubscription.finish()
+  ```
+
 h2(#set). Set typing status
 
 blang[javascript].
@@ -125,6 +144,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+try await room.typing.start()
+```
+
 blang[javascript].
   Use the "@stop()@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_js.Typing.html#stop method to emit a typing event with @isTyping@ set to @false@.
 
@@ -153,6 +176,10 @@ const MyComponent = () => {
 };
 ```
 
+```[swift]
+try await room.typing.stop()
+```
+
 h2(#retrieve). Retrieve a list of users that are currently typing
 
 blang[javascript].
@@ -162,5 +189,9 @@ blang[javascript].
   const currentlyTypingClientIds = await room.typing.get();
   ```
 
+  ```[swift]
+  let currentlyTypingClientIds = try await room.typing.get()
+  ```
+
 blang[react].
   Use the "@currentlyTyping@":https://sdk.ably.com/builds/ably/ably-chat-js/main/typedoc/interfaces/chat_react.UseTypingResponse.html#currentlyTyping property available from the response of the @useTyping@ hook to view a list of all users that are currently typing in the room.