@connectedxm/client 1.0.2 → 1.0.4

package/dist/index.js

@@ -36,12 +36,14 @@ __export(src_exports, {
   ACCOUNT_FOLLOWERS_QUERY_KEY: () => ACCOUNT_FOLLOWERS_QUERY_KEY,
   ACCOUNT_FOLLOWINGS_QUERY_KEY: () => ACCOUNT_FOLLOWINGS_QUERY_KEY,
   ACCOUNT_GROUPS_QUERY_KEY: () => ACCOUNT_GROUPS_QUERY_KEY,
+  ACCOUNT_MEDIA_QUERY_KEY: () => ACCOUNT_MEDIA_QUERY_KEY,
   ACCOUNT_QUERY_KEY: () => ACCOUNT_QUERY_KEY,
   ACTIVITIES_QUERY_KEY: () => ACTIVITIES_QUERY_KEY,
   ACTIVITY_COMMENTS_QUERY_KEY: () => ACTIVITY_COMMENTS_QUERY_KEY,
   ACTIVITY_QUERY_KEY: () => ACTIVITY_QUERY_KEY,
   ADD_SELF_RELATIONSHIP: () => ADD_SELF_RELATIONSHIP,
   ADVERTISEMENT_QUERY_KEY: () => ADVERTISEMENT_QUERY_KEY,
+  ALL_GROUP_EVENTS: () => ALL_GROUP_EVENTS,
   AcceptGroupInvitation: () => AcceptGroupInvitation,
   AcceptGroupRequest: () => AcceptGroupRequest,
   AcceptTransfer: () => AcceptTransfer,
@@ -176,11 +178,13 @@ __export(src_exports, {
   GetAccountFollowers: () => GetAccountFollowers,
   GetAccountFollowings: () => GetAccountFollowings,
   GetAccountGroups: () => GetAccountGroups,
+  GetAccountMedia: () => GetAccountMedia,
   GetAccounts: () => GetAccounts,
   GetActivities: () => GetActivities,
   GetActivity: () => GetActivity,
   GetActivityComments: () => GetActivityComments,
   GetAdvertisement: () => GetAdvertisement,
+  GetAllGroupEvents: () => GetAllGroupEvents,
   GetBaseInfiniteQueryKeys: () => GetBaseInfiniteQueryKeys,
   GetBaseSingleQueryKeys: () => GetBaseSingleQueryKeys,
   GetBenefits: () => GetBenefits,
@@ -294,6 +298,7 @@ __export(src_exports, {
   GetSelfEventTicketCouponIntent: () => GetSelfEventTicketCouponIntent,
   GetSelfEvents: () => GetSelfEvents,
   GetSelfFeed: () => GetSelfFeed,
+  GetSelfGroupActivities: () => GetSelfGroupActivities,
   GetSelfGroupMembership: () => GetSelfGroupMembership,
   GetSelfGroupMemberships: () => GetSelfGroupMemberships,
   GetSelfInterests: () => GetSelfInterests,
@@ -424,6 +429,7 @@ __export(src_exports, {
   SELF_EVENT_SESSIONS_QUERY_KEY: () => SELF_EVENT_SESSIONS_QUERY_KEY,
   SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY: () => SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY,
   SELF_FEED_QUERY_KEY: () => SELF_FEED_QUERY_KEY,
+  SELF_GROUP_ACTIVITIES_QUERY_KEY: () => SELF_GROUP_ACTIVITIES_QUERY_KEY,
   SELF_GROUP_MEMBERSHIPS_QUERY_KEY: () => SELF_GROUP_MEMBERSHIPS_QUERY_KEY,
   SELF_GROUP_MEMBERSHIP_QUERY_KEY: () => SELF_GROUP_MEMBERSHIP_QUERY_KEY,
   SELF_INTERESTS_QUERY_KEY: () => SELF_INTERESTS_QUERY_KEY,
@@ -450,11 +456,13 @@ __export(src_exports, {
   SET_ACCOUNT_FOLLOWERS_QUERY_DATA: () => SET_ACCOUNT_FOLLOWERS_QUERY_DATA,
   SET_ACCOUNT_FOLLOWINGS_QUERY_DATA: () => SET_ACCOUNT_FOLLOWINGS_QUERY_DATA,
   SET_ACCOUNT_GROUPS_QUERY_DATA: () => SET_ACCOUNT_GROUPS_QUERY_DATA,
+  SET_ACCOUNT_MEDIA_QUERY_DATA: () => SET_ACCOUNT_MEDIA_QUERY_DATA,
   SET_ACCOUNT_QUERY_DATA: () => SET_ACCOUNT_QUERY_DATA,
   SET_ACTIVITIES_QUERY_DATA: () => SET_ACTIVITIES_QUERY_DATA,
   SET_ACTIVITY_COMMENTS_QUERY_DATA: () => SET_ACTIVITY_COMMENTS_QUERY_DATA,
   SET_ACTIVITY_QUERY_DATA: () => SET_ACTIVITY_QUERY_DATA,
   SET_ADVERTISEMENT_QUERY_DATA: () => SET_ADVERTISEMENT_QUERY_DATA,
+  SET_ALL_GROUP_EVENTS_QUERY_DATA: () => SET_ALL_GROUP_EVENTS_QUERY_DATA,
   SET_BENEFITS_QUERY_DATA: () => SET_BENEFITS_QUERY_DATA,
   SET_CHANNELS_QUERY_DATA: () => SET_CHANNELS_QUERY_DATA,
   SET_CHANNEL_COLLECTIONS_QUERY_DATA: () => SET_CHANNEL_COLLECTIONS_QUERY_DATA,
@@ -718,11 +726,13 @@ __export(src_exports, {
   useGetAccountFollowers: () => useGetAccountFollowers,
   useGetAccountFollowings: () => useGetAccountFollowings,
   useGetAccountGroups: () => useGetAccountGroups,
+  useGetAccountMedia: () => useGetAccountMedia,
   useGetAccounts: () => useGetAccounts,
   useGetActivities: () => useGetActivities,
   useGetActivity: () => useGetActivity,
   useGetActivityComments: () => useGetActivityComments,
   useGetAdvertisement: () => useGetAdvertisement,
+  useGetAllGroupEvents: () => useGetAllGroupEvents,
   useGetBenefits: () => useGetBenefits,
   useGetChannel: () => useGetChannel,
   useGetChannelCollection: () => useGetChannelCollection,
@@ -832,6 +842,7 @@ __export(src_exports, {
   useGetSelfEventTicketCouponIntent: () => useGetSelfEventTicketCouponIntent,
   useGetSelfEvents: () => useGetSelfEvents,
   useGetSelfFeed: () => useGetSelfFeed,
+  useGetSelfGroupActivities: () => useGetSelfGroupActivities,
   useGetSelfGroupMembership: () => useGetSelfGroupMembership,
   useGetSelfGroupMemberships: () => useGetSelfGroupMemberships,
   useGetSelfInterests: () => useGetSelfInterests,
@@ -2187,6 +2198,50 @@ var useGetAccountFollowings = (accountId = "", params = {}, options = {}) => {
   );
 };
 
+// src/queries/accounts/useGetAccountMedia.ts
+var ACCOUNT_MEDIA_QUERY_KEY = (accountId, type) => [...ACCOUNT_QUERY_KEY(accountId), "MEDIA", type || "all"];
+var SET_ACCOUNT_MEDIA_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...ACCOUNT_MEDIA_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetAccountMedia = async ({
+  accountId,
+  type,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/accounts/${accountId}/media`, {
+    params: {
+      type: type || void 0,
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetAccountMedia = (accountId = "", type, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    ACCOUNT_MEDIA_QUERY_KEY(accountId, type),
+    (params2) => GetAccountMedia({ accountId, type, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!accountId && (options?.enabled ?? true)
+    }
+  );
+};
+
 // src/queries/advertisements/useGetAdvertisement.ts
 var ADVERTISEMENT_QUERY_KEY = (position) => [
   "ADVERTISEMENT",
@@ -2874,10 +2929,15 @@ var useGetGroupsFeatured = (params = {}, options = {}) => {
 };
 
 // src/queries/groups/useGetGroupsInvited.ts
-var GROUPS_INVITED_QUERY_KEY = () => {
-  return [...GROUPS_QUERY_KEY(), "INVITED"];
+var GROUPS_INVITED_QUERY_KEY = (rejected) => {
+  const keys = [...GROUPS_QUERY_KEY(), "INVITED"];
+  if (typeof rejected === "boolean") {
+    keys.push(rejected ? "REJECTED" : "NEW");
+  }
+  return keys;
 };
 var GetGroupsInvited = async ({
+  rejected,
   pageParam,
   pageSize,
   orderBy,
@@ -2892,7 +2952,8 @@ var GetGroupsInvited = async ({
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
       orderBy: orderBy || void 0,
-      search: search || void 0
+      search: search || void 0,
+      rejected
     }
   });
   if (queryClient && data.status === "ok") {
@@ -2905,10 +2966,10 @@ var GetGroupsInvited = async ({
   }
   return data;
 };
-var useGetGroupsInvited = (params = {}, options = {}) => {
+var useGetGroupsInvited = (rejected, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    GROUPS_INVITED_QUERY_KEY(),
-    (params2) => GetGroupsInvited({ ...params2 }),
+    GROUPS_INVITED_QUERY_KEY(rejected),
+    (params2) => GetGroupsInvited({ rejected, ...params2 }),
     params,
     options
   );
@@ -2955,18 +3016,22 @@ var useGetGroupsRequested = (params = {}, options = {}) => {
   );
 };
 
-// src/queries/channels/useGetChannels.ts
-var CHANNELS_QUERY_KEY = () => ["CHANNELS"];
-var SET_CHANNELS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/events/useGetEventActivities.ts
+var EVENT_ACTIVITIES_QUERY_KEY = (eventId) => [
+  ...ACTIVITIES_QUERY_KEY(),
+  ...EVENT_QUERY_KEY(eventId)
+];
+var SET_EVENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CHANNELS_QUERY_KEY(...keyParams),
+      ...EVENT_ACTIVITIES_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetChannels = async ({
+var GetEventActivities = async ({
+  eventId,
   pageParam,
   pageSize,
   orderBy,
@@ -2976,7 +3041,7 @@ var GetChannels = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels`, {
+  const { data } = await clientApi.get(`/events/${eventId}/activities`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -2988,70 +3053,40 @@ var GetChannels = async ({
     CacheIndividualQueries(
       data,
       queryClient,
-      (channelId) => CHANNEL_QUERY_KEY(channelId),
+      (activityId) => ACTIVITY_QUERY_KEY(activityId),
       locale
     );
   }
   return data;
 };
-var useGetChannels = (params = {}, options = {}) => {
+var useGetEventActivities = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNELS_QUERY_KEY(),
-    (params2) => GetChannels({ ...params2 }),
+    EVENT_ACTIVITIES_QUERY_KEY(eventId),
+    (params2) => GetEventActivities({ eventId, ...params2 }),
     params,
-    options
-  );
-};
-
-// src/queries/channels/useGetChannel.ts
-var CHANNEL_QUERY_KEY = (channelId) => [
-  ...CHANNELS_QUERY_KEY(),
-  channelId
-];
-var SET_CHANNEL_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...CHANNEL_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetChannel = async ({
-  channelId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/${channelId}`);
-  return data;
-};
-var useGetChannel = (channelId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    CHANNEL_QUERY_KEY(channelId),
-    (params) => GetChannel({ channelId: channelId || "", ...params }),
     {
       ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
+      enabled: !!eventId
     }
   );
 };
 
-// src/queries/channels/collections/useGetChannelCollections.ts
-var CHANNEL_COLLECTIONS_QUERY_KEY = (channelId) => [
-  ...CHANNEL_QUERY_KEY(channelId),
-  "COLLECTIONS"
+// src/queries/events/useGetEventFAQSections.ts
+var EVENT_FAQ_SECTIONS_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "FAQ_SECTIONS"
 ];
-var SET_CHANNEL_COLLECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_EVENT_FAQ_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CHANNEL_COLLECTIONS_QUERY_KEY(...keyParams),
+      ...EVENT_FAQ_SECTIONS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetChannelCollections = async ({
-  channelId,
+var GetEventFaqSections = async ({
+  eventId,
   pageParam,
   pageSize,
   orderBy,
@@ -3061,7 +3096,7 @@ var GetChannelCollections = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/${channelId}/collections`, {
+  const { data } = await clientApi.get(`/events/${eventId}/faqs`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -3073,154 +3108,177 @@ var GetChannelCollections = async ({
     CacheIndividualQueries(
       data,
       queryClient,
-      (collectionId) => CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
+      (sectionId) => EVENT_FAQ_SECTION_QUERY_KEY(eventId, sectionId),
       locale
     );
   }
   return data;
 };
-var useGetChannelCollections = (channelId, params = {}, options = {}) => {
+var useGetEventFaqSections = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_COLLECTIONS_QUERY_KEY(channelId),
-    (params2) => GetChannelCollections({ channelId, ...params2 }),
+    EVENT_FAQ_SECTIONS_QUERY_KEY(eventId),
+    (params2) => GetEventFaqSections({ eventId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!eventId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/channels/collections/useGetChannelCollection.ts
-var CHANNEL_COLLECTION_QUERY_KEY = (channelId, collectionId) => [...CHANNEL_COLLECTIONS_QUERY_KEY(channelId), collectionId];
-var SET_CHANNEL_COLLECTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/events/useGetEventFAQSection.ts
+var EVENT_FAQ_SECTION_QUERY_KEY = (eventId, sectionId) => [...EVENT_FAQ_SECTIONS_QUERY_KEY(eventId), sectionId];
+var SET_EVENT_FAQ_SECTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CHANNEL_COLLECTION_QUERY_KEY(...keyParams),
+      ...EVENT_FAQ_SECTION_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetChannelCollection = async ({
-  channelId,
-  collectionId,
+var GetEventFAQSection = async ({
+  eventId,
+  sectionId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/${channelId}/collections/${collectionId}`
-  );
+  const { data } = await clientApi.get(`/events/${eventId}/faqs/${sectionId}`);
   return data;
 };
-var useGetChannelCollection = (channelId = "", collectionId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
-    (params) => GetChannelCollection({ channelId, collectionId, ...params }),
+var useGetEventFAQSection = (eventId = "", sectionId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    EVENT_FAQ_SECTION_QUERY_KEY(eventId, sectionId),
+    (params) => GetEventFAQSection({ eventId, sectionId, ...params }),
     {
       ...options,
-      enabled: !!channelId && !!collectionId && (options?.enabled ?? true)
+      enabled: !!eventId && !!sectionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/contents/useGetContents.ts
-var CONTENTS_QUERY_KEY = (type, featured, interest, past) => {
-  const key = ["CONTENTS"];
-  if (type) key.push(type);
-  if (featured) key.push("FEATURED");
-  if (interest) key.push(interest);
-  if (typeof past !== "undefined") key.push(past ? "PAST" : "UPCOMING");
-  return key;
-};
-var SET_CONTENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/events/useGetEventFAQSectionQuestions.ts
+var EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY = (eventId, sectionId) => [
+  ...EVENT_FAQ_SECTION_QUERY_KEY(eventId, sectionId),
+  "FAQ_SECTION_QUESTIONS"
+];
+var SET_EVENT_FAQ_SECTION_QUESTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CONTENTS_QUERY_KEY(...keyParams),
+      ...EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetContents = async ({
-  type,
-  featured,
-  interest,
-  past,
+var GetEventFaqs = async ({
+  eventId,
+  sectionId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  clientApiParams
+  queryClient,
+  clientApiParams,
+  locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/contents`, {
-    params: {
-      type: type || void 0,
-      featured: typeof featured !== "undefined" ? featured ? "true" : "false" : void 0,
-      interest: interest || void 0,
-      past,
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/events/${eventId}/faqs/${sectionId}/questions`,
+    {
+      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,
+      (faqId) => EVENT_FAQ_SECTION_QUESTION_QUERY_KEY(eventId, sectionId, faqId),
+      locale
+    );
+  }
   return data;
 };
-var useGetContents = (type, featured, interest, past, params = {}, options = {}) => {
+var useGetEventFaqs = (eventId = "", sectionId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CONTENTS_QUERY_KEY(type, featured, interest, past),
-    (params2) => GetContents({ type, featured, interest, past, ...params2 }),
+    EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY(eventId, sectionId),
+    (params2) => GetEventFaqs({ eventId, sectionId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!eventId && !!sectionId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/contents/useGetContent.ts
-var CONTENT_QUERY_KEY = (contentId) => [
-  ...CONTENTS_QUERY_KEY(),
-  contentId
+// src/queries/events/useGetEventFAQSectionQuestion.ts
+var EVENT_FAQ_SECTION_QUESTION_QUERY_KEY = (eventId, sectionId, questionId) => [
+  ...EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY(eventId, sectionId),
+  questionId
 ];
-var SET_CONTENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_EVENT_FAQ_SECTION_QUESTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CONTENT_QUERY_KEY(...keyParams),
+      ...EVENT_FAQ_SECTION_QUESTION_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetContent = async ({
-  contentId,
+var GetEventFAQSectionQuestion = async ({
+  eventId,
+  sectionId,
+  questionId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/contents/${contentId}`);
+  const { data } = await clientApi.get(
+    `/events/${eventId}/faqs/${sectionId}/questions/${questionId}`
+  );
   return data;
 };
-var useGetContent = (contentId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    CONTENT_QUERY_KEY(contentId),
-    (params) => GetContent({ contentId, ...params }),
+var useGetEventFAQSectionQuestion = (eventId = "", sectionId = "", questionId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    EVENT_FAQ_SECTION_QUESTION_QUERY_KEY(eventId, sectionId, questionId),
+    (params) => GetEventFAQSectionQuestion({ eventId, sectionId, questionId, ...params }),
     {
       ...options,
-      enabled: !!contentId && options.enabled
+      enabled: !!eventId && !!sectionId && !!questionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/contents/useGetContentInterests.ts
-var CONTENT_INTERESTS_QUERY_KEY = () => {
-  const key = ["CONTENTS_INTERESTS"];
-  return key;
+// src/queries/events/useGetEventPages.ts
+var EVENT_PAGES_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "PAGES"
+];
+var SET_EVENT_PAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...EVENT_PAGES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
 };
-var GetContentInterests = async ({
+var GetEventPages = async ({
+  eventId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  clientApiParams
+  queryClient,
+  clientApiParams,
+  locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/contents/interests`, {
+  const { data } = await clientApi.get(`/events/${eventId}/pages`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -3228,27 +3286,64 @@ var GetContentInterests = async ({
       search: search || void 0
     }
   });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (pageId) => EVENT_PAGE_QUERY_KEY(eventId, pageId),
+      locale
+    );
+  }
   return data;
 };
-var useGetContentInterests = (params = {}, options = {}) => {
+var useGetEventPages = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CONTENT_INTERESTS_QUERY_KEY(),
-    (params2) => GetContentInterests({ ...params2 }),
+    EVENT_PAGES_QUERY_KEY(eventId),
+    (params2) => GetEventPages({ eventId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!eventId
+    }
   );
 };
 
-// src/queries/contents/useGetSubscribedContents.ts
-var SUBSCRIBED_CONTENTS_QUERY_KEY = (type, interest) => {
-  const key = ["SUBSCRIBED_CONTENTS"];
-  if (type) key.push(type);
-  if (interest) key.push(interest);
-  return key;
+// src/queries/events/useGetEventPage.ts
+var EVENT_PAGE_QUERY_KEY = (eventId, pageId) => [...EVENT_PAGES_QUERY_KEY(eventId), pageId];
+var SET_EVENT_PAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...EVENT_PAGE_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
 };
-var GetSubscribedContents = async ({
-  type,
-  interest,
+var GetEventPage = async ({
+  eventId,
+  pageId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/events/${eventId}/pages/${pageId}`);
+  return data;
+};
+var useGetEventPage = (eventId = "", pageId, options = {}) => {
+  return useConnectedSingleQuery(
+    EVENT_PAGE_QUERY_KEY(eventId, pageId),
+    (params) => GetEventPage({ eventId, pageId, ...params }),
+    {
+      ...options,
+      enabled: !!eventId && !!pageId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/events/useGetEventQuestionValues.ts
+var EVENT_QUESTION_VALUES_QUERY_KEY = (eventId, questionId) => [...EVENT_QUERY_KEY(eventId), "QUESTIONS", questionId, "VALUES"];
+var GetEventQuestionSearchValues = async ({
+  eventId,
+  questionId,
   pageParam,
   pageSize,
   orderBy,
@@ -3256,49 +3351,106 @@ var GetSubscribedContents = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/contents/subscribed`, {
+  const { data } = await clientApi.get(
+    `/events/${eventId}/questions/${questionId}/values`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetEventQuestionSearchValues = (eventId = "", questionId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    EVENT_QUESTION_VALUES_QUERY_KEY(eventId, questionId),
+    (params2) => GetEventQuestionSearchValues({
+      eventId,
+      questionId,
+      ...params2
+    }),
+    params,
+    {
+      ...options,
+      enabled: !!eventId && !!questionId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/events/useGetEventRegistrants.ts
+var EVENT_REGISTRANTS_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "REGISTRANTS"
+];
+var SET_EVENT_REGISTRANTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...EVENT_REGISTRANTS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetEventRegistrants = async ({
+  eventId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/events/${eventId}/registrants`, {
     params: {
-      type: type || void 0,
-      interest: interest || void 0,
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
       orderBy: orderBy || void 0,
       search: search || void 0
     }
   });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (accountId) => ACCOUNT_QUERY_KEY(accountId),
+      locale
+    );
+  }
   return data;
 };
-var useGetSubscribedContents = (type, interest, params = {}, options = {}) => {
+var useGetEventRegistrants = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    SUBSCRIBED_CONTENTS_QUERY_KEY(interest),
-    (params2) => GetSubscribedContents({ interest, ...params2 }),
+    EVENT_REGISTRANTS_QUERY_KEY(eventId),
+    (params2) => GetEventRegistrants({ eventId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!eventId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/channels/content/useGetChannelContents.ts
-var CHANNEL_CONTENTS_QUERY_KEY = (channelId, type, featured, past) => {
-  const key = [...CHANNEL_QUERY_KEY(channelId), "CONTENTS"];
-  if (featured) key.push("FEATURED");
-  if (typeof past !== "undefined") key.push(past ? "PAST" : "UPCOMING");
-  if (type) key.push(type);
-  return key;
-};
-var SET_CHANNEL_CONTENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/events/useGetEventSessions.ts
+var EVENT_SESSIONS_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "SESSIONS"
+];
+var SET_EVENT_SESSIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CHANNEL_CONTENTS_QUERY_KEY(...keyParams),
+      ...EVENT_SESSIONS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetChannelContents = async ({
-  channelId,
-  type,
-  featured,
-  past,
+var GetEventSessions = async ({
+  eventId,
   pageParam,
   pageSize,
   orderBy,
@@ -3308,11 +3460,8 @@ var GetChannelContents = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/${channelId}/contents`, {
+  const { data } = await clientApi.get(`/events/${eventId}/sessions`, {
     params: {
-      type: type || void 0,
-      featured: featured || void 0,
-      past,
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
       orderBy: orderBy || void 0,
@@ -3323,80 +3472,73 @@ var GetChannelContents = async ({
     CacheIndividualQueries(
       data,
       queryClient,
-      (contentId) => CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+      (sessionId) => EVENT_SESSION_QUERY_KEY(eventId, sessionId),
       locale
     );
   }
   return data;
 };
-var useGetChannelContents = (channelId = "", type, featured, past, params = {}, options = {}) => {
+var useGetEventSessions = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_CONTENTS_QUERY_KEY(channelId, type, featured, past),
-    (params2) => GetChannelContents({
-      ...params2,
-      channelId: channelId || "",
-      type,
-      featured,
-      past
-    }),
+    EVENT_SESSIONS_QUERY_KEY(eventId),
+    (params2) => GetEventSessions({ eventId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
+      enabled: !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/content/useGetChannelContent.ts
-var CHANNEL_CONTENT_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENTS_QUERY_KEY(channelId), contentId];
-var SET_CHANNEL_CONTENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/events/useGetEventSession.ts
+var EVENT_SESSION_QUERY_KEY = (eventId, sessionId) => [...EVENT_SESSIONS_QUERY_KEY(eventId), sessionId];
+var SET_EVENT_SESSION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CHANNEL_CONTENT_QUERY_KEY(...keyParams),
+      ...EVENT_SESSION_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetChannelContent = async ({
-  contentId,
-  channelId,
+var GetEventSession = async ({
+  eventId,
+  sessionId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/channels/${channelId}/contents/${contentId}`
+    `/events/${eventId}/sessions/${sessionId}`
   );
   return data;
 };
-var useGetChannelContent = (channelId = "", contentId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-    (params) => GetChannelContent({ contentId, channelId, ...params }),
+var useGetEventSession = (eventId = "", sessionId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    EVENT_SESSION_QUERY_KEY(eventId, sessionId),
+    (params) => GetEventSession({ eventId, sessionId, ...params }),
     {
       ...options,
-      enabled: !!channelId && !!contentId && options.enabled
+      enabled: !!eventId && !!sessionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/content/useGetChannelContentActivities.ts
-var CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY = (channelId, contentId) => [
-  ...ACTIVITIES_QUERY_KEY(),
-  ...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId)
+// src/queries/events/useGetEventSpeakers.ts
+var EVENT_SPEAKERS_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "SPEAKERS"
 ];
-var SET_CONTENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_EVENT_SPEAKERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(...keyParams),
+      ...EVENT_SPEAKERS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetChannelContentActivities = async ({
-  channelId,
-  contentId,
+var GetEventSpeakers = async ({
+  eventId,
   pageParam,
   pageSize,
   orderBy,
@@ -3406,84 +3548,83 @@ var GetChannelContentActivities = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/${channelId}/contents/${contentId}/activities`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+  const { data } = await clientApi.get(`/events/${eventId}/speakers`, {
+    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,
-      (activityId) => ACTIVITY_QUERY_KEY(activityId),
+      (speakerId) => EVENT_SPEAKER_QUERY_KEY(eventId, speakerId),
       locale
     );
   }
   return data;
 };
-var useGetChannelContentActivities = (channelId = "", contentId = "", params = {}, options = {}) => {
+var useGetEventSpeakers = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(channelId, contentId),
-    (params2) => GetChannelContentActivities({ channelId, contentId, ...params2 }),
+    EVENT_SPEAKERS_QUERY_KEY(eventId),
+    (params2) => GetEventSpeakers({ eventId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+      enabled: !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/content/useGetChannelContentInterests.ts
-var CHANNEL_CONTENT_INTERESTS_QUERY_KEY = (channelId, contentId) => [
-  ...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-  "INTERESTS"
-];
-var GetChannelContentInterests = async ({
-  channelId,
-  contentId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
+// src/queries/events/useGetEventSpeaker.ts
+var EVENT_SPEAKER_QUERY_KEY = (eventId, speakerId) => [...EVENT_SPEAKERS_QUERY_KEY(eventId), speakerId];
+var SET_EVENT_SPEAKER_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...EVENT_SPEAKER_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetEventSpeaker = async ({
+  eventId,
+  speakerId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/channels/${channelId}/contents/${contentId}/interests`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
+    `/events/${eventId}/speakers/${speakerId}`
   );
   return data;
 };
-var useGetChannelContentInterests = (channelId, contentId, params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    CHANNEL_CONTENT_INTERESTS_QUERY_KEY(channelId, contentId),
-    (params2) => GetChannelContentInterests({ channelId, contentId, ...params2 }),
-    params,
+var useGetEventSpeaker = (eventId = "", speakerId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    EVENT_SPEAKER_QUERY_KEY(eventId, speakerId),
+    (params) => GetEventSpeaker({ eventId, speakerId, ...params }),
     {
       ...options,
-      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+      enabled: !!eventId && !!speakerId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/content/useGetChannelContentGuests.ts
-var CHANNEL_CONTENT_GUESTS_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "GUESTS"];
-var GetChannelContentGuests = async ({
-  channelId,
-  contentId,
+// src/queries/events/useGetEventTickets.ts
+var EVENT_TICKETS_QUERY_KEY = (eventId, ticketId = "") => [...EVENT_QUERY_KEY(eventId), "TICKETS", ticketId];
+var SET_EVENT_TICKETS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...EVENT_TICKETS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetEventTickets = async ({
+  eventId,
+  ticketId,
   pageParam,
   pageSize,
   orderBy,
@@ -3491,39 +3632,45 @@ var GetChannelContentGuests = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/${channelId}/contents/${contentId}/guests`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+  const { data } = await clientApi.get(`/events/${eventId}/tickets`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      ticketId: ticketId || void 0
     }
-  );
+  });
   return data;
 };
-var useGetChannelContentGuests = (channelId, contentId, params = {}, options = {}) => {
+var useGetEventTickets = (eventId = "", ticketId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId),
-    (params2) => GetChannelContentGuests({ channelId, contentId, ...params2 }),
+    EVENT_TICKETS_QUERY_KEY(eventId),
+    (params2) => GetEventTickets({ eventId, ticketId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+      enabled: !!eventId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/collections/useGetChannelCollectionContents.ts
-var CHANNEL_COLLECTION_CONTENTS_QUERY_KEY = (channelId, collectionId) => [
-  ...CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
-  "CONTENTS"
+// src/queries/events/useGetEventSponsors.ts
+var EVENT_SPONSORS_QUERY_KEY = (eventId) => [
+  ...EVENT_QUERY_KEY(eventId),
+  "SPONSORS"
 ];
-var GetChannelCollectionContents = async ({
-  channelId,
-  collectionId,
+var SET_EVENT_SPONSORS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...EVENT_SPONSORS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetEventSponsors = async ({
+  eventId,
   pageParam,
   pageSize,
   orderBy,
@@ -3533,319 +3680,235 @@ var GetChannelCollectionContents = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/${channelId}/collections/${collectionId}/contents`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+  const { data } = await clientApi.get(`/events/${eventId}/sponsors`, {
+    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,
-      (contentId) => CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-      locale
-    );
-    CacheIndividualQueries(
-      data,
-      queryClient,
-      (contentId) => CONTENT_QUERY_KEY(contentId),
+      (sponsorId) => ACCOUNT_QUERY_KEY(sponsorId),
       locale
     );
   }
   return data;
 };
-var useGetChannelCollectionContents = (channelId, collectionId, params = {}, options = {}) => {
+var useGetEventSponsors = (eventId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    CHANNEL_COLLECTION_CONTENTS_QUERY_KEY(channelId, collectionId),
-    (params2) => GetChannelCollectionContents({ channelId, collectionId, ...params2 }),
+    EVENT_TICKETS_QUERY_KEY(eventId),
+    (params2) => GetEventSponsors({ eventId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!eventId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/channels/managed/useGetManagedChannels.ts
-var MANAGED_CHANNELS_QUERY_KEY = () => [
-  "CHANNELS",
-  "MANAGED"
+// src/queries/events/useGetFeaturedEvents.ts
+var EVENTS_FEATURED_QUERY_KEY = () => [
+  ...EVENTS_QUERY_KEY(),
+  "FEATURED"
 ];
-var SET_MANAGED_CHANNELS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_EVENTS_FEATURED_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...MANAGED_CHANNELS_QUERY_KEY(...keyParams),
+      ...EVENTS_FEATURED_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetManagedChannels = async ({
+var GetFeaturedEvents = async ({
   pageParam,
   pageSize,
   orderBy,
-  search,
   queryClient,
   clientApiParams,
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/managed`, {
+  const { data } = await clientApi.get(`/events/featured`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+      orderBy: orderBy || void 0
     }
   });
   if (queryClient && data.status === "ok") {
     CacheIndividualQueries(
       data,
       queryClient,
-      (channelId) => MANAGED_CHANNEL_QUERY_KEY(channelId),
+      (eventId) => EVENT_QUERY_KEY(eventId),
       locale
     );
   }
   return data;
 };
-var useGetManagedChannels = (params = {}, options = {}) => {
+var useGetFeaturedEvents = (params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    MANAGED_CHANNELS_QUERY_KEY(),
-    (params2) => GetManagedChannels({ ...params2 }),
+    EVENTS_FEATURED_QUERY_KEY(),
+    (params2) => GetFeaturedEvents({ ...params2 }),
     params,
     options
   );
 };
 
-// src/queries/channels/managed/useGetManagedChannel.ts
-var MANAGED_CHANNEL_QUERY_KEY = (channelId) => [
-  ...MANAGED_CHANNELS_QUERY_KEY(),
-  channelId
+// src/queries/groups/useGetAllGroupEvents.ts
+var ALL_GROUP_EVENTS = (past) => [
+  ...EVENTS_QUERY_KEY(past),
+  "GROUPS_EVENTS"
 ];
-var SET_MANAGED_CHANNEL_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...MANAGED_CHANNEL_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetManagedChannel = async ({
-  channelId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/managed/${channelId}`);
-  return data;
-};
-var useGetManagedChannel = (channelId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    MANAGED_CHANNEL_QUERY_KEY(channelId),
-    (params) => GetManagedChannel({ channelId: channelId || "", ...params }),
-    {
-      ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/channels/managed/collections/useGetManagedChannelCollections.ts
-var MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "COLLECTIONS"];
-var SET_MANAGED_CHANNEL_COLLECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_ALL_GROUP_EVENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY(...keyParams),
+      ...ALL_GROUP_EVENTS(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetManagedChannelCollections = async ({
-  channelId,
+var GetAllGroupEvents = async ({
   pageParam,
   pageSize,
   orderBy,
   search,
+  past,
   queryClient,
   clientApiParams,
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/collections`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
-  );
-  if (queryClient && data.status === "ok") {
-    CacheIndividualQueries(
-      data,
+  const { data } = await clientApi.get(`/groups/events`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      past: past !== void 0 ? past : void 0
+    }
+  });
+  if (queryClient) {
+    CacheIndividualQueries(
+      data,
       queryClient,
-      (collectionId) => MANAGED_CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
+      (eventId) => EVENT_QUERY_KEY(eventId),
       locale
     );
   }
   return data;
 };
-var useGetManagedChannelCollections = (channelId, params = {}, options = {}) => {
+var useGetAllGroupEvents = (past = false, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY(channelId),
-    (params2) => GetManagedChannelCollections({ channelId, ...params2 }),
+    ALL_GROUP_EVENTS(past),
+    (params2) => GetAllGroupEvents({ past, ...params2 }),
     params,
     options
   );
 };
 
-// src/queries/channels/managed/collections/useGetManagedChannelCollection.ts
-var MANAGED_CHANNEL_COLLECTION_QUERY_KEY = (channelId, collectionId) => [
-  ...MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY(channelId),
-  collectionId
-];
-var SET_MANAGED_CHANNEL_COLLECTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...MANAGED_CHANNEL_COLLECTION_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetManagedChannelCollection = async ({
-  channelId,
-  collectionId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/collections/${collectionId}`
-  );
-  return data;
-};
-var useGetManagedChannelCollection = (channelId = "", collectionId = "", options = {}) => {
-  return useConnectedSingleQuery_default(
-    MANAGED_CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
-    (params) => GetManagedChannelCollection({ channelId, collectionId, ...params }),
-    {
-      ...options,
-      enabled: !!channelId && !!collectionId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/channels/managed/content/useGetManagedChannelContents.ts
-var MANAGED_CHANNEL_CONTENTS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "CONTENTS"];
-var SET_MANAGED_CHANNEL_CONTENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/useGetChannels.ts
+var CHANNELS_QUERY_KEY = () => ["CHANNELS"];
+var SET_CHANNELS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...MANAGED_CHANNEL_CONTENTS_QUERY_KEY(...keyParams),
+      ...CHANNELS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetManagedChannelContents = async ({
+var GetChannels = async ({
   pageParam,
   pageSize,
   orderBy,
   search,
-  channelId,
   queryClient,
   clientApiParams,
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/contents`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+  const { data } = await clientApi.get(`/channels`, {
+    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,
-      (contentId) => MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+      (channelId) => CHANNEL_QUERY_KEY(channelId),
       locale
     );
   }
   return data;
 };
-var useGetManagedChannelContents = (channelId = "", params = {}, options = {}) => {
+var useGetChannels = (params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_CONTENTS_QUERY_KEY(channelId),
-    (params2) => GetManagedChannelContents({ ...params2, channelId: channelId || "" }),
+    CHANNELS_QUERY_KEY(),
+    (params2) => GetChannels({ ...params2 }),
     params,
-    {
-      ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
-    }
+    options
   );
 };
 
-// src/queries/channels/managed/content/useGetManagedChannelContent.ts
-var MANAGED_CHANNEL_CONTENT_QUERY_KEY = (channelId, contentId) => [...MANAGED_CHANNEL_CONTENTS_QUERY_KEY(channelId), contentId];
-var SET_MANAGED_CHANNEL_CONTENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/useGetChannel.ts
+var CHANNEL_QUERY_KEY = (channelId) => [
+  ...CHANNELS_QUERY_KEY(),
+  channelId
+];
+var SET_CHANNEL_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(...keyParams),
+      ...CHANNEL_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetManagedChannelContent = async ({
-  contentId,
+var GetChannel = async ({
   channelId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/contents/${contentId}`
-  );
+  const { data } = await clientApi.get(`/channels/${channelId}`);
   return data;
 };
-var useGetManagedChannelContent = (channelId = "", contentId = "", options = {}) => {
+var useGetChannel = (channelId = "", options = {}) => {
   return useConnectedSingleQuery_default(
-    MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-    (params) => GetManagedChannelContent({ contentId, channelId, ...params }),
+    CHANNEL_QUERY_KEY(channelId),
+    (params) => GetChannel({ channelId: channelId || "", ...params }),
     {
       ...options,
-      enabled: !!channelId && !!contentId && options.enabled
+      enabled: !!channelId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/managed/content/useGetManagedChannelContentActivities.ts
-var MANAGED_CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY = (channelId, contentId) => [
-  ...ACTIVITIES_QUERY_KEY(),
-  ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId)
+// src/queries/channels/collections/useGetChannelCollections.ts
+var CHANNEL_COLLECTIONS_QUERY_KEY = (channelId) => [
+  ...CHANNEL_QUERY_KEY(channelId),
+  "COLLECTIONS"
 ];
-var SET_MANAGED_CONTENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_CHANNEL_COLLECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...MANAGED_CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(...keyParams),
+      ...CHANNEL_COLLECTIONS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetManagedChannelContentActivities = async ({
+var GetChannelCollections = async ({
   channelId,
-  contentId,
   pageParam,
   pageSize,
   orderBy,
@@ -3855,87 +3918,89 @@ var GetManagedChannelContentActivities = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/contents/${contentId}/activities`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+  const { data } = await clientApi.get(`/channels/${channelId}/collections`, {
+    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,
-      (activityId) => ACTIVITY_QUERY_KEY(activityId),
+      (collectionId) => CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
       locale
     );
   }
   return data;
 };
-var useGetManagedChannelContentActivities = (channelId = "", contentId = "", params = {}, options = {}) => {
+var useGetChannelCollections = (channelId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(channelId, contentId),
-    (params2) => GetManagedChannelContentActivities({ channelId, contentId, ...params2 }),
+    CHANNEL_COLLECTIONS_QUERY_KEY(channelId),
+    (params2) => GetChannelCollections({ channelId, ...params2 }),
     params,
-    {
-      ...options,
-      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
-    }
+    options
   );
 };
 
-// src/queries/channels/managed/content/useGetManagedChannelContentInterests.ts
-var MANAGED_CHANNEL_CONTENT_INTERESTS_QUERY_KEY = (channelId, contentId) => [
-  ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-  "INTERESTS"
-];
-var GetManagedChannelContentInterests = async ({
+// src/queries/channels/collections/useGetChannelCollection.ts
+var CHANNEL_COLLECTION_QUERY_KEY = (channelId, collectionId) => [...CHANNEL_COLLECTIONS_QUERY_KEY(channelId), collectionId];
+var SET_CHANNEL_COLLECTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...CHANNEL_COLLECTION_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetChannelCollection = async ({
   channelId,
-  contentId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
+  collectionId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/contents/${contentId}/interests`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
+    `/channels/${channelId}/collections/${collectionId}`
   );
   return data;
 };
-var useGetManagedChannelContentInterests = (channelId, contentId, params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_CONTENT_INTERESTS_QUERY_KEY(channelId, contentId),
-    (params2) => GetManagedChannelContentInterests({ channelId, contentId, ...params2 }),
-    params,
+var useGetChannelCollection = (channelId = "", collectionId = "", options = {}) => {
+  return useConnectedSingleQuery_default(
+    CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
+    (params) => GetChannelCollection({ channelId, collectionId, ...params }),
     {
       ...options,
-      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+      enabled: !!channelId && !!collectionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/managed/content/useGetManagedChannelContentGuests.ts
-var MANAGED_CHANNEL_CONTENT_GUESTS_QUERY_KEY = (channelId, contentId) => [
-  ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-  "GUESTS"
-];
-var GetManagedChannelContentGuests = async ({
-  channelId,
-  contentId,
+// src/queries/contents/useGetContents.ts
+var CONTENTS_QUERY_KEY = (type, featured, interest, past) => {
+  const key = ["CONTENTS"];
+  if (type) key.push(type);
+  if (featured) key.push("FEATURED");
+  if (interest) key.push(interest);
+  if (typeof past !== "undefined") key.push(past ? "PAST" : "UPCOMING");
+  return key;
+};
+var SET_CONTENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...CONTENTS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetContents = async ({
+  type,
+  featured,
+  interest,
+  past,
   pageParam,
   pageSize,
   orderBy,
@@ -3943,39 +4008,154 @@ var GetManagedChannelContentGuests = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/contents/${contentId}/guests`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
-  );
-  return data;
-};
-var useGetManagedChannelContentGuests = (channelId, contentId, params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId),
-    (params2) => GetManagedChannelContentGuests({ channelId, contentId, ...params2 }),
+  const { data } = await clientApi.get(`/contents`, {
+    params: {
+      type: type || void 0,
+      featured: typeof featured !== "undefined" ? featured ? "true" : "false" : void 0,
+      interest: interest || void 0,
+      past,
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetContents = (type, featured, interest, past, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    CONTENTS_QUERY_KEY(type, featured, interest, past),
+    (params2) => GetContents({ type, featured, interest, past, ...params2 }),
     params,
+    options
+  );
+};
+
+// src/queries/contents/useGetContent.ts
+var CONTENT_QUERY_KEY = (contentId) => [
+  ...CONTENTS_QUERY_KEY(),
+  contentId
+];
+var SET_CONTENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...CONTENT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response
+  );
+};
+var GetContent = async ({
+  contentId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/contents/${contentId}`);
+  return data;
+};
+var useGetContent = (contentId = "", options = {}) => {
+  return useConnectedSingleQuery_default(
+    CONTENT_QUERY_KEY(contentId),
+    (params) => GetContent({ contentId, ...params }),
     {
       ...options,
-      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+      enabled: !!contentId && options.enabled
     }
   );
 };
 
-// src/queries/channels/managed/collections/useGetManagedChannelCollectionContents.ts
-var MANAGED_CHANNEL_COLLECTION_CONTENTS_QUERY_KEY = (channelId, collectionId) => [
-  ...MANAGED_CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
-  "CONTENTS"
-];
-var GetManagedChannelCollectionContents = async ({
+// src/queries/contents/useGetContentInterests.ts
+var CONTENT_INTERESTS_QUERY_KEY = () => {
+  const key = ["CONTENTS_INTERESTS"];
+  return key;
+};
+var GetContentInterests = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/contents/interests`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetContentInterests = (params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    CONTENT_INTERESTS_QUERY_KEY(),
+    (params2) => GetContentInterests({ ...params2 }),
+    params,
+    options
+  );
+};
+
+// src/queries/contents/useGetSubscribedContents.ts
+var SUBSCRIBED_CONTENTS_QUERY_KEY = (type, interest) => {
+  const key = ["SUBSCRIBED_CONTENTS"];
+  if (type) key.push(type);
+  if (interest) key.push(interest);
+  return key;
+};
+var GetSubscribedContents = async ({
+  type,
+  interest,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/contents/subscribed`, {
+    params: {
+      type: type || void 0,
+      interest: interest || void 0,
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetSubscribedContents = (type, interest, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    SUBSCRIBED_CONTENTS_QUERY_KEY(interest),
+    (params2) => GetSubscribedContents({ interest, ...params2 }),
+    params,
+    options
+  );
+};
+
+// src/queries/channels/content/useGetChannelContents.ts
+var CHANNEL_CONTENTS_QUERY_KEY = (channelId, type, featured, past) => {
+  const key = [...CHANNEL_QUERY_KEY(channelId), "CONTENTS"];
+  if (featured) key.push("FEATURED");
+  if (typeof past !== "undefined") key.push(past ? "PAST" : "UPCOMING");
+  if (type) key.push(type);
+  return key;
+};
+var SET_CHANNEL_CONTENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...CHANNEL_CONTENTS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetChannelContents = async ({
   channelId,
-  collectionId,
+  type,
+  featured,
+  past,
   pageParam,
   pageSize,
   orderBy,
@@ -3985,104 +4165,106 @@ var GetManagedChannelCollectionContents = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/collections/${collectionId}/contents`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+  const { data } = await clientApi.get(`/channels/${channelId}/contents`, {
+    params: {
+      type: type || void 0,
+      featured: featured || void 0,
+      past,
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
     }
-  );
+  });
   if (queryClient && data.status === "ok") {
     CacheIndividualQueries(
       data,
       queryClient,
-      (contentId) => MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
-      locale
-    );
-    CacheIndividualQueries(
-      data,
-      queryClient,
-      (contentId) => CONTENT_QUERY_KEY(contentId),
+      (contentId) => CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
       locale
     );
   }
   return data;
 };
-var useGetManagedChannelCollectionContents = (channelId, collectionId, params = {}, options = {}) => {
+var useGetChannelContents = (channelId = "", type, featured, past, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_COLLECTION_CONTENTS_QUERY_KEY(channelId, collectionId),
-    (params2) => GetManagedChannelCollectionContents({
-      channelId,
-      collectionId,
-      ...params2
+    CHANNEL_CONTENTS_QUERY_KEY(channelId, type, featured, past),
+    (params2) => GetChannelContents({
+      ...params2,
+      channelId: channelId || "",
+      type,
+      featured,
+      past
     }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!channelId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/channels/managed/useGetManagedChannelSubscribers.ts
-var MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "SUBSCRIBERS"];
-var SET_MANAGED_CHANNEL_SUBSCRIBERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/content/useGetChannelContent.ts
+var CHANNEL_CONTENT_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENTS_QUERY_KEY(channelId), contentId];
+var SET_CHANNEL_CONTENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
+      ...CHANNEL_CONTENT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
     ],
-    setFirstPageData(response)
+    response
   );
 };
-var GetManagedChannelSubscribers = async ({
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
+var GetChannelContent = async ({
+  contentId,
   channelId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/subscribers`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
-    }
+    `/channels/${channelId}/contents/${contentId}`
   );
   return data;
 };
-var useGetManagedChannelSubscribers = (channelId = "", params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY(channelId),
-    (params2) => GetManagedChannelSubscribers({ ...params2, channelId: channelId || "" }),
-    params,
+var useGetChannelContent = (channelId = "", contentId = "", options = {}) => {
+  return useConnectedSingleQuery_default(
+    CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+    (params) => GetChannelContent({ contentId, channelId, ...params }),
     {
       ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
+      enabled: !!channelId && !!contentId && options.enabled
     }
   );
 };
 
-// src/queries/channels/managed/useGetManagedChannelInterests.ts
-var MANAGED_CHANNEL_INTERESTS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "INTERESTS"];
-var GetManagedChannelInterests = async ({
+// src/queries/channels/content/useGetChannelContentActivities.ts
+var CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY = (channelId, contentId) => [
+  ...ACTIVITIES_QUERY_KEY(),
+  ...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId)
+];
+var SET_CONTENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetChannelContentActivities = async ({
   channelId,
+  contentId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  clientApiParams
+  queryClient,
+  clientApiParams,
+  locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/channels/managed/${channelId}/interests`,
+    `/channels/${channelId}/contents/${contentId}/activities`,
     {
       params: {
         page: pageParam || void 0,
@@ -4092,69 +4274,73 @@ var GetManagedChannelInterests = async ({
       }
     }
   );
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (activityId) => ACTIVITY_QUERY_KEY(activityId),
+      locale
+    );
+  }
   return data;
 };
-var useGetManagedChannelInterests = (channelId, params = {}, options = {}) => {
+var useGetChannelContentActivities = (channelId = "", contentId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    MANAGED_CHANNEL_INTERESTS_QUERY_KEY(channelId),
-    (params2) => GetManagedChannelInterests({ channelId, ...params2 }),
+    CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(channelId, contentId),
+    (params2) => GetChannelContentActivities({ channelId, contentId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
+      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/channels/useGetSubscribedChannels.ts
-var SUBSCRIBED_CHANNELS_QUERY_KEY = () => [
-  ...CHANNELS_QUERY_KEY(),
-  "SUBSCRIBED"
+// src/queries/channels/content/useGetChannelContentInterests.ts
+var CHANNEL_CONTENT_INTERESTS_QUERY_KEY = (channelId, contentId) => [
+  ...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+  "INTERESTS"
 ];
-var GetSubscribedChannels = async ({
+var GetChannelContentInterests = async ({
+  channelId,
+  contentId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  queryClient,
-  clientApiParams,
-  locale
+  clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/subscribed`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/channels/${channelId}/contents/${contentId}/interests`,
+    {
+      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,
-      (channelId) => CHANNEL_QUERY_KEY(channelId),
-      locale
-    );
-  }
+  );
   return data;
 };
-var useGetSubscribedChannels = (params = {}, options = {}) => {
+var useGetChannelContentInterests = (channelId, contentId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    SUBSCRIBED_CHANNELS_QUERY_KEY(),
-    (params2) => GetSubscribedChannels({ ...params2 }),
+    CHANNEL_CONTENT_INTERESTS_QUERY_KEY(channelId, contentId),
+    (params2) => GetChannelContentInterests({ channelId, contentId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/channels/useGetChannelInterests.ts
-var CHANNEL_INTERESTS_QUERY_KEY = (channelId) => [
-  ...CHANNEL_QUERY_KEY(channelId),
-  "INTERESTS"
-];
-var GetChannelInterests = async ({
+// src/queries/channels/content/useGetChannelContentGuests.ts
+var CHANNEL_CONTENT_GUESTS_QUERY_KEY = (channelId, contentId) => [...CHANNEL_CONTENT_QUERY_KEY(channelId, contentId), "GUESTS"];
+var GetChannelContentGuests = async ({
   channelId,
+  contentId,
   pageParam,
   pageSize,
   orderBy,
@@ -4162,44 +4348,39 @@ var GetChannelInterests = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/channels/${channelId}/interests`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/channels/${channelId}/contents/${contentId}/guests`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
     }
-  });
+  );
   return data;
 };
-var useGetChannelInterests = (channelId, params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    CHANNEL_INTERESTS_QUERY_KEY(channelId),
-    (params2) => GetChannelInterests({ channelId, ...params2 }),
+var useGetChannelContentGuests = (channelId, contentId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId),
+    (params2) => GetChannelContentGuests({ channelId, contentId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!channelId && (options?.enabled ?? true)
+      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventActivities.ts
-var EVENT_ACTIVITIES_QUERY_KEY = (eventId) => [
-  ...ACTIVITIES_QUERY_KEY(),
-  ...EVENT_QUERY_KEY(eventId)
+// src/queries/channels/collections/useGetChannelCollectionContents.ts
+var CHANNEL_COLLECTION_CONTENTS_QUERY_KEY = (channelId, collectionId) => [
+  ...CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
+  "CONTENTS"
 ];
-var SET_EVENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_ACTIVITIES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetEventActivities = async ({
-  eventId,
+var GetChannelCollectionContents = async ({
+  channelId,
+  collectionId,
   pageParam,
   pageSize,
   orderBy,
@@ -4209,52 +4390,57 @@ var GetEventActivities = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/activities`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/channels/${channelId}/collections/${collectionId}/contents`,
+    {
+      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,
-      (activityId) => ACTIVITY_QUERY_KEY(activityId),
+      (contentId) => CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+      locale
+    );
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (contentId) => CONTENT_QUERY_KEY(contentId),
       locale
     );
   }
   return data;
 };
-var useGetEventActivities = (eventId = "", params = {}, options = {}) => {
+var useGetChannelCollectionContents = (channelId, collectionId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_ACTIVITIES_QUERY_KEY(eventId),
-    (params2) => GetEventActivities({ eventId, ...params2 }),
+    CHANNEL_COLLECTION_CONTENTS_QUERY_KEY(channelId, collectionId),
+    (params2) => GetChannelCollectionContents({ channelId, collectionId, ...params2 }),
     params,
-    {
-      ...options,
-      enabled: !!eventId
-    }
+    options
   );
 };
 
-// src/queries/events/useGetEventFAQSections.ts
-var EVENT_FAQ_SECTIONS_QUERY_KEY = (eventId) => [
-  ...EVENT_QUERY_KEY(eventId),
-  "FAQ_SECTIONS"
+// src/queries/channels/managed/useGetManagedChannels.ts
+var MANAGED_CHANNELS_QUERY_KEY = () => [
+  "CHANNELS",
+  "MANAGED"
 ];
-var SET_EVENT_FAQ_SECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_MANAGED_CHANNELS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_FAQ_SECTIONS_QUERY_KEY(...keyParams),
+      ...MANAGED_CHANNELS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetEventFaqSections = async ({
-  eventId,
+var GetManagedChannels = async ({
   pageParam,
   pageSize,
   orderBy,
@@ -4264,7 +4450,7 @@ var GetEventFaqSections = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/faqs`, {
+  const { data } = await clientApi.get(`/channels/managed`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -4276,72 +4462,67 @@ var GetEventFaqSections = async ({
     CacheIndividualQueries(
       data,
       queryClient,
-      (sectionId) => EVENT_FAQ_SECTION_QUERY_KEY(eventId, sectionId),
+      (channelId) => MANAGED_CHANNEL_QUERY_KEY(channelId),
       locale
     );
   }
   return data;
 };
-var useGetEventFaqSections = (eventId = "", params = {}, options = {}) => {
+var useGetManagedChannels = (params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_FAQ_SECTIONS_QUERY_KEY(eventId),
-    (params2) => GetEventFaqSections({ eventId, ...params2 }),
+    MANAGED_CHANNELS_QUERY_KEY(),
+    (params2) => GetManagedChannels({ ...params2 }),
     params,
-    {
-      ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
-    }
+    options
   );
 };
 
-// src/queries/events/useGetEventFAQSection.ts
-var EVENT_FAQ_SECTION_QUERY_KEY = (eventId, sectionId) => [...EVENT_FAQ_SECTIONS_QUERY_KEY(eventId), sectionId];
-var SET_EVENT_FAQ_SECTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/managed/useGetManagedChannel.ts
+var MANAGED_CHANNEL_QUERY_KEY = (channelId) => [
+  ...MANAGED_CHANNELS_QUERY_KEY(),
+  channelId
+];
+var SET_MANAGED_CHANNEL_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_FAQ_SECTION_QUERY_KEY(...keyParams),
+      ...MANAGED_CHANNEL_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetEventFAQSection = async ({
-  eventId,
-  sectionId,
+var GetManagedChannel = async ({
+  channelId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/faqs/${sectionId}`);
+  const { data } = await clientApi.get(`/channels/managed/${channelId}`);
   return data;
 };
-var useGetEventFAQSection = (eventId = "", sectionId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    EVENT_FAQ_SECTION_QUERY_KEY(eventId, sectionId),
-    (params) => GetEventFAQSection({ eventId, sectionId, ...params }),
+var useGetManagedChannel = (channelId = "", options = {}) => {
+  return useConnectedSingleQuery_default(
+    MANAGED_CHANNEL_QUERY_KEY(channelId),
+    (params) => GetManagedChannel({ channelId: channelId || "", ...params }),
     {
       ...options,
-      enabled: !!eventId && !!sectionId && (options?.enabled ?? true)
+      enabled: !!channelId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventFAQSectionQuestions.ts
-var EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY = (eventId, sectionId) => [
-  ...EVENT_FAQ_SECTION_QUERY_KEY(eventId, sectionId),
-  "FAQ_SECTION_QUESTIONS"
-];
-var SET_EVENT_FAQ_SECTION_QUESTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/managed/collections/useGetManagedChannelCollections.ts
+var MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "COLLECTIONS"];
+var SET_MANAGED_CHANNEL_COLLECTIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY(...keyParams),
+      ...MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetEventFaqs = async ({
-  eventId,
-  sectionId,
+var GetManagedChannelCollections = async ({
+  channelId,
   pageParam,
   pageSize,
   orderBy,
@@ -4352,7 +4533,7 @@ var GetEventFaqs = async ({
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/events/${eventId}/faqs/${sectionId}/questions`,
+    `/channels/managed/${channelId}/collections`,
     {
       params: {
         page: pageParam || void 0,
@@ -4366,161 +4547,81 @@ var GetEventFaqs = async ({
     CacheIndividualQueries(
       data,
       queryClient,
-      (faqId) => EVENT_FAQ_SECTION_QUESTION_QUERY_KEY(eventId, sectionId, faqId),
+      (collectionId) => MANAGED_CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
       locale
     );
   }
   return data;
 };
-var useGetEventFaqs = (eventId = "", sectionId = "", params = {}, options = {}) => {
+var useGetManagedChannelCollections = (channelId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY(eventId, sectionId),
-    (params2) => GetEventFaqs({ eventId, sectionId, ...params2 }),
+    MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY(channelId),
+    (params2) => GetManagedChannelCollections({ channelId, ...params2 }),
     params,
-    {
-      ...options,
-      enabled: !!eventId && !!sectionId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/events/useGetEventFAQSectionQuestion.ts
-var EVENT_FAQ_SECTION_QUESTION_QUERY_KEY = (eventId, sectionId, questionId) => [
-  ...EVENT_FAQ_SECTION_QUESTIONS_QUERY_KEY(eventId, sectionId),
-  questionId
-];
-var SET_EVENT_FAQ_SECTION_QUESTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_FAQ_SECTION_QUESTION_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetEventFAQSectionQuestion = async ({
-  eventId,
-  sectionId,
-  questionId,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/events/${eventId}/faqs/${sectionId}/questions/${questionId}`
-  );
-  return data;
-};
-var useGetEventFAQSectionQuestion = (eventId = "", sectionId = "", questionId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    EVENT_FAQ_SECTION_QUESTION_QUERY_KEY(eventId, sectionId, questionId),
-    (params) => GetEventFAQSectionQuestion({ eventId, sectionId, questionId, ...params }),
-    {
-      ...options,
-      enabled: !!eventId && !!sectionId && !!questionId && (options?.enabled ?? true)
-    }
+    options
   );
 };
 
-// src/queries/events/useGetEventPages.ts
-var EVENT_PAGES_QUERY_KEY = (eventId) => [
-  ...EVENT_QUERY_KEY(eventId),
-  "PAGES"
+// src/queries/channels/managed/collections/useGetManagedChannelCollection.ts
+var MANAGED_CHANNEL_COLLECTION_QUERY_KEY = (channelId, collectionId) => [
+  ...MANAGED_CHANNEL_COLLECTIONS_QUERY_KEY(channelId),
+  collectionId
 ];
-var SET_EVENT_PAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_PAGES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetEventPages = async ({
-  eventId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  queryClient,
-  clientApiParams,
-  locale
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/pages`, {
-    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,
-      (pageId) => EVENT_PAGE_QUERY_KEY(eventId, pageId),
-      locale
-    );
-  }
-  return data;
-};
-var useGetEventPages = (eventId = "", params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    EVENT_PAGES_QUERY_KEY(eventId),
-    (params2) => GetEventPages({ eventId, ...params2 }),
-    params,
-    {
-      ...options,
-      enabled: !!eventId
-    }
-  );
-};
-
-// src/queries/events/useGetEventPage.ts
-var EVENT_PAGE_QUERY_KEY = (eventId, pageId) => [...EVENT_PAGES_QUERY_KEY(eventId), pageId];
-var SET_EVENT_PAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_MANAGED_CHANNEL_COLLECTION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_PAGE_QUERY_KEY(...keyParams),
+      ...MANAGED_CHANNEL_COLLECTION_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
     response
   );
 };
-var GetEventPage = async ({
-  eventId,
-  pageId,
+var GetManagedChannelCollection = async ({
+  channelId,
+  collectionId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/pages/${pageId}`);
+  const { data } = await clientApi.get(
+    `/channels/managed/${channelId}/collections/${collectionId}`
+  );
   return data;
 };
-var useGetEventPage = (eventId = "", pageId, options = {}) => {
-  return useConnectedSingleQuery(
-    EVENT_PAGE_QUERY_KEY(eventId, pageId),
-    (params) => GetEventPage({ eventId, pageId, ...params }),
+var useGetManagedChannelCollection = (channelId = "", collectionId = "", options = {}) => {
+  return useConnectedSingleQuery_default(
+    MANAGED_CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
+    (params) => GetManagedChannelCollection({ channelId, collectionId, ...params }),
     {
       ...options,
-      enabled: !!eventId && !!pageId && (options?.enabled ?? true)
+      enabled: !!channelId && !!collectionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventQuestionValues.ts
-var EVENT_QUESTION_VALUES_QUERY_KEY = (eventId, questionId) => [...EVENT_QUERY_KEY(eventId), "QUESTIONS", questionId, "VALUES"];
-var GetEventQuestionSearchValues = async ({
-  eventId,
-  questionId,
+// src/queries/channels/managed/content/useGetManagedChannelContents.ts
+var MANAGED_CHANNEL_CONTENTS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "CONTENTS"];
+var SET_MANAGED_CHANNEL_CONTENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...MANAGED_CHANNEL_CONTENTS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetManagedChannelContents = async ({
   pageParam,
   pageSize,
   orderBy,
   search,
-  clientApiParams
+  channelId,
+  queryClient,
+  clientApiParams,
+  locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/events/${eventId}/questions/${questionId}/values`,
+    `/channels/managed/${channelId}/contents`,
     {
       params: {
         page: pageParam || void 0,
@@ -4530,95 +4631,78 @@ var GetEventQuestionSearchValues = async ({
       }
     }
   );
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (contentId) => MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+      locale
+    );
+  }
   return data;
 };
-var useGetEventQuestionSearchValues = (eventId = "", questionId = "", params = {}, options = {}) => {
+var useGetManagedChannelContents = (channelId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_QUESTION_VALUES_QUERY_KEY(eventId, questionId),
-    (params2) => GetEventQuestionSearchValues({
-      eventId,
-      questionId,
-      ...params2
-    }),
+    MANAGED_CHANNEL_CONTENTS_QUERY_KEY(channelId),
+    (params2) => GetManagedChannelContents({ ...params2, channelId: channelId || "" }),
     params,
     {
       ...options,
-      enabled: !!eventId && !!questionId && (options?.enabled ?? true)
+      enabled: !!channelId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventRegistrants.ts
-var EVENT_REGISTRANTS_QUERY_KEY = (eventId) => [
-  ...EVENT_QUERY_KEY(eventId),
-  "REGISTRANTS"
-];
-var SET_EVENT_REGISTRANTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/managed/content/useGetManagedChannelContent.ts
+var MANAGED_CHANNEL_CONTENT_QUERY_KEY = (channelId, contentId) => [...MANAGED_CHANNEL_CONTENTS_QUERY_KEY(channelId), contentId];
+var SET_MANAGED_CHANNEL_CONTENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_REGISTRANTS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
+      ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
     ],
-    setFirstPageData(response)
+    response
   );
 };
-var GetEventRegistrants = async ({
-  eventId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  queryClient,
-  clientApiParams,
-  locale
+var GetManagedChannelContent = async ({
+  contentId,
+  channelId,
+  clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/registrants`, {
-    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,
-      (accountId) => ACCOUNT_QUERY_KEY(accountId),
-      locale
-    );
-  }
+  const { data } = await clientApi.get(
+    `/channels/managed/${channelId}/contents/${contentId}`
+  );
   return data;
 };
-var useGetEventRegistrants = (eventId = "", params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    EVENT_REGISTRANTS_QUERY_KEY(eventId),
-    (params2) => GetEventRegistrants({ eventId, ...params2 }),
-    params,
+var useGetManagedChannelContent = (channelId = "", contentId = "", options = {}) => {
+  return useConnectedSingleQuery_default(
+    MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+    (params) => GetManagedChannelContent({ contentId, channelId, ...params }),
     {
       ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
+      enabled: !!channelId && !!contentId && options.enabled
     }
   );
 };
 
-// src/queries/events/useGetEventSessions.ts
-var EVENT_SESSIONS_QUERY_KEY = (eventId) => [
-  ...EVENT_QUERY_KEY(eventId),
-  "SESSIONS"
+// src/queries/channels/managed/content/useGetManagedChannelContentActivities.ts
+var MANAGED_CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY = (channelId, contentId) => [
+  ...ACTIVITIES_QUERY_KEY(),
+  ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId)
 ];
-var SET_EVENT_SESSIONS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_MANAGED_CONTENT_ACTIVITIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_SESSIONS_QUERY_KEY(...keyParams),
+      ...MANAGED_CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetEventSessions = async ({
-  eventId,
+var GetManagedChannelContentActivities = async ({
+  channelId,
+  contentId,
   pageParam,
   pageSize,
   orderBy,
@@ -4628,85 +4712,127 @@ var GetEventSessions = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/sessions`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/channels/managed/${channelId}/contents/${contentId}/activities`,
+    {
+      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,
-      (sessionId) => EVENT_SESSION_QUERY_KEY(eventId, sessionId),
+      (activityId) => ACTIVITY_QUERY_KEY(activityId),
       locale
     );
   }
   return data;
 };
-var useGetEventSessions = (eventId = "", params = {}, options = {}) => {
+var useGetManagedChannelContentActivities = (channelId = "", contentId = "", params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_SESSIONS_QUERY_KEY(eventId),
-    (params2) => GetEventSessions({ eventId, ...params2 }),
+    MANAGED_CHANNEL_CONTENT_ACTIVITIES_QUERY_KEY(channelId, contentId),
+    (params2) => GetManagedChannelContentActivities({ channelId, contentId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
+      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventSession.ts
-var EVENT_SESSION_QUERY_KEY = (eventId, sessionId) => [...EVENT_SESSIONS_QUERY_KEY(eventId), sessionId];
-var SET_EVENT_SESSION_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_SESSION_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response
-  );
-};
-var GetEventSession = async ({
-  eventId,
-  sessionId,
+// src/queries/channels/managed/content/useGetManagedChannelContentInterests.ts
+var MANAGED_CHANNEL_CONTENT_INTERESTS_QUERY_KEY = (channelId, contentId) => [
+  ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+  "INTERESTS"
+];
+var GetManagedChannelContentInterests = async ({
+  channelId,
+  contentId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/events/${eventId}/sessions/${sessionId}`
+    `/channels/managed/${channelId}/contents/${contentId}/interests`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
   );
   return data;
 };
-var useGetEventSession = (eventId = "", sessionId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    EVENT_SESSION_QUERY_KEY(eventId, sessionId),
-    (params) => GetEventSession({ eventId, sessionId, ...params }),
+var useGetManagedChannelContentInterests = (channelId, contentId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    MANAGED_CHANNEL_CONTENT_INTERESTS_QUERY_KEY(channelId, contentId),
+    (params2) => GetManagedChannelContentInterests({ channelId, contentId, ...params2 }),
+    params,
     {
       ...options,
-      enabled: !!eventId && !!sessionId && (options?.enabled ?? true)
+      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventSpeakers.ts
-var EVENT_SPEAKERS_QUERY_KEY = (eventId) => [
-  ...EVENT_QUERY_KEY(eventId),
-  "SPEAKERS"
+// src/queries/channels/managed/content/useGetManagedChannelContentGuests.ts
+var MANAGED_CHANNEL_CONTENT_GUESTS_QUERY_KEY = (channelId, contentId) => [
+  ...MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+  "GUESTS"
 ];
-var SET_EVENT_SPEAKERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_SPEAKERS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
+var GetManagedChannelContentGuests = async ({
+  channelId,
+  contentId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/channels/managed/${channelId}/contents/${contentId}/guests`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  return data;
+};
+var useGetManagedChannelContentGuests = (channelId, contentId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    MANAGED_CHANNEL_CONTENT_GUESTS_QUERY_KEY(channelId, contentId),
+    (params2) => GetManagedChannelContentGuests({ channelId, contentId, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!channelId && !!contentId && (options?.enabled ?? true)
+    }
   );
 };
-var GetEventSpeakers = async ({
-  eventId,
+
+// src/queries/channels/managed/collections/useGetManagedChannelCollectionContents.ts
+var MANAGED_CHANNEL_COLLECTION_CONTENTS_QUERY_KEY = (channelId, collectionId) => [
+  ...MANAGED_CHANNEL_COLLECTION_QUERY_KEY(channelId, collectionId),
+  "CONTENTS"
+];
+var GetManagedChannelCollectionContents = async ({
+  channelId,
+  collectionId,
   pageParam,
   pageSize,
   orderBy,
@@ -4716,83 +4842,95 @@ var GetEventSpeakers = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/speakers`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/channels/managed/${channelId}/collections/${collectionId}/contents`,
+    {
+      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,
-      (speakerId) => EVENT_SPEAKER_QUERY_KEY(eventId, speakerId),
+      (contentId) => MANAGED_CHANNEL_CONTENT_QUERY_KEY(channelId, contentId),
+      locale
+    );
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (contentId) => CONTENT_QUERY_KEY(contentId),
       locale
     );
   }
   return data;
 };
-var useGetEventSpeakers = (eventId = "", params = {}, options = {}) => {
+var useGetManagedChannelCollectionContents = (channelId, collectionId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_SPEAKERS_QUERY_KEY(eventId),
-    (params2) => GetEventSpeakers({ eventId, ...params2 }),
+    MANAGED_CHANNEL_COLLECTION_CONTENTS_QUERY_KEY(channelId, collectionId),
+    (params2) => GetManagedChannelCollectionContents({
+      channelId,
+      collectionId,
+      ...params2
+    }),
     params,
-    {
-      ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
-    }
+    options
   );
 };
 
-// src/queries/events/useGetEventSpeaker.ts
-var EVENT_SPEAKER_QUERY_KEY = (eventId, speakerId) => [...EVENT_SPEAKERS_QUERY_KEY(eventId), speakerId];
-var SET_EVENT_SPEAKER_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/channels/managed/useGetManagedChannelSubscribers.ts
+var MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "SUBSCRIBERS"];
+var SET_MANAGED_CHANNEL_SUBSCRIBERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...EVENT_SPEAKER_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
+      ...MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
-    response
+    setFirstPageData(response)
   );
 };
-var GetEventSpeaker = async ({
-  eventId,
-  speakerId,
+var GetManagedChannelSubscribers = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  channelId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/events/${eventId}/speakers/${speakerId}`
+    `/channels/managed/${channelId}/subscribers`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
   );
   return data;
 };
-var useGetEventSpeaker = (eventId = "", speakerId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    EVENT_SPEAKER_QUERY_KEY(eventId, speakerId),
-    (params) => GetEventSpeaker({ eventId, speakerId, ...params }),
+var useGetManagedChannelSubscribers = (channelId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY(channelId),
+    (params2) => GetManagedChannelSubscribers({ ...params2, channelId: channelId || "" }),
+    params,
     {
       ...options,
-      enabled: !!eventId && !!speakerId && (options?.enabled ?? true)
+      enabled: !!channelId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventTickets.ts
-var EVENT_TICKETS_QUERY_KEY = (eventId, ticketId = "") => [...EVENT_QUERY_KEY(eventId), "TICKETS", ticketId];
-var SET_EVENT_TICKETS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_TICKETS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetEventTickets = async ({
-  eventId,
-  ticketId,
+// src/queries/channels/managed/useGetManagedChannelInterests.ts
+var MANAGED_CHANNEL_INTERESTS_QUERY_KEY = (channelId) => [...MANAGED_CHANNEL_QUERY_KEY(channelId), "INTERESTS"];
+var GetManagedChannelInterests = async ({
+  channelId,
   pageParam,
   pageSize,
   orderBy,
@@ -4800,45 +4938,37 @@ var GetEventTickets = async ({
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/tickets`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0,
-      ticketId: ticketId || void 0
+  const { data } = await clientApi.get(
+    `/channels/managed/${channelId}/interests`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
     }
-  });
+  );
   return data;
 };
-var useGetEventTickets = (eventId = "", ticketId = "", params = {}, options = {}) => {
+var useGetManagedChannelInterests = (channelId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_TICKETS_QUERY_KEY(eventId),
-    (params2) => GetEventTickets({ eventId, ticketId, ...params2 }),
+    MANAGED_CHANNEL_INTERESTS_QUERY_KEY(channelId),
+    (params2) => GetManagedChannelInterests({ channelId, ...params2 }),
     params,
     {
       ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
+      enabled: !!channelId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/events/useGetEventSponsors.ts
-var EVENT_SPONSORS_QUERY_KEY = (eventId) => [
-  ...EVENT_QUERY_KEY(eventId),
-  "SPONSORS"
+// src/queries/channels/useGetSubscribedChannels.ts
+var SUBSCRIBED_CHANNELS_QUERY_KEY = () => [
+  ...CHANNELS_QUERY_KEY(),
+  "SUBSCRIBED"
 ];
-var SET_EVENT_SPONSORS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENT_SPONSORS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetEventSponsors = async ({
-  eventId,
+var GetSubscribedChannels = async ({
   pageParam,
   pageSize,
   orderBy,
@@ -4848,7 +4978,7 @@ var GetEventSponsors = async ({
   locale
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/${eventId}/sponsors`, {
+  const { data } = await clientApi.get(`/channels/subscribed`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
@@ -4860,70 +4990,54 @@ var GetEventSponsors = async ({
     CacheIndividualQueries(
       data,
       queryClient,
-      (sponsorId) => ACCOUNT_QUERY_KEY(sponsorId),
+      (channelId) => CHANNEL_QUERY_KEY(channelId),
       locale
     );
   }
   return data;
 };
-var useGetEventSponsors = (eventId = "", params = {}, options = {}) => {
+var useGetSubscribedChannels = (params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENT_TICKETS_QUERY_KEY(eventId),
-    (params2) => GetEventSponsors({ eventId, ...params2 }),
+    SUBSCRIBED_CHANNELS_QUERY_KEY(),
+    (params2) => GetSubscribedChannels({ ...params2 }),
     params,
-    {
-      ...options,
-      enabled: !!eventId && (options?.enabled ?? true)
-    }
+    options
   );
 };
 
-// src/queries/events/useGetFeaturedEvents.ts
-var EVENTS_FEATURED_QUERY_KEY = () => [
-  ...EVENTS_QUERY_KEY(),
-  "FEATURED"
+// src/queries/channels/useGetChannelInterests.ts
+var CHANNEL_INTERESTS_QUERY_KEY = (channelId) => [
+  ...CHANNEL_QUERY_KEY(channelId),
+  "INTERESTS"
 ];
-var SET_EVENTS_FEATURED_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...EVENTS_FEATURED_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetFeaturedEvents = async ({
+var GetChannelInterests = async ({
+  channelId,
   pageParam,
   pageSize,
   orderBy,
-  queryClient,
-  clientApiParams,
-  locale
+  search,
+  clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/events/featured`, {
+  const { data } = await clientApi.get(`/channels/${channelId}/interests`, {
     params: {
       page: pageParam || void 0,
       pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0
+      orderBy: orderBy || void 0,
+      search: search || void 0
     }
   });
-  if (queryClient && data.status === "ok") {
-    CacheIndividualQueries(
-      data,
-      queryClient,
-      (eventId) => EVENT_QUERY_KEY(eventId),
-      locale
-    );
-  }
   return data;
 };
-var useGetFeaturedEvents = (params = {}, options = {}) => {
+var useGetChannelInterests = (channelId, params = {}, options = {}) => {
   return useConnectedInfiniteQuery(
-    EVENTS_FEATURED_QUERY_KEY(),
-    (params2) => GetFeaturedEvents({ ...params2 }),
+    CHANNEL_INTERESTS_QUERY_KEY(channelId),
+    (params2) => GetChannelInterests({ channelId, ...params2 }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!channelId && (options?.enabled ?? true)
+    }
   );
 };
 
@@ -6762,6 +6876,42 @@ var useGetSelfTransfer = (transferId = "", options = {}) => {
   );
 };
 
+// src/queries/self/useGetSelfGroupActivities.ts
+var SELF_GROUP_ACTIVITIES_QUERY_KEY = () => [
+  ...SELF_QUERY_KEY(),
+  "GROUP_ACTIVITIES"
+];
+var GetSelfGroupActivities = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/self/groups/activities`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetSelfGroupActivities = (params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    SELF_GROUP_ACTIVITIES_QUERY_KEY(),
+    (params2) => GetSelfGroupActivities({ ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!authenticated && (options?.enabled ?? true)
+    }
+  );
+};
+
 // src/queries/series/useGetSeriesList.ts
 var SERIES_LIST_QUERY_KEY = () => ["SERIES"];
 var SET_SERIES_LIST_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
@@ -10324,6 +10474,9 @@ var AcceptGroupInvitation = async ({
     `/groups/${groupId}/invitations/accept`
   );
   if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: GROUPS_INVITED_QUERY_KEY()
+    });
     queryClient.invalidateQueries({
       queryKey: SELF_NOTIFICATIONS_QUERY_KEY("")
     });
@@ -10386,6 +10539,9 @@ var CancelGroupRequest = async ({
       "groups",
       groupId
     );
+    queryClient.invalidateQueries({
+      queryKey: GROUPS_REQUESTED_QUERY_KEY()
+    });
   }
   return data;
 };
@@ -10792,6 +10948,9 @@ var RejectGroupInvitation = async ({
     `/groups/${groupId}/invitations/reject`
   );
   if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: GROUPS_INVITED_QUERY_KEY()
+    });
     queryClient.invalidateQueries({
       queryKey: SELF_NOTIFICATIONS_QUERY_KEY("")
     });
@@ -11770,12 +11929,14 @@ var useAddThreadMessageReply = (options = {}) => {
   ACCOUNT_FOLLOWERS_QUERY_KEY,
   ACCOUNT_FOLLOWINGS_QUERY_KEY,
   ACCOUNT_GROUPS_QUERY_KEY,
+  ACCOUNT_MEDIA_QUERY_KEY,
   ACCOUNT_QUERY_KEY,
   ACTIVITIES_QUERY_KEY,
   ACTIVITY_COMMENTS_QUERY_KEY,
   ACTIVITY_QUERY_KEY,
   ADD_SELF_RELATIONSHIP,
   ADVERTISEMENT_QUERY_KEY,
+  ALL_GROUP_EVENTS,
   AcceptGroupInvitation,
   AcceptGroupRequest,
   AcceptTransfer,
@@ -11910,11 +12071,13 @@ var useAddThreadMessageReply = (options = {}) => {
   GetAccountFollowers,
   GetAccountFollowings,
   GetAccountGroups,
+  GetAccountMedia,
   GetAccounts,
   GetActivities,
   GetActivity,
   GetActivityComments,
   GetAdvertisement,
+  GetAllGroupEvents,
   GetBaseInfiniteQueryKeys,
   GetBaseSingleQueryKeys,
   GetBenefits,
@@ -12028,6 +12191,7 @@ var useAddThreadMessageReply = (options = {}) => {
   GetSelfEventTicketCouponIntent,
   GetSelfEvents,
   GetSelfFeed,
+  GetSelfGroupActivities,
   GetSelfGroupMembership,
   GetSelfGroupMemberships,
   GetSelfInterests,
@@ -12158,6 +12322,7 @@ var useAddThreadMessageReply = (options = {}) => {
   SELF_EVENT_SESSIONS_QUERY_KEY,
   SELF_EVENT_TICKET_COUPON_INTENT_QUERY_KEY,
   SELF_FEED_QUERY_KEY,
+  SELF_GROUP_ACTIVITIES_QUERY_KEY,
   SELF_GROUP_MEMBERSHIPS_QUERY_KEY,
   SELF_GROUP_MEMBERSHIP_QUERY_KEY,
   SELF_INTERESTS_QUERY_KEY,
@@ -12184,11 +12349,13 @@ var useAddThreadMessageReply = (options = {}) => {
   SET_ACCOUNT_FOLLOWERS_QUERY_DATA,
   SET_ACCOUNT_FOLLOWINGS_QUERY_DATA,
   SET_ACCOUNT_GROUPS_QUERY_DATA,
+  SET_ACCOUNT_MEDIA_QUERY_DATA,
   SET_ACCOUNT_QUERY_DATA,
   SET_ACTIVITIES_QUERY_DATA,
   SET_ACTIVITY_COMMENTS_QUERY_DATA,
   SET_ACTIVITY_QUERY_DATA,
   SET_ADVERTISEMENT_QUERY_DATA,
+  SET_ALL_GROUP_EVENTS_QUERY_DATA,
   SET_BENEFITS_QUERY_DATA,
   SET_CHANNELS_QUERY_DATA,
   SET_CHANNEL_COLLECTIONS_QUERY_DATA,
@@ -12452,11 +12619,13 @@ var useAddThreadMessageReply = (options = {}) => {
   useGetAccountFollowers,
   useGetAccountFollowings,
   useGetAccountGroups,
+  useGetAccountMedia,
   useGetAccounts,
   useGetActivities,
   useGetActivity,
   useGetActivityComments,
   useGetAdvertisement,
+  useGetAllGroupEvents,
   useGetBenefits,
   useGetChannel,
   useGetChannelCollection,
@@ -12566,6 +12735,7 @@ var useAddThreadMessageReply = (options = {}) => {
   useGetSelfEventTicketCouponIntent,
   useGetSelfEvents,
   useGetSelfFeed,
+  useGetSelfGroupActivities,
   useGetSelfGroupMembership,
   useGetSelfGroupMemberships,
   useGetSelfInterests,