@connectedxm/client 0.5.39 → 1.0.2

package/dist/index.mjs

@@ -179,7 +179,7 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
   return EventType2;
 })(EventType || {});
 var isTypeEvent = (event) => {
-  return event._count !== void 0;
+  return event.sessions !== void 0;
 };
 var RegistrationQuestionType = /* @__PURE__ */ ((RegistrationQuestionType2) => {
   RegistrationQuestionType2["text"] = "text";
@@ -379,6 +379,27 @@ var EventEmailType = /* @__PURE__ */ ((EventEmailType2) => {
   EventEmailType2["reminder"] = "reminder";
   return EventEmailType2;
 })(EventEmailType || {});
+var ThreadInvitationStatus = /* @__PURE__ */ ((ThreadInvitationStatus2) => {
+  ThreadInvitationStatus2["invited"] = "invited";
+  ThreadInvitationStatus2["rejected"] = "rejected";
+  return ThreadInvitationStatus2;
+})(ThreadInvitationStatus || {});
+var ThreadAccessLevel = /* @__PURE__ */ ((ThreadAccessLevel2) => {
+  ThreadAccessLevel2["public"] = "public";
+  ThreadAccessLevel2["private"] = "private";
+  return ThreadAccessLevel2;
+})(ThreadAccessLevel || {});
+var ThreadMemberRole = /* @__PURE__ */ ((ThreadMemberRole2) => {
+  ThreadMemberRole2["member"] = "member";
+  ThreadMemberRole2["moderator"] = "moderator";
+  return ThreadMemberRole2;
+})(ThreadMemberRole || {});
+var ThreadMessageType = /* @__PURE__ */ ((ThreadMessageType2) => {
+  ThreadMessageType2["user"] = "user";
+  ThreadMessageType2["bot"] = "bot";
+  ThreadMessageType2["system"] = "system";
+  return ThreadMessageType2;
+})(ThreadMessageType || {});
 var SupportedLocale = /* @__PURE__ */ ((SupportedLocale2) => {
   SupportedLocale2["en"] = "en";
   SupportedLocale2["es"] = "es";
@@ -6664,6 +6685,472 @@ var useGetInterests = (params = {}, 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_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/useGetThreads.ts
+var THREADS_QUERY_KEY = (access, groupId) => {
+  const keys = ["THREADS"];
+  if (access) keys.push(access);
+  if (groupId) keys.push(groupId);
+  return keys;
+};
+var SET_THREADS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREADS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreads = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  queryClient,
+  access,
+  groupId,
+  eventId,
+  search,
+  locale,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      access: access || void 0,
+      groupId: groupId || void 0,
+      eventId: eventId || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (threadId) => THREAD_QUERY_KEY(threadId),
+      locale
+    );
+  }
+  return data;
+};
+var useGetThreads = (access = "public", groupId, eventId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREADS_QUERY_KEY(access, groupId),
+    (params2) => GetThreads({ access, groupId, eventId, ...params2 }),
+    params,
+    {
+      ...options
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMember.ts
+var THREAD_MEMBER_QUERY_KEY = (threadId, accountId) => {
+  return [...THREAD_QUERY_KEY(threadId, accountId)];
+};
+var SET_THREAD_MEMBER_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_MEMBER_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadMember = async ({
+  threadId,
+  accountId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/members/${accountId}`
+  );
+  return data;
+};
+var useGetThreadMember = (threadId, accountId, options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MEMBER_QUERY_KEY(threadId, accountId),
+    (params) => GetThreadMember({ threadId, accountId, ...params }),
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMembers.ts
+var THREAD_MEMBERS_QUERY_KEY = (threadId, role) => {
+  const keys = [...THREAD_QUERY_KEY(threadId), "MEMBERS"];
+  if (role) {
+    keys.push(role);
+  }
+  return keys;
+};
+var SET_THREAD_MEMBERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MEMBERS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMembers = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  role,
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}/members`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      role: role || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadMembers = (threadId = "", role, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MEMBERS_QUERY_KEY(threadId, role),
+    (params2) => GetThreadMembers({ threadId, role, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessage.ts
+var THREAD_MESSAGE_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGES_QUERY_KEY(threadId, messageId)];
+};
+var SET_THREAD_MESSAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGE_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadMessage = async ({
+  threadId,
+  messageId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/messages/${messageId}`
+  );
+  return data;
+};
+var useGetThreadMessage = (threadId, messageId, options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+    (params) => GetThreadMessage({ threadId, messageId, ...params }),
+    {
+      staleTime: Infinity,
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessages.ts
+var THREAD_MESSAGES_QUERY_KEY = (threadId, messageId) => [...THREAD_QUERY_KEY(threadId, messageId), "MESSAGES"];
+var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMessages = async ({
+  threadId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}/messages`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (messageId) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+      locale
+    );
+    SET_THREAD_QUERY_DATA(queryClient, [threadId], (old) => ({
+      ...old,
+      data: {
+        ...old.data,
+        read: true
+      }
+    }));
+  }
+  return data;
+};
+var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGES_QUERY_KEY(threadId),
+    (params2) => GetThreadMessages({ ...params2, threadId }),
+    params,
+    {
+      refetchInterval: 5 * 1e3,
+      ...options,
+      enabled: !!authenticated && !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessageReplies.ts
+var THREAD_MESSAGE_REPLIES_QUERY_KEY = (threadId, messageId) => [...THREAD_MESSAGE_QUERY_KEY(threadId, messageId), "REPLIES"];
+var SET_THREAD_MESSAGE_REPLIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGE_REPLIES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMessageReplies = async ({
+  threadId,
+  messageId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/messages/${messageId}/replies`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (messageId2) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId2),
+      locale
+    );
+  }
+  return data;
+};
+var useGetThreadMessageReplies = (threadId = "", messageId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGE_REPLIES_QUERY_KEY(threadId, messageId),
+    (params2) => GetThreadMessageReplies({ ...params2, threadId, messageId }),
+    params,
+    {
+      refetchInterval: 5 * 1e3,
+      ...options,
+      enabled: !!authenticated && !!threadId && !!messageId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadGroups.ts
+var THREAD_GROUPS_QUERY_KEY = (accountId) => [
+  ...THREADS_QUERY_KEY(),
+  "groups",
+  accountId
+];
+var SET_THREAD_GROUPS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_GROUPS_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadGroups = async ({
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/groups`);
+  return data;
+};
+var useGetThreadGroups = (options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_GROUPS_QUERY_KEY(),
+    (params) => GetThreadGroups({ ...params }),
+    {
+      ...options,
+      enabled: options?.enabled ?? true
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadGroup.ts
+var THREAD_GROUP_QUERY_KEY = (groupId) => [
+  ...THREADS_QUERY_KEY(),
+  "group",
+  groupId
+];
+var SET_THREAD_GROUP_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_GROUP_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadGroup = async ({
+  groupId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/groups/${groupId}`);
+  return data;
+};
+var useGetThreadGroup = (groupId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_GROUP_QUERY_KEY(groupId),
+    (params) => GetThreadGroup({ groupId, ...params }),
+    {
+      ...options,
+      enabled: !!groupId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadEvents.ts
+var THREAD_EVENTS_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), "events", threadId, accountId];
+var SET_THREAD_EVENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_EVENTS_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadEvents = async ({
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}/events`);
+  return data;
+};
+var useGetThreadEvents = (threadId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_EVENTS_QUERY_KEY(threadId),
+    (params) => GetThreadEvents({ threadId, ...params }),
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadEvent.ts
+var THREAD_EVENT_QUERY_KEY = (eventId) => [
+  ...THREADS_QUERY_KEY(),
+  "event",
+  eventId
+];
+var SET_THREAD_EVENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_EVENT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadEvent = async ({
+  eventId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/events/${eventId}`);
+  return data;
+};
+var useGetThreadEvent = (eventId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_EVENT_QUERY_KEY(eventId),
+    (params) => GetThreadEvent({ eventId, ...params }),
+    {
+      ...options,
+      enabled: !!eventId && (options?.enabled ?? true)
+    }
+  );
+};
+
 // src/mutations/useConnectedMutation.ts
 import {
   useMutation,
@@ -10007,6 +10494,349 @@ var UploadFile = async ({
 var useUploadFile = (options = {}) => {
   return useConnectedMutation_default(UploadFile, options);
 };
+
+// src/mutations/threads/useCreateThread.ts
+var CreateThread = async ({
+  thread,
+  accountIds,
+  firstMessage,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads`,
+    {
+      thread,
+      accountIds,
+      firstMessage
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_THREAD_QUERY_DATA(queryClient, [data.data.id], data);
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useCreateThread = (options = {}) => {
+  return useConnectedMutation_default(CreateThread, options);
+};
+
+// src/mutations/threads/useAddThreadMember.ts
+var AddThreadMember = async ({
+  threadId,
+  accountId,
+  role,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/members/${accountId}`,
+    {
+      role
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useAddThreadMember = (options = {}) => {
+  return useConnectedMutation_default(AddThreadMember, options);
+};
+
+// src/mutations/threads/useUpdateThread.ts
+var UpdateThread = async ({
+  threadId,
+  thread,
+  imageDataUri,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.patch(
+    `/threads/${threadId}`,
+    {
+      thread,
+      imageDataUri
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_THREAD_QUERY_DATA(queryClient, [data.data.id], data);
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useUpdateThread = (options = {}) => {
+  return useConnectedMutation_default(UpdateThread, options);
+};
+
+// src/mutations/threads/useUpdateThreadMember.ts
+var UpdateThreadMember = async ({
+  threadId,
+  accountId,
+  role,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.patch(
+    `/threads/${threadId}/members/${accountId}`,
+    {
+      role
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useUpdateThreadMember = (options = {}) => {
+  return useConnectedMutation_default(UpdateThreadMember, options);
+};
+
+// src/mutations/threads/useDeleteThreadMember.ts
+var DeleteThreadMember = async ({
+  threadId,
+  accountId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/members/${accountId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useDeleteThreadMember = (options = {}) => {
+  return useConnectedMutation_default(DeleteThreadMember, options);
+};
+
+// src/mutations/threads/useMarkUnread.ts
+var MarkUnread = async ({
+  threadId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/unread`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.setQueryData(
+      [...THREAD_QUERY_KEY(threadId), clientApiParams.locale],
+      (oldData) => {
+        if (!oldData) {
+          return oldData;
+        }
+        return {
+          ...oldData,
+          read: false
+        };
+      }
+    );
+  }
+  return data;
+};
+var useMarkUnread = (options = {}) => {
+  return useConnectedMutation_default(MarkUnread, options);
+};
+
+// src/mutations/threads/useCreateThreadMessage.ts
+var CreateThreadMessage = async ({
+  threadId,
+  body,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/messages`,
+    { body }
+  );
+  if (queryClient && data.status === "ok") {
+    AppendInfiniteQuery(
+      queryClient,
+      [
+        ...THREAD_MESSAGES_QUERY_KEY(threadId),
+        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+      ],
+      data.data
+    );
+  }
+  return data;
+};
+var useCreateThreadMessage = (options = {}) => {
+  return useConnectedMutation_default(CreateThreadMessage, options);
+};
+
+// src/mutations/threads/useUpdateThreadMessage.ts
+var UpdateThreadMessage = async ({
+  threadId,
+  messageId,
+  body,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.put(
+    `/threads/${threadId}/messages/${messageId}`,
+    { body }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_THREAD_MESSAGE_QUERY_DATA(queryClient, [threadId, messageId], data, [
+      clientApiParams.locale
+    ]);
+  }
+  return data;
+};
+var useUpdateThreadMessage = (options = {}) => {
+  return useConnectedMutation_default(UpdateThreadMessage, options);
+};
+
+// src/mutations/threads/useDeleteThreadMessage.ts
+import { produce as produce6 } from "immer";
+var DeleteThreadMessage = async ({
+  threadId,
+  messageId,
+  body,
+  moderator,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/messages/${messageId}`,
+    {
+      data: { body, moderator }
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.setQueryData(
+      [
+        ...THREAD_MESSAGES_QUERY_KEY(threadId),
+        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+      ],
+      (oldData) => {
+        if (!oldData) return oldData;
+        return produce6(oldData, (draft) => {
+          draft.pages.forEach((page) => {
+            const index = page.data.findIndex((m) => m.id === messageId);
+            if (index !== -1) {
+              page.data.splice(index, 1);
+            }
+          });
+        });
+      }
+    );
+  }
+  return data;
+};
+var useDeleteThreadMessage = (options = {}) => {
+  return useConnectedMutation_default(DeleteThreadMessage, options);
+};
+
+// src/mutations/threads/useAddThreadMessageReaction.ts
+var AddThreadMessageReaction = async ({
+  threadId,
+  messageId,
+  emojiName,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(`/threads/${threadId}/messages/${messageId}/reactions`, { emojiName });
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useAddThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation_default(AddThreadMessageReaction, options);
+};
+
+// src/mutations/threads/useRemoveThreadMessageReaction.ts
+var RemoveThreadMessageReaction = async ({
+  threadId,
+  messageId,
+  emojiName,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/messages/${messageId}/reactions`,
+    {
+      data: { emojiName }
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useRemoveThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation_default(RemoveThreadMessageReaction, options);
+};
+
+// src/mutations/threads/useAddThreadMessageReply.ts
+var AddThreadMessageReply = async ({
+  threadId,
+  messageId,
+  body,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/messages/${messageId}/replies`,
+    { body }
+  );
+  if (queryClient && data.status === "ok") {
+    AppendInfiniteQuery(
+      queryClient,
+      [
+        ...THREAD_MESSAGE_REPLIES_QUERY_KEY(threadId, messageId),
+        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+      ],
+      data.data
+    );
+  }
+  return data;
+};
+var useAddThreadMessageReply = (options = {}) => {
+  return useConnectedMutation_default(AddThreadMessageReply, options);
+};
 export {
   ACCOUNTS_QUERY_KEY,
   ACCOUNT_ACTIVITIES_QUERY_KEY,
@@ -10036,6 +10866,9 @@ export {
   AddSelfEventRegistrationPurchaseAddOn,
   AddSelfEventSession,
   AddSelfInterests,
+  AddThreadMember,
+  AddThreadMessageReaction,
+  AddThreadMessageReply,
   AdvertisementType,
   AppendInfiniteQuery,
   BENEFITS_QUERY_KEY,
@@ -10084,6 +10917,8 @@ export {
   CreateSubscription,
   CreateSupportTicket,
   CreateTeamAccount,
+  CreateThread,
+  CreateThreadMessage,
   Currency,
   DeactivateGroup,
   DefaultAuthAction,
@@ -10103,6 +10938,8 @@ export {
   DeleteSelfChatChannel,
   DeleteSelfChatChannelMessage,
   DeleteSelfPushDevice,
+  DeleteThreadMember,
+  DeleteThreadMessage,
   DemoteGroupModerator,
   EVENTS_FEATURED_QUERY_KEY,
   EVENTS_QUERY_KEY,
@@ -10285,6 +11122,17 @@ export {
   GetSeriesList,
   GetSubscribedChannels,
   GetSubscribedContents,
+  GetThread,
+  GetThreadEvent,
+  GetThreadEvents,
+  GetThreadGroup,
+  GetThreadGroups,
+  GetThreadMember,
+  GetThreadMembers,
+  GetThreadMessage,
+  GetThreadMessageReplies,
+  GetThreadMessages,
+  GetThreads,
   GroupAccess,
   GroupInvitationStatus,
   GroupMembershipRole,
@@ -10326,6 +11174,7 @@ export {
   MANAGED_CHANNEL_INTERESTS_QUERY_KEY,
   MANAGED_CHANNEL_QUERY_KEY,
   MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY,
+  MarkUnread,
   MergeInfinitePages,
   NotificationType,
   ORGANIZATION_EXPLORE_QUERY_KEY,
@@ -10357,6 +11206,7 @@ export {
   RemoveSelfEventRegistrationPurchase,
   RemoveSelfEventRegistrationPurchaseAddOn,
   RemoveSelfEventSession,
+  RemoveThreadMessageReaction,
   ReshareActivity,
   SELF_ACTIVITIES_QUERY_KEY,
   SELF_ANNOUNCEMENT_QUERY_KEY,
@@ -10489,6 +11339,17 @@ export {
   SET_SERIES_EVENTS_QUERY_DATA,
   SET_SERIES_LIST_QUERY_DATA,
   SET_SERIES_QUERY_DATA,
+  SET_THREADS_QUERY_DATA,
+  SET_THREAD_EVENTS_QUERY_DATA,
+  SET_THREAD_EVENT_QUERY_DATA,
+  SET_THREAD_GROUPS_QUERY_DATA,
+  SET_THREAD_GROUP_QUERY_DATA,
+  SET_THREAD_MEMBERS_QUERY_DATA,
+  SET_THREAD_MEMBER_QUERY_DATA,
+  SET_THREAD_MESSAGES_QUERY_DATA,
+  SET_THREAD_MESSAGE_QUERY_DATA,
+  SET_THREAD_MESSAGE_REPLIES_QUERY_DATA,
+  SET_THREAD_QUERY_DATA,
   SUBSCRIBED_CHANNELS_QUERY_KEY,
   SUBSCRIBED_CONTENTS_QUERY_KEY,
   SelectSelfEventRegistrationCoupon,
@@ -10500,6 +11361,21 @@ export {
   SubscriptionStatus,
   SupportTicketType,
   SupportedLocale,
+  THREADS_QUERY_KEY,
+  THREAD_EVENTS_QUERY_KEY,
+  THREAD_EVENT_QUERY_KEY,
+  THREAD_GROUPS_QUERY_KEY,
+  THREAD_GROUP_QUERY_KEY,
+  THREAD_MEMBERS_QUERY_KEY,
+  THREAD_MEMBER_QUERY_KEY,
+  THREAD_MESSAGES_QUERY_KEY,
+  THREAD_MESSAGE_QUERY_KEY,
+  THREAD_MESSAGE_REPLIES_QUERY_KEY,
+  THREAD_QUERY_KEY,
+  ThreadAccessLevel,
+  ThreadInvitationStatus,
+  ThreadMemberRole,
+  ThreadMessageType,
   TicketEventAccessLevel,
   TicketVisibility,
   TransferPurchase,
@@ -10527,6 +11403,9 @@ export {
   UpdateSelfNotificationPreferences,
   UpdateSelfPushDevice,
   UpdateSubscriptionPaymentMethod,
+  UpdateThread,
+  UpdateThreadMember,
+  UpdateThreadMessage,
   UploadChannelContentImage,
   UploadFile,
   isListing,
@@ -10584,6 +11463,9 @@ export {
   useAddSelfEventRegistrationPurchaseAddOn,
   useAddSelfEventSession,
   useAddSelfInterests,
+  useAddThreadMember,
+  useAddThreadMessageReaction,
+  useAddThreadMessageReply,
   useCancelGroupInvitation,
   useCancelGroupRequest,
   useCancelSubscription,
@@ -10615,6 +11497,8 @@ export {
   useCreateSubscription,
   useCreateSupportTicket,
   useCreateTeamAccount,
+  useCreateThread,
+  useCreateThreadMessage,
   useDeactivateGroup,
   useDeleteActivity,
   useDeleteChannel,
@@ -10632,6 +11516,8 @@ export {
   useDeleteSelfChatChannel,
   useDeleteSelfChatChannelMessage,
   useDeleteSelfPushDevice,
+  useDeleteThreadMember,
+  useDeleteThreadMessage,
   useDemoteGroupModerator,
   useFollowAccount,
   useGetAccount,
@@ -10774,6 +11660,17 @@ export {
   useGetSeriesList,
   useGetSubscribedChannels,
   useGetSubscribedContents,
+  useGetThread,
+  useGetThreadEvent,
+  useGetThreadEvents,
+  useGetThreadGroup,
+  useGetThreadGroups,
+  useGetThreadMember,
+  useGetThreadMembers,
+  useGetThreadMessage,
+  useGetThreadMessageReplies,
+  useGetThreadMessages,
+  useGetThreads,
   useGroupStatus,
   useIsAccountFollowing,
   useIsChannelSubscribed,
@@ -10783,6 +11680,7 @@ export {
   useLeaveSelfChatChannel,
   useLikeActivity,
   useLikeContent,
+  useMarkUnread,
   usePromoteGroupMember,
   useReinviteGroupInvitation,
   useRejectGroupInvitation,
@@ -10799,6 +11697,7 @@ export {
   useRemoveSelfEventRegistrationPurchase,
   useRemoveSelfEventRegistrationPurchaseAddOn,
   useRemoveSelfEventSession,
+  useRemoveThreadMessageReaction,
   useReshareActivity,
   useSelectSelfEventRegistrationCoupon,
   useSelectSelfEventRegistrationPurchaseReservation,
@@ -10831,6 +11730,9 @@ export {
   useUpdateSelfNotificationPreferences,
   useUpdateSelfPushDevice,
   useUpdateSubscriptionPaymentMethod,
+  useUpdateThread,
+  useUpdateThreadMember,
+  useUpdateThreadMessage,
   useUploadChannelContentImage,
   useUploadFile
 };