@connectedxm/admin 2.3.19 → 2.4.1

package/dist/index.js

@@ -1222,6 +1222,49 @@ var useGetAccountSubscriptions = (accountId = "", params = {}, options = {}) =>
   );
 };
 
+// src/queries/accounts/useGetAccountThreads.ts
+var ACCOUNT_THREADS_QUERY_KEY = (accountId) => {
+  const keys = ["THREADS", "ACCOUNT", accountId];
+  return keys;
+};
+var SET_ACCOUNT_THREADS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(ACCOUNT_THREADS_QUERY_KEY(...keyParams), response);
+};
+var GetAccountThreads = async ({
+  accountId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/accounts/${accountId}/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetAccountThreads = (accountId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    ACCOUNT_THREADS_QUERY_KEY(accountId),
+    (params2) => GetAccountThreads({
+      ...params2,
+      accountId
+    }),
+    params,
+    {
+      enabled: !!accountId && (options.enabled ?? true),
+      ...options
+    },
+    "threads"
+  );
+};
+
 // src/queries/accounts/useGetAccountTiers.ts
 var ACCOUNT_TIERS_QUERY_KEY = (accountId, type) => {
   const keys = [...ACCOUNT_QUERY_KEY(accountId), "TIERS"];
@@ -11686,6 +11729,49 @@ var useGetEventActivities = (eventId = "", params = {}, options = {}) => {
   );
 };
 
+// src/queries/events/useGetEventThreads.ts
+var EVENT_THREADS_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "THREADS"
+];
+var SET_EVENT_THREADS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(EVENT_THREADS_QUERY_KEY(...keyParams), response);
+};
+var GetEventThreads = async ({
+  eventId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/events/${eventId}/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetEventThreads = (eventId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    EVENT_THREADS_QUERY_KEY(eventId),
+    (params2) => GetEventThreads({
+      ...params2,
+      eventId
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!eventId && (options.enabled ?? true)
+    },
+    ["events", "threads"]
+  );
+};
+
 // src/queries/events/useGetFeaturedEvents.ts
 var FEATURED_EVENTS_QUERY_KEY = () => [
   ...EVENTS_QUERY_KEY(),
@@ -12165,11 +12251,6 @@ var PassTypeAccessLevel = /* @__PURE__ */ ((PassTypeAccessLevel2) => {
   PassTypeAccessLevel2["vip"] = "vip";
   return PassTypeAccessLevel2;
 })(PassTypeAccessLevel || {});
-var ThreadAccessLevel = /* @__PURE__ */ ((ThreadAccessLevel2) => {
-  ThreadAccessLevel2["public"] = "public";
-  ThreadAccessLevel2["private"] = "private";
-  return ThreadAccessLevel2;
-})(ThreadAccessLevel || {});
 var GroupAccess = /* @__PURE__ */ ((GroupAccess2) => {
   GroupAccess2["public"] = "public";
   GroupAccess2["private"] = "private";
@@ -12518,6 +12599,13 @@ var ThreadInvitationStatus = /* @__PURE__ */ ((ThreadInvitationStatus2) => {
   ThreadInvitationStatus2["rejected"] = "rejected";
   return ThreadInvitationStatus2;
 })(ThreadInvitationStatus || {});
+var ThreadType = /* @__PURE__ */ ((ThreadType2) => {
+  ThreadType2["circle"] = "circle";
+  ThreadType2["group"] = "group";
+  ThreadType2["event"] = "event";
+  ThreadType2["stream"] = "stream";
+  return ThreadType2;
+})(ThreadType || {});
 var ThreadMemberRole = /* @__PURE__ */ ((ThreadMemberRole2) => {
   ThreadMemberRole2["member"] = "member";
   ThreadMemberRole2["moderator"] = "moderator";
@@ -12529,6 +12617,17 @@ var ThreadMessageType = /* @__PURE__ */ ((ThreadMessageType2) => {
   ThreadMessageType2["system"] = "system";
   return ThreadMessageType2;
 })(ThreadMessageType || {});
+var ThreadCircleAccountRole = /* @__PURE__ */ ((ThreadCircleAccountRole2) => {
+  ThreadCircleAccountRole2["member"] = "member";
+  ThreadCircleAccountRole2["manager"] = "manager";
+  ThreadCircleAccountRole2["invited"] = "invited";
+  return ThreadCircleAccountRole2;
+})(ThreadCircleAccountRole || {});
+var ThreadCircleType = /* @__PURE__ */ ((ThreadCircleType2) => {
+  ThreadCircleType2["private"] = "private";
+  ThreadCircleType2["direct"] = "direct";
+  return ThreadCircleType2;
+})(ThreadCircleType || {});
 var LeadStatus = /* @__PURE__ */ ((LeadStatus2) => {
   LeadStatus2["new"] = "new";
   LeadStatus2["favorited"] = "favorited";
@@ -12856,6 +12955,49 @@ var useGetGroupSponsors = (groupId = "", params = {}, options = {}) => {
   );
 };
 
+// src/queries/groups/useGetGroupThreads.ts
+var GROUP_THREADS_QUERY_KEY = (groupId) => [
+  ...GROUP_QUERY_KEY(groupId),
+  "THREADS"
+];
+var SET_GROUP_THREADS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(GROUP_THREADS_QUERY_KEY(...keyParams), response);
+};
+var GetGroupThreads = async ({
+  groupId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/groups/${groupId}/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetGroupThreads = (groupId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    GROUP_THREADS_QUERY_KEY(groupId),
+    (params2) => GetGroupThreads({
+      ...params2,
+      groupId
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!groupId && (options.enabled ?? true)
+    },
+    ["groups", "threads"]
+  );
+};
+
 // src/queries/images/useGetImages.ts
 var IMAGES_QUERY_KEY = (type) => {
   const keys = ["IMAGES"];
@@ -15584,6 +15726,92 @@ var useGetStreamInputOutput = (streamId = "", output = "", options = {}) => {
   );
 };
 
+// src/queries/streams/useGetStreamThreads.ts
+var STREAM_THREADS_QUERY_KEY = (streamId) => [
+  ...STREAM_QUERY_KEY(streamId),
+  "THREADS"
+];
+var SET_STREAM_THREADS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(STREAM_THREADS_QUERY_KEY(...keyParams), response);
+};
+var GetStreamThreads = async ({
+  streamId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/streams/${streamId}/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetStreamThreads = (streamId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    STREAM_THREADS_QUERY_KEY(streamId),
+    (params2) => GetStreamThreads({
+      ...params2,
+      streamId
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!streamId && (options.enabled ?? true)
+    },
+    ["events", "threads"]
+  );
+};
+
+// src/queries/streams/useGetStreamVideos.ts
+var STREAM_VIDEOS_QUERY_KEY = (streamId) => [
+  ...STREAM_QUERY_KEY(streamId),
+  "VIDEOS"
+];
+var SET_STREAM_VIDEOS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(STREAM_VIDEOS_QUERY_KEY(...keyParams), response);
+};
+var GetStreamVideos = async ({
+  streamId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/streams/${streamId}/videos`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetStreamVideos = (streamId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    STREAM_VIDEOS_QUERY_KEY(streamId),
+    (params2) => GetStreamVideos({
+      ...params2,
+      streamId
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!streamId && (options.enabled ?? true)
+    },
+    ["events", "storage"]
+  );
+};
+
 // src/queries/supportTickets/useGetSupportTickets.ts
 var SUPPORT_TICKETS_QUERY_KEY = (status, type) => [
   "SUPPORT_TICKETS",
@@ -16709,12 +16937,10 @@ var useGetSurveyTranslation = (surveyId = "", locale = "", options = {}) => {
 };
 
 // src/queries/threads/useGetThreads.ts
-var THREADS_QUERY_KEY = (access, groupId, eventId) => {
-  const keys = ["THREADS"];
-  if (access) keys.push(access);
-  if (groupId) keys.push(groupId);
-  if (eventId) keys.push(eventId);
-  return keys;
+var THREADS_QUERY_KEY = (type) => {
+  const key = ["THREADS"];
+  if (type) key.push(type);
+  return key;
 };
 var SET_THREADS_QUERY_DATA = (client, keyParams, response) => {
   client.setQueryData(THREADS_QUERY_KEY(...keyParams), response);
@@ -16723,10 +16949,8 @@ var GetThreads = async ({
   pageParam,
   pageSize,
   orderBy,
-  access,
-  groupId,
-  eventId,
   search,
+  type,
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
@@ -16736,22 +16960,15 @@ var GetThreads = async ({
       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
     }
   });
   return data;
 };
-var useGetThreads = (access, groupId, eventId, params = {}, options = {}) => {
+var useGetThreads = (type, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    THREADS_QUERY_KEY(access, groupId, eventId),
-    (params2) => GetThreads({
-      ...params2,
-      access,
-      groupId,
-      eventId
-    }),
+    THREADS_QUERY_KEY(type),
+    (params2) => GetThreads({ ...params2, type }),
     params,
     options,
     "threads"
@@ -16759,10 +16976,9 @@ var useGetThreads = (access, groupId, eventId, params = {}, options = {}) => {
 };
 
 // src/queries/threads/useGetThread.ts
-var THREAD_QUERY_KEY = (threadId, messageId) => [
-  ...THREADS_QUERY_KEY(),
-  threadId,
-  messageId
+var THREAD_QUERY_KEY = (threadId) => [
+  THREADS_QUERY_KEY(),
+  threadId
 ];
 var SET_THREAD_QUERY_DATA = (client, keyParams, response, options) => {
   client.setQueryData([...THREAD_QUERY_KEY(...keyParams)], response, options);
@@ -16787,48 +17003,132 @@ var useGetThread = (threadId = "", options = {}) => {
   );
 };
 
-// src/queries/threads/useGetThreadMember.ts
-var THREAD_MEMBER_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), "MEMBER", threadId, accountId];
-var GetThreadMember = async ({
+// src/queries/threads/useGetThreadAccounts.ts
+var THREAD_ACCOUNTS_QUERY_KEY = (threadId) => {
+  const key = [...THREAD_QUERY_KEY(threadId), "ACCOUNTS"];
+  return key;
+};
+var GetThreadAccounts = async ({
   threadId,
-  accountId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(
-    `/threads/${threadId}/members/${accountId}`
+  const { data } = await adminApi.get(`/threads/${threadId}/accounts`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadAccounts = (threadId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_ACCOUNTS_QUERY_KEY(threadId),
+    (params2) => GetThreadAccounts({ ...params2, threadId }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && (options.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadCircles.ts
+var THREAD_CIRCLES_QUERY_KEY = (type) => {
+  const key = ["CIRCLES"];
+  if (type) key.push(type);
+  return key;
+};
+var SET_THREAD_CIRCLES_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(THREAD_CIRCLES_QUERY_KEY(...keyParams), response);
+};
+var GetThreadCircles = async ({
+  type,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/circles`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      type: type || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadCircles = (type, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_CIRCLES_QUERY_KEY(type),
+    (params2) => GetThreadCircles({ type, ...params2 }),
+    params,
+    options,
+    "threads"
   );
+};
+
+// 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) => {
+  client.setQueryData(THREAD_CIRCLE_QUERY_KEY(...keyParams), response);
+};
+var GetThreadCircle = async ({
+  circleId,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.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 && !!accountId && (options?.enabled ?? true)
+      enabled: !!circleId && (options.enabled ?? true)
     },
     "threads"
   );
 };
 
-// src/queries/threads/useGetThreadMembers.ts
-var THREAD_MEMBERS_QUERY_KEY = (threadId) => [
-  ...THREADS_QUERY_KEY(),
-  "MEMBERS",
-  threadId
-];
-var GetThreadMembers = async ({
-  threadId,
+// src/queries/threads/useGetThreadCircleAccounts.ts
+var THREAD_CIRCLE_ACCOUNTS_QUERY_KEY = (circleId, role) => {
+  const key = [...THREAD_CIRCLE_QUERY_KEY(circleId), "ACCOUNTS"];
+  if (role) {
+    key.push(role);
+  }
+  return key;
+};
+var SET_THREAD_CIRCLE_ACCOUNTS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(...keyParams), response);
+};
+var GetThreadCircleAccounts = async ({
+  circleId,
+  role,
   pageParam,
   pageSize,
   orderBy,
   search,
-  role,
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(`/threads/${threadId}/members`, {
+  const { data } = await adminApi.get(`/threads/circles/${circleId}/accounts`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -16839,14 +17139,79 @@ var GetThreadMembers = async ({
   });
   return data;
 };
-var useGetThreadMembers = (threadId = "", params = {}, options = {}) => {
+var useGetThreadCircleAccounts = (circleId, role, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    THREAD_MEMBERS_QUERY_KEY(threadId),
-    (params2) => GetThreadMembers({ ...params2, threadId }),
+    THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId, role),
+    (params2) => GetThreadCircleAccounts({ circleId, role, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!threadId && (options.enabled ?? true)
+      enabled: !!circleId && (options.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// 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) => {
+  client.setQueryData(THREAD_CIRCLE_ACCOUNT_QUERY_KEY(...keyParams), response);
+};
+var GetThreadCircleAccount = async ({
+  circleId,
+  accountId,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.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,
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadCircleThreads.ts
+var THREAD_CIRCLE_THREADS_QUERY_KEY = (circleId) => [
+  THREAD_CIRCLE_QUERY_KEY(circleId),
+  circleId
+];
+var SET_THREAD_CIRCLE_THREADS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(THREAD_CIRCLE_THREADS_QUERY_KEY(...keyParams), response);
+};
+var GetThreadCircleThreads = async ({
+  circleId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/circles/${circleId}/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadCircleThreads = (circleId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_CIRCLE_THREADS_QUERY_KEY(circleId),
+    (params2) => GetThreadCircleThreads({ circleId, ...params2 }),
+    params,
+    {
+      enabled: !!circleId && (options.enabled ?? true),
+      ...options
     },
     "threads"
   );
@@ -16971,7 +17336,10 @@ var TransformPrice = (value, currency) => {
 };
 
 // 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(
     [
@@ -17005,13 +17373,6 @@ var GetThreadMessages = async ({
       queryClient,
       (messageId) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId)
     );
-    SET_THREAD_QUERY_DATA(queryClient, [threadId], (old) => ({
-      ...old,
-      data: {
-        ...old.data,
-        read: true
-      }
-    }));
   }
   return data;
 };
@@ -17022,7 +17383,6 @@ var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
     (params2) => GetThreadMessages({ ...params2, threadId }),
     params,
     {
-      refetchInterval: 5 * 1e3,
       ...options,
       enabled: !!authenticated && !!threadId && (options?.enabled ?? true)
     },
@@ -17032,7 +17392,7 @@ var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
 
 // src/queries/threads/useGetThreadMessage.ts
 var THREAD_MESSAGE_QUERY_KEY = (threadId, messageId) => {
-  return [...THREAD_MESSAGES_QUERY_KEY(threadId, messageId)];
+  return [...THREAD_MESSAGES_QUERY_KEY(threadId), messageId];
 };
 var SET_THREAD_MESSAGE_QUERY_DATA = (client, keyParams, response, options) => {
   client.setQueryData(
@@ -17065,30 +17425,29 @@ var useGetThreadMessage = (threadId, messageId, options = {}) => {
   );
 };
 
-// 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"]) => {
+// src/queries/threads/useGetThreadMessageFiles.ts
+var THREAD_MESSAGE_FILES_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGE_QUERY_KEY(threadId, messageId), "files"];
+};
+var SET_THREAD_MESSAGE_FILES_QUERY_DATA = (client, keyParams, response, options) => {
   client.setQueryData(
-    [
-      ...THREAD_MESSAGE_REPLIES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
+    THREAD_MESSAGE_FILES_QUERY_KEY(...keyParams),
+    response,
+    options
   );
 };
-var GetThreadMessageReplies = async ({
+var GetThreadMessageFiles = async ({
   threadId,
   messageId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  queryClient,
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
   const { data } = await adminApi.get(
-    `/threads/${threadId}/messages/${messageId}/replies`,
+    `/threads/${threadId}/messages/${messageId}/files`,
     {
       params: {
         page: pageParam || void 0,
@@ -17098,40 +17457,34 @@ var GetThreadMessageReplies = async ({
       }
     }
   );
-  if (queryClient && data.status === "ok") {
-    CacheIndividualQueries(
-      data,
-      queryClient,
-      (messageId2) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId2)
-    );
-  }
   return data;
 };
-var useGetThreadMessageReplies = (threadId = "", messageId = "", params = {}, options = {}) => {
-  const { authenticated } = useConnectedXM();
+var useGetThreadMessageFiles = (threadId, messageId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    THREAD_MESSAGE_REPLIES_QUERY_KEY(threadId, messageId),
-    (params2) => GetThreadMessageReplies({ ...params2, threadId, messageId }),
+    THREAD_MESSAGE_FILES_QUERY_KEY(threadId, messageId),
+    (params2) => GetThreadMessageFiles({ threadId, messageId, ...params2 }),
     params,
     {
-      refetchInterval: 5 * 1e3,
       ...options,
-      enabled: !!authenticated && !!threadId && !!messageId && (options?.enabled ?? true)
-    },
-    "threads"
+      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/threads/useGetThreadModerators.ts
-var THREAD_MODERATORS_QUERY_KEY = (threadId) => [
-  ...THREAD_QUERY_KEY(threadId),
-  "MODERATORS"
-];
-var SET_THREAD_MODERATORS_QUERY_DATA = (client, keyParams, response) => {
-  client.setQueryData(THREAD_MODERATORS_QUERY_KEY(...keyParams), response);
+// src/queries/threads/useGetThreadMessageImages.ts
+var THREAD_MESSAGE_IMAGES_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGE_QUERY_KEY(threadId, messageId), "images"];
 };
-var GetThreadModerators = async ({
+var SET_THREAD_MESSAGE_IMAGES_QUERY_DATA = (client, keyParams, response, options) => {
+  client.setQueryData(
+    THREAD_MESSAGE_IMAGES_QUERY_KEY(...keyParams),
+    response,
+    options
+  );
+};
+var GetThreadMessageImages = async ({
   threadId,
+  messageId,
   pageParam,
   pageSize,
   orderBy,
@@ -17139,7 +17492,138 @@ var GetThreadModerators = async ({
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(`/threads/${threadId}/moderators`, {
+  const { data } = await adminApi.get(
+    `/threads/${threadId}/messages/${messageId}/images`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetThreadMessageImages = (threadId, messageId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGE_IMAGES_QUERY_KEY(threadId, messageId),
+    (params2) => GetThreadMessageImages({ threadId, messageId, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessageReactions.ts
+var THREAD_MESSAGE_REACTIONS_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGE_QUERY_KEY(threadId, messageId), "reactions"];
+};
+var SET_THREAD_MESSAGE_REACTIONS_QUERY_DATA = (client, keyParams, response, options) => {
+  client.setQueryData(
+    THREAD_MESSAGE_REACTIONS_QUERY_KEY(...keyParams),
+    response,
+    options
+  );
+};
+var GetThreadMessageReactions = async ({
+  threadId,
+  messageId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/threads/${threadId}/messages/${messageId}/reactions`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetThreadMessageReactions = (threadId, messageId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGE_REACTIONS_QUERY_KEY(threadId, messageId),
+    (params2) => GetThreadMessageReactions({ threadId, messageId, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessageVideos.ts
+var THREAD_MESSAGE_VIDEOS_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGE_QUERY_KEY(threadId, messageId), "videos"];
+};
+var SET_THREAD_MESSAGE_VIDEOS_QUERY_DATA = (client, keyParams, response, options) => {
+  client.setQueryData(
+    THREAD_MESSAGE_VIDEOS_QUERY_KEY(...keyParams),
+    response,
+    options
+  );
+};
+var GetThreadMessageVideos = async ({
+  threadId,
+  messageId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/threads/${threadId}/messages/${messageId}/videos`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetThreadMessageVideos = (threadId, messageId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGE_VIDEOS_QUERY_KEY(threadId, messageId),
+    (params2) => GetThreadMessageVideos({ threadId, messageId, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadViewers.ts
+var THREAD_VIEWERS_QUERY_KEY = (threadId) => {
+  const key = [...THREAD_QUERY_KEY(threadId), "VIEWERS"];
+  return key;
+};
+var GetThreadViewers = async ({
+  threadId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/${threadId}/viewers`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -17149,10 +17633,10 @@ var GetThreadModerators = async ({
   });
   return data;
 };
-var useGetThreadModerators = (threadId = "", params = {}, options = {}) => {
+var useGetThreadViewers = (threadId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    THREAD_MODERATORS_QUERY_KEY(threadId),
-    (params2) => GetThreadModerators({ ...params2, threadId }),
+    THREAD_VIEWERS_QUERY_KEY(threadId),
+    (params2) => GetThreadViewers({ ...params2, threadId }),
     params,
     {
       ...options,
@@ -22413,6 +22897,9 @@ var CreateEventMatch = async ({
     queryClient.invalidateQueries({
       queryKey: EVENT_ROUND_MATCHES_QUERY_KEY(eventId, roundId)
     });
+    queryClient.invalidateQueries({
+      queryKey: EVENT_ROUNDS_QUERY_KEY(eventId)
+    });
   }
   return data;
 };
@@ -22463,6 +22950,9 @@ var DeleteEventMatch = async ({
     queryClient.invalidateQueries({
       queryKey: EVENT_ROUND_MATCHES_QUERY_KEY(eventId, roundId)
     });
+    queryClient.invalidateQueries({
+      queryKey: EVENT_ROUNDS_QUERY_KEY(eventId)
+    });
   }
   return data;
 };
@@ -22537,6 +23027,27 @@ var useRemoveEventMatchPass = (options = {}) => {
   });
 };
 
+// src/mutations/event/matches/useStartEventRoundMatchmaking.ts
+var StartEventRoundMatchmaking = async ({
+  eventId,
+  roundId,
+  targetMatchSize,
+  adminApiParams
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/events/${eventId}/rounds/${roundId}/start`,
+    { targetMatchSize }
+  );
+  return data;
+};
+var useStartEventRoundMatchmaking = (options = {}) => {
+  return useConnectedMutation(StartEventRoundMatchmaking, options, {
+    domain: "events",
+    type: "update"
+  });
+};
+
 // src/mutations/event/matches/useUpdateEventMatch.ts
 var UpdateEventMatch = async ({
   eventId,
@@ -25965,6 +26476,9 @@ var CreateEventSessionMatch = async ({
         roundId
       )
     });
+    queryClient.invalidateQueries({
+      queryKey: EVENT_SESSION_ROUNDS_QUERY_KEY(eventId, sessionId)
+    });
   }
   return data;
 };
@@ -26021,6 +26535,9 @@ var DeleteEventSessionMatch = async ({
         roundId
       )
     });
+    queryClient.invalidateQueries({
+      queryKey: EVENT_SESSION_ROUNDS_QUERY_KEY(eventId, sessionId)
+    });
   }
   return data;
 };
@@ -26113,6 +26630,28 @@ var useRemoveEventSessionMatchPass = (options = {}) => {
   });
 };
 
+// src/mutations/event/sessions/matches/useStartEventSessionRoundMatchmaking.ts
+var StartEventSessionRoundMatchmaking = async ({
+  eventId,
+  sessionId,
+  roundId,
+  targetMatchSize,
+  adminApiParams
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/events/${eventId}/sessions/${sessionId}/rounds/${roundId}/start`,
+    { targetMatchSize }
+  );
+  return data;
+};
+var useStartEventSessionRoundMatchmaking = (options = {}) => {
+  return useConnectedMutation(StartEventSessionRoundMatchmaking, options, {
+    domain: "events",
+    type: "update"
+  });
+};
+
 // src/mutations/event/sessions/matches/useUpdateEventSessionMatch.ts
 var UpdateEventSessionMatch = async ({
   eventId,
@@ -33610,97 +34149,225 @@ var useUpdateSurvey = (options = {}) => {
   });
 };
 
-// src/mutations/threads/useAddThreadMember.ts
-var AddThreadMember = async ({
-  threadId,
-  accountId,
-  role,
+// src/mutations/threads/useCreateThread.ts
+var CreateThread = async ({
+  thread,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
   const { data } = await connectedXM.post(
-    `/threads/${threadId}/members/${accountId}`,
-    {
-      role
+    `/threads`,
+    thread
+  );
+  if (queryClient && data.status === "ok") {
+    if (thread.groupId) {
+      queryClient.invalidateQueries({
+        queryKey: GROUP_THREADS_QUERY_KEY(thread.groupId)
+      });
     }
+    if (thread.circleId) {
+      queryClient.invalidateQueries({
+        queryKey: THREAD_CIRCLE_THREADS_QUERY_KEY(thread.circleId)
+      });
+    }
+    if (thread.eventId) {
+      queryClient.invalidateQueries({
+        queryKey: EVENT_THREADS_QUERY_KEY(thread.eventId)
+      });
+    }
+    if (thread.streamId) {
+      queryClient.invalidateQueries({
+        queryKey: STREAM_THREADS_QUERY_KEY(thread.streamId)
+      });
+    }
+  }
+  return data;
+};
+var useCreateThread = (options = {}) => {
+  return useConnectedMutation(CreateThread, options, {
+    domain: "threads",
+    type: "create"
+  });
+};
+
+// src/mutations/threads/useCreateThreadCircle.ts
+var CreateThreadCircle = async ({
+  circle,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/threads/circles`,
+    circle
   );
-  if (queryClient && data.status === "ok" && role === "member") {
+  if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+      queryKey: THREAD_CIRCLES_QUERY_KEY()
     });
   }
-  if (queryClient && data.status === "ok" && role === "moderator") {
+  return data;
+};
+var useCreateThreadCircle = (options = {}) => {
+  return useConnectedMutation(CreateThreadCircle, options, {
+    domain: "threads",
+    type: "create"
+  });
+};
+
+// src/mutations/threads/useCreateThreadCircleAccount.ts
+var CreateThreadCircleAccount = async ({
+  circleId,
+  account,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(`/threads/circles/${circleId}/accounts`, account);
+  if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: THREAD_MODERATORS_QUERY_KEY(threadId)
+      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
     });
   }
   return data;
 };
-var useAddThreadMember = (options = {}) => {
-  return useConnectedMutation(AddThreadMember, options, {
+var useCreateThreadCircleAccount = (options = {}) => {
+  return useConnectedMutation(CreateThreadCircleAccount, options, {
+    domain: "threads",
+    type: "create"
+  });
+};
+
+// src/mutations/threads/useCreateThreadMessage.ts
+var CreateThreadMessage = async ({
+  threadId,
+  message,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/threads/${threadId}/messages`,
+    message
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useCreateThreadMessage = (options = {}) => {
+  return useConnectedMutation(CreateThreadMessage, options, {
+    domain: "threads",
+    type: "create"
+  });
+};
+
+// src/mutations/threads/useCreateThreadMessageFile.ts
+var CreateThreadMessageFile = async ({
+  threadId,
+  messageId,
+  fileId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/threads/${threadId}/messages/${messageId}/files/${fileId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_FILES_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useCreateThreadMessageFile = (options = {}) => {
+  return useConnectedMutation(CreateThreadMessageFile, options, {
     domain: "threads",
     type: "update"
   });
 };
 
-// src/mutations/threads/useAddThreadModerator.ts
-var AddThreadModerator = async ({
+// src/mutations/threads/useCreateThreadMessageImage.ts
+var CreateThreadMessageImage = async ({
   threadId,
-  accountId,
+  messageId,
+  imageId,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
   const { data } = await connectedXM.post(
-    `/threads/${threadId}/moderators/${accountId}`
+    `/threads/${threadId}/messages/${messageId}/images/${imageId}`
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: THREAD_MODERATORS_QUERY_KEY(threadId)
+      queryKey: THREAD_MESSAGE_IMAGES_QUERY_KEY(threadId, messageId)
     });
+  }
+  return data;
+};
+var useCreateThreadMessageImage = (options = {}) => {
+  return useConnectedMutation(CreateThreadMessageImage, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
+// src/mutations/threads/useCreateThreadMessageReaction.ts
+var CreateThreadMessageReaction = async ({
+  threadId,
+  messageId,
+  accountId,
+  reaction,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(`/threads/${threadId}/messages/${messageId}/reactions`, {
+    accountId,
+    ...reaction
+  });
+  if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+      queryKey: THREAD_MESSAGE_REACTIONS_QUERY_KEY(threadId, messageId)
     });
   }
   return data;
 };
-var useAddThreadModerator = (options = {}) => {
-  return useConnectedMutation(AddThreadModerator, options, {
+var useCreateThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation(CreateThreadMessageReaction, options, {
     domain: "threads",
     type: "update"
   });
 };
 
-// src/mutations/threads/useCreateThread.ts
-var CreateThread = async ({
-  thread,
-  accountIds,
-  firstMessage,
-  imageDataUri,
+// src/mutations/threads/useCreateThreadMessageVideo.ts
+var CreateThreadMessageVideo = async ({
+  threadId,
+  messageId,
+  videoId,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
   const { data } = await connectedXM.post(
-    `/threads`,
-    {
-      thread,
-      accountIds,
-      firstMessage,
-      imageDataUri
-    }
+    `/threads/${threadId}/messages/${messageId}/videos/${videoId}`
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({ queryKey: THREADS_QUERY_KEY() });
-    SET_THREAD_QUERY_DATA(queryClient, [data.data?.id], data);
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_VIDEOS_QUERY_KEY(threadId, messageId)
+    });
   }
   return data;
 };
-var useCreateThread = (options = {}) => {
-  return useConnectedMutation(CreateThread, options, {
+var useCreateThreadMessageVideo = (options = {}) => {
+  return useConnectedMutation(CreateThreadMessageVideo, options, {
     domain: "threads",
-    type: "create"
+    type: "update"
   });
 };
 
@@ -33715,7 +34382,7 @@ var DeleteThread = async ({
     `/threads/${threadId}`
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({ queryKey: THREADS_QUERY_KEY() });
+    queryClient.invalidateQueries({ queryKey: ["THREADS"], exact: false });
     queryClient.removeQueries({ queryKey: THREAD_QUERY_KEY(threadId) });
   }
   return data;
@@ -33727,49 +34394,187 @@ var useDeleteThread = (options = {}) => {
   });
 };
 
-// src/mutations/threads/useRemoveThreadMember.ts
-var RemoveThreadMember = async ({
-  threadId,
+// src/mutations/threads/useDeleteThreadCircle.ts
+var DeleteThreadCircle = async ({
+  circleId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(
+    `/threads/circles/${circleId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_CIRCLE_QUERY_KEY(circleId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_CIRCLES_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useDeleteThreadCircle = (options = {}) => {
+  return useConnectedMutation(DeleteThreadCircle, options, {
+    domain: "threads",
+    type: "del"
+  });
+};
+
+// src/mutations/threads/useDeleteThreadCircleAccount.ts
+var DeleteThreadCircleAccount = async ({
+  circleId,
   accountId,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.delete(`/threads/${threadId}/members/${accountId}`);
+  const { data } = await connectedXM.delete(
+    `/threads/circles/${circleId}/accounts/${accountId}`
+  );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
+    });
+    queryClient.removeQueries({
+      queryKey: THREAD_CIRCLE_ACCOUNT_QUERY_KEY(circleId, accountId)
     });
   }
   return data;
 };
-var useRemoveThreadMember = (options = {}) => {
-  return useConnectedMutation(RemoveThreadMember, options, {
+var useDeleteThreadCircleAccount = (options = {}) => {
+  return useConnectedMutation(DeleteThreadCircleAccount, options, {
     domain: "threads",
-    type: "update"
+    type: "del"
   });
 };
 
-// src/mutations/threads/useRemoveThreadModerator.ts
-var RemoveThreadModerator = async ({
+// src/mutations/threads/useDeleteThreadMessage.ts
+var DeleteThreadMessage = async ({
   threadId,
-  accountId,
+  messageId,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.delete(`/threads/${threadId}/moderators/${accountId}`);
+  const { data } = await connectedXM.delete(
+    `/threads/${threadId}/messages/${messageId}`
+  );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: THREAD_MODERATORS_QUERY_KEY(threadId)
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
     });
   }
   return data;
 };
-var useRemoveThreadModerator = (options = {}) => {
-  return useConnectedMutation(RemoveThreadModerator, options, {
+var useDeleteThreadMessage = (options = {}) => {
+  return useConnectedMutation(DeleteThreadMessage, options, {
     domain: "threads",
-    type: "update"
+    type: "del"
+  });
+};
+
+// src/mutations/threads/useDeleteThreadMessageFile.ts
+var DeleteThreadMessageFile = async ({
+  threadId,
+  messageId,
+  fileId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(
+    `/threads/${threadId}/messages/${messageId}/files/${fileId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_FILES_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useDeleteThreadMessageFile = (options = {}) => {
+  return useConnectedMutation(DeleteThreadMessageFile, options, {
+    domain: "threads",
+    type: "del"
+  });
+};
+
+// src/mutations/threads/useDeleteThreadMessageImage.ts
+var DeleteThreadMessageImage = async ({
+  threadId,
+  messageId,
+  imageId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(
+    `/threads/${threadId}/messages/${messageId}/images/${imageId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_IMAGES_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useDeleteThreadMessageImage = (options = {}) => {
+  return useConnectedMutation(DeleteThreadMessageImage, options, {
+    domain: "threads",
+    type: "del"
+  });
+};
+
+// src/mutations/threads/useDeleteThreadMessageReaction.ts
+var DeleteThreadMessageReaction = async ({
+  threadId,
+  messageId,
+  reactionId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(
+    `/threads/${threadId}/messages/${messageId}/reactions/${reactionId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_REACTIONS_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useDeleteThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation(DeleteThreadMessageReaction, options, {
+    domain: "threads",
+    type: "del"
+  });
+};
+
+// src/mutations/threads/useDeleteThreadMessageVideo.ts
+var DeleteThreadMessageVideo = async ({
+  threadId,
+  messageId,
+  videoId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(
+    `/threads/${threadId}/messages/${messageId}/videos/${videoId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_VIDEOS_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useDeleteThreadMessageVideo = (options = {}) => {
+  return useConnectedMutation(DeleteThreadMessageVideo, options, {
+    domain: "threads",
+    type: "del"
   });
 };
 
@@ -33777,20 +34582,16 @@ var useRemoveThreadModerator = (options = {}) => {
 var UpdateThread = async ({
   threadId,
   thread,
-  imageDataUri,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
   const { data } = await connectedXM.put(
     `/threads/${threadId}`,
-    {
-      thread,
-      imageDataUri
-    }
+    thread
   );
   if (queryClient && data.status === "ok") {
-    queryClient.invalidateQueries({ queryKey: THREADS_QUERY_KEY() });
+    queryClient.invalidateQueries({ queryKey: ["THREADS"], exact: false });
     SET_THREAD_QUERY_DATA(queryClient, [threadId], data);
   }
   return data;
@@ -33802,6 +34603,86 @@ var useUpdateThread = (options = {}) => {
   });
 };
 
+// src/mutations/threads/useUpdateThreadCircle.ts
+var UpdateThreadCircle = async ({
+  circleId,
+  circle,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/threads/circles/${circleId}`,
+    circle
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_CIRCLE_QUERY_KEY(circleId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_CIRCLES_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useUpdateThreadCircle = (options = {}) => {
+  return useConnectedMutation(UpdateThreadCircle, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
+// src/mutations/threads/useUpdateThreadCircleAccount.ts
+var UpdateThreadCircleAccount = async ({
+  circleId,
+  accountId,
+  account,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(`/threads/circles/${circleId}/accounts/${accountId}`, account);
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId)
+    });
+  }
+  return data;
+};
+var useUpdateThreadCircleAccount = (options = {}) => {
+  return useConnectedMutation(UpdateThreadCircleAccount, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
+// src/mutations/threads/useUpdateThreadMessage.ts
+var UpdateThreadMessage = async ({
+  threadId,
+  messageId,
+  message,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/threads/${threadId}/messages/${messageId}`,
+    message
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useUpdateThreadMessage = (options = {}) => {
+  return useConnectedMutation(UpdateThreadMessage, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
 // src/mutations/tier/useAddTierAccount.ts
 var AddTierAccount = async ({
   tierId,
@@ -34059,6 +34940,7 @@ export {
   ACCOUNT_PUSH_DEVICE_QUERY_KEY,
   ACCOUNT_QUERY_KEY,
   ACCOUNT_SUBSCRIPTIONS_QUERY_KEY,
+  ACCOUNT_THREADS_QUERY_KEY,
   ACCOUNT_TIERS_QUERY_KEY,
   ACTIVITIES_QUERY_KEY,
   ACTIVITY_COMMENTS_QUERY_KEY,
@@ -34134,8 +35016,6 @@ export {
   AddSeriesEvent,
   AddSurveyQuestionChoiceSubQuestion,
   AddSurveySectionQuestion,
-  AddThreadMember,
-  AddThreadModerator,
   AddTierAccount,
   AdvertisementType,
   AppendInfiniteQuery,
@@ -34323,6 +35203,13 @@ export {
   CreateSurveyTranslation,
   CreateTaxIntegration,
   CreateThread,
+  CreateThreadCircle,
+  CreateThreadCircleAccount,
+  CreateThreadMessage,
+  CreateThreadMessageFile,
+  CreateThreadMessageImage,
+  CreateThreadMessageReaction,
+  CreateThreadMessageVideo,
   CreateTier,
   Currency,
   CustomModulePosition,
@@ -34464,6 +35351,13 @@ export {
   DeleteSurveyTranslation,
   DeleteTaxIntegration,
   DeleteThread,
+  DeleteThreadCircle,
+  DeleteThreadCircleAccount,
+  DeleteThreadMessage,
+  DeleteThreadMessageFile,
+  DeleteThreadMessageImage,
+  DeleteThreadMessageReaction,
+  DeleteThreadMessageVideo,
   DeleteTier,
   DeleteUserImage,
   DeleteVideo,
@@ -34641,6 +35535,7 @@ export {
   EVENT_SPONSORSHIP_TRANSLATION_QUERY_KEY,
   EVENT_SPONSORS_QUERY_KEY,
   EVENT_SPONSOR_ACCOUNTS_QUERY_KEY,
+  EVENT_THREADS_QUERY_KEY,
   EVENT_TRACKS_QUERY_KEY,
   EVENT_TRACK_QUERY_KEY,
   EVENT_TRACK_SESSIONS_QUERY_KEY,
@@ -34677,6 +35572,7 @@ export {
   GROUP_REQUESTS_QUERY_KEY,
   GROUP_REQUEST_QUERY_KEY,
   GROUP_SPONSORS_QUERY_KEY,
+  GROUP_THREADS_QUERY_KEY,
   GROUP_TRANSLATIONS_QUERY_KEY,
   GROUP_TRANSLATION_QUERY_KEY,
   GetAPILog,
@@ -34707,6 +35603,7 @@ export {
   GetAccountPushDevice,
   GetAccountPushDevices,
   GetAccountSubscriptions,
+  GetAccountThreads,
   GetAccountTiers,
   GetAccounts,
   GetActivities,
@@ -34952,6 +35849,7 @@ export {
   GetEventSponsorshipTranslation,
   GetEventSponsorshipTranslations,
   GetEventSponsorships,
+  GetEventThreads,
   GetEventTrack,
   GetEventTrackSessions,
   GetEventTrackSponsors,
@@ -34978,6 +35876,7 @@ export {
   GetGroupRequest,
   GetGroupRequests,
   GetGroupSponsors,
+  GetGroupThreads,
   GetGroupTranslation,
   GetGroupTranslations,
   GetGroups,
@@ -35049,6 +35948,8 @@ export {
   GetStreamInputOutput,
   GetStreamInputOutputs,
   GetStreamInputs,
+  GetStreamThreads,
+  GetStreamVideos,
   GetSubscription,
   GetSubscriptionPayments,
   GetSubscriptions,
@@ -35082,12 +35983,19 @@ export {
   GetTaxIntegration,
   GetTaxIntegrations,
   GetThread,
-  GetThreadMember,
-  GetThreadMembers,
+  GetThreadAccounts,
+  GetThreadCircle,
+  GetThreadCircleAccount,
+  GetThreadCircleAccounts,
+  GetThreadCircleThreads,
+  GetThreadCircles,
   GetThreadMessage,
-  GetThreadMessageReplies,
+  GetThreadMessageFiles,
+  GetThreadMessageImages,
+  GetThreadMessageReactions,
+  GetThreadMessageVideos,
   GetThreadMessages,
-  GetThreadModerators,
+  GetThreadViewers,
   GetThreads,
   GetTier,
   GetTierAccounts,
@@ -35235,8 +36143,6 @@ export {
   RemoveSeriesEvent,
   RemoveSurveyQuestionChoiceSubQuestion,
   RemoveSurveySectionQuestion,
-  RemoveThreadMember,
-  RemoveThreadModerator,
   RemoveTierAccount,
   RemoveTierAccounts,
   ReorderEventFaqSectionQuestions,
@@ -35286,6 +36192,7 @@ export {
   SET_ACCOUNT_PUSH_DEVICE_QUERY_DATA,
   SET_ACCOUNT_QUERY_DATA,
   SET_ACCOUNT_SUBSCRIPTIONS_QUERY_DATA,
+  SET_ACCOUNT_THREADS_QUERY_DATA,
   SET_ACCOUNT_TIERS_QUERY_DATA,
   SET_ACTIVITIES_QUERY_DATA,
   SET_ACTIVITY_COMMENTS_QUERY_DATA,
@@ -35527,6 +36434,7 @@ export {
   SET_EVENT_SPONSORSHIP_TRANSLATION_QUERY_DATA,
   SET_EVENT_SPONSORS_QUERY_DATA,
   SET_EVENT_SPONSOR_ACCOUNTS_QUERY_DATA,
+  SET_EVENT_THREADS_QUERY_DATA,
   SET_EVENT_TRACKS_QUERY_DATA,
   SET_EVENT_TRACK_QUERY_DATA,
   SET_EVENT_TRACK_SESSIONS_QUERY_DATA,
@@ -35553,6 +36461,7 @@ export {
   SET_GROUP_REQUESTS_QUERY_DATA,
   SET_GROUP_REQUEST_QUERY_DATA,
   SET_GROUP_SPONSORS_QUERY_DATA,
+  SET_GROUP_THREADS_QUERY_DATA,
   SET_GROUP_TRANSLATIONS_QUERY_DATA,
   SET_GROUP_TRANSLATION_QUERY_DATA,
   SET_IMAGES_QUERY_DATA,
@@ -35622,6 +36531,8 @@ export {
   SET_STREAM_INPUT_OUTPUTS_QUERY_DATA,
   SET_STREAM_INPUT_OUTPUT_QUERY_DATA,
   SET_STREAM_INPUT_QUERY_DATA,
+  SET_STREAM_THREADS_QUERY_DATA,
+  SET_STREAM_VIDEOS_QUERY_DATA,
   SET_SUBSCRIPTIONS_QUERY_DATA,
   SET_SUBSCRIPTION_PAYMENTS_QUERY_DATA,
   SET_SUBSCRIPTION_QUERY_DATA,
@@ -35654,10 +36565,17 @@ export {
   SET_TAX_INTEGRATIONS_QUERY_DATA,
   SET_TAX_INTEGRATION_QUERY_DATA,
   SET_THREADS_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_CIRCLE_THREADS_QUERY_DATA,
   SET_THREAD_MESSAGES_QUERY_DATA,
+  SET_THREAD_MESSAGE_FILES_QUERY_DATA,
+  SET_THREAD_MESSAGE_IMAGES_QUERY_DATA,
   SET_THREAD_MESSAGE_QUERY_DATA,
-  SET_THREAD_MESSAGE_REPLIES_QUERY_DATA,
-  SET_THREAD_MODERATORS_QUERY_DATA,
+  SET_THREAD_MESSAGE_REACTIONS_QUERY_DATA,
+  SET_THREAD_MESSAGE_VIDEOS_QUERY_DATA,
   SET_THREAD_QUERY_DATA,
   SET_TIERS_QUERY_DATA,
   SET_TIER_ACCOUNTS_QUERY_DATA,
@@ -35670,6 +36588,8 @@ export {
   STREAM_INPUT_OUTPUTS_QUERY_KEY,
   STREAM_INPUT_OUTPUT_QUERY_KEY,
   STREAM_QUERY_KEY,
+  STREAM_THREADS_QUERY_KEY,
+  STREAM_VIDEOS_QUERY_KEY,
   SUBSCRIPTIONS_QUERY_KEY,
   SUBSCRIPTION_PAYMENTS_QUERY_KEY,
   SUBSCRIPTION_QUERY_KEY,
@@ -35703,6 +36623,8 @@ export {
   SearchOrganization,
   SelfLeaveOrganization,
   SendAnnouncementPreview,
+  StartEventRoundMatchmaking,
+  StartEventSessionRoundMatchmaking,
   SubscriptionStatus,
   SupportTicketState,
   SupportTicketType,
@@ -35712,13 +36634,20 @@ export {
   TAX_INTEGRATIONS_QUERY_KEY,
   TAX_INTEGRATION_QUERY_KEY,
   THREADS_QUERY_KEY,
-  THREAD_MEMBERS_QUERY_KEY,
-  THREAD_MEMBER_QUERY_KEY,
+  THREAD_ACCOUNTS_QUERY_KEY,
+  THREAD_CIRCLES_QUERY_KEY,
+  THREAD_CIRCLE_ACCOUNTS_QUERY_KEY,
+  THREAD_CIRCLE_ACCOUNT_QUERY_KEY,
+  THREAD_CIRCLE_QUERY_KEY,
+  THREAD_CIRCLE_THREADS_QUERY_KEY,
   THREAD_MESSAGES_QUERY_KEY,
+  THREAD_MESSAGE_FILES_QUERY_KEY,
+  THREAD_MESSAGE_IMAGES_QUERY_KEY,
   THREAD_MESSAGE_QUERY_KEY,
-  THREAD_MESSAGE_REPLIES_QUERY_KEY,
-  THREAD_MODERATORS_QUERY_KEY,
+  THREAD_MESSAGE_REACTIONS_QUERY_KEY,
+  THREAD_MESSAGE_VIDEOS_QUERY_KEY,
   THREAD_QUERY_KEY,
+  THREAD_VIEWERS_QUERY_KEY,
   TIERS_QUERY_KEY,
   TIER_ACCOUNTS_QUERY_KEY,
   TIER_IMPORTS_QUERY_KEY,
@@ -35727,10 +36656,12 @@ export {
   TIER_QUERY_KEY,
   TIER_SUBSCRIBERS_QUERY_KEY,
   TaxIntegrationType,
-  ThreadAccessLevel,
+  ThreadCircleAccountRole,
+  ThreadCircleType,
   ThreadInvitationStatus,
   ThreadMemberRole,
   ThreadMessageType,
+  ThreadType,
   ToggleOrganizationPaymentIntegration,
   ToggleTaxIntegration,
   TransferEventPass,
@@ -35882,6 +36813,9 @@ export {
   UpdateSurveySubmissionResponses,
   UpdateSurveyTranslation,
   UpdateThread,
+  UpdateThreadCircle,
+  UpdateThreadCircleAccount,
+  UpdateThreadMessage,
   UpdateTier,
   UpdateUserImage,
   UpdateVideo,
@@ -35947,8 +36881,6 @@ export {
   useAddSeriesEvent,
   useAddSurveyQuestionChoiceSubQuestion,
   useAddSurveySectionQuestion,
-  useAddThreadMember,
-  useAddThreadModerator,
   useAddTierAccount,
   useCancelAnnouncementSchedule,
   useCancelChannelContentPublishSchedule,
@@ -36083,6 +37015,13 @@ export {
   useCreateSurveyTranslation,
   useCreateTaxIntegration,
   useCreateThread,
+  useCreateThreadCircle,
+  useCreateThreadCircleAccount,
+  useCreateThreadMessage,
+  useCreateThreadMessageFile,
+  useCreateThreadMessageImage,
+  useCreateThreadMessageReaction,
+  useCreateThreadMessageVideo,
   useCreateTier,
   useDeleteAccount,
   useDeleteAccountAddress,
@@ -36216,6 +37155,13 @@ export {
   useDeleteSurveyTranslation,
   useDeleteTaxIntegration,
   useDeleteThread,
+  useDeleteThreadCircle,
+  useDeleteThreadCircleAccount,
+  useDeleteThreadMessage,
+  useDeleteThreadMessageFile,
+  useDeleteThreadMessageImage,
+  useDeleteThreadMessageReaction,
+  useDeleteThreadMessageVideo,
   useDeleteTier,
   useDeleteUserImage,
   useDeleteVideo,
@@ -36249,6 +37195,7 @@ export {
   useGetAccountPushDevice,
   useGetAccountPushDevices,
   useGetAccountSubscriptions,
+  useGetAccountThreads,
   useGetAccountTiers,
   useGetAccounts,
   useGetActivities,
@@ -36491,6 +37438,7 @@ export {
   useGetEventSponsorshipTranslation,
   useGetEventSponsorshipTranslations,
   useGetEventSponsorships,
+  useGetEventThreads,
   useGetEventTrack,
   useGetEventTrackSessions,
   useGetEventTrackSponsors,
@@ -36517,6 +37465,7 @@ export {
   useGetGroupRequest,
   useGetGroupRequests,
   useGetGroupSponsors,
+  useGetGroupThreads,
   useGetGroupTranslation,
   useGetGroupTranslations,
   useGetGroups,
@@ -36587,6 +37536,8 @@ export {
   useGetStreamInputOutput,
   useGetStreamInputOutputs,
   useGetStreamInputs,
+  useGetStreamThreads,
+  useGetStreamVideos,
   useGetSubscription,
   useGetSubscriptionPayments,
   useGetSubscriptions,
@@ -36620,12 +37571,19 @@ export {
   useGetTaxIntegration,
   useGetTaxIntegrations,
   useGetThread,
-  useGetThreadMember,
-  useGetThreadMembers,
+  useGetThreadAccounts,
+  useGetThreadCircle,
+  useGetThreadCircleAccount,
+  useGetThreadCircleAccounts,
+  useGetThreadCircleThreads,
+  useGetThreadCircles,
   useGetThreadMessage,
-  useGetThreadMessageReplies,
+  useGetThreadMessageFiles,
+  useGetThreadMessageImages,
+  useGetThreadMessageReactions,
+  useGetThreadMessageVideos,
   useGetThreadMessages,
-  useGetThreadModerators,
+  useGetThreadViewers,
   useGetThreads,
   useGetTier,
   useGetTierAccounts,
@@ -36690,8 +37648,6 @@ export {
   useRemoveSeriesEvent,
   useRemoveSurveyQuestionChoiceSubQuestion,
   useRemoveSurveySectionQuestion,
-  useRemoveThreadMember,
-  useRemoveThreadModerator,
   useRemoveTierAccount,
   useRemoveTierAccounts,
   useReorderEventFaqSectionQuestions,
@@ -36710,6 +37666,8 @@ export {
   useSearchOrganization,
   useSelfLeaveOrganization,
   useSendAnnouncementPreview,
+  useStartEventRoundMatchmaking,
+  useStartEventSessionRoundMatchmaking,
   useSwitchImage,
   useToggleOrganizationPaymentIntegration,
   useToggleTaxIntegration,
@@ -36861,6 +37819,9 @@ export {
   useUpdateSurveySubmissionResponses,
   useUpdateSurveyTranslation,
   useUpdateThread,
+  useUpdateThreadCircle,
+  useUpdateThreadCircleAccount,
+  useUpdateThreadMessage,
   useUpdateTier,
   useUpdateUserImage,
   useUpdateVideo,