@connectedxm/admin 0.0.18 → 0.0.20

package/dist/index.mjs

@@ -1943,16 +1943,14 @@ var useGetChannelTranslation = (channelId = "", locale = "", options = {}) => {
   );
 };
 
-// src/queries/channels/useGetChannelActivities.ts
-var CHANNEL_ACTIVITIES_QUERY_KEY = (channelId) => [
-  ...CHANNEL_QUERY_KEY(channelId),
-  "ACTIVITIES"
-];
-var SET_CHANNEL_ACTIVITIES_QUERY_DATA = (client, keyParams, response) => {
-  client.setQueryData(CHANNEL_ACTIVITIES_QUERY_KEY(...keyParams), response);
+// src/queries/channels/useGetChannelContentGuests.ts
+var CHANNEL_CONTENT_GUESTS_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "GUESTS"];
+var SET_CHANNEL_CONTENT_GUESTS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(CHANNEL_CONTENT_GUESTS_QUERY_KEY(...keyParams), response);
 };
-var GetChannelActivities = async ({
+var GetChannelContentGuests = async ({
   channelId,
+  contentId,
   pageParam,
   pageSize,
   orderBy,
@@ -1960,7 +1958,7 @@ var GetChannelActivities = async ({
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(`/channels/${channelId}/activities`, {
+  const { data } = await adminApi.get(`/channels/${channelId}/contents/${contentId}/guests`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -1970,33 +1968,72 @@ var GetChannelActivities = async ({
   });
   return data;
 };
-var useGetChannelActivities = (groupId = "", params = {}, options = {}) => {
+var useGetChannelContentGuests = (channelId = "", contentId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_ACTIVITIES_QUERY_KEY(groupId),
-    (params2) => GetChannelActivities({
-      channelId: groupId,
+    CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId),
+    (params2) => GetChannelContentGuests({
+      channelId,
+      contentId,
       ...params2
     }),
     params,
     {
       ...options,
-      enabled: !!groupId && (options.enabled ?? true)
+      enabled: !!channelId && !!contentId && (options.enabled ?? true)
     },
     "contents"
   );
 };
 
-// src/queries/channels/useGetChannelContentActivities.ts
-var CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "ACTIVITIES"];
-var SET_CHANNEL_CONTENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response) => {
+// src/queries/channels/useGetChannelContentGuest.ts
+var CHANNEL_CONTENT_GUEST_QUERY_KEY = (channelId, contentId, guestId) => [...CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId), guestId];
+var SET_CHANNEL_CONTENT_GUEST_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(CHANNEL_CONTENT_GUEST_QUERY_KEY(...keyParams), response);
+};
+var GetChannelContentGuest = async ({
+  channelId,
+  contentId,
+  guestId,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}`
+  );
+  return data;
+};
+var useGetChannelContentGuest = (channelId = "", contentId = "", guestId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    CHANNEL_CONTENT_GUEST_QUERY_KEY(channelId, contentId, guestId),
+    (params) => GetChannelContentGuest({
+      channelId,
+      contentId,
+      guestId,
+      ...params
+    }),
+    {
+      ...options,
+      enabled: !!channelId && !!contentId && !!guestId && (options.enabled ?? true)
+    },
+    "contents"
+  );
+};
+
+// src/queries/channels/translations/useGetChannelContentGuestTranslations.ts
+var CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY = (channelId, contentId, guestId) => [
+  ...CHANNEL_CONTENT_GUEST_QUERY_KEY(channelId, contentId, guestId),
+  "TRANSLATIONS"
+];
+var SET_CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_DATA = (client, keyParams, response) => {
   client.setQueryData(
-    CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(...keyParams),
+    CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY(...keyParams),
     response
   );
 };
-var GetChannelContentActivities = async ({
+var GetChannelContentGuestTranslations = async ({
   channelId,
   contentId,
+  guestId,
   pageParam,
   pageSize,
   orderBy,
@@ -2005,7 +2042,7 @@ var GetChannelContentActivities = async ({
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
   const { data } = await adminApi.get(
-    `/channels/${channelId}/contents/${contentId}/activities`,
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}/translations`,
     {
       params: {
         page: pageParam || void 0,
@@ -2017,63 +2054,85 @@ var GetChannelContentActivities = async ({
   );
   return data;
 };
-var useGetChannelContentActivities = (channelId = "", contentId = "", params = {}, options = {}) => {
+var useGetChannelContentGuestTranslations = (channelId = "", contentId = "", guestId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(channelId, contentId),
-    (params2) => GetChannelContentActivities({
+    CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY(channelId, contentId, guestId),
+    (params2) => GetChannelContentGuestTranslations({
+      ...params2,
       channelId,
       contentId,
-      ...params2
+      guestId
     }),
     params,
     {
       ...options,
-      enabled: !!channelId && !!contentId && (options.enabled ?? true)
+      enabled: !!contentId && !!channelId && !!guestId && (options?.enabled ?? true)
     },
     "contents"
   );
 };
 
-// src/queries/channels/useGetChannelContentGuest.ts
-var CHANNEL_CONTENT_GUEST_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "GUESTS"];
-var SET_CHANNEL_CONTENT_GUEST_QUERY_DATA = (client, keyParams, response) => {
-  client.setQueryData(CHANNEL_CONTENT_GUEST_QUERY_KEY(...keyParams), response);
+// src/queries/channels/translations/useGetChannelContentGuestTranslation.ts
+var CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_KEY = (channelId, contentId, guestId, locale) => [
+  ...CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY(
+    channelId,
+    contentId,
+    guestId
+  ),
+  locale
+];
+var SET_CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(
+    CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_KEY(...keyParams),
+    response
+  );
 };
-var GetChannelContentGuest = async ({
+var GetChannelContentGuestTranslation = async ({
   channelId,
   contentId,
   guestId,
+  locale,
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(`/channels/${channelId}/contents/${contentId}/guests/${guestId}`);
+  const { data } = await adminApi.get(
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}/translations/${locale}`
+  );
   return data;
 };
-var useGetChannelContentGuest = (channelId = "", contentId = "", guestId = "", options = {}) => {
+var useGetChannelContentGuestTranslation = (channelId = "", contentId = "", guestId = "", locale = "", options = {}) => {
   return useConnectedSingleQuery(
-    CHANNEL_CONTENT_GUEST_QUERY_KEY(channelId, contentId),
-    (params) => GetChannelContentGuest({
+    CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_KEY(
       channelId,
       contentId,
       guestId,
-      ...params
+      locale
+    ),
+    (params) => GetChannelContentGuestTranslation({
+      ...params,
+      channelId,
+      contentId,
+      guestId,
+      locale
     }),
     {
       ...options,
-      enabled: !!channelId && !!contentId && !!guestId && (options.enabled ?? true)
+      enabled: !!channelId && !!contentId && !!locale && !!guestId && (options?.enabled ?? true)
     },
     "contents"
   );
 };
 
-// src/queries/channels/useGetChannelContentGuests.ts
-var CHANNEL_CONTENT_GUESTS_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "GUESTS"];
-var SET_CHANNEL_CONTENT_GUESTS_QUERY_DATA = (client, keyParams, response) => {
-  client.setQueryData(CHANNEL_CONTENT_GUESTS_QUERY_KEY(...keyParams), response);
+// src/queries/channels/useGetChannelActivities.ts
+var CHANNEL_ACTIVITIES_QUERY_KEY = (channelId) => [
+  ...CHANNEL_QUERY_KEY(channelId),
+  "ACTIVITIES"
+];
+var SET_CHANNEL_ACTIVITIES_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(CHANNEL_ACTIVITIES_QUERY_KEY(...keyParams), response);
 };
-var GetChannelContentGuests = async ({
+var GetChannelActivities = async ({
   channelId,
-  contentId,
   pageParam,
   pageSize,
   orderBy,
@@ -2081,7 +2140,7 @@ var GetChannelContentGuests = async ({
   adminApiParams
 }) => {
   const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(`/channels/${channelId}/contents/${contentId}/guests`, {
+  const { data } = await adminApi.get(`/channels/${channelId}/activities`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -2091,10 +2150,57 @@ var GetChannelContentGuests = async ({
   });
   return data;
 };
-var useGetChannelContentGuests = (channelId = "", contentId = "", params = {}, options = {}) => {
+var useGetChannelActivities = (groupId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId),
-    (params2) => GetChannelContentGuests({
+    CHANNEL_ACTIVITIES_QUERY_KEY(groupId),
+    (params2) => GetChannelActivities({
+      channelId: groupId,
+      ...params2
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!groupId && (options.enabled ?? true)
+    },
+    "contents"
+  );
+};
+
+// src/queries/channels/useGetChannelContentActivities.ts
+var CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "ACTIVITIES"];
+var SET_CHANNEL_CONTENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(
+    CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(...keyParams),
+    response
+  );
+};
+var GetChannelContentActivities = async ({
+  channelId,
+  contentId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/channels/${channelId}/contents/${contentId}/activities`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetChannelContentActivities = (channelId = "", contentId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(channelId, contentId),
+    (params2) => GetChannelContentActivities({
       channelId,
       contentId,
       ...params2
@@ -2183,6 +2289,51 @@ var useGetChannelSubscribers = (channelId = "", status, params = {}, options = {
   );
 };
 
+// src/queries/channels/useGetChannelContentLikes.ts
+var CHANNEL_CONTENT_LIKES_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "LIKES"];
+var SET_CHANNEL_CONTENT_LIKES_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(CHANNEL_CONTENT_LIKES_QUERY_KEY(...keyParams), response);
+};
+var GetChannelContentLikes = async ({
+  channelId,
+  contentId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/channels/${channelId}/contents/${contentId}/likes`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetChannelContentLikes = (channelId = "", contentId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    CHANNEL_CONTENT_LIKES_QUERY_KEY(channelId, contentId),
+    (params2) => GetChannelContentLikes({
+      channelId,
+      contentId,
+      ...params2
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!channelId && !!contentId && (options.enabled ?? true)
+    },
+    "contents"
+  );
+};
+
 // src/queries/email-receipts/useGetEmailReceipts.ts
 var EMAIL_RECEIPTS_QUERY_KEY = (status) => [
   "EMAIL_RECEIPTS",
@@ -7228,11 +7379,16 @@ var useGetEventActivities = (eventId = "", params = {}, options = {}) => {
 };
 
 // src/queries/events/useGetEventPurchases.ts
-var EVENT_PURCHASES_QUERY_KEY = (eventId) => {
-  return [...EVENT_QUERY_KEY(eventId), "PURCHASES"];
+var EVENT_PURCHASES_QUERY_KEY = (eventId, checkedIn) => {
+  const key = [...EVENT_QUERY_KEY(eventId), "PURCHASES"];
+  if (checkedIn) {
+    key.push("CHECKED_IN");
+  }
+  return key;
 };
 var GetEventPurchases = async ({
   eventId,
+  checkedIn,
   pageParam,
   pageSize,
   orderBy,
@@ -7242,6 +7398,7 @@ var GetEventPurchases = async ({
   const adminApi = await GetAdminAPI(adminApiParams);
   const { data } = await adminApi.get(`/events/${eventId}/purchases`, {
     params: {
+      checkedIn: typeof checkedIn !== "undefined" ? checkedIn : void 0,
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
       orderBy: orderBy || void 0,
@@ -7250,12 +7407,13 @@ var GetEventPurchases = async ({
   });
   return data;
 };
-var useGetEventPurchases = (eventId = "", params = {}, options = {}) => {
+var useGetEventPurchases = (eventId = "", checkedIn, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_PURCHASES_QUERY_KEY(eventId),
+    EVENT_PURCHASES_QUERY_KEY(eventId, checkedIn),
     (params2) => GetEventPurchases({
       ...params2,
-      eventId
+      eventId,
+      checkedIn
     }),
     params,
     {
@@ -7718,16 +7876,34 @@ var useGetGroupInterests = (groupId = "", params = {}, options = {}) => {
 };
 
 // src/interfaces.ts
+var OrganizationActionType = /* @__PURE__ */ ((OrganizationActionType2) => {
+  OrganizationActionType2["create"] = "create";
+  OrganizationActionType2["read"] = "read";
+  OrganizationActionType2["update"] = "update";
+  OrganizationActionType2["delete"] = "delete";
+  return OrganizationActionType2;
+})(OrganizationActionType || {});
+var OrganizationModuleType = /* @__PURE__ */ ((OrganizationModuleType2) => {
+  OrganizationModuleType2["accounts"] = "accounts";
+  OrganizationModuleType2["events"] = "events";
+  OrganizationModuleType2["listings"] = "listings";
+  OrganizationModuleType2["activities"] = "activities";
+  OrganizationModuleType2["groups"] = "groups";
+  OrganizationModuleType2["contents"] = "contents";
+  OrganizationModuleType2["chat"] = "chat";
+  OrganizationModuleType2["support"] = "support";
+  OrganizationModuleType2["sponsors"] = "sponsors";
+  OrganizationModuleType2["benefits"] = "benefits";
+  OrganizationModuleType2["advertisements"] = "advertisements";
+  OrganizationModuleType2["announcements"] = "announcements";
+  OrganizationModuleType2["subscriptions"] = "subscriptions";
+  OrganizationModuleType2["threads"] = "threads";
+  return OrganizationModuleType2;
+})(OrganizationModuleType || {});
 var Currency = /* @__PURE__ */ ((Currency2) => {
   Currency2["USD"] = "USD";
   return Currency2;
 })(Currency || {});
-var ContentType = /* @__PURE__ */ ((ContentType2) => {
-  ContentType2["article"] = "article";
-  ContentType2["podcast"] = "podcast";
-  ContentType2["video"] = "video";
-  return ContentType2;
-})(ContentType || {});
 var ContentGuestType = /* @__PURE__ */ ((ContentGuestType2) => {
   ContentGuestType2["guest"] = "guest";
   ContentGuestType2["host"] = "host";
@@ -7982,6 +8158,22 @@ var VideoSource = /* @__PURE__ */ ((VideoSource2) => {
   VideoSource2["content"] = "content";
   return VideoSource2;
 })(VideoSource || {});
+var ThreadInvitationStatus = /* @__PURE__ */ ((ThreadInvitationStatus2) => {
+  ThreadInvitationStatus2["invited"] = "invited";
+  ThreadInvitationStatus2["rejected"] = "rejected";
+  return ThreadInvitationStatus2;
+})(ThreadInvitationStatus || {});
+var ThreadMemberRole = /* @__PURE__ */ ((ThreadMemberRole2) => {
+  ThreadMemberRole2["member"] = "member";
+  ThreadMemberRole2["moderator"] = "moderator";
+  return ThreadMemberRole2;
+})(ThreadMemberRole || {});
+var ThreadMessageType = /* @__PURE__ */ ((ThreadMessageType2) => {
+  ThreadMessageType2["user"] = "user";
+  ThreadMessageType2["bot"] = "bot";
+  ThreadMessageType2["system"] = "system";
+  return ThreadMessageType2;
+})(ThreadMessageType || {});
 
 // src/queries/groups/useGetGroupInvitations.ts
 var GROUP_INVITATIONS_QUERY_KEY = (groupId, status) => {
@@ -9027,6 +9219,52 @@ var useGetLevelAccounts = (levelId = "", params = {}, options = {}) => {
   );
 };
 
+// src/queries/organization/useGetOrganization.ts
+var ORGANIZATION_QUERY_KEY = () => ["ORGANIZATION"];
+var SET_ORGANIZATION_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(ORGANIZATION_QUERY_KEY(...keyParams), response);
+};
+var GetOrganization = async ({
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/organization`);
+  return data;
+};
+var useGetOrganization = (options = {}) => {
+  return useConnectedSingleQuery(
+    ORGANIZATION_QUERY_KEY(),
+    (params) => GetOrganization(params),
+    options,
+    "org"
+  );
+};
+
+// src/queries/organization/modules/useGetOrganizationModules.ts
+var ORGANIZATION_MODULES_QUERY_KEY = () => [
+  ...ORGANIZATION_QUERY_KEY(),
+  "MODULES"
+];
+var SET_ORGANIZATION_MODULES_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(ORGANIZATION_MODULES_QUERY_KEY(...keyParams), response);
+};
+var GetOrganizationModules = async ({
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/organization/modules`);
+  console.log({ data });
+  return data;
+};
+var useGetOrganizationModules = (options = {}) => {
+  return useConnectedInfiniteQuery(
+    ORGANIZATION_MODULES_QUERY_KEY(),
+    (params) => GetOrganizationModules(params),
+    {},
+    options
+  );
+};
+
 // src/queries/organization/pages/useGetOrganizationPage.ts
 var ORGANIZATION_PAGE_QUERY_KEY = (type) => ["PAGE", type];
 var SET_ORGANIZATION_PAGE_QUERY_DATA = (client, keyParams, response) => {
@@ -9295,38 +9533,17 @@ var useGetOrganizationTrigger = (type, options = {}) => {
   );
 };
 
-// src/queries/organization/useGetOrganization.ts
-var ORGANIZATION_QUERY_KEY = () => ["ORGANIZATION"];
-var SET_ORGANIZATION_QUERY_DATA = (client, keyParams, response) => {
-  client.setQueryData(ORGANIZATION_QUERY_KEY(...keyParams), response);
-};
-var GetOrganization = async ({
-  adminApiParams
-}) => {
-  const adminApi = await GetAdminAPI(adminApiParams);
-  const { data } = await adminApi.get(`/organization`);
-  return data;
-};
-var useGetOrganization = (options = {}) => {
-  return useConnectedSingleQuery(
-    ORGANIZATION_QUERY_KEY(),
-    (params) => GetOrganization(params),
-    options,
-    "org"
-  );
-};
-
-// src/queries/organization/useGetOrganizationMembership.ts
-var ORGANIZATION_MEMBERSHIP_QUERY_KEY = (userId) => [
-  ...ORGANIZATION_QUERY_KEY(),
-  "MEMBERSHIP",
-  userId
-];
-var SET_ORGANIZATION_MEMBERSHIP_QUERY_DATA = (client, keyParams, response) => {
-  client.setQueryData(
-    ORGANIZATION_MEMBERSHIP_QUERY_KEY(...keyParams),
-    response
-  );
+// src/queries/organization/useGetOrganizationMembership.ts
+var ORGANIZATION_MEMBERSHIP_QUERY_KEY = (userId) => [
+  ...ORGANIZATION_QUERY_KEY(),
+  "MEMBERSHIP",
+  userId
+];
+var SET_ORGANIZATION_MEMBERSHIP_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(
+    ORGANIZATION_MEMBERSHIP_QUERY_KEY(...keyParams),
+    response
+  );
 };
 var GetOrganizationMembership = async ({
   userId,
@@ -10702,107 +10919,148 @@ var useGetVideo = (videoId = "", options = {}) => {
   );
 };
 
-// src/PermissionsWrapper.tsx
-var PermissionsWrapper = ({
-  children,
-  setPermissions,
-  authenticated
+// 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 SET_THREADS_QUERY_DATA = (client, keyParams, response) => {
+  client.setQueryData(THREADS_QUERY_KEY(...keyParams), response);
+};
+var GetThreads = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  access,
+  groupId,
+  eventId,
+  search,
+  adminApiParams
 }) => {
-  const { data: membership } = useGetSelfOrgMembership({
-    enabled: authenticated
-  });
-  React.useEffect(() => {
-    if (membership) {
-      setPermissions(membership.data);
-    } else {
-      setPermissions();
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      access,
+      groupId,
+      eventId
     }
-  }, [membership, setPermissions]);
-  return children;
+  });
+  return data;
+};
+var useGetThreads = (access, groupId, eventId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREADS_QUERY_KEY(access, groupId, eventId),
+    (params2) => GetThreads({
+      ...params2,
+      access,
+      groupId,
+      eventId
+    }),
+    params,
+    options,
+    "threads"
+  );
 };
-var PermissionsWrapper_default = PermissionsWrapper;
 
-// src/ConnectedXMProvider.tsx
-var ConnectedXMClientContext = React2.createContext(
-  {}
-);
-var ConnectedXMProvider = ({
-  queryClient,
-  children,
-  getToken,
-  ...state
+// src/queries/threads/useGetThread.ts
+var THREAD_QUERY_KEY = (threadId, messageId) => [
+  ...THREADS_QUERY_KEY(),
+  threadId,
+  messageId
+];
+var SET_THREAD_QUERY_DATA = (client, keyParams, response, options) => {
+  client.setQueryData([...THREAD_QUERY_KEY(...keyParams)], response, options);
+};
+var GetThread = async ({
+  threadId,
+  adminApiParams
 }) => {
-  const [authenticated, setAuthenticated] = React2.useState(false);
-  const [ssr, setSSR] = React2.useState(true);
-  const [permissions, setPermissions] = React2.useState();
-  React2.useEffect(() => {
-    if (!authenticated) {
-      getToken().then((token) => {
-        if (token) {
-          setAuthenticated(true);
-        }
-      });
-    }
-  }, [authenticated, getToken]);
-  React2.useEffect(() => {
-    setSSR(false);
-  }, []);
-  if (ssr) {
-    return /* @__PURE__ */ React2.createElement(QueryClientProvider, { client: queryClient }, /* @__PURE__ */ React2.createElement(
-      ConnectedXMClientContext.Provider,
-      {
-        value: {
-          ...state,
-          getToken,
-          authenticated,
-          setAuthenticated,
-          queryClient,
-          permissions
-        }
-      },
-      /* @__PURE__ */ React2.createElement(
-        PermissionsWrapper_default,
-        {
-          authenticated,
-          setPermissions
-        },
-        children
-      )
-    ));
-  }
-  return /* @__PURE__ */ React2.createElement(
-    ConnectedXMClientContext.Provider,
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/${threadId}`);
+  return data;
+};
+var useGetThread = (threadId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_QUERY_KEY(threadId),
+    (params) => GetThread({ threadId, ...params }),
     {
-      value: {
-        ...state,
-        getToken,
-        authenticated,
-        setAuthenticated,
-        queryClient,
-        permissions
-      }
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
     },
-    /* @__PURE__ */ React2.createElement(
-      PermissionsWrapper_default,
-      {
-        authenticated,
-        setPermissions
-      },
-      children
-    )
+    "threads"
   );
 };
 
-// src/hooks/useConnectedXM.ts
-import React3 from "react";
-var useConnectedXM = () => {
-  const context = React3.useContext(
-    ConnectedXMClientContext
+// src/queries/threads/useGetThreadMember.ts
+var THREAD_MEMBER_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), "MEMBER", threadId, accountId];
+var GetThreadMember = async ({
+  threadId,
+  accountId,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/threads/${threadId}/members/${accountId}`
+  );
+  return data;
+};
+var useGetThreadMember = (threadId = "", accountId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MEMBER_QUERY_KEY(threadId, accountId),
+    (params) => GetThreadMember({ threadId, accountId, ...params }),
+    {
+      ...options,
+      enabled: !!threadId && !!accountId && (options?.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadMembers.ts
+var THREAD_MEMBERS_QUERY_KEY = (threadId) => [
+  ...THREADS_QUERY_KEY(),
+  "MEMBERS",
+  threadId
+];
+var GetThreadMembers = async ({
+  threadId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  role,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/${threadId}/members`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      role: role || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadMembers = (threadId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MEMBERS_QUERY_KEY(threadId),
+    (params2) => GetThreadMembers({ ...params2, threadId }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && (options.enabled ?? true)
+    },
+    "threads"
   );
-  if (!context) {
-    throw new Error("useConnectedXM must be used within a ConnectedXMProvider");
-  }
-  return context;
 };
 
 // src/utilities/AppendInfiniteQuery.ts
@@ -10923,63 +11181,440 @@ var TransformPrice = (value, withDollar = false, freeText = "FREE") => {
   }
 };
 
-// src/mutations/useConnectedMutation.ts
-import {
-  useMutation,
-  useQueryClient
-} from "@tanstack/react-query";
-var useConnectedMutation = (mutation, options, permission) => {
-  const { apiUrl, getToken, organizationId, getExecuteAs, onMutationError } = useConnectedXM();
-  const queryClient = useQueryClient();
-  const { allowed, enabled } = usePermission_default(
-    permission?.domain,
-    permission?.type
+// 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, options) => {
+  client.setQueryData(
+    [...THREAD_MESSAGE_QUERY_KEY(...keyParams)],
+    response,
+    options
   );
-  return useMutation({
-    mutationFn: (data) => {
-      if (!!permission?.domain && !!permission.type) {
-        if (!enabled) {
-          throw Error(
-            `${capitalize(permission.type.toString())} ${permission.domain} feature not enabled`
-          );
-        } else if (!allowed) {
-          throw Error(
-            `Missing ${permission.type} ${permission.domain} permission`
-          );
-        }
-      }
-      return mutation({
-        queryClient,
-        adminApiParams: {
-          apiUrl,
-          getToken,
-          organizationId,
-          getExecuteAs
-        },
-        ...data
-      });
-    },
-    ...options,
-    onError: (error, variables, context) => {
-      if (onMutationError) onMutationError(error, variables, context);
-      if (options?.onError) options.onError(error, variables, context);
-    }
-  });
 };
-var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
-
-// src/mutations/account/useAddAccountDelegate.ts
-var AddAccountDelegate = async ({
-  accountId,
-  delegateId,
-  adminApiParams,
-  queryClient
+var GetThreadMessage = async ({
+  threadId,
+  messageId,
+  adminApiParams
 }) => {
-  const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.post(
-    `/accounts/${accountId}/delegates/${delegateId}`
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(
+    `/threads/${threadId}/messages/${messageId}`
   );
-  if (queryClient && data.status === "ok") {
+  return data;
+};
+var useGetThreadMessage = (threadId, messageId, options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+    (params) => GetThreadMessage({ threadId, messageId, ...params }),
+    {
+      staleTime: Infinity,
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadMessages.ts
+var THREAD_MESSAGES_QUERY_KEY = (threadId, messageId) => [...THREAD_QUERY_KEY(threadId, messageId), "MESSAGES"];
+var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMessages = async ({
+  threadId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/${threadId}/messages`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (messageId) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId)
+    );
+    SET_THREAD_QUERY_DATA(queryClient, [threadId], (old) => ({
+      ...old,
+      data: {
+        ...old.data,
+        read: true
+      }
+    }));
+  }
+  return data;
+};
+var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGES_QUERY_KEY(threadId),
+    (params2) => GetThreadMessages({ ...params2, threadId }),
+    params,
+    {
+      refetchInterval: 5 * 1e3,
+      ...options,
+      enabled: !!authenticated && !!threadId && (options?.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// 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,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.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)
+    );
+  }
+  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)
+    },
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadGroups.ts
+var THREAD_GROUPS_QUERY_KEY = () => [...THREADS_QUERY_KEY(), "GROUPS"];
+var GetThreadGroups = async ({
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/groups`);
+  return data;
+};
+var useGetThreadGroups = (params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_GROUPS_QUERY_KEY(),
+    (params2) => GetThreadGroups({ ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: options.enabled ?? true
+    },
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadsGroup.ts
+var THREAD_GROUP_QUERY_KEY = (groupId) => [
+  ...THREADS_QUERY_KEY(),
+  "GROUP",
+  groupId
+];
+var GetThreadsGroup = async ({
+  groupId,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/groups/${groupId}`);
+  return data;
+};
+var useGetThreadsGroup = (groupId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_GROUP_QUERY_KEY(groupId),
+    (params) => GetThreadsGroup({ groupId, ...params }),
+    {
+      ...options,
+      enabled: !!groupId && (options?.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// src/queries/threads/useGetThreadEvents.ts
+var THREAD_EVENTS_QUERY_KEY = () => {
+  return ["THREAD_EVENTS"];
+};
+var GetThreadEvents = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/events`, {
+    params: {
+      page: pageParam,
+      pageSize,
+      orderBy,
+      search
+    }
+  });
+  return data;
+};
+var useGetThreadEvents = (params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_EVENTS_QUERY_KEY(),
+    (params2) => GetThreadEvents({
+      ...params2
+    }),
+    params,
+    options,
+    "threads"
+  );
+};
+
+// 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);
+};
+var GetThreadModerators = async ({
+  threadId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  adminApiParams
+}) => {
+  const adminApi = await GetAdminAPI(adminApiParams);
+  const { data } = await adminApi.get(`/threads/${threadId}/moderators`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadModerators = (threadId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MODERATORS_QUERY_KEY(threadId),
+    (params2) => GetThreadModerators({ ...params2, threadId }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && (options.enabled ?? true)
+    },
+    "threads"
+  );
+};
+
+// src/PermissionsWrapper.tsx
+var PermissionsWrapper = ({
+  children,
+  setPermissions,
+  authenticated
+}) => {
+  const { data: membership } = useGetSelfOrgMembership({
+    enabled: authenticated
+  });
+  React.useEffect(() => {
+    if (membership) {
+      setPermissions(membership.data);
+    } else {
+      setPermissions();
+    }
+  }, [membership, setPermissions]);
+  return children;
+};
+var PermissionsWrapper_default = PermissionsWrapper;
+
+// src/ConnectedXMProvider.tsx
+var ConnectedXMClientContext = React2.createContext(
+  {}
+);
+var ConnectedXMProvider = ({
+  queryClient,
+  children,
+  getToken,
+  ...state
+}) => {
+  const [authenticated, setAuthenticated] = React2.useState(false);
+  const [ssr, setSSR] = React2.useState(true);
+  const [permissions, setPermissions] = React2.useState();
+  React2.useEffect(() => {
+    if (!authenticated) {
+      getToken().then((token) => {
+        if (token) {
+          setAuthenticated(true);
+        }
+      });
+    }
+  }, [authenticated, getToken]);
+  React2.useEffect(() => {
+    setSSR(false);
+  }, []);
+  if (ssr) {
+    return /* @__PURE__ */ React2.createElement(QueryClientProvider, { client: queryClient }, /* @__PURE__ */ React2.createElement(
+      ConnectedXMClientContext.Provider,
+      {
+        value: {
+          ...state,
+          getToken,
+          authenticated,
+          setAuthenticated,
+          queryClient,
+          permissions
+        }
+      },
+      /* @__PURE__ */ React2.createElement(
+        PermissionsWrapper_default,
+        {
+          authenticated,
+          setPermissions
+        },
+        children
+      )
+    ));
+  }
+  return /* @__PURE__ */ React2.createElement(
+    ConnectedXMClientContext.Provider,
+    {
+      value: {
+        ...state,
+        getToken,
+        authenticated,
+        setAuthenticated,
+        queryClient,
+        permissions
+      }
+    },
+    /* @__PURE__ */ React2.createElement(
+      PermissionsWrapper_default,
+      {
+        authenticated,
+        setPermissions
+      },
+      children
+    )
+  );
+};
+
+// src/hooks/useConnectedXM.ts
+import React3 from "react";
+var useConnectedXM = () => {
+  const context = React3.useContext(
+    ConnectedXMClientContext
+  );
+  if (!context) {
+    throw new Error("useConnectedXM must be used within a ConnectedXMProvider");
+  }
+  return context;
+};
+
+// src/mutations/useConnectedMutation.ts
+import {
+  useMutation,
+  useQueryClient
+} from "@tanstack/react-query";
+var useConnectedMutation = (mutation, options, permission) => {
+  const { apiUrl, getToken, organizationId, getExecuteAs, onMutationError } = useConnectedXM();
+  const queryClient = useQueryClient();
+  const { allowed, enabled } = usePermission_default(
+    permission?.domain,
+    permission?.type
+  );
+  return useMutation({
+    mutationFn: (data) => {
+      if (!!permission?.domain && !!permission.type) {
+        if (!enabled) {
+          throw Error(
+            `${capitalize(permission.type.toString())} ${permission.domain} feature not enabled`
+          );
+        } else if (!allowed) {
+          throw Error(
+            `Missing ${permission.type} ${permission.domain} permission`
+          );
+        }
+      }
+      return mutation({
+        queryClient,
+        adminApiParams: {
+          apiUrl,
+          getToken,
+          organizationId,
+          getExecuteAs
+        },
+        ...data
+      });
+    },
+    ...options,
+    onError: (error, variables, context) => {
+      if (onMutationError) onMutationError(error, variables, context);
+      if (options?.onError) options.onError(error, variables, context);
+    }
+  });
+};
+var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+// src/mutations/account/useAddAccountDelegate.ts
+var AddAccountDelegate = async ({
+  accountId,
+  delegateId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/accounts/${accountId}/delegates/${delegateId}`
+  );
+  if (queryClient && data.status === "ok") {
     SET_ACCOUNT_QUERY_DATA(queryClient, [accountId], data);
     queryClient.invalidateQueries({
       queryKey: ACCOUNT_DELEGATES_QUERY_KEY(accountId)
@@ -11952,6 +12587,47 @@ var useCreateChannelTranslation = (options = {}) => {
   });
 };
 
+// src/mutations/channels/translations/useCreateChannelContentGuestTranslation.ts
+var CreateChannelContentGuestTranslation = async ({
+  channelId,
+  contentId,
+  guestId,
+  locale,
+  autoTranslate,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}/translations`,
+    {
+      locale,
+      autoTranslate
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY(
+        channelId,
+        contentId,
+        guestId
+      )
+    });
+    SET_CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_DATA(
+      queryClient,
+      [channelId, contentId, guestId, data?.data.locale],
+      data
+    );
+  }
+  return data;
+};
+var useCreateChannelContentGuestTranslation = (options = {}) => {
+  return useConnectedMutation(CreateChannelContentGuestTranslation, options, {
+    domain: "contents",
+    type: "update"
+  });
+};
+
 // src/mutations/channels/translations/useDeleteChannelContentTranslation.ts
 var DeleteChannelContentTranslation = async ({
   channelId,
@@ -12013,6 +12689,45 @@ var useDeleteChannelTranslation = (options = {}) => {
   });
 };
 
+// src/mutations/channels/translations/useDeleteChannelContentGuestTranslation.ts
+var DeleteChannelContentGuestTranslation = async ({
+  channelId,
+  contentId,
+  guestId,
+  locale,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}/translations/${locale}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY(
+        channelId,
+        contentId,
+        guestId
+      )
+    });
+    queryClient.invalidateQueries({
+      queryKey: CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_KEY(
+        channelId,
+        contentId,
+        guestId,
+        locale
+      )
+    });
+  }
+  return data;
+};
+var useDeleteChannelContentGuestTranslation = (options = {}) => {
+  return useConnectedMutation(DeleteChannelContentGuestTranslation, options, {
+    domain: "contents",
+    type: "update"
+  });
+};
+
 // src/mutations/channels/translations/useUpdateChannelContentTranslation.ts
 var UpdateChannelContentTranslation = async ({
   channelId,
@@ -12075,27 +12790,39 @@ var useUpdateChannelTranslation = (options = {}) => {
   });
 };
 
-// src/mutations/channels/useAddChannelContentGuest.ts
-var AddChannelContentGuest = async ({
-  contentId,
+// src/mutations/channels/translations/useUpdateChannelContentGuestTranslation.ts
+var UpdateChannelContentGuestTranslation = async ({
   channelId,
-  accountId,
+  contentId,
+  guestId,
+  guestTranslation,
+  locale,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.post(
-    `/channels/${channelId}/contents/${contentId}/guests/${accountId}`
+  const { data } = await connectedXM.put(
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}/translations/${locale}`,
+    guestTranslation
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId)
+      queryKey: CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY(
+        channelId,
+        contentId,
+        guestId
+      )
     });
+    SET_CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_DATA(
+      queryClient,
+      [channelId, contentId, guestId, data.data.locale],
+      data
+    );
   }
   return data;
 };
-var useAddChannelContentGuest = (options = {}) => {
-  return useConnectedMutation(AddChannelContentGuest, options, {
+var useUpdateChannelContentGuestTranslation = (options = {}) => {
+  return useConnectedMutation(UpdateChannelContentGuestTranslation, options, {
     domain: "contents",
     type: "update"
   });
@@ -12230,25 +12957,28 @@ var useDeleteChannelContent = (options = {}) => {
   });
 };
 
-// src/mutations/channels/useRemoveChannelContentGuest.ts
-var RemoveChannelContentGuest = async ({
+// src/mutations/channels/useDeleteChannelContentGuest.ts
+var DeleteChannelContentGuest = async ({
   contentId,
-  accountId,
+  guestId,
   channelId,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.delete(`/channels/${channelId}/contents/${contentId}/guests/${accountId}`);
+  const { data } = await connectedXM.delete(`/channels/${channelId}/contents/${contentId}/guests/${guestId}`);
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
       queryKey: CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId)
     });
+    queryClient.removeQueries({
+      queryKey: CHANNEL_CONTENT_GUEST_QUERY_KEY(channelId, contentId, guestId)
+    });
   }
   return data;
 };
-var useRemoveChannelContentGuest = (options = {}) => {
-  return useConnectedMutation(RemoveChannelContentGuest, options, {
+var useDeleteChannelContentGuest = (options = {}) => {
+  return useConnectedMutation(DeleteChannelContentGuest, options, {
     domain: "contents",
     type: "update"
   });
@@ -12304,101 +13034,182 @@ var UpdateChannel = async ({
   }
   return data;
 };
-var useUpdateChannel = (options = {}) => {
-  return useConnectedMutation(UpdateChannel, options, {
+var useUpdateChannel = (options = {}) => {
+  return useConnectedMutation(UpdateChannel, options, {
+    domain: "contents",
+    type: "update"
+  });
+};
+
+// src/mutations/channels/useUpdateChannelContent.ts
+var UpdateChannelContent = async ({
+  contentId,
+  channelId,
+  content,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/channels/${channelId}/contents/${contentId}`,
+    content
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: CHANNEL_CONTENT_QUERY_KEY(channelId, contentId)
+    });
+    SET_CHANNEL_CONTENT_QUERY_DATA(queryClient, [channelId, contentId], data);
+  }
+  return data;
+};
+var useUpdateChannelContent = (options = {}) => {
+  return useConnectedMutation(UpdateChannelContent, options, {
+    domain: "contents",
+    type: "update"
+  });
+};
+
+// src/mutations/channels/useUpdateChannelContentGuest.ts
+var UpdateChannelContentGuest = async ({
+  contentId,
+  channelId,
+  guestId,
+  contentGuest: content,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/channels/${channelId}/contents/${contentId}/guests/${guestId}`,
+    content
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId)
+    });
+    SET_CHANNEL_CONTENT_GUEST_QUERY_DATA(
+      queryClient,
+      [channelId, contentId, guestId],
+      data
+    );
+  }
+  return data;
+};
+var useUpdateChannelContentGuest = (options = {}) => {
+  return useConnectedMutation(UpdateChannelContentGuest, options, {
+    domain: "contents",
+    type: "update"
+  });
+};
+
+// src/mutations/channels/useUpdateChannelSubscriber.ts
+var UpdateChannelSubscriber = async ({
+  accountId,
+  channelId,
+  channelSubscriber,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/channels/${channelId}/subscribers/${accountId}`,
+    channelSubscriber
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: CHANNEL_SUBSCRIBERS_QUERY_KEY(channelId)
+    });
+    SET_CHANNEL_SUBSCRIBER_QUERY_DATA(
+      queryClient,
+      [channelId, accountId],
+      data
+    );
+  }
+  return data;
+};
+var useUpdateChannelSubscriber = (options = {}) => {
+  return useConnectedMutation(UpdateChannelSubscriber, options, {
     domain: "contents",
     type: "update"
   });
 };
 
-// src/mutations/channels/useUpdateChannelContent.ts
-var UpdateChannelContent = async ({
+// src/mutations/channels/useCreateChannelContentGuest.ts
+var CreateChannelContentGuest = async ({
   contentId,
   channelId,
-  content,
+  contentGuest: content,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.put(
-    `/channels/${channelId}/contents/${contentId}`,
-    content
-  );
+  const { data } = await connectedXM.post(`/channels/${channelId}/contents/${contentId}/guests`, content);
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: CHANNEL_CONTENT_QUERY_KEY(channelId, contentId)
+      queryKey: CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId)
     });
-    SET_CHANNEL_CONTENT_QUERY_DATA(queryClient, [channelId, contentId], data);
+    SET_CHANNEL_CONTENT_GUEST_QUERY_DATA(
+      queryClient,
+      [channelId, contentId, data.data.id],
+      data
+    );
   }
   return data;
 };
-var useUpdateChannelContent = (options = {}) => {
-  return useConnectedMutation(UpdateChannelContent, options, {
+var useCreateChannelContentGuest = (options = {}) => {
+  return useConnectedMutation(CreateChannelContentGuest, options, {
     domain: "contents",
     type: "update"
   });
 };
 
-// src/mutations/channels/useUpdateChannelContentGuest.ts
-var UpdateChannelContentGuest = async ({
+// src/mutations/channels/useUpdateChannelContentPublishSchedule.ts
+var UpdateChannelContentPublishSchedule = async ({
   contentId,
   channelId,
-  guestId,
-  contentGuest: content,
+  schedule,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.put(
-    `/channels/${channelId}/contents/${contentId}/guests/${guestId}`,
-    content
+  const { data } = await connectedXM.post(
+    `/channels/${channelId}/contents/${contentId}/schedule`,
+    schedule
   );
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId)
+      queryKey: CHANNEL_CONTENTS_QUERY_KEY(channelId)
     });
-    SET_CHANNEL_CONTENT_GUESTS_QUERY_DATA(
-      queryClient,
-      [channelId, contentId],
-      data
-    );
+    SET_CHANNEL_CONTENT_QUERY_DATA(queryClient, [channelId, contentId], data);
   }
   return data;
 };
-var useUpdateChannelContentGuest = (options = {}) => {
-  return useConnectedMutation(UpdateChannelContentGuest, options, {
+var useUpdateChannelContentPublishSchedule = (options = {}) => {
+  return useConnectedMutation(UpdateChannelContentPublishSchedule, options, {
     domain: "contents",
     type: "update"
   });
 };
 
-// src/mutations/channels/useUpdateChannelSubscriber.ts
-var UpdateChannelSubscriber = async ({
-  accountId,
+// src/mutations/channels/useCancelChannelContentPublishSchedule.ts
+var CancelChannelContentPublishSchedule = async ({
+  contentId,
   channelId,
-  channelSubscriber,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.put(
-    `/channels/${channelId}/subscribers/${accountId}`,
-    channelSubscriber
-  );
+  const { data } = await connectedXM.delete(`/channels/${channelId}/contents/${contentId}/schedule`);
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({
-      queryKey: CHANNEL_SUBSCRIBERS_QUERY_KEY(channelId)
+      queryKey: CHANNEL_CONTENTS_QUERY_KEY(channelId)
     });
-    SET_CHANNEL_SUBSCRIBER_QUERY_DATA(
-      queryClient,
-      [channelId, accountId],
-      data
-    );
+    SET_CHANNEL_CONTENT_QUERY_DATA(queryClient, [channelId, contentId], data);
   }
   return data;
 };
-var useUpdateChannelSubscriber = (options = {}) => {
-  return useConnectedMutation(UpdateChannelSubscriber, options, {
+var useCancelChannelContentPublishSchedule = (options = {}) => {
+  return useConnectedMutation(CancelChannelContentPublishSchedule, options, {
     domain: "contents",
     type: "update"
   });
@@ -13612,6 +14423,38 @@ var useDeleteEventFaqSectionQuestion = (options = {}) => {
   });
 };
 
+// src/mutations/event/faqs/useReorderEventFaqSectionQuestions.ts
+var ReorderEventFaqSectionQuestions = async ({
+  eventId,
+  sectionId,
+  questionIds,
+  adminApiParams,
+  queryClient
+}) => {
+  if (!sectionId) throw new Error("Section ID Undefined");
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/events/${eventId}/faqs/${sectionId}/questions/reorder`,
+    {
+      questionIds
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_EVENT_FAQ_SECTION_QUESTIONS_QUERY_DATA(
+      queryClient,
+      [eventId, sectionId],
+      data
+    );
+  }
+  return data;
+};
+var useReorderEventFaqSectionQuestions = (options = {}) => {
+  return useConnectedMutation(ReorderEventFaqSectionQuestions, options, {
+    domain: "events",
+    type: "update"
+  });
+};
+
 // src/mutations/event/faqs/useUpdateEventFaqSection.ts
 var UpdateEventFaqSection = async ({
   eventId,
@@ -13697,38 +14540,6 @@ var useUpdateEventFaqSectionQuestion = (options = {}) => {
   });
 };
 
-// src/mutations/event/faqs/useReorderEventFaqSectionQuestions.ts
-var ReorderEventFaqSectionQuestions = async ({
-  eventId,
-  sectionId,
-  questionIds,
-  adminApiParams,
-  queryClient
-}) => {
-  if (!sectionId) throw new Error("Section ID Undefined");
-  const connectedXM = await GetAdminAPI(adminApiParams);
-  const { data } = await connectedXM.put(
-    `/events/${eventId}/faqs/${sectionId}/questions/reorder`,
-    {
-      questionIds
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    SET_EVENT_FAQ_SECTION_QUESTIONS_QUERY_DATA(
-      queryClient,
-      [eventId, sectionId],
-      data
-    );
-  }
-  return data;
-};
-var useReorderEventFaqSectionQuestions = (options = {}) => {
-  return useConnectedMutation(ReorderEventFaqSectionQuestions, options, {
-    domain: "events",
-    type: "update"
-  });
-};
-
 // src/mutations/event/on-site/useUpdateEventCheckinCode.ts
 var UpdateEventCheckinCode = async ({
   eventId,
@@ -14878,6 +15689,9 @@ var CreateEventRegistrationPurchase = async ({
     queryClient.invalidateQueries({
       queryKey: EVENT_REGISTRATION_PURCHASES_QUERY_KEY(eventId, registrationId)
     });
+    queryClient.invalidateQueries({
+      queryKey: EVENT_REGISTRATION_QUERY_KEY(eventId, registrationId)
+    });
     SET_EVENT_REGISTRATION_PURCHASE_QUERY_DATA(
       queryClient,
       [eventId, registrationId, data.data.id],
@@ -18457,6 +19271,21 @@ var CreateInterest = async ({
   if (queryClient && data.status === "ok") {
     queryClient.invalidateQueries({ queryKey: INTERESTS_QUERY_KEY() });
     SET_INTEREST_QUERY_DATA(queryClient, [data.data.id], data);
+    if (interest.accountId) {
+      queryClient.invalidateQueries({
+        queryKey: ACCOUNT_INTERESTS_QUERY_KEY(interest.accountId)
+      });
+    }
+    if (interest.activityId) {
+      queryClient.invalidateQueries({
+        queryKey: ACTIVITY_INTERESTS_QUERY_KEY(interest.activityId)
+      });
+    }
+    if (interest.groupId) {
+      queryClient.invalidateQueries({
+        queryKey: GROUP_INTERESTS_QUERY_KEY(interest.groupId)
+      });
+    }
   }
   return data;
 };
@@ -18927,6 +19756,50 @@ var useUpdateLevel = (options = {}) => {
   });
 };
 
+// src/mutations/organization/modules/useUpdateOrganizationModule.ts
+var UpdateOrganizationModule = async ({
+  module,
+  moduleType,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(`/organization/modules/${moduleType}`, {
+    module
+  });
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: ORGANIZATION_MODULES_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useUpdateOrganizationModules = (options = {}) => {
+  return useConnectedMutation(UpdateOrganizationModule, options);
+};
+
+// src/mutations/organization/modules/useUpdateOrganizationModuleActions.ts
+var UpdateOrganizationModuleActions = async ({
+  moduleType,
+  moduleActions,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(`/organization/modules/${moduleType}/actions`, {
+    moduleActions
+  });
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: ORGANIZATION_MODULES_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useUpdateOrganizationModuleActions = (options = {}) => {
+  return useConnectedMutation(UpdateOrganizationModuleActions, options);
+};
+
 // src/mutations/organization/pages/translations/useCreateOrganizationPageTranslation.ts
 var CreateOrganizationPageTranslation = async ({
   type,
@@ -19127,13 +20000,13 @@ var useToggleOrganizationPaymentIntegration = (options = {}) => {
 // src/mutations/organization/triggers/useUpdateOrganizationTrigger.ts
 var UpdateOrganizationTrigger = async ({
   type,
-  code,
+  trigger,
   adminApiParams,
   queryClient
 }) => {
   const connectedXM = await GetAdminAPI(adminApiParams);
   const { data } = await connectedXM.put(`/organization/triggers/${type}`, {
-    code
+    code: trigger.code
   });
   if (queryClient && data.status === "ok") {
     SET_ORGANIZATION_TRIGGER_QUERY_DATA(queryClient, [type], data);
@@ -19450,6 +20323,27 @@ var useUpdateReport = (options = {}) => {
   });
 };
 
+// src/mutations/self/useUpdateUserImage.ts
+var UpdateUserImage = async ({
+  image,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/self/image`,
+    image
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({ queryKey: SELF_QUERY_KEY() });
+    SET_SELF_QUERY_DATA(queryClient, [], data);
+  }
+  return data;
+};
+var useUpdateUserImage = (options = {}) => {
+  return useConnectedMutation(UpdateUserImage, options);
+};
+
 // src/mutations/self/useSelfLeaveOrganization.ts
 var SelfLeaveOrganization = async ({
   organizationId,
@@ -20396,6 +21290,147 @@ var useUpdateVideo = (options = {}) => {
     type: "update"
   });
 };
+
+// src/mutations/threads/useCreateThread.ts
+var CreateThread = async ({
+  thread,
+  accountIds,
+  firstMessage,
+  imageDataUri,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/threads`,
+    {
+      thread,
+      accountIds,
+      firstMessage,
+      imageDataUri
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({ queryKey: THREADS_QUERY_KEY() });
+    SET_THREAD_QUERY_DATA(queryClient, [data.data?.id], data);
+  }
+  return data;
+};
+var useCreateThread = (options = {}) => {
+  return useConnectedMutation(CreateThread, options, {
+    domain: "threads",
+    type: "create"
+  });
+};
+
+// src/mutations/threads/useUpdateThread.ts
+var UpdateThread = async ({
+  threadId,
+  thread,
+  imageDataUri,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.put(
+    `/threads/${threadId}`,
+    {
+      thread,
+      imageDataUri
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({ queryKey: THREADS_QUERY_KEY() });
+    SET_THREAD_QUERY_DATA(queryClient, [threadId], data);
+  }
+  return data;
+};
+var useUpdateThread = (options = {}) => {
+  return useConnectedMutation(UpdateThread, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
+// src/mutations/threads/useAddThreadMember.ts
+var AddThreadMember = async ({
+  threadId,
+  accountId,
+  role,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.post(
+    `/threads/${threadId}/members/${accountId}`,
+    {
+      role
+    }
+  );
+  if (queryClient && data.status === "ok" && role === "member") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+  }
+  if (queryClient && data.status === "ok" && role === "moderator") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MODERATORS_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useAddThreadMember = (options = {}) => {
+  return useConnectedMutation(AddThreadMember, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
+// src/mutations/threads/useRemoveThreadMember.ts
+var RemoveThreadMember = async ({
+  threadId,
+  accountId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(`/threads/${threadId}/members/${accountId}`);
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useRemoveThreadMember = (options = {}) => {
+  return useConnectedMutation(RemoveThreadMember, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
+
+// src/mutations/threads/useRemoveThreadModerator.ts
+var RemoveThreadModerator = async ({
+  threadId,
+  accountId,
+  adminApiParams,
+  queryClient
+}) => {
+  const connectedXM = await GetAdminAPI(adminApiParams);
+  const { data } = await connectedXM.delete(`/threads/${threadId}/moderators/${accountId}`);
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MODERATORS_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useRemoveThreadModerator = (options = {}) => {
+  return useConnectedMutation(RemoveThreadModerator, options, {
+    domain: "threads",
+    type: "update"
+  });
+};
 export {
   ACCOUNTS_QUERY_KEY,
   ACCOUNT_ACTIVITIES_QUERY_KEY,
@@ -20438,7 +21473,6 @@ export {
   AddAccountInterest,
   AddAccountTier,
   AddActivityInterest,
-  AddChannelContentGuest,
   AddChannelSubscriber,
   AddEventAddOnTicket,
   AddEventAddOnTier,
@@ -20472,6 +21506,7 @@ export {
   AddOrganizationUser,
   AddSeriesEvent,
   AddSubscriptionProductTier,
+  AddThreadMember,
   AddTierAccount,
   AdvertisementType,
   AppendInfiniteQuery,
@@ -20490,6 +21525,9 @@ export {
   CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY,
   CHANNEL_CONTENT_GUESTS_QUERY_KEY,
   CHANNEL_CONTENT_GUEST_QUERY_KEY,
+  CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_KEY,
+  CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_KEY,
+  CHANNEL_CONTENT_LIKES_QUERY_KEY,
   CHANNEL_CONTENT_QUERY_KEY,
   CHANNEL_CONTENT_TRANSLATIONS_QUERY_KEY,
   CHANNEL_CONTENT_TRANSLATION_QUERY_KEY,
@@ -20500,6 +21538,7 @@ export {
   CHANNEL_TRANSLATION_QUERY_KEY,
   CacheIndividualQueries,
   CancelAnnouncementSchedule,
+  CancelChannelContentPublishSchedule,
   CancelEventRegistrationPurchaseTransfer,
   CancelSubscription,
   ChannelFormat,
@@ -20507,7 +21546,6 @@ export {
   ConnectedXMProvider,
   ContentGuestType,
   ContentStatus,
-  ContentType,
   CreateAccount,
   CreateAdvertisement,
   CreateAnnouncement,
@@ -20515,6 +21553,8 @@ export {
   CreateBenefitTranslation,
   CreateChannel,
   CreateChannelContent,
+  CreateChannelContentGuest,
+  CreateChannelContentGuestTranslation,
   CreateChannelContentTranslation,
   CreateChannelTranslation,
   CreateEvent,
@@ -20574,6 +21614,7 @@ export {
   CreateSubscriptionProductPrice,
   CreateSupportTicket,
   CreateSupportTicketNote,
+  CreateThread,
   CreateTier,
   Currency,
   DelegateRole,
@@ -20584,6 +21625,8 @@ export {
   DeleteBenefitTranslation,
   DeleteChannel,
   DeleteChannelContent,
+  DeleteChannelContentGuest,
+  DeleteChannelContentGuestTranslation,
   DeleteChannelContentTranslation,
   DeleteChannelTranslation,
   DeleteEvent,
@@ -20835,7 +21878,10 @@ export {
   GetChannelContent,
   GetChannelContentActivities,
   GetChannelContentGuest,
+  GetChannelContentGuestTranslation,
+  GetChannelContentGuestTranslations,
   GetChannelContentGuests,
+  GetChannelContentLikes,
   GetChannelContentTranslation,
   GetChannelContentTranslations,
   GetChannelContents,
@@ -20997,6 +22043,7 @@ export {
   GetLevels,
   GetOrganization,
   GetOrganizationMembership,
+  GetOrganizationModules,
   GetOrganizationPage,
   GetOrganizationPageTranslation,
   GetOrganizationPageTranslations,
@@ -21046,6 +22093,17 @@ export {
   GetSubscriptions,
   GetSupportTicket,
   GetSupportTickets,
+  GetThread,
+  GetThreadEvents,
+  GetThreadGroups,
+  GetThreadMember,
+  GetThreadMembers,
+  GetThreadMessage,
+  GetThreadMessageReplies,
+  GetThreadMessages,
+  GetThreadModerators,
+  GetThreads,
+  GetThreadsGroup,
   GetTier,
   GetTierAccounts,
   GetTierSubscribers,
@@ -21086,6 +22144,7 @@ export {
   MergeInfinitePages,
   NotificationType,
   ORGANIZATION_MEMBERSHIP_QUERY_KEY,
+  ORGANIZATION_MODULES_QUERY_KEY,
   ORGANIZATION_PAGE_QUERY_KEY,
   ORGANIZATION_PAGE_TRANSLATIONS_QUERY_KEY,
   ORGANIZATION_PAGE_TRANSLATION_QUERY_KEY,
@@ -21097,6 +22156,8 @@ export {
   ORGANIZATION_TEAM_MEMBER_QUERY_KEY,
   ORGANIZATION_TRIGGER_QUERY_KEY,
   ORGANIZATION_USERS_QUERY_KEY,
+  OrganizationActionType,
+  OrganizationModuleType,
   OrganizationTriggerType,
   PAYMENTS_QUERY_KEY,
   PAYMENT_QUERY_KEY,
@@ -21120,7 +22181,6 @@ export {
   RemoveAccountInterest,
   RemoveAccountTier,
   RemoveActivityInterest,
-  RemoveChannelContentGuest,
   RemoveChannelSubscriber,
   RemoveEventAddOnTicket,
   RemoveEventAddOnTier,
@@ -21154,6 +22214,8 @@ export {
   RemoveLevelAccount,
   RemoveSeriesEvent,
   RemoveSubscriptionProductTier,
+  RemoveThreadMember,
+  RemoveThreadModerator,
   RemoveTierAccount,
   ReorderEventFaqSectionQuestions,
   ReorderEventQuestionChoices,
@@ -21209,6 +22271,9 @@ export {
   SET_CHANNEL_CONTENT_ACTIVITIES_QUERY_DATA,
   SET_CHANNEL_CONTENT_GUESTS_QUERY_DATA,
   SET_CHANNEL_CONTENT_GUEST_QUERY_DATA,
+  SET_CHANNEL_CONTENT_GUEST_TRANSLATIONS_QUERY_DATA,
+  SET_CHANNEL_CONTENT_GUEST_TRANSLATION_QUERY_DATA,
+  SET_CHANNEL_CONTENT_LIKES_QUERY_DATA,
   SET_CHANNEL_CONTENT_QUERY_DATA,
   SET_CHANNEL_CONTENT_TRANSLATIONS_QUERY_DATA,
   SET_CHANNEL_CONTENT_TRANSLATION_QUERY_DATA,
@@ -21373,6 +22438,7 @@ export {
   SET_LEVEL_TRANSLATIONS_QUERY_DATA,
   SET_LEVEL_TRANSLATION_QUERY_DATA,
   SET_ORGANIZATION_MEMBERSHIP_QUERY_DATA,
+  SET_ORGANIZATION_MODULES_QUERY_DATA,
   SET_ORGANIZATION_PAGE_QUERY_DATA,
   SET_ORGANIZATION_PAGE_TRANSLATIONS_QUERY_DATA,
   SET_ORGANIZATION_PAGE_TRANSLATION_QUERY_DATA,
@@ -21414,6 +22480,12 @@ export {
   SET_SUBSCRIPTION_QUERY_DATA,
   SET_SUPPORT_TICKETS_QUERY_DATA,
   SET_SUPPORT_TICKET_QUERY_DATA,
+  SET_THREADS_QUERY_DATA,
+  SET_THREAD_MESSAGES_QUERY_DATA,
+  SET_THREAD_MESSAGE_QUERY_DATA,
+  SET_THREAD_MESSAGE_REPLIES_QUERY_DATA,
+  SET_THREAD_MODERATORS_QUERY_DATA,
+  SET_THREAD_QUERY_DATA,
   SET_TIERS_QUERY_DATA,
   SET_TIER_ACCOUNTS_QUERY_DATA,
   SET_TIER_QUERY_DATA,
@@ -21444,11 +22516,25 @@ export {
   SubscriptionStatus,
   SupportTicketType,
   SwitchImage,
+  THREADS_QUERY_KEY,
+  THREAD_EVENTS_QUERY_KEY,
+  THREAD_GROUPS_QUERY_KEY,
+  THREAD_GROUP_QUERY_KEY,
+  THREAD_MEMBERS_QUERY_KEY,
+  THREAD_MEMBER_QUERY_KEY,
+  THREAD_MESSAGES_QUERY_KEY,
+  THREAD_MESSAGE_QUERY_KEY,
+  THREAD_MESSAGE_REPLIES_QUERY_KEY,
+  THREAD_MODERATORS_QUERY_KEY,
+  THREAD_QUERY_KEY,
   TIERS_QUERY_KEY,
   TIER_ACCOUNTS_QUERY_KEY,
   TIER_QUERY_KEY,
   TIER_SUBSCRIBERS_QUERY_KEY,
   ThreadAccessLevel,
+  ThreadInvitationStatus,
+  ThreadMemberRole,
+  ThreadMessageType,
   TicketEventAccessLevel,
   TicketVisibility,
   ToggleOrganizationPaymentIntegration,
@@ -21466,6 +22552,8 @@ export {
   UpdateChannel,
   UpdateChannelContent,
   UpdateChannelContentGuest,
+  UpdateChannelContentGuestTranslation,
+  UpdateChannelContentPublishSchedule,
   UpdateChannelContentTranslation,
   UpdateChannelSubscriber,
   UpdateChannelTranslation,
@@ -21525,6 +22613,8 @@ export {
   UpdateOrganization,
   UpdateOrganizationIntegrations,
   UpdateOrganizationMembership,
+  UpdateOrganizationModule,
+  UpdateOrganizationModuleActions,
   UpdateOrganizationPage,
   UpdateOrganizationPageTranslation,
   UpdateOrganizationTeamMember,
@@ -21539,7 +22629,9 @@ export {
   UpdateSubscriptionProduct,
   UpdateSubscriptionProductPrice,
   UpdateSupportTicket,
+  UpdateThread,
   UpdateTier,
+  UpdateUserImage,
   UpdateVideo,
   UploadFile,
   UserRole,
@@ -21556,7 +22648,6 @@ export {
   useAddAccountInterest,
   useAddAccountTier,
   useAddActivityInterest,
-  useAddChannelContentGuest,
   useAddChannelSubscriber,
   useAddEventAddOnTicket,
   useAddEventAddOnTier,
@@ -21590,10 +22681,12 @@ export {
   useAddOrganizationUser,
   useAddSeriesEvent,
   useAddSubscriptionProductTier,
+  useAddThreadMember,
   useAddTierAccount,
   useApplyEventRegistrationCoupon,
   useApproveEvent,
   useCancelAnnouncementSchedule,
+  useCancelChannelContentPublishSchedule,
   useCancelEventRegistrationPurchaseTransfer,
   useCancelSubscription,
   useConfirmAccountCognitoUser,
@@ -21608,6 +22701,8 @@ export {
   useCreateBenefitTranslation,
   useCreateChannel,
   useCreateChannelContent,
+  useCreateChannelContentGuest,
+  useCreateChannelContentGuestTranslation,
   useCreateChannelContentTranslation,
   useCreateChannelTranslation,
   useCreateEvent,
@@ -21667,6 +22762,7 @@ export {
   useCreateSubscriptionProductPrice,
   useCreateSupportTicket,
   useCreateSupportTicketNote,
+  useCreateThread,
   useCreateTier,
   useDeleteAccount,
   useDeleteActivity,
@@ -21675,6 +22771,8 @@ export {
   useDeleteBenefitTranslation,
   useDeleteChannel,
   useDeleteChannelContent,
+  useDeleteChannelContentGuest,
+  useDeleteChannelContentGuestTranslation,
   useDeleteChannelContentTranslation,
   useDeleteChannelTranslation,
   useDeleteEvent,
@@ -21781,7 +22879,10 @@ export {
   useGetChannelContent,
   useGetChannelContentActivities,
   useGetChannelContentGuest,
+  useGetChannelContentGuestTranslation,
+  useGetChannelContentGuestTranslations,
   useGetChannelContentGuests,
+  useGetChannelContentLikes,
   useGetChannelContentTranslation,
   useGetChannelContentTranslations,
   useGetChannelContents,
@@ -21941,6 +23042,7 @@ export {
   useGetLevels,
   useGetOrganization,
   useGetOrganizationMembership,
+  useGetOrganizationModules,
   useGetOrganizationPage,
   useGetOrganizationPageTranslation,
   useGetOrganizationPageTranslations,
@@ -21990,6 +23092,17 @@ export {
   useGetSubscriptions,
   useGetSupportTicket,
   useGetSupportTickets,
+  useGetThread,
+  useGetThreadEvents,
+  useGetThreadGroups,
+  useGetThreadMember,
+  useGetThreadMembers,
+  useGetThreadMessage,
+  useGetThreadMessageReplies,
+  useGetThreadMessages,
+  useGetThreadModerators,
+  useGetThreads,
+  useGetThreadsGroup,
   useGetTier,
   useGetTierAccounts,
   useGetTierSubscribers,
@@ -22006,7 +23119,6 @@ export {
   useRemoveAccountInterest,
   useRemoveAccountTier,
   useRemoveActivityInterest,
-  useRemoveChannelContentGuest,
   useRemoveChannelSubscriber,
   useRemoveEventAddOnTicket,
   useRemoveEventAddOnTier,
@@ -22040,6 +23152,8 @@ export {
   useRemoveLevelAccount,
   useRemoveSeriesEvent,
   useRemoveSubscriptionProductTier,
+  useRemoveThreadMember,
+  useRemoveThreadModerator,
   useRemoveTierAccount,
   useReorderEventFaqSectionQuestions,
   useReorderEventQuestionChoices,
@@ -22062,6 +23176,8 @@ export {
   useUpdateChannel,
   useUpdateChannelContent,
   useUpdateChannelContentGuest,
+  useUpdateChannelContentGuestTranslation,
+  useUpdateChannelContentPublishSchedule,
   useUpdateChannelContentTranslation,
   useUpdateChannelSubscriber,
   useUpdateChannelTranslation,
@@ -22121,6 +23237,8 @@ export {
   useUpdateOrganization,
   useUpdateOrganizationIntegrations,
   useUpdateOrganizationMembership,
+  useUpdateOrganizationModuleActions,
+  useUpdateOrganizationModules,
   useUpdateOrganizationPage,
   useUpdateOrganizationPageTranslation,
   useUpdateOrganizationTeamMember,
@@ -22135,7 +23253,9 @@ export {
   useUpdateSubscriptionProduct,
   useUpdateSubscriptionProductPrice,
   useUpdateSupportTicket,
+  useUpdateThread,
   useUpdateTier,
+  useUpdateUserImage,
   useUpdateVideo,
   useUploadFile
 };