@connectedxm/client 2.4.0 → 2.4.1

package/dist/index.js

@@ -409,21 +409,12 @@ 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 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";
@@ -8194,212 +8185,192 @@ var useGetInterestActivities = (interest = "", 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"]) => {
+// src/queries/threads/useGetThreadCircles.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"]) => {
   client.setQueryData(
     [
-      ...THREADS_QUERY_KEY(...keyParams),
+      ...THREAD_CIRCLES_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetThreads = async ({
+var GetThreadCircles = async ({
   pageParam,
   pageSize,
   orderBy,
-  queryClient,
-  access,
-  groupId,
-  eventId,
   search,
-  locale,
+  type,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads`, {
+  const { data } = await clientApi.get(`/threads/circles`, {
     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
+      type: type || 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 = {}) => {
+var useGetThreadCircles = (params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
   return useConnectedInfiniteQuery(
-    THREADS_QUERY_KEY(access, groupId),
-    (params2) => GetThreads({ access, groupId, eventId, ...params2 }),
+    THREAD_CIRCLES_QUERY_KEY(),
+    (params2) => GetThreadCircles(params2),
     params,
     {
-      ...options
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
     }
   );
 };
 
-// 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) => {
+// 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) => {
   client.setQueryData(
     [
-      ...THREAD_MEMBER_QUERY_KEY(...keyParams),
+      ...THREAD_CIRCLE_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response,
     options
   );
 };
-var GetThreadMember = async ({
-  threadId,
-  accountId,
+var GetThreadCircle = async ({
+  circleId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/threads/${threadId}/members/${accountId}`
-  );
+  const { data } = await clientApi.get(`/threads/circles/${circleId}`);
   return data;
 };
-var useGetThreadMember = (threadId, accountId, options = {}) => {
+var useGetThreadCircle = (circleId = "", options = {}) => {
   return useConnectedSingleQuery(
-    THREAD_MEMBER_QUERY_KEY(threadId, accountId),
-    (params) => GetThreadMember({ threadId, accountId, ...params }),
+    THREAD_CIRCLE_QUERY_KEY(circleId),
+    (params) => GetThreadCircle({ circleId, ...params }),
     {
       ...options,
-      enabled: !!threadId && (options?.enabled ?? true)
+      enabled: !!circleId && (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"]) => {
+// 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"]) => {
   client.setQueryData(
     [
-      ...THREAD_MEMBERS_QUERY_KEY(...keyParams),
+      ...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetThreadMembers = async ({
+var GetThreadCircleAccounts = async ({
+  circleId,
   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
+  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
+      }
     }
-  });
+  );
   return data;
 };
-var useGetThreadMembers = (threadId = "", role, params = {}, options = {}) => {
+var useGetThreadCircleAccounts = (circleId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
   return useConnectedInfiniteQuery(
-    THREAD_MEMBERS_QUERY_KEY(threadId, role),
-    (params2) => GetThreadMembers({ threadId, role, ...params2 }),
+    THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId),
+    (params2) => GetThreadCircleAccounts({ ...params2, circleId }),
     params,
     {
       ...options,
-      enabled: !!threadId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!circleId && (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) => {
+// 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) => {
   client.setQueryData(
     [
-      ...THREAD_MESSAGE_QUERY_KEY(...keyParams),
+      ...THREAD_CIRCLE_ACCOUNT_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response,
     options
   );
 };
-var GetThreadMessage = async ({
-  threadId,
-  messageId,
+var GetThreadCircleAccount = async ({
+  circleId,
+  accountId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/threads/${threadId}/messages/${messageId}`
+    `/threads/circles/${circleId}/accounts/${accountId}`
   );
   return data;
 };
-var useGetThreadMessage = (threadId, messageId, options = {}) => {
+var useGetThreadCircleAccount = (circleId = "", accountId = "", options = {}) => {
   return useConnectedSingleQuery(
-    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
-    (params) => GetThreadMessage({ threadId, messageId, ...params }),
+    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 }),
     {
-      staleTime: Infinity,
       ...options,
       enabled: !!threadId && (options?.enabled ?? true)
     }
@@ -8407,7 +8378,10 @@ var useGetThreadMessage = (threadId, messageId, options = {}) => {
 };
 
 // src/queries/threads/useGetThreadMessages.ts
-var THREAD_MESSAGES_QUERY_KEY = (threadId, messageId) => [...THREAD_QUERY_KEY(threadId, messageId), "MESSAGES"];
+var THREAD_MESSAGES_QUERY_KEY = (threadId) => [
+  ...THREAD_QUERY_KEY(threadId),
+  "MESSAGES"
+];
 var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
@@ -8423,9 +8397,7 @@ var GetThreadMessages = async ({
   pageSize,
   orderBy,
   search,
-  queryClient,
-  clientApiParams,
-  locale
+  clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(`/threads/${threadId}/messages`, {
@@ -8436,21 +8408,6 @@ var GetThreadMessages = async ({
       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 = {}) => {
@@ -8460,202 +8417,45 @@ var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
     (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/useGetThreadMessage.ts
+var THREAD_MESSAGE_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGES_QUERY_KEY(threadId), messageId];
 };
-
-// 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) => {
+var SET_THREAD_MESSAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
   client.setQueryData(
     [
-      ...THREAD_EVENTS_QUERY_KEY(...keyParams),
+      ...THREAD_MESSAGE_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response,
     options
   );
 };
-var GetThreadEvents = async ({
+var GetThreadMessage = async ({
   threadId,
+  messageId,
   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
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/messages/${messageId}`
   );
-};
-var GetThreadEvent = async ({
-  eventId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/events/${eventId}`);
   return data;
 };
-var useGetThreadEvent = (eventId = "", options = {}) => {
+var useGetThreadMessage = (threadId, messageId, options = {}) => {
   return useConnectedSingleQuery(
-    THREAD_EVENT_QUERY_KEY(eventId),
-    (params) => GetThreadEvent({ eventId, ...params }),
+    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+    (params) => GetThreadMessage({ threadId, messageId, ...params }),
     {
+      staleTime: Infinity,
       ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
+      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
     }
   );
 };
@@ -12688,347 +12488,251 @@ var useUploadImage = (options = {}) => {
   return useConnectedMutation_default(UploadImage, 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 ({
+// src/mutations/threads/useUpdateThread.ts
+var UpdateThread = async ({
   threadId,
-  accountId,
-  role,
+  subject,
+  imageId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/threads/${threadId}/members/${accountId}`,
-    {
-      role
-    }
-  );
+  const { data } = await clientApi.put(`/threads/${threadId}`, {
+    subject,
+    imageId
+  });
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
-    });
-    queryClient.invalidateQueries({
-      queryKey: THREAD_QUERY_KEY(threadId)
-    });
+    SET_THREAD_QUERY_DATA(queryClient, [threadId], data, [
+      clientApiParams.locale
+    ]);
   }
   return data;
 };
-var useAddThreadMember = (options = {}) => {
-  return useConnectedMutation_default(AddThreadMember, options);
+var useUpdateThread = (options = {}) => {
+  return useConnectedMutation(UpdateThread, options);
 };
 
-// src/mutations/threads/useUpdateThread.ts
-var UpdateThread = async ({
+// src/mutations/threads/useCreateThreadMessage.ts
+var CreateThreadMessage = async ({
   threadId,
-  thread,
-  imageDataUri,
+  body,
+  entities,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.patch(
-    `/threads/${threadId}`,
-    {
-      thread,
-      imageDataUri
-    }
-  );
+  const { data } = await clientApi.post(`/threads/${threadId}/messages`, {
+    body,
+    entities
+  });
   if (queryClient && data.status === "ok") {
-    SET_THREAD_QUERY_DATA(queryClient, [data.data.id], data);
-    queryClient.invalidateQueries({
-      queryKey: THREADS_QUERY_KEY()
-    });
+    AppendInfiniteQuery(
+      queryClient,
+      THREAD_MESSAGES_QUERY_KEY(threadId),
+      data.data
+    );
   }
   return data;
 };
-var useUpdateThread = (options = {}) => {
-  return useConnectedMutation_default(UpdateThread, options);
+var useCreateThreadMessage = (options = {}) => {
+  return useConnectedMutation(CreateThreadMessage, options);
 };
 
-// src/mutations/threads/useUpdateThreadMember.ts
-var UpdateThreadMember = async ({
+// src/mutations/threads/useUpdateThreadMessage.ts
+var UpdateThreadMessage = async ({
   threadId,
-  accountId,
-  role,
+  messageId,
+  body,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.patch(
-    `/threads/${threadId}/members/${accountId}`,
+  const { data } = await clientApi.put(
+    `/threads/${threadId}/messages/${messageId}`,
     {
-      role
+      body
     }
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
-    });
-    queryClient.invalidateQueries({
-      queryKey: THREAD_QUERY_KEY(threadId)
-    });
+    SET_THREAD_MESSAGE_QUERY_DATA(queryClient, [threadId, messageId], data, [
+      clientApiParams.locale
+    ]);
   }
   return data;
 };
-var useUpdateThreadMember = (options = {}) => {
-  return useConnectedMutation_default(UpdateThreadMember, options);
+var useUpdateThreadMessage = (options = {}) => {
+  return useConnectedMutation(UpdateThreadMessage, options);
 };
 
-// src/mutations/threads/useDeleteThreadMember.ts
-var DeleteThreadMember = async ({
+// src/mutations/threads/useDeleteThreadMessage.ts
+var DeleteThreadMessage = async ({
   threadId,
-  accountId,
+  messageId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.delete(
-    `/threads/${threadId}/members/${accountId}`
+    `/threads/${threadId}/messages/${messageId}`
   );
   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)
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
     });
   }
   return data;
 };
-var useDeleteThreadMember = (options = {}) => {
-  return useConnectedMutation_default(DeleteThreadMember, options);
+var useDeleteThreadMessage = (options = {}) => {
+  return useConnectedMutation(DeleteThreadMessage, options);
 };
 
-// src/mutations/threads/useMarkUnread.ts
-var MarkUnread = async ({
+// 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}/unread`
+    `/threads/${threadId}/messages/${messageId}/reactions`,
+    {
+      emojiName
+    }
   );
   if (queryClient && data.status === "ok") {
-    queryClient.setQueryData(
-      [...THREAD_QUERY_KEY(threadId), clientApiParams.locale],
-      (oldData) => {
-        if (!oldData) {
-          return oldData;
-        }
-        return {
-          ...oldData,
-          read: false
-        };
-      }
-    );
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
+    });
   }
   return data;
 };
-var useMarkUnread = (options = {}) => {
-  return useConnectedMutation_default(MarkUnread, options);
+var useAddThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation(AddThreadMessageReaction, options);
 };
 
-// src/mutations/threads/useCreateThreadMessage.ts
-var CreateThreadMessage = async ({
+// src/mutations/threads/useRemoveThreadMessageReaction.ts
+var RemoveThreadMessageReaction = async ({
   threadId,
-  body,
+  messageId,
+  reactionId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/threads/${threadId}/messages`,
-    { body }
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/messages/${messageId}/reactions/${reactionId}`
   );
   if (queryClient && data.status === "ok") {
-    AppendInfiniteQuery(
-      queryClient,
-      [
-        ...THREAD_MESSAGES_QUERY_KEY(threadId),
-        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
-      ],
-      data.data
-    );
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
+    });
   }
   return data;
 };
-var useCreateThreadMessage = (options = {}) => {
-  return useConnectedMutation_default(CreateThreadMessage, options);
+var useRemoveThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation(RemoveThreadMessageReaction, options);
 };
 
-// src/mutations/threads/useUpdateThreadMessage.ts
-var UpdateThreadMessage = async ({
-  threadId,
-  messageId,
-  body,
+// src/mutations/threads/useUpdateThreadCircle.ts
+var UpdateThreadCircle = async ({
+  circleId,
+  name,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.put(
-    `/threads/${threadId}/messages/${messageId}`,
-    { body }
-  );
+  const { data } = await clientApi.put(`/threads/circles/${circleId}`, {
+    name
+  });
   if (queryClient && data.status === "ok") {
-    SET_THREAD_MESSAGE_QUERY_DATA(queryClient, [threadId, messageId], data, [
+    SET_THREAD_CIRCLE_QUERY_DATA(queryClient, [circleId], data, [
       clientApiParams.locale
     ]);
   }
   return data;
 };
-var useUpdateThreadMessage = (options = {}) => {
-  return useConnectedMutation_default(UpdateThreadMessage, options);
+var useUpdateThreadCircle = (options = {}) => {
+  return useConnectedMutation(UpdateThreadCircle, options);
 };
 
-// src/mutations/threads/useDeleteThreadMessage.ts
-import { produce as produce6 } from "immer";
-var DeleteThreadMessage = async ({
-  threadId,
-  messageId,
-  body,
-  moderator,
+// src/mutations/threads/useAddThreadCircleAccount.ts
+var AddThreadCircleAccount = async ({
+  circleId,
+  accountId,
+  role,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/threads/${threadId}/messages/${messageId}`,
+  const { data } = await clientApi.post(
+    `/threads/circles/${circleId}/accounts`,
     {
-      data: { body, moderator }
+      accountId,
+      role
     }
   );
-  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)
+      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
     });
   }
   return data;
 };
-var useAddThreadMessageReaction = (options = {}) => {
-  return useConnectedMutation_default(AddThreadMessageReaction, options);
+var useAddThreadCircleAccount = (options = {}) => {
+  return useConnectedMutation(AddThreadCircleAccount, options);
 };
 
-// src/mutations/threads/useRemoveThreadMessageReaction.ts
-var RemoveThreadMessageReaction = async ({
-  threadId,
-  messageId,
-  emojiName,
+// src/mutations/threads/useUpdateThreadCircleAccount.ts
+var UpdateThreadCircleAccount = async ({
+  circleId,
+  accountId,
+  role,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.delete(
-    `/threads/${threadId}/messages/${messageId}/reactions`,
+  const { data } = await clientApi.put(
+    `/threads/circles/${circleId}/accounts/${accountId}`,
     {
-      data: { emojiName }
+      role
     }
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({
-      queryKey: THREAD_MESSAGE_QUERY_KEY(threadId, messageId)
-    });
+    SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA(
+      queryClient,
+      [circleId, accountId],
+      data,
+      [clientApiParams.locale]
+    );
   }
   return data;
 };
-var useRemoveThreadMessageReaction = (options = {}) => {
-  return useConnectedMutation_default(RemoveThreadMessageReaction, options);
+var useUpdateThreadCircleAccount = (options = {}) => {
+  return useConnectedMutation(UpdateThreadCircleAccount, options);
 };
 
-// src/mutations/threads/useAddThreadMessageReply.ts
-var AddThreadMessageReply = async ({
-  threadId,
-  messageId,
-  body,
+// src/mutations/threads/useDeleteThreadCircleAccount.ts
+var DeleteThreadCircleAccount = async ({
+  circleId,
+  accountId,
   clientApiParams,
   queryClient
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.post(
-    `/threads/${threadId}/messages/${messageId}/replies`,
-    { body }
+  const { data } = await clientApi.delete(
+    `/threads/circles/${circleId}/accounts/${accountId}`
   );
   if (queryClient && data.status === "ok") {
-    AppendInfiniteQuery(
-      queryClient,
-      [
-        ...THREAD_MESSAGE_REPLIES_QUERY_KEY(threadId, messageId),
-        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
-      ],
-      data.data
-    );
+    queryClient.invalidateQueries({
+      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
+    });
   }
   return data;
 };
-var useAddThreadMessageReply = (options = {}) => {
-  return useConnectedMutation_default(AddThreadMessageReply, options);
+var useDeleteThreadCircleAccount = (options = {}) => {
+  return useConnectedMutation(DeleteThreadCircleAccount, options);
 };
 
 // src/mutations/integrations/useBlockIntegration.ts
@@ -13207,9 +12911,8 @@ export {
   AddSelfDelegate,
   AddSelfEventSession,
   AddSelfInterests,
-  AddThreadMember,
+  AddThreadCircleAccount,
   AddThreadMessageReaction,
-  AddThreadMessageReply,
   AdvertisementType,
   AppendInfiniteQuery,
   BENEFITS_QUERY_KEY,
@@ -13273,7 +12976,6 @@ export {
   CreateSubscription,
   CreateSupportTicket,
   CreateTeamAccount,
-  CreateThread,
   CreateThreadMessage,
   Currency,
   DayOfWeek,
@@ -13297,7 +12999,7 @@ export {
   DeleteSelfChatChannelMessage,
   DeleteSelfLead,
   DeleteSelfPushDevice,
-  DeleteThreadMember,
+  DeleteThreadCircleAccount,
   DeleteThreadMessage,
   DemoteGroupModerator,
   DisableIntegration,
@@ -13551,16 +13253,12 @@ export {
   GetSurveySubmissionSections,
   GetSurveySubmissions,
   GetThread,
-  GetThreadEvent,
-  GetThreadEvents,
-  GetThreadGroup,
-  GetThreadGroups,
-  GetThreadMember,
-  GetThreadMembers,
+  GetThreadCircle,
+  GetThreadCircleAccount,
+  GetThreadCircleAccounts,
+  GetThreadCircles,
   GetThreadMessage,
-  GetThreadMessageReplies,
   GetThreadMessages,
-  GetThreads,
   GetVideo,
   GroupAccess,
   GroupInvitationStatus,
@@ -13612,7 +13310,6 @@ export {
   MANAGED_CHANNEL_INTERESTS_QUERY_KEY,
   MANAGED_CHANNEL_QUERY_KEY,
   MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY,
-  MarkUnread,
   MergeInfinitePages,
   NotificationType,
   ORGANIZATION_CONFIG_QUERY_KEY,
@@ -13824,16 +13521,12 @@ export {
   SET_SERIES_QUERY_DATA,
   SET_SURVEY_QUERY_DATA,
   SET_SURVEY_SUBMISSION_SECTIONS_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_CIRCLES_QUERY_DATA,
+  SET_THREAD_CIRCLE_ACCOUNTS_QUERY_DATA,
+  SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA,
+  SET_THREAD_CIRCLE_QUERY_DATA,
   SET_THREAD_MESSAGES_QUERY_DATA,
   SET_THREAD_MESSAGE_QUERY_DATA,
-  SET_THREAD_MESSAGE_REPLIES_QUERY_DATA,
   SET_THREAD_QUERY_DATA,
   SET_TRANSFER_ACCOUNTS_QUERY_DATA,
   SET_VIDEO_QUERY_DATA,
@@ -13855,19 +13548,14 @@ export {
   SupportTicketType,
   SurveyQuestionType,
   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_CIRCLES_QUERY_KEY,
+  THREAD_CIRCLE_ACCOUNTS_QUERY_KEY,
+  THREAD_CIRCLE_ACCOUNT_QUERY_KEY,
+  THREAD_CIRCLE_QUERY_KEY,
   THREAD_MESSAGES_QUERY_KEY,
   THREAD_MESSAGE_QUERY_KEY,
-  THREAD_MESSAGE_REPLIES_QUERY_KEY,
   THREAD_QUERY_KEY,
-  ThreadAccessLevel,
-  ThreadInvitationStatus,
-  ThreadMemberRole,
+  ThreadCircleAccountRole,
   ThreadMessageType,
   TicketEventAccessLevel,
   TicketVisibility,
@@ -13909,7 +13597,8 @@ export {
   UpdateSubscriptionPaymentMethod,
   UpdateSurveyResponse,
   UpdateThread,
-  UpdateThreadMember,
+  UpdateThreadCircle,
+  UpdateThreadCircleAccount,
   UpdateThreadMessage,
   UploadChannelContentImage,
   UploadFile,
@@ -13967,9 +13656,8 @@ export {
   useAddSelfDelegate,
   useAddSelfEventSession,
   useAddSelfInterests,
-  useAddThreadMember,
+  useAddThreadCircleAccount,
   useAddThreadMessageReaction,
-  useAddThreadMessageReply,
   useBlockAccount,
   useBlockIntegration,
   useCancelBooking,
@@ -14008,7 +13696,6 @@ export {
   useCreateSubscription,
   useCreateSupportTicket,
   useCreateTeamAccount,
-  useCreateThread,
   useCreateThreadMessage,
   useDeactivateGroup,
   useDeleteActivity,
@@ -14029,7 +13716,7 @@ export {
   useDeleteSelfChatChannelMessage,
   useDeleteSelfLead,
   useDeleteSelfPushDevice,
-  useDeleteThreadMember,
+  useDeleteThreadCircleAccount,
   useDeleteThreadMessage,
   useDemoteGroupModerator,
   useDisableIntegration,
@@ -14225,16 +13912,12 @@ export {
   useGetSurveySubmissionSections,
   useGetSurveySubmissions,
   useGetThread,
-  useGetThreadEvent,
-  useGetThreadEvents,
-  useGetThreadGroup,
-  useGetThreadGroups,
-  useGetThreadMember,
-  useGetThreadMembers,
+  useGetThreadCircle,
+  useGetThreadCircleAccount,
+  useGetThreadCircleAccounts,
+  useGetThreadCircles,
   useGetThreadMessage,
-  useGetThreadMessageReplies,
   useGetThreadMessages,
-  useGetThreads,
   useGetVideo,
   useGroupStatus,
   useIsAccountFollowing,
@@ -14245,7 +13928,6 @@ export {
   useLeaveSelfChatChannel,
   useLikeActivity,
   useLikeContent,
-  useMarkUnread,
   usePromoteGroupMember,
   useReinviteGroupInvitation,
   useRejectGroupInvitation,
@@ -14307,7 +13989,8 @@ export {
   useUpdateSubscriptionPaymentMethod,
   useUpdateSurveyResponse,
   useUpdateThread,
-  useUpdateThreadMember,
+  useUpdateThreadCircle,
+  useUpdateThreadCircleAccount,
   useUpdateThreadMessage,
   useUploadChannelContentImage,
   useUploadFile,