@connectedxm/client 9.0.1 → 10.0.0

package/dist/index.js

@@ -1,5 +1,11 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/ConnectedProvider.tsx
-import React2 from "react";
+import React4 from "react";
 
 // src/websockets/useConnectedWebsocket.tsx
 import React from "react";
@@ -59,25 +65,6 @@ import {
   useInfiniteQuery
 } from "@tanstack/react-query";
 
-// src/utilities/AppendInfiniteQuery.ts
-import { produce } from "immer";
-var AppendInfiniteQuery = (queryClient, key, newData) => {
-  queryClient.setQueryData(
-    key,
-    (oldData) => {
-      return produce(oldData, (draft) => {
-        if (draft?.pages?.[0]?.data) {
-          if (draft?.pages?.[0]?.data && draft?.pages?.[0]?.data?.length > 0 && newData) {
-            draft?.pages?.[0]?.data?.unshift(newData);
-          } else {
-            draft.pages[0].data = [newData];
-          }
-        }
-      });
-    }
-  );
-};
-
 // src/utilities/GetErrorMessage.ts
 import axios from "axios";
 var ERR_NOT_GROUP_MEMBER = 453;
@@ -136,6 +123,97 @@ var isUUID = (id) => {
   return uuidRegex.test(id);
 };
 
+// src/utilities/InfiniteQueryHelpers.ts
+var InfiniteQueryHelpers_exports = {};
+__export(InfiniteQueryHelpers_exports, {
+  prepend: () => prepend,
+  remove: () => remove,
+  update: () => update
+});
+import { produce } from "immer";
+var prepend = (queryClient, key, item) => {
+  queryClient.setQueryData(
+    key,
+    (oldData) => {
+      if (!oldData) return oldData;
+      return produce(oldData, (draft) => {
+        if (draft?.pages?.[0]?.data) {
+          draft.pages[0].data.unshift(item);
+        }
+      });
+    }
+  );
+};
+var update = (queryClient, key, item) => {
+  queryClient.setQueryData(
+    key,
+    (oldData) => {
+      if (!oldData) return oldData;
+      return produce(oldData, (draft) => {
+        for (const page of draft.pages) {
+          if (page?.data) {
+            const idx = page.data.findIndex(
+              (entry) => entry.id === item.id
+            );
+            if (idx !== -1) {
+              page.data[idx] = item;
+              return;
+            }
+          }
+        }
+      });
+    }
+  );
+};
+var remove = (queryClient, key, itemId) => {
+  queryClient.setQueryData(
+    key,
+    (oldData) => {
+      if (!oldData) return oldData;
+      return produce(oldData, (draft) => {
+        for (const page of draft.pages) {
+          if (page?.data) {
+            const idx = page.data.findIndex(
+              (entry) => entry.id === itemId
+            );
+            if (idx !== -1) {
+              page.data.splice(idx, 1);
+              return;
+            }
+          }
+        }
+      });
+    }
+  );
+};
+
+// src/utilities/SingleQueryHelpers.ts
+var SingleQueryHelpers_exports = {};
+__export(SingleQueryHelpers_exports, {
+  remove: () => remove2,
+  update: () => update2
+});
+import { produce as produce2 } from "immer";
+var update2 = (queryClient, key, updater) => {
+  queryClient.setQueryData(
+    key,
+    (oldData) => {
+      if (!oldData) return oldData;
+      return produce2(oldData, (draft) => {
+        if (draft?.data) {
+          const next = updater(draft.data);
+          if (next !== void 0) {
+            draft.data = next;
+          }
+        }
+      });
+    }
+  );
+};
+var remove2 = (queryClient, key) => {
+  queryClient.removeQueries({ queryKey: key });
+};
+
 // src/queries/useConnectedInfiniteQuery.ts
 var GetBaseInfiniteQueryKeys = (locale, search = "") => {
   return [locale, search];
@@ -5685,196 +5763,6 @@ var useGetSelfLeadCounts = (options = {}) => {
   );
 };
 
-// src/queries/self/chat/useGetSelfChatChannels.ts
-var SELF_CHAT_CHANNELS_QUERY_KEY = () => [
-  ...SELF_QUERY_KEY(),
-  "CHANNELS"
-];
-var SET_SELF_CHAT_CHANNELS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...SELF_CHAT_CHANNELS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetSelfChatChannels = async ({
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/self/chat/channels`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
-    }
-  });
-  return data;
-};
-var useGetSelfChatChannels = (params = {}, options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedInfiniteQuery(
-    SELF_CHAT_CHANNELS_QUERY_KEY(),
-    (params2) => GetSelfChatChannels(params2),
-    params,
-    {
-      ...options,
-      enabled: !!authenticated && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/self/chat/useGetSelfChatChannel.ts
-var SELF_CHAT_CHANNEL_QUERY_KEY = (channelId) => [
-  ...SELF_CHAT_CHANNELS_QUERY_KEY(),
-  channelId
-];
-var SET_SELF_CHAT_CHANNEL_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...SELF_CHAT_CHANNEL_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetSelfChatChannel = async ({
-  channelId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/self/chat/channels/${channelId}`);
-  return data;
-};
-var useGetSelfChatChannel = (channelId = "", options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedSingleQuery(
-    SELF_CHAT_CHANNEL_QUERY_KEY(channelId),
-    (params) => GetSelfChatChannel({
-      channelId: channelId || "unknown",
-      ...params
-    }),
-    {
-      staleTime: Infinity,
-      ...options,
-      enabled: !!authenticated && !!channelId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/self/chat/useGetSelfChatChannelMembers.ts
-var SELF_CHAT_CHANNEL_MEMBERS_QUERY_KEY = (channelId) => [...SELF_CHAT_CHANNEL_QUERY_KEY(channelId), "MEMBERS"];
-var SET_SELF_CHAT_CHANNEL_MEMBERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...SELF_CHAT_CHANNEL_MEMBERS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetSelfChatChannelMembers = async ({
-  channelId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/self/chat/channels/${channelId}/members`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
-  );
-  return data;
-};
-var useGetSelfChatChannelMembers = (channelId = "", params = {}, options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedInfiniteQuery(
-    SELF_CHAT_CHANNEL_MEMBERS_QUERY_KEY(channelId),
-    (params2) => GetSelfChatChannelMembers({ ...params2, channelId }),
-    params,
-    {
-      ...options,
-      enabled: !!authenticated && !!channelId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/self/chat/useGetSelfChatChannelMessages.ts
-var SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY = (channelId) => [...SELF_CHAT_CHANNEL_QUERY_KEY(channelId), "MESSAGES"];
-var SET_SELF_CHAT_CHANNEL_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetSelfChatChannelMessages = async ({
-  channelId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  queryClient,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/self/chat/channels/${channelId}/messages`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    SET_SELF_CHAT_CHANNEL_QUERY_DATA(queryClient, [channelId], (old) => {
-      if (old && old.data) {
-        return {
-          ...old,
-          data: {
-            ...old.data,
-            read: true
-          }
-        };
-      }
-      return old;
-    });
-  }
-  return data;
-};
-var useGetSelfChatChannelMessages = (channelId = "", params = {}, options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedInfiniteQuery(
-    SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(channelId),
-    (params2) => GetSelfChatChannelMessages({ ...params2, channelId }),
-    params,
-    {
-      ...options,
-      enabled: !!authenticated && !!channelId && (options?.enabled ?? true)
-    }
-  );
-};
-
 // src/queries/self/useGetSelfProfile.ts
 var SELF_PROFILE_QUERY_KEY = (ignoreExecuteAs) => {
   const keys = ["SELF_PROFILE"];
@@ -6955,46 +6843,40 @@ var useGetStreamChatMessages = (streamId = "", sessionId = "", params = {}, opti
   );
 };
 
-// src/queries/threads/useGetThreadCircles.ts
+// src/queries/threads/useGetThreads.ts
 var THREADS_QUERY_KEY = () => ["THREADS"];
-var THREAD_CIRCLES_QUERY_KEY = () => [
-  ...THREADS_QUERY_KEY(),
-  "CIRCLES"
-];
-var SET_THREAD_CIRCLES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_THREADS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...THREAD_CIRCLES_QUERY_KEY(...keyParams),
+      ...THREADS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetThreadCircles = async ({
+var GetThreads = async ({
   pageParam,
   pageSize,
   orderBy,
   search,
-  type,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/circles`, {
+  const { data } = await clientApi.get(`/threads`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
       orderBy: orderBy || void 0,
-      search: search || void 0,
-      type: type || void 0
+      search: search || void 0
     }
   });
   return data;
 };
-var useGetThreadCircles = (params = {}, options = {}) => {
+var useGetThreads = (params = {}, options = {}) => {
   const { authenticated } = useConnected();
   return useConnectedInfiniteQuery(
-    THREAD_CIRCLES_QUERY_KEY(),
-    (params2) => GetThreadCircles(params2),
+    THREADS_QUERY_KEY(),
+    (params2) => GetThreads(params2),
     params,
     {
       ...options,
@@ -7003,162 +6885,92 @@ var useGetThreadCircles = (params = {}, options = {}) => {
   );
 };
 
-// src/queries/threads/useGetThreadCircle.ts
-var THREAD_CIRCLE_QUERY_KEY = (circleId) => [
-  ...THREAD_CIRCLES_QUERY_KEY(),
-  circleId
-];
-var SET_THREAD_CIRCLE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+// src/queries/threads/useGetThread.ts
+var THREAD_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), threadId, accountId];
+var SET_THREAD_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
   client.setQueryData(
-    [
-      ...THREAD_CIRCLE_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
+    [...THREAD_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
     response,
     options
   );
 };
-var GetThreadCircle = async ({
-  circleId,
+var GetThread = async ({
+  threadId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/circles/${circleId}`);
+  const { data } = await clientApi.get(`/threads/${threadId}`);
   return data;
 };
-var useGetThreadCircle = (circleId = "", options = {}) => {
+var useGetThread = (threadId = "", options = {}) => {
   return useConnectedSingleQuery(
-    THREAD_CIRCLE_QUERY_KEY(circleId),
-    (params) => GetThreadCircle({ circleId, ...params }),
+    THREAD_QUERY_KEY(threadId),
+    (params) => GetThread({ threadId, ...params }),
     {
       ...options,
-      enabled: !!circleId && (options?.enabled ?? true)
+      enabled: !!threadId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/threads/useGetThreadCircleAccounts.ts
-var THREAD_CIRCLE_ACCOUNTS_QUERY_KEY = (circleId) => [...THREAD_CIRCLE_QUERY_KEY(circleId), "ACCOUNTS"];
-var SET_THREAD_CIRCLE_ACCOUNTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/threads/useGetThreadAccounts.ts
+var THREAD_ACCOUNTS_QUERY_KEY = (threadId) => [
+  ...THREAD_QUERY_KEY(threadId),
+  "ACCOUNTS"
+];
+var SET_THREAD_ACCOUNTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(...keyParams),
+      ...THREAD_ACCOUNTS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetThreadCircleAccounts = async ({
-  circleId,
+var GetThreadAccounts = async ({
+  threadId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  role,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/threads/circles/${circleId}/accounts`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0,
-        role: role || void 0
-      }
+  const { data } = await clientApi.get(`/threads/${threadId}/accounts`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
     }
-  );
+  });
   return data;
 };
-var useGetThreadCircleAccounts = (circleId = "", params = {}, options = {}) => {
+var useGetThreadAccounts = (threadId = "", params = {}, options = {}) => {
   const { authenticated } = useConnected();
   return useConnectedInfiniteQuery(
-    THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId),
-    (params2) => GetThreadCircleAccounts({ ...params2, circleId }),
+    THREAD_ACCOUNTS_QUERY_KEY(threadId),
+    (params2) => GetThreadAccounts({ ...params2, threadId }),
     params,
     {
       ...options,
-      enabled: !!authenticated && !!circleId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!threadId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/threads/useGetThreadCircleAccount.ts
-var THREAD_CIRCLE_ACCOUNT_QUERY_KEY = (circleId, accountId) => [...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId), accountId];
-var SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+// src/queries/threads/useGetThreadMessages.ts
+var THREAD_MESSAGES_QUERY_KEY = (threadId) => [
+  ...THREAD_QUERY_KEY(threadId),
+  "MESSAGES"
+];
+var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...THREAD_CIRCLE_ACCOUNT_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
+      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
-    response,
-    options
-  );
-};
-var GetThreadCircleAccount = async ({
-  circleId,
-  accountId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/threads/circles/${circleId}/accounts/${accountId}`
-  );
-  return data;
-};
-var useGetThreadCircleAccount = (circleId = "", accountId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    THREAD_CIRCLE_ACCOUNT_QUERY_KEY(circleId, accountId),
-    (params) => GetThreadCircleAccount({ circleId, accountId, ...params }),
-    {
-      ...options,
-      enabled: !!circleId && !!accountId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/threads/useGetThread.ts
-var THREAD_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), threadId, accountId];
-var SET_THREAD_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
-  client.setQueryData(
-    [...THREAD_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
-    response,
-    options
-  );
-};
-var GetThread = async ({
-  threadId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/${threadId}`);
-  return data;
-};
-var useGetThread = (threadId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    THREAD_QUERY_KEY(threadId),
-    (params) => GetThread({ threadId, ...params }),
-    {
-      ...options,
-      enabled: !!threadId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/threads/useGetThreadMessages.ts
-var THREAD_MESSAGES_QUERY_KEY = (threadId) => [
-  ...THREAD_QUERY_KEY(threadId),
-  "MESSAGES"
-];
-var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
+    setFirstPageData(response)
   );
 };
 var GetThreadMessages = async ({
@@ -7675,96 +7487,6 @@ var useGetSupportTicketActivityLog = (supportTicketId = "", params = {}, options
   );
 };
 
-// src/websockets/chat/ChatMessageCreated.ts
-var ChatMessageCreated = (queryClient, locale, message) => {
-  const QueryKey4 = [
-    ...SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(message.body.channelId.toString()),
-    ...GetBaseInfiniteQueryKeys(locale || "en")
-  ];
-  const existingMessages = queryClient.getQueryData(QueryKey4);
-  const exists = existingMessages ? MergeInfinitePages(existingMessages).find(
-    (msg) => msg.id === message.body.message.id
-  ) : false;
-  if (!exists) {
-    AppendInfiniteQuery(queryClient, QueryKey4, message.body.message);
-  }
-};
-var ChatMessageCreated_default = ChatMessageCreated;
-
-// src/websockets/chat/ChatMessageDeleted.ts
-import { produce as produce2 } from "immer";
-var ChatMessageDeleted = (queryClient, locale, message) => {
-  const QueryKey4 = [
-    ...SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(message.body.channelId.toString()),
-    ...GetBaseInfiniteQueryKeys(locale || "en")
-  ];
-  queryClient.setQueryData(
-    QueryKey4,
-    (oldData) => {
-      return produce2(oldData, (draft) => {
-        if (draft?.pages) {
-          for (const page of draft.pages) {
-            if (page?.data) {
-              page.data = page.data.filter(
-                (msg) => msg.id !== message.body.messageId
-              );
-            }
-          }
-        }
-      });
-    }
-  );
-};
-var ChatMessageDeleted_default = ChatMessageDeleted;
-
-// src/websockets/chat/ChatMessageUpdated.ts
-import { produce as produce3 } from "immer";
-var ChatMessageUpdated = (queryClient, locale, message) => {
-  const QueryKey4 = [
-    ...SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(message.body.channelId.toString()),
-    ...GetBaseInfiniteQueryKeys(locale || "en")
-  ];
-  queryClient.setQueryData(
-    QueryKey4,
-    (oldData) => {
-      return produce3(oldData, (draft) => {
-        if (draft?.pages) {
-          for (const page of draft.pages) {
-            if (page?.data) {
-              const index = page.data.findIndex(
-                (msg) => msg.id === message.body.message.id
-              );
-              if (index !== -1) {
-                page.data[index] = message.body.message;
-                break;
-              }
-            }
-          }
-        }
-      });
-    }
-  );
-};
-var ChatMessageUpdated_default = ChatMessageUpdated;
-
-// src/websockets/threads/messages/ThreadMessageCreated.ts
-var ThreadMessageCreated = (_queryClient, _locale, _message) => {
-  return;
-};
-var ThreadMessageCreated_default = ThreadMessageCreated;
-
-// src/websockets/threads/messages/ThreadMessageDeleted.ts
-var ThreadMessageDeleted = (_queryClient, _locale, _message) => {
-  return;
-};
-var ThreadMessageDeleted_default = ThreadMessageDeleted;
-
-// src/websockets/threads/messages/ThreadMessageUpdated.ts
-var ThreadMessageUpdated = (_queryClient, _locale, _message) => {
-  return;
-};
-var ThreadMessageUpdated_default = ThreadMessageUpdated;
-
 // src/websockets/stream/StreamChatCreated.ts
 var StreamChatCreated = (queryClient, locale, message) => {
   const QueryKey4 = [
@@ -7779,13 +7501,13 @@ var StreamChatCreated = (queryClient, locale, message) => {
     (msg) => msg.messageId === message.body.message.messageId
   ) : false;
   if (!exists) {
-    AppendInfiniteQuery(queryClient, QueryKey4, message.body.message);
+    InfiniteQueryHelpers_exports.prepend(queryClient, QueryKey4, message.body.message);
   }
 };
 var StreamChatCreated_default = StreamChatCreated;
 
 // src/websockets/stream/StreamChatDeleted.ts
-import { produce as produce4 } from "immer";
+import { produce as produce3 } from "immer";
 var StreamChatDeleted = (queryClient, locale, message) => {
   const QueryKey4 = [
     ...STREAM_CHAT_MESSAGES_QUERY_KEY(
@@ -7797,7 +7519,7 @@ var StreamChatDeleted = (queryClient, locale, message) => {
   queryClient.setQueryData(
     QueryKey4,
     (oldData) => {
-      return produce4(oldData, (draft) => {
+      return produce3(oldData, (draft) => {
         if (draft?.pages) {
           for (const page of draft.pages) {
             if (page?.data) {
@@ -7814,7 +7536,7 @@ var StreamChatDeleted = (queryClient, locale, message) => {
 var StreamChatDeleted_default = StreamChatDeleted;
 
 // src/websockets/stream/StreamChatUpdated.ts
-import { produce as produce5 } from "immer";
+import { produce as produce4 } from "immer";
 var StreamChatUpdated = (queryClient, locale, message) => {
   const QueryKey4 = [
     ...STREAM_CHAT_MESSAGES_QUERY_KEY(
@@ -7826,7 +7548,7 @@ var StreamChatUpdated = (queryClient, locale, message) => {
   queryClient.setQueryData(
     QueryKey4,
     (oldData) => {
-      return produce5(oldData, (draft) => {
+      return produce4(oldData, (draft) => {
         if (draft?.pages) {
           for (const page of draft.pages) {
             if (page?.data) {
@@ -7872,7 +7594,8 @@ var useConnectedWebsocket = (useWebSocket, {
   getToken,
   getExecuteAs,
   websocketUrl,
-  organizationId
+  organizationId,
+  bus
 }) => {
   const queryClient = useQueryClient();
   const [socketUrl, setSocketUrl] = React.useState(null);
@@ -7928,21 +7651,15 @@ var useConnectedWebsocket = (useWebSocket, {
   const sendWSMessage = (message) => {
     sendJsonMessage(message);
   };
+  const lastDispatchedRef = React.useRef(null);
   React.useEffect(() => {
     if (!lastWSMessage) return;
-    if (lastWSMessage.type === "chat.message.created") {
-      ChatMessageCreated_default(queryClient, locale, lastWSMessage);
-    } else if (lastWSMessage.type === "chat.message.deleted") {
-      ChatMessageDeleted_default(queryClient, locale, lastWSMessage);
-    } else if (lastWSMessage.type === "chat.message.updated") {
-      ChatMessageUpdated_default(queryClient, locale, lastWSMessage);
-    } else if (lastWSMessage.type === "thread.message.created") {
-      ThreadMessageCreated_default(queryClient, locale, lastWSMessage);
-    } else if (lastWSMessage.type === "thread.message.updated") {
-      ThreadMessageUpdated_default(queryClient, locale, lastWSMessage);
-    } else if (lastWSMessage.type === "thread.message.deleted") {
-      ThreadMessageDeleted_default(queryClient, locale, lastWSMessage);
-    } else if (lastWSMessage.type === "stream.chat.created") {
+    if (lastDispatchedRef.current === lastWSMessage) return;
+    lastDispatchedRef.current = lastWSMessage;
+    if (bus) {
+      bus.dispatch(lastWSMessage);
+    }
+    if (lastWSMessage.type === "stream.chat.created") {
       StreamChatCreated_default(queryClient, locale, lastWSMessage);
     } else if (lastWSMessage.type === "stream.chat.deleted") {
       StreamChatDeleted_default(queryClient, locale, lastWSMessage);
@@ -7955,24 +7672,193 @@ var useConnectedWebsocket = (useWebSocket, {
     } else if (lastWSMessage.type === "pulse") {
       PulseMessage_default(queryClient, locale, lastWSMessage);
     }
-  });
+  }, [lastWSMessage, bus, queryClient, locale]);
   return { sendWSMessage, lastWSMessage, readyState };
 };
 
+// src/socket/WSMessageBus.tsx
+import React2 from "react";
+var WSMessageBus = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  register(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => {
+      const current = this.handlers.get(event);
+      if (current) {
+        current.delete(handler);
+        if (current.size === 0) {
+          this.handlers.delete(event);
+        }
+      }
+    };
+  }
+  dispatch(envelope) {
+    if (!envelope) return;
+    const eventName = envelope.event ?? envelope.type;
+    if (!eventName) return;
+    const handlers = this.handlers.get(eventName);
+    if (!handlers || handlers.size === 0) return;
+    const payload = envelope.body ?? envelope.payload;
+    if (payload === void 0) {
+      console.warn(
+        `[WSMessageBus] envelope for "${eventName}" had no body/payload; skipping`
+      );
+      return;
+    }
+    handlers.forEach((handler) => {
+      try {
+        handler(payload);
+      } catch (err) {
+        console.error(`[WSMessageBus] handler for "${eventName}" threw`, err);
+      }
+    });
+  }
+  clear() {
+    this.handlers.clear();
+  }
+};
+var WSMessageBusContext = React2.createContext(null);
+var WSMessageBusProvider = ({
+  bus,
+  children
+}) => {
+  const ref = React2.useRef(null);
+  if (!ref.current) {
+    ref.current = bus ?? new WSMessageBus();
+  }
+  return /* @__PURE__ */ React2.createElement(WSMessageBusContext.Provider, { value: ref.current }, children);
+};
+var useWSMessageBus = () => {
+  const ctx = React2.useContext(WSMessageBusContext);
+  if (!ctx) {
+    throw new Error(
+      "useWSMessageBus must be used within a WSMessageBusProvider"
+    );
+  }
+  return ctx;
+};
+var useWSEvent = (event, handler) => {
+  const bus = useWSMessageBus();
+  React2.useEffect(() => {
+    return bus.register(event, handler);
+  }, [bus, event, handler]);
+};
+
+// src/socket/threads/ThreadTypingEffect.tsx
+import React3 from "react";
+var TYPING_TTL_MS = 6e3;
+var EMPTY_THREAD_TYPING = Object.freeze({});
+var ThreadTypingStore = class {
+  constructor() {
+    this.state = {};
+    this.listeners = /* @__PURE__ */ new Set();
+    this.expiryTimers = /* @__PURE__ */ new Map();
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    };
+    this.getSnapshot = () => this.state;
+  }
+  setState(next) {
+    this.state = next;
+    this.listeners.forEach((listener) => listener(this.state));
+  }
+  scheduleExpiry(threadId, accountId) {
+    const key = `${threadId}::${accountId}`;
+    const existing = this.expiryTimers.get(key);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.expiryTimers.delete(key);
+      const threadMap = this.state[threadId];
+      if (!threadMap || !(accountId in threadMap)) return;
+      const nextThreadMap = { ...threadMap };
+      delete nextThreadMap[accountId];
+      const next = { ...this.state };
+      if (Object.keys(nextThreadMap).length === 0) {
+        delete next[threadId];
+      } else {
+        next[threadId] = nextThreadMap;
+      }
+      this.setState(next);
+    }, TYPING_TTL_MS);
+    this.expiryTimers.set(key, timer);
+  }
+  record(threadId, accountId, typingAt) {
+    const nextThreadMap = {
+      ...this.state[threadId] ?? {},
+      [accountId]: typingAt
+    };
+    this.setState({ ...this.state, [threadId]: nextThreadMap });
+    this.scheduleExpiry(threadId, accountId);
+  }
+};
+var ThreadTypingStoreContext = React3.createContext(
+  null
+);
+var ThreadTypingStoreProvider = ({
+  store,
+  children
+}) => {
+  const ref = React3.useRef(null);
+  if (!ref.current) {
+    ref.current = store ?? new ThreadTypingStore();
+  }
+  return /* @__PURE__ */ React3.createElement(ThreadTypingStoreContext.Provider, { value: ref.current }, children);
+};
+var useThreadTypingStore = () => {
+  const store = React3.useContext(ThreadTypingStoreContext);
+  if (!store) {
+    throw new Error(
+      "useThreadTypingStore must be used within a ConnectedProvider"
+    );
+  }
+  return store;
+};
+var useThreadTyping = (threadId) => {
+  const store = useThreadTypingStore();
+  const fullState = React3.useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot
+  );
+  return fullState[threadId] ?? EMPTY_THREAD_TYPING;
+};
+var ThreadTypingEffect = () => {
+  const store = useThreadTypingStore();
+  const handler = React3.useCallback(
+    (payload) => {
+      store.record(payload.threadId, payload.accountId, payload.typingAt);
+    },
+    [store]
+  );
+  useWSEvent("thread.typing", handler);
+  return null;
+};
+
 // src/ConnectedProvider.tsx
-var ConnectedXMClientContext = React2.createContext(
+var ConnectedXMClientContext = React4.createContext(
   {}
 );
-var ConnectedProvider = ({
+var ConnectedProviderInner = ({
   children,
   useWebSocket,
+  bus,
   ...state
 }) => {
   const { sendWSMessage, lastWSMessage, readyState } = useConnectedWebsocket(
     useWebSocket,
-    state
+    { ...state, bus }
   );
-  return /* @__PURE__ */ React2.createElement(
+  return /* @__PURE__ */ React4.createElement(
     ConnectedXMClientContext.Provider,
     {
       value: {
@@ -7985,11 +7871,22 @@ var ConnectedProvider = ({
     children
   );
 };
+var ConnectedProvider = (props) => {
+  const busRef = React4.useRef(null);
+  if (!busRef.current) {
+    busRef.current = new WSMessageBus();
+  }
+  const typingStoreRef = React4.useRef(null);
+  if (!typingStoreRef.current) {
+    typingStoreRef.current = new ThreadTypingStore();
+  }
+  return /* @__PURE__ */ React4.createElement(WSMessageBusProvider, { bus: busRef.current }, /* @__PURE__ */ React4.createElement(ThreadTypingStoreProvider, { store: typingStoreRef.current }, /* @__PURE__ */ React4.createElement(ConnectedProviderInner, { ...props, bus: busRef.current })));
+};
 
 // src/hooks/useConnected.ts
-import React3 from "react";
+import React5 from "react";
 var useConnected = () => {
-  const context = React3.useContext(
+  const context = React5.useContext(
     ConnectedXMClientContext
   );
   if (!context) {
@@ -8424,12 +8321,6 @@ var PaymentIntentSource = /* @__PURE__ */ ((PaymentIntentSource2) => {
   PaymentIntentSource2["booking"] = "booking";
   return PaymentIntentSource2;
 })(PaymentIntentSource || {});
-var ThreadCircleAccountRole = /* @__PURE__ */ ((ThreadCircleAccountRole2) => {
-  ThreadCircleAccountRole2["member"] = "member";
-  ThreadCircleAccountRole2["manager"] = "manager";
-  ThreadCircleAccountRole2["invited"] = "invited";
-  return ThreadCircleAccountRole2;
-})(ThreadCircleAccountRole || {});
 var ThreadMessageType = /* @__PURE__ */ ((ThreadMessageType2) => {
   ThreadMessageType2["user"] = "user";
   ThreadMessageType2["bot"] = "bot";
@@ -8575,7 +8466,7 @@ var useConnectedMutation = (mutation, options) => {
 var useConnectedMutation_default = useConnectedMutation;
 
 // src/mutations/accounts/useFollowAccount.ts
-import { produce as produce6 } from "immer";
+import { produce as produce5 } from "immer";
 var FollowAccount = async ({
   accountId,
   clientApiParams,
@@ -8588,7 +8479,7 @@ var FollowAccount = async ({
   if (queryClient && data.status === "ok") {
     queryClient.setQueryData(
       [...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.id), clientApiParams.locale],
-      (prev) => produce6(prev, (data2) => {
+      (prev) => produce5(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers + 1;
         }
@@ -8599,7 +8490,7 @@ var FollowAccount = async ({
         ...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.username),
         clientApiParams.locale
       ],
-      (prev) => produce6(prev, (data2) => {
+      (prev) => produce5(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers + 1;
         }
@@ -8622,7 +8513,7 @@ var useFollowAccount = (options = {}) => {
 };
 
 // src/mutations/accounts/useUnfollowAccount.ts
-import { produce as produce7 } from "immer";
+import { produce as produce6 } from "immer";
 var UnfollowAccount = async ({
   accountId,
   clientApiParams,
@@ -8635,7 +8526,7 @@ var UnfollowAccount = async ({
   if (queryClient && data.status === "ok") {
     queryClient.setQueryData(
       [...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.id), clientApiParams.locale],
-      (prev) => produce7(prev, (data2) => {
+      (prev) => produce6(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers - 1;
         }
@@ -8646,7 +8537,7 @@ var UnfollowAccount = async ({
         ...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.username),
         clientApiParams.locale
       ],
-      (prev) => produce7(prev, (data2) => {
+      (prev) => produce6(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers - 1;
         }
@@ -8717,11 +8608,11 @@ var useUnblockAccount = (options = {}) => {
 };
 
 // src/mutations/activities/optimistic/UpdateComments.ts
-import { produce as produce8 } from "immer";
+import { produce as produce7 } from "immer";
 var UpdateCommentsSingle = (increment, queryClient, KEY) => {
   queryClient.setQueryData(
     KEY,
-    (originalData) => produce8(originalData, (draft) => {
+    (originalData) => produce7(originalData, (draft) => {
       if (!draft?.data) {
         return;
       }
@@ -8733,7 +8624,7 @@ var UpdateCommentsSingle = (increment, queryClient, KEY) => {
 var UpdateCommentsInfinite = (increment, queryClient, KEY, activityId) => {
   queryClient.setQueriesData(
     { queryKey: KEY, exact: false },
-    (originalData) => produce8(originalData, (draft) => {
+    (originalData) => produce7(originalData, (draft) => {
       if (!draft?.pages || draft.pages.length === 0) {
         return;
       }
@@ -8778,7 +8669,7 @@ var CreateActivity = async ({
     let nested = false;
     if (activity.commentedId) {
       nested = true;
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         [
           ...ACTIVITY_COMMENTS_QUERY_KEY(activity.commentedId),
@@ -8817,22 +8708,22 @@ var CreateActivity = async ({
         ),
         ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
       ];
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         iDIDKey,
         data.data
       );
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         iDSlugKey,
         data.data
       );
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         slugIDKey,
         data.data
       );
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         slugSlugKey,
         data.data
@@ -8848,12 +8739,12 @@ var CreateActivity = async ({
         ...EVENT_ACTIVITIES_QUERY_KEY(data.data.event?.slug || ""),
         ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
       ];
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         iDKey,
         data.data
       );
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         slugKey,
         data.data
@@ -8869,19 +8760,19 @@ var CreateActivity = async ({
         ...GROUP_ACTIVITIES_QUERY_KEY(data.data.group?.slug || ""),
         ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
       ];
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         iDKey,
         data.data
       );
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         slugKey,
         data.data
       );
     }
     if (!nested) {
-      AppendInfiniteQuery(
+      InfiniteQueryHelpers_exports.prepend(
         queryClient,
         [
           ...ACTIVITIES_QUERY_KEY(),
@@ -8917,11 +8808,11 @@ var useDeleteActivity = (options = {}) => {
 };
 
 // src/mutations/activities/optimistic/UpdateLikes.ts
-import { produce as produce9 } from "immer";
+import { produce as produce8 } from "immer";
 var UpdateLikesSingle = (increment, queryClient, KEY) => {
   queryClient.setQueryData(
     KEY,
-    (originalData) => produce9(originalData, (draft) => {
+    (originalData) => produce8(originalData, (draft) => {
       if (!draft?.data) {
         return;
       }
@@ -8933,7 +8824,7 @@ var UpdateLikesSingle = (increment, queryClient, KEY) => {
 var UpdateLikesInfinite = (increment, queryClient, KEY, activityId) => {
   queryClient.setQueriesData(
     { queryKey: KEY, exact: false },
-    (originalData) => produce9(originalData, (draft) => {
+    (originalData) => produce8(originalData, (draft) => {
       if (!draft?.pages || draft.pages.length === 0) {
         return;
       }
@@ -10406,170 +10297,6 @@ var useUpdateSelfLead = (options = {}) => {
   return useConnectedMutation_default(UpdateSelfLead, options);
 };
 
-// src/mutations/self/chat/useAddSelfChatChannelMember.ts
-var AddSelfChatChannelMember = async ({
-  channelId,
-  accountId,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/self/chat/channels/${channelId}/members/${accountId}`
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: SELF_CHAT_CHANNEL_MEMBERS_QUERY_KEY(channelId)
-    });
-  }
-  return data;
-};
-var useAddSelfChatChannelMember = (options = {}) => {
-  return useConnectedMutation_default(AddSelfChatChannelMember, options);
-};
-
-// src/mutations/self/chat/useCreateSelfChatChannel.ts
-var CreateSelfChatChannel = async ({
-  name,
-  accountIds,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/self/chat/channels`,
-    {
-      name,
-      accountIds
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: SELF_CHAT_CHANNELS_QUERY_KEY()
-    });
-  }
-  return data;
-};
-var useCreateSelfChatChannel = (options = {}) => {
-  return useConnectedMutation_default(CreateSelfChatChannel, options);
-};
-
-// src/mutations/self/chat/useCreateSelfChatChannelMessage.ts
-var CreateSelfChatChannelMessage = async ({
-  channelId,
-  text,
-  queryClient,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(`/self/chat/channels/${channelId}/messages`, {
-    text
-  });
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(channelId.toString())
-    });
-  }
-  return data;
-};
-var useCreateSelfChatChannelMessage = (options = {}) => {
-  return useConnectedMutation_default(CreateSelfChatChannelMessage, options);
-};
-
-// src/mutations/self/chat/useDeleteSelfChatChannel.ts
-var DeleteSelfChatChannel = async ({
-  channelId,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/self/chat/channels/${channelId}`
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({ queryKey: SELF_CHAT_CHANNELS_QUERY_KEY() });
-    queryClient.removeQueries({
-      queryKey: SELF_CHAT_CHANNEL_QUERY_KEY(channelId)
-    });
-  }
-  return data;
-};
-var useDeleteSelfChatChannel = (options = {}) => {
-  return useConnectedMutation_default(DeleteSelfChatChannel, options);
-};
-
-// src/mutations/self/chat/useDeleteSelfChatChannelMessage.ts
-var DeleteSelfChatChannelMessage = async ({
-  channelId,
-  messageId,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/self/chat/channels/${channelId}/messages/${messageId}`
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY(channelId)
-    });
-  }
-  return data;
-};
-var useDeleteSelfChatChannelMessage = (options = {}) => {
-  return useConnectedMutation_default(DeleteSelfChatChannelMessage, options);
-};
-
-// src/mutations/self/chat/useLeaveSelfChatChannel.ts
-var LeaveSelfChatChannel = async ({
-  channelId,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/self/chat/channels/${channelId}/leave`
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({ queryKey: SELF_CHAT_CHANNELS_QUERY_KEY() });
-    queryClient.removeQueries({
-      queryKey: SELF_CHAT_CHANNEL_QUERY_KEY(channelId)
-    });
-  }
-  return data;
-};
-var useLeaveSelfChatChannel = (options = {}) => {
-  return useConnectedMutation_default(LeaveSelfChatChannel, options);
-};
-
-// src/mutations/self/chat/useUpdateSelfChatChannelNotifications.ts
-var UpdateSelfChatChannelNotifications = async ({
-  channelId,
-  notifications,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.put(
-    `/self/chat/channels/${channelId}/notifications`,
-    {
-      notifications
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    SET_SELF_CHAT_CHANNEL_QUERY_DATA(queryClient, [channelId], data, [
-      clientApiParams.locale
-    ]);
-    queryClient.invalidateQueries({
-      queryKey: SELF_CHAT_CHANNELS_QUERY_KEY()
-    });
-  }
-  return data;
-};
-var useUpdateSelfChatChannelNotifications = (options = {}) => {
-  return useConnectedMutation_default(UpdateSelfChatChannelNotifications, options);
-};
-
 // src/mutations/self/useAddSelfEventSession.ts
 var AddSelfEventSession = async ({
   eventId,
@@ -10866,7 +10593,7 @@ var CreateSupportTicket = async ({
     SET_SUPPORT_TICKET_QUERY_DATA(queryClient, [data.data.id], data, [
       clientApiParams.locale
     ]);
-    AppendInfiniteQuery(
+    InfiniteQueryHelpers_exports.prepend(
       queryClient,
       [
         ...SUPPORT_TICKETS_QUERY_KEY(type, data.data.state),
@@ -10874,7 +10601,7 @@ var CreateSupportTicket = async ({
       ],
       data.data
     );
-    AppendInfiniteQuery(
+    InfiniteQueryHelpers_exports.prepend(
       queryClient,
       [
         ...SUPPORT_TICKETS_QUERY_KEY(),
@@ -10899,7 +10626,7 @@ var CreateSupportTicketMessage = async ({
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.post(`/supportTickets/${supportTicketId}/messages`, { message });
   if (queryClient && data.status === "ok") {
-    AppendInfiniteQuery(
+    InfiniteQueryHelpers_exports.prepend(
       queryClient,
       [
         ...SUPPORT_TICKET_MESSAGES_QUERY_KEY(supportTicketId),
@@ -12316,7 +12043,7 @@ var CreateStreamChatMessage = async ({
       ...STREAM_CHAT_MESSAGES_QUERY_KEY(streamId, sessionId),
       ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
     ];
-    AppendInfiniteQuery(queryClient, QueryKey4, data.data);
+    InfiniteQueryHelpers_exports.prepend(queryClient, QueryKey4, data.data);
   }
   return data;
 };
@@ -12325,7 +12052,7 @@ var useCreateStreamChatMessage = (options = {}) => {
 };
 
 // src/mutations/streams/useUpdateStreamChatMessage.ts
-import { produce as produce10 } from "immer";
+import { produce as produce9 } from "immer";
 var UpdateStreamChatMessage = async ({
   streamId,
   sessionId,
@@ -12349,7 +12076,7 @@ var UpdateStreamChatMessage = async ({
     queryClient.setQueryData(
       QueryKey4,
       (oldData) => {
-        return produce10(oldData, (draft) => {
+        return produce9(oldData, (draft) => {
           if (draft?.pages) {
             for (const page of draft.pages) {
               if (page?.data) {
@@ -12396,6 +12123,31 @@ var useDeleteStreamChatMessage = (options = {}) => {
   return useConnectedMutation(DeleteStreamChatMessage, options);
 };
 
+// src/mutations/threads/useCreateThread.ts
+var CreateThread = async ({
+  accountIds,
+  subject,
+  imageId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(`/threads`, {
+    accountIds,
+    subject,
+    imageId
+  });
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useCreateThread = (options = {}) => {
+  return useConnectedMutation(CreateThread, options);
+};
+
 // src/mutations/threads/useUpdateThread.ts
 var UpdateThread = async ({
   threadId,
@@ -12420,6 +12172,51 @@ var useUpdateThread = (options = {}) => {
   return useConnectedMutation(UpdateThread, options);
 };
 
+// src/mutations/threads/useMarkThreadRead.ts
+var MarkThreadRead = async ({
+  threadId,
+  messageId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(`/threads/${threadId}/read`, {
+    messageId
+  });
+  return data;
+};
+var useMarkThreadRead = (options = {}) => {
+  return useConnectedMutation(MarkThreadRead, options);
+};
+
+// src/mutations/threads/useMarkThreadMessageRead.ts
+var MarkThreadMessageRead = async ({
+  threadId,
+  messageId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/messages/${messageId}/read`
+  );
+  return data;
+};
+var useMarkThreadMessageRead = (options = {}) => {
+  return useConnectedMutation(MarkThreadMessageRead, options);
+};
+
+// src/mutations/threads/useSendThreadTyping.ts
+var SendThreadTyping = async ({
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(`/threads/${threadId}/typing`, {});
+  return data;
+};
+var useSendThreadTyping = (options = {}) => {
+  return useConnectedMutation(SendThreadTyping, options);
+};
+
 // src/mutations/threads/useCreateThreadMessage.ts
 var CreateThreadMessage = async ({
   threadId,
@@ -12434,7 +12231,7 @@ var CreateThreadMessage = async ({
     entities
   });
   if (queryClient && data.status === "ok") {
-    AppendInfiniteQuery(
+    InfiniteQueryHelpers_exports.prepend(
       queryClient,
       THREAD_MESSAGES_QUERY_KEY(threadId),
       data.data
@@ -12543,106 +12340,6 @@ var useRemoveThreadMessageReaction = (options = {}) => {
   return useConnectedMutation(RemoveThreadMessageReaction, options);
 };
 
-// src/mutations/threads/useUpdateThreadCircle.ts
-var UpdateThreadCircle = async ({
-  circleId,
-  name,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.put(`/threads/circles/${circleId}`, {
-    name
-  });
-  if (queryClient && data.status === "ok") {
-    SET_THREAD_CIRCLE_QUERY_DATA(queryClient, [circleId], data, [
-      clientApiParams.locale
-    ]);
-  }
-  return data;
-};
-var useUpdateThreadCircle = (options = {}) => {
-  return useConnectedMutation(UpdateThreadCircle, options);
-};
-
-// src/mutations/threads/useAddThreadCircleAccount.ts
-var AddThreadCircleAccount = async ({
-  circleId,
-  accountId,
-  role,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/threads/circles/${circleId}/accounts`,
-    {
-      accountId,
-      role
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
-    });
-  }
-  return data;
-};
-var useAddThreadCircleAccount = (options = {}) => {
-  return useConnectedMutation(AddThreadCircleAccount, options);
-};
-
-// src/mutations/threads/useUpdateThreadCircleAccount.ts
-var UpdateThreadCircleAccount = async ({
-  circleId,
-  accountId,
-  role,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.put(
-    `/threads/circles/${circleId}/accounts/${accountId}`,
-    {
-      role
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA(
-      queryClient,
-      [circleId, accountId],
-      data,
-      [clientApiParams.locale]
-    );
-  }
-  return data;
-};
-var useUpdateThreadCircleAccount = (options = {}) => {
-  return useConnectedMutation(UpdateThreadCircleAccount, options);
-};
-
-// src/mutations/threads/useDeleteThreadCircleAccount.ts
-var DeleteThreadCircleAccount = async ({
-  circleId,
-  accountId,
-  clientApiParams,
-  queryClient
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/threads/circles/${circleId}/accounts/${accountId}`
-  );
-  if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
-    });
-  }
-  return data;
-};
-var useDeleteThreadCircleAccount = (options = {}) => {
-  return useConnectedMutation(DeleteThreadCircleAccount, options);
-};
-
 // src/mutations/integrations/useBlockIntegration.ts
 var BlockIntegration = async ({
   type,
@@ -12848,6 +12545,179 @@ var CreateInterest = async ({
 var useCreateInterest = (options = {}) => {
   return useConnectedMutation_default(CreateInterest, options);
 };
+
+// src/socket/threads/ThreadMessageCreatedEffect.tsx
+import React6 from "react";
+import { useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+import { produce as produce10 } from "immer";
+var ThreadMessageCreatedEffect = () => {
+  const queryClient = useQueryClient3();
+  const { locale } = useConnected();
+  const handler = React6.useCallback(
+    (payload) => {
+      const messagesKey = [
+        ...THREAD_MESSAGES_QUERY_KEY(payload.threadId),
+        ...GetBaseInfiniteQueryKeys(locale || "en")
+      ];
+      const existing = queryClient.getQueryData(messagesKey);
+      const alreadyCached = existing ? MergeInfinitePages(existing).some(
+        (msg) => msg.id === payload.message.id
+      ) : false;
+      if (!alreadyCached) {
+        prepend(queryClient, messagesKey, payload.message);
+      }
+      const threadsKey = [
+        ...THREADS_QUERY_KEY(),
+        ...GetBaseInfiniteQueryKeys(locale || "en")
+      ];
+      queryClient.setQueryData(
+        threadsKey,
+        (oldData) => {
+          if (!oldData) return oldData;
+          return produce10(oldData, (draft) => {
+            let found = null;
+            let foundPageIdx = -1;
+            let foundIdx = -1;
+            for (let p = 0; p < draft.pages.length; p++) {
+              const page = draft.pages[p];
+              if (!page?.data) continue;
+              const idx = page.data.findIndex(
+                (t) => t.id === payload.threadId
+              );
+              if (idx !== -1) {
+                found = page.data[idx];
+                foundPageIdx = p;
+                foundIdx = idx;
+                break;
+              }
+            }
+            if (found && foundPageIdx !== -1) {
+              const sourcePage = draft.pages[foundPageIdx];
+              if (sourcePage?.data) {
+                sourcePage.data.splice(foundIdx, 1);
+              }
+              found.lastMessageAt = payload.message.sentAt;
+              found.lastMessage = payload.message.body;
+              const firstPage = draft.pages[0];
+              if (firstPage?.data) {
+                firstPage.data.unshift(found);
+              }
+            }
+          });
+        }
+      );
+    },
+    [queryClient, locale]
+  );
+  useWSEvent("thread.message.created", handler);
+  return null;
+};
+
+// src/socket/threads/ThreadMessageUpdatedEffect.tsx
+import React7 from "react";
+import { useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+var ThreadMessageUpdatedEffect = () => {
+  const queryClient = useQueryClient4();
+  const { locale } = useConnected();
+  const handler = React7.useCallback(
+    (payload) => {
+      const messagesKey = [
+        ...THREAD_MESSAGES_QUERY_KEY(payload.threadId),
+        ...GetBaseInfiniteQueryKeys(locale || "en")
+      ];
+      update(queryClient, messagesKey, payload.message);
+    },
+    [queryClient, locale]
+  );
+  useWSEvent("thread.message.updated", handler);
+  return null;
+};
+
+// src/socket/threads/ThreadMessageDeletedEffect.tsx
+import React8 from "react";
+import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
+var ThreadMessageDeletedEffect = () => {
+  const queryClient = useQueryClient5();
+  const { locale } = useConnected();
+  const handler = React8.useCallback(
+    (payload) => {
+      const messagesKey = [
+        ...THREAD_MESSAGES_QUERY_KEY(payload.threadId),
+        ...GetBaseInfiniteQueryKeys(locale || "en")
+      ];
+      remove(queryClient, messagesKey, payload.messageId);
+    },
+    [queryClient, locale]
+  );
+  useWSEvent("thread.message.deleted", handler);
+  return null;
+};
+
+// src/socket/threads/ThreadReadEffect.tsx
+import React9 from "react";
+import { useQueryClient as useQueryClient6 } from "@tanstack/react-query";
+import { produce as produce11 } from "immer";
+var ThreadReadEffect = () => {
+  const queryClient = useQueryClient6();
+  const { locale } = useConnected();
+  const { data: self } = useGetSelf();
+  const selfId = self?.data?.id;
+  const handler = React9.useCallback(
+    (payload) => {
+      const accountsKey = [
+        ...THREAD_ACCOUNTS_QUERY_KEY(payload.threadId),
+        ...GetBaseInfiniteQueryKeys(locale || "en")
+      ];
+      queryClient.setQueryData(
+        accountsKey,
+        (oldData) => {
+          if (!oldData) return oldData;
+          return produce11(oldData, (draft) => {
+            for (const page of draft.pages) {
+              if (!page?.data) continue;
+              const idx = page.data.findIndex(
+                (entry) => entry.accountId === payload.accountId
+              );
+              if (idx !== -1) {
+                page.data[idx].lastReadAt = payload.readAt;
+                return;
+              }
+            }
+          });
+        }
+      );
+      if (!selfId || payload.accountId !== selfId) return;
+      const threadsKey = [
+        ...THREADS_QUERY_KEY(),
+        ...GetBaseInfiniteQueryKeys(locale || "en")
+      ];
+      queryClient.setQueryData(
+        threadsKey,
+        (oldData) => {
+          if (!oldData) return oldData;
+          return produce11(oldData, (draft) => {
+            for (const page of draft.pages) {
+              if (!page?.data) continue;
+              const idx = page.data.findIndex(
+                (t) => t.id === payload.threadId
+              );
+              if (idx !== -1) {
+                const row = page.data[idx];
+                if (row?._count) {
+                  row._count.messages = 0;
+                  return;
+                }
+              }
+            }
+          });
+        }
+      );
+    },
+    [queryClient, locale, selfId]
+  );
+  useWSEvent("thread.read", handler);
+  return null;
+};
 export {
   ACCOUNTS_POPULAR_QUERY_KEY,
   ACCOUNTS_QUERY_KEY,
@@ -12876,13 +12746,10 @@ export {
   AddListingCoHost,
   AddListingSponsor,
   AddLogin,
-  AddSelfChatChannelMember,
   AddSelfEventSession,
   AddSelfInterests,
-  AddThreadCircleAccount,
   AddThreadMessageReaction,
   AdvertisementType,
-  AppendInfiniteQuery,
   ApplyEventRegistrationCoupon,
   BENEFITS_QUERY_KEY,
   BOOKINGS_QUERY_KEY,
@@ -12944,12 +12811,11 @@ export {
   CreateListingSpeaker,
   CreateLoginAccount,
   CreateSelfAddress,
-  CreateSelfChatChannel,
-  CreateSelfChatChannelMessage,
   CreateSelfLead,
   CreateStreamChatMessage,
   CreateSupportTicket,
   CreateSupportTicketMessage,
+  CreateThread,
   CreateThreadMessage,
   DayOfWeek,
   DeactivateGroup,
@@ -12968,12 +12834,9 @@ export {
   DeleteListingSpeaker,
   DeleteSelf,
   DeleteSelfAddress,
-  DeleteSelfChatChannel,
-  DeleteSelfChatChannelMessage,
   DeleteSelfLead,
   DeleteSelfPushDevice,
   DeleteStreamChatMessage,
-  DeleteThreadCircleAccount,
   DeleteThreadMessage,
   DemoteGroupModerator,
   DisableIntegration,
@@ -13197,10 +13060,6 @@ export {
   GetSelfAddresses,
   GetSelfAnnouncement,
   GetSelfChannelSubscriber,
-  GetSelfChatChannel,
-  GetSelfChatChannelMembers,
-  GetSelfChatChannelMessages,
-  GetSelfChatChannels,
   GetSelfContacts,
   GetSelfEventListing,
   GetSelfEventListingAnnouncement,
@@ -13249,12 +13108,10 @@ export {
   GetSurveySubmissions,
   GetSurveys,
   GetThread,
-  GetThreadCircle,
-  GetThreadCircleAccount,
-  GetThreadCircleAccounts,
-  GetThreadCircles,
+  GetThreadAccounts,
   GetThreadMessage,
   GetThreadMessages,
+  GetThreads,
   GetUsernameAvailability,
   GetVideo,
   GroupAccess,
@@ -13272,6 +13129,7 @@ export {
   INVOICE_PAYMENTS_QUERY_KEY,
   INVOICE_QUERY_KEY,
   ImageType,
+  InfiniteQueryHelpers_exports as InfiniteQueryHelpers,
   IntegrationType,
   InvoiceStatus,
   JoinGroup,
@@ -13299,11 +13157,12 @@ export {
   LOGIN_QUERY_KEY,
   LeadStatus,
   LeaveGroup,
-  LeaveSelfChatChannel,
   LikeActivity,
   LikeContent,
   LocationQuestionOption,
   MEETING_QUERY_KEY,
+  MarkThreadMessageRead,
+  MarkThreadRead,
   MeetingType,
   MergeInfinitePages,
   NotificationType,
@@ -13346,10 +13205,6 @@ export {
   SELF_ANNOUNCEMENT_QUERY_KEY,
   SELF_BOOKING_INTENT_QUERY_KEY,
   SELF_CHANNEL_SUBSCRIBER_QUERY_KEY,
-  SELF_CHAT_CHANNELS_QUERY_KEY,
-  SELF_CHAT_CHANNEL_MEMBERS_QUERY_KEY,
-  SELF_CHAT_CHANNEL_MESSAGES_QUERY_KEY,
-  SELF_CHAT_CHANNEL_QUERY_KEY,
   SELF_CONTACTS_QUERY_KEY,
   SELF_EVENTS_QUERY_KEY,
   SELF_EVENT_SESSIONS_QUERY_KEY,
@@ -13473,10 +13328,6 @@ export {
   SET_PAYMENT_QUERY_DATA,
   SET_PUSH_DEVICE_QUERY_DATA,
   SET_SELF_CHANNEL_SUBSCRIBER_QUERY_DATA,
-  SET_SELF_CHAT_CHANNELS_QUERY_DATA,
-  SET_SELF_CHAT_CHANNEL_MEMBERS_QUERY_DATA,
-  SET_SELF_CHAT_CHANNEL_MESSAGES_QUERY_DATA,
-  SET_SELF_CHAT_CHANNEL_QUERY_DATA,
   SET_SELF_GROUP_MEMBERSHIP_QUERY_DATA,
   SET_SELF_PROFILE_QUERY_DATA,
   SET_SELF_QUERY_DATA,
@@ -13494,10 +13345,8 @@ export {
   SET_SURVEYS_QUERY_DATA,
   SET_SURVEY_QUERY_DATA,
   SET_SURVEY_SUBMISSION_SECTIONS_QUERY_DATA,
-  SET_THREAD_CIRCLES_QUERY_DATA,
-  SET_THREAD_CIRCLE_ACCOUNTS_QUERY_DATA,
-  SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA,
-  SET_THREAD_CIRCLE_QUERY_DATA,
+  SET_THREADS_QUERY_DATA,
+  SET_THREAD_ACCOUNTS_QUERY_DATA,
   SET_THREAD_MESSAGES_QUERY_DATA,
   SET_THREAD_MESSAGE_QUERY_DATA,
   SET_THREAD_QUERY_DATA,
@@ -13515,10 +13364,12 @@ export {
   SURVEY_SUBMISSIONS_QUERY_KEY,
   SURVEY_SUBMISSION_QUERY_KEY,
   SURVEY_SUBMISSION_SECTIONS_QUERY_KEY,
+  SendThreadTyping,
   SeriesQuestionType,
   SessionAccess,
   SessionVisibility,
   SetContentPublishSchedule,
+  SingleQueryHelpers_exports as SingleQueryHelpers,
   StartSurvey,
   SubmitSurvey,
   SupportTicketActivityLogSource,
@@ -13529,15 +13380,18 @@ export {
   SurveyQuestionType,
   SurveyStatus,
   THREADS_QUERY_KEY,
-  THREAD_CIRCLES_QUERY_KEY,
-  THREAD_CIRCLE_ACCOUNTS_QUERY_KEY,
-  THREAD_CIRCLE_ACCOUNT_QUERY_KEY,
-  THREAD_CIRCLE_QUERY_KEY,
+  THREAD_ACCOUNTS_QUERY_KEY,
   THREAD_MESSAGES_QUERY_KEY,
   THREAD_MESSAGE_QUERY_KEY,
   THREAD_QUERY_KEY,
-  ThreadCircleAccountRole,
+  ThreadMessageCreatedEffect,
+  ThreadMessageDeletedEffect,
   ThreadMessageType,
+  ThreadMessageUpdatedEffect,
+  ThreadReadEffect,
+  ThreadTypingEffect,
+  ThreadTypingStore,
+  ThreadTypingStoreProvider,
   TicketEventAccessLevel,
   TicketVisibility,
   TransferEventAttendeePass,
@@ -13571,7 +13425,6 @@ export {
   UpdateSelf,
   UpdateSelfAddress,
   UpdateSelfBanner,
-  UpdateSelfChatChannelNotifications,
   UpdateSelfGroupMembership,
   UpdateSelfImage,
   UpdateSelfLead,
@@ -13582,14 +13435,14 @@ export {
   UpdateSurveyResponse,
   UpdateSurveySearchListResponse,
   UpdateThread,
-  UpdateThreadCircle,
-  UpdateThreadCircleAccount,
   UpdateThreadMessage,
   UploadFile,
   UploadImage,
   UpsertLinkPreview,
   VIDEO_QUERY_KEY,
   VerifyLoginAccount,
+  WSMessageBus,
+  WSMessageBusProvider,
   isListing,
   isManagedCoupon,
   isRegistrationQuestion,
@@ -13635,10 +13488,8 @@ export {
   useAddListingCoHost,
   useAddListingSponsor,
   useAddLogin,
-  useAddSelfChatChannelMember,
   useAddSelfEventSession,
   useAddSelfInterests,
-  useAddThreadCircleAccount,
   useAddThreadMessageReaction,
   useApplyEventRegistrationCoupon,
   useBlockAccount,
@@ -13678,12 +13529,11 @@ export {
   useCreateListingSpeaker,
   useCreateLoginAccount,
   useCreateSelfAddress,
-  useCreateSelfChatChannel,
-  useCreateSelfChatChannelMessage,
   useCreateSelfLead,
   useCreateStreamChatMessage,
   useCreateSupportTicket,
   useCreateSupportTicketMessage,
+  useCreateThread,
   useCreateThreadMessage,
   useDeactivateGroup,
   useDeleteActivity,
@@ -13700,12 +13550,9 @@ export {
   useDeleteListingSpeaker,
   useDeleteSelf,
   useDeleteSelfAddress,
-  useDeleteSelfChatChannel,
-  useDeleteSelfChatChannelMessage,
   useDeleteSelfLead,
   useDeleteSelfPushDevice,
   useDeleteStreamChatMessage,
-  useDeleteThreadCircleAccount,
   useDeleteThreadMessage,
   useDemoteGroupModerator,
   useDisableIntegration,
@@ -13843,10 +13690,6 @@ export {
   useGetSelfAddresses,
   useGetSelfAnnouncement,
   useGetSelfChannelSubscriber,
-  useGetSelfChatChannel,
-  useGetSelfChatChannelMembers,
-  useGetSelfChatChannelMessages,
-  useGetSelfChatChannels,
   useGetSelfContacts,
   useGetSelfEventListing,
   useGetSelfEventListingAnnouncement,
@@ -13895,12 +13738,10 @@ export {
   useGetSurveySubmissions,
   useGetSurveys,
   useGetThread,
-  useGetThreadCircle,
-  useGetThreadCircleAccount,
-  useGetThreadCircleAccounts,
-  useGetThreadCircles,
+  useGetThreadAccounts,
   useGetThreadMessage,
   useGetThreadMessages,
+  useGetThreads,
   useGetUsernameAvailability,
   useGetVideo,
   useGroupStatus,
@@ -13914,9 +13755,10 @@ export {
   useJoinMeetingViaEvent,
   useJoinMeetingViaGroup,
   useLeaveGroup,
-  useLeaveSelfChatChannel,
   useLikeActivity,
   useLikeContent,
+  useMarkThreadMessageRead,
+  useMarkThreadRead,
   usePromoteGroupMember,
   useReinviteGroupInvitation,
   useRejectGroupInvitation,
@@ -13932,9 +13774,11 @@ export {
   useRemoveSelfEventSession,
   useRemoveThreadMessageReaction,
   useReportActivity,
+  useSendThreadTyping,
   useSetContentPublishSchedule,
   useStartSurvey,
   useSubmitSurvey,
+  useThreadTyping,
   useTransferEventAttendeePass,
   useUnblockAccount,
   useUnbookmarkEventAttendeePassSession,
@@ -13965,7 +13809,6 @@ export {
   useUpdateSelf,
   useUpdateSelfAddress,
   useUpdateSelfBanner,
-  useUpdateSelfChatChannelNotifications,
   useUpdateSelfGroupMembership,
   useUpdateSelfImage,
   useUpdateSelfLead,
@@ -13976,11 +13819,11 @@ export {
   useUpdateSurveyResponse,
   useUpdateSurveySearchListResponse,
   useUpdateThread,
-  useUpdateThreadCircle,
-  useUpdateThreadCircleAccount,
   useUpdateThreadMessage,
   useUploadFile,
   useUploadImage,
   useUpsertLinkPreview,
-  useVerifyLoginAccount
+  useVerifyLoginAccount,
+  useWSEvent,
+  useWSMessageBus
 };