@connectedxm/client 0.5.39 → 1.0.2

package/dist/index.js

@@ -58,6 +58,9 @@ __export(src_exports, {
   AddSelfEventRegistrationPurchaseAddOn: () => AddSelfEventRegistrationPurchaseAddOn,
   AddSelfEventSession: () => AddSelfEventSession,
   AddSelfInterests: () => AddSelfInterests,
+  AddThreadMember: () => AddThreadMember,
+  AddThreadMessageReaction: () => AddThreadMessageReaction,
+  AddThreadMessageReply: () => AddThreadMessageReply,
   AdvertisementType: () => AdvertisementType,
   AppendInfiniteQuery: () => AppendInfiniteQuery,
   BENEFITS_QUERY_KEY: () => BENEFITS_QUERY_KEY,
@@ -106,6 +109,8 @@ __export(src_exports, {
   CreateSubscription: () => CreateSubscription,
   CreateSupportTicket: () => CreateSupportTicket,
   CreateTeamAccount: () => CreateTeamAccount,
+  CreateThread: () => CreateThread,
+  CreateThreadMessage: () => CreateThreadMessage,
   Currency: () => Currency,
   DeactivateGroup: () => DeactivateGroup,
   DefaultAuthAction: () => DefaultAuthAction,
@@ -125,6 +130,8 @@ __export(src_exports, {
   DeleteSelfChatChannel: () => DeleteSelfChatChannel,
   DeleteSelfChatChannelMessage: () => DeleteSelfChatChannelMessage,
   DeleteSelfPushDevice: () => DeleteSelfPushDevice,
+  DeleteThreadMember: () => DeleteThreadMember,
+  DeleteThreadMessage: () => DeleteThreadMessage,
   DemoteGroupModerator: () => DemoteGroupModerator,
   EVENTS_FEATURED_QUERY_KEY: () => EVENTS_FEATURED_QUERY_KEY,
   EVENTS_QUERY_KEY: () => EVENTS_QUERY_KEY,
@@ -307,6 +314,17 @@ __export(src_exports, {
   GetSeriesList: () => GetSeriesList,
   GetSubscribedChannels: () => GetSubscribedChannels,
   GetSubscribedContents: () => GetSubscribedContents,
+  GetThread: () => GetThread,
+  GetThreadEvent: () => GetThreadEvent,
+  GetThreadEvents: () => GetThreadEvents,
+  GetThreadGroup: () => GetThreadGroup,
+  GetThreadGroups: () => GetThreadGroups,
+  GetThreadMember: () => GetThreadMember,
+  GetThreadMembers: () => GetThreadMembers,
+  GetThreadMessage: () => GetThreadMessage,
+  GetThreadMessageReplies: () => GetThreadMessageReplies,
+  GetThreadMessages: () => GetThreadMessages,
+  GetThreads: () => GetThreads,
   GroupAccess: () => GroupAccess,
   GroupInvitationStatus: () => GroupInvitationStatus,
   GroupMembershipRole: () => GroupMembershipRole,
@@ -348,6 +366,7 @@ __export(src_exports, {
   MANAGED_CHANNEL_INTERESTS_QUERY_KEY: () => MANAGED_CHANNEL_INTERESTS_QUERY_KEY,
   MANAGED_CHANNEL_QUERY_KEY: () => MANAGED_CHANNEL_QUERY_KEY,
   MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY: () => MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY,
+  MarkUnread: () => MarkUnread,
   MergeInfinitePages: () => MergeInfinitePages,
   NotificationType: () => NotificationType,
   ORGANIZATION_EXPLORE_QUERY_KEY: () => ORGANIZATION_EXPLORE_QUERY_KEY,
@@ -379,6 +398,7 @@ __export(src_exports, {
   RemoveSelfEventRegistrationPurchase: () => RemoveSelfEventRegistrationPurchase,
   RemoveSelfEventRegistrationPurchaseAddOn: () => RemoveSelfEventRegistrationPurchaseAddOn,
   RemoveSelfEventSession: () => RemoveSelfEventSession,
+  RemoveThreadMessageReaction: () => RemoveThreadMessageReaction,
   ReshareActivity: () => ReshareActivity,
   SELF_ACTIVITIES_QUERY_KEY: () => SELF_ACTIVITIES_QUERY_KEY,
   SELF_ANNOUNCEMENT_QUERY_KEY: () => SELF_ANNOUNCEMENT_QUERY_KEY,
@@ -511,6 +531,17 @@ __export(src_exports, {
   SET_SERIES_EVENTS_QUERY_DATA: () => SET_SERIES_EVENTS_QUERY_DATA,
   SET_SERIES_LIST_QUERY_DATA: () => SET_SERIES_LIST_QUERY_DATA,
   SET_SERIES_QUERY_DATA: () => SET_SERIES_QUERY_DATA,
+  SET_THREADS_QUERY_DATA: () => SET_THREADS_QUERY_DATA,
+  SET_THREAD_EVENTS_QUERY_DATA: () => SET_THREAD_EVENTS_QUERY_DATA,
+  SET_THREAD_EVENT_QUERY_DATA: () => SET_THREAD_EVENT_QUERY_DATA,
+  SET_THREAD_GROUPS_QUERY_DATA: () => SET_THREAD_GROUPS_QUERY_DATA,
+  SET_THREAD_GROUP_QUERY_DATA: () => SET_THREAD_GROUP_QUERY_DATA,
+  SET_THREAD_MEMBERS_QUERY_DATA: () => SET_THREAD_MEMBERS_QUERY_DATA,
+  SET_THREAD_MEMBER_QUERY_DATA: () => SET_THREAD_MEMBER_QUERY_DATA,
+  SET_THREAD_MESSAGES_QUERY_DATA: () => SET_THREAD_MESSAGES_QUERY_DATA,
+  SET_THREAD_MESSAGE_QUERY_DATA: () => SET_THREAD_MESSAGE_QUERY_DATA,
+  SET_THREAD_MESSAGE_REPLIES_QUERY_DATA: () => SET_THREAD_MESSAGE_REPLIES_QUERY_DATA,
+  SET_THREAD_QUERY_DATA: () => SET_THREAD_QUERY_DATA,
   SUBSCRIBED_CHANNELS_QUERY_KEY: () => SUBSCRIBED_CHANNELS_QUERY_KEY,
   SUBSCRIBED_CONTENTS_QUERY_KEY: () => SUBSCRIBED_CONTENTS_QUERY_KEY,
   SelectSelfEventRegistrationCoupon: () => SelectSelfEventRegistrationCoupon,
@@ -522,6 +553,21 @@ __export(src_exports, {
   SubscriptionStatus: () => SubscriptionStatus,
   SupportTicketType: () => SupportTicketType,
   SupportedLocale: () => SupportedLocale,
+  THREADS_QUERY_KEY: () => THREADS_QUERY_KEY,
+  THREAD_EVENTS_QUERY_KEY: () => THREAD_EVENTS_QUERY_KEY,
+  THREAD_EVENT_QUERY_KEY: () => THREAD_EVENT_QUERY_KEY,
+  THREAD_GROUPS_QUERY_KEY: () => THREAD_GROUPS_QUERY_KEY,
+  THREAD_GROUP_QUERY_KEY: () => THREAD_GROUP_QUERY_KEY,
+  THREAD_MEMBERS_QUERY_KEY: () => THREAD_MEMBERS_QUERY_KEY,
+  THREAD_MEMBER_QUERY_KEY: () => THREAD_MEMBER_QUERY_KEY,
+  THREAD_MESSAGES_QUERY_KEY: () => THREAD_MESSAGES_QUERY_KEY,
+  THREAD_MESSAGE_QUERY_KEY: () => THREAD_MESSAGE_QUERY_KEY,
+  THREAD_MESSAGE_REPLIES_QUERY_KEY: () => THREAD_MESSAGE_REPLIES_QUERY_KEY,
+  THREAD_QUERY_KEY: () => THREAD_QUERY_KEY,
+  ThreadAccessLevel: () => ThreadAccessLevel,
+  ThreadInvitationStatus: () => ThreadInvitationStatus,
+  ThreadMemberRole: () => ThreadMemberRole,
+  ThreadMessageType: () => ThreadMessageType,
   TicketEventAccessLevel: () => TicketEventAccessLevel,
   TicketVisibility: () => TicketVisibility,
   TransferPurchase: () => TransferPurchase,
@@ -549,6 +595,9 @@ __export(src_exports, {
   UpdateSelfNotificationPreferences: () => UpdateSelfNotificationPreferences,
   UpdateSelfPushDevice: () => UpdateSelfPushDevice,
   UpdateSubscriptionPaymentMethod: () => UpdateSubscriptionPaymentMethod,
+  UpdateThread: () => UpdateThread,
+  UpdateThreadMember: () => UpdateThreadMember,
+  UpdateThreadMessage: () => UpdateThreadMessage,
   UploadChannelContentImage: () => UploadChannelContentImage,
   UploadFile: () => UploadFile,
   isListing: () => isListing,
@@ -606,6 +655,9 @@ __export(src_exports, {
   useAddSelfEventRegistrationPurchaseAddOn: () => useAddSelfEventRegistrationPurchaseAddOn,
   useAddSelfEventSession: () => useAddSelfEventSession,
   useAddSelfInterests: () => useAddSelfInterests,
+  useAddThreadMember: () => useAddThreadMember,
+  useAddThreadMessageReaction: () => useAddThreadMessageReaction,
+  useAddThreadMessageReply: () => useAddThreadMessageReply,
   useCancelGroupInvitation: () => useCancelGroupInvitation,
   useCancelGroupRequest: () => useCancelGroupRequest,
   useCancelSubscription: () => useCancelSubscription,
@@ -637,6 +689,8 @@ __export(src_exports, {
   useCreateSubscription: () => useCreateSubscription,
   useCreateSupportTicket: () => useCreateSupportTicket,
   useCreateTeamAccount: () => useCreateTeamAccount,
+  useCreateThread: () => useCreateThread,
+  useCreateThreadMessage: () => useCreateThreadMessage,
   useDeactivateGroup: () => useDeactivateGroup,
   useDeleteActivity: () => useDeleteActivity,
   useDeleteChannel: () => useDeleteChannel,
@@ -654,6 +708,8 @@ __export(src_exports, {
   useDeleteSelfChatChannel: () => useDeleteSelfChatChannel,
   useDeleteSelfChatChannelMessage: () => useDeleteSelfChatChannelMessage,
   useDeleteSelfPushDevice: () => useDeleteSelfPushDevice,
+  useDeleteThreadMember: () => useDeleteThreadMember,
+  useDeleteThreadMessage: () => useDeleteThreadMessage,
   useDemoteGroupModerator: () => useDemoteGroupModerator,
   useFollowAccount: () => useFollowAccount,
   useGetAccount: () => useGetAccount,
@@ -796,6 +852,17 @@ __export(src_exports, {
   useGetSeriesList: () => useGetSeriesList,
   useGetSubscribedChannels: () => useGetSubscribedChannels,
   useGetSubscribedContents: () => useGetSubscribedContents,
+  useGetThread: () => useGetThread,
+  useGetThreadEvent: () => useGetThreadEvent,
+  useGetThreadEvents: () => useGetThreadEvents,
+  useGetThreadGroup: () => useGetThreadGroup,
+  useGetThreadGroups: () => useGetThreadGroups,
+  useGetThreadMember: () => useGetThreadMember,
+  useGetThreadMembers: () => useGetThreadMembers,
+  useGetThreadMessage: () => useGetThreadMessage,
+  useGetThreadMessageReplies: () => useGetThreadMessageReplies,
+  useGetThreadMessages: () => useGetThreadMessages,
+  useGetThreads: () => useGetThreads,
   useGroupStatus: () => useGroupStatus,
   useIsAccountFollowing: () => useIsAccountFollowing,
   useIsChannelSubscribed: () => useIsChannelSubscribed,
@@ -805,6 +872,7 @@ __export(src_exports, {
   useLeaveSelfChatChannel: () => useLeaveSelfChatChannel,
   useLikeActivity: () => useLikeActivity,
   useLikeContent: () => useLikeContent,
+  useMarkUnread: () => useMarkUnread,
   usePromoteGroupMember: () => usePromoteGroupMember,
   useReinviteGroupInvitation: () => useReinviteGroupInvitation,
   useRejectGroupInvitation: () => useRejectGroupInvitation,
@@ -821,6 +889,7 @@ __export(src_exports, {
   useRemoveSelfEventRegistrationPurchase: () => useRemoveSelfEventRegistrationPurchase,
   useRemoveSelfEventRegistrationPurchaseAddOn: () => useRemoveSelfEventRegistrationPurchaseAddOn,
   useRemoveSelfEventSession: () => useRemoveSelfEventSession,
+  useRemoveThreadMessageReaction: () => useRemoveThreadMessageReaction,
   useReshareActivity: () => useReshareActivity,
   useSelectSelfEventRegistrationCoupon: () => useSelectSelfEventRegistrationCoupon,
   useSelectSelfEventRegistrationPurchaseReservation: () => useSelectSelfEventRegistrationPurchaseReservation,
@@ -853,6 +922,9 @@ __export(src_exports, {
   useUpdateSelfNotificationPreferences: () => useUpdateSelfNotificationPreferences,
   useUpdateSelfPushDevice: () => useUpdateSelfPushDevice,
   useUpdateSubscriptionPaymentMethod: () => useUpdateSubscriptionPaymentMethod,
+  useUpdateThread: () => useUpdateThread,
+  useUpdateThreadMember: () => useUpdateThreadMember,
+  useUpdateThreadMessage: () => useUpdateThreadMessage,
   useUploadChannelContentImage: () => useUploadChannelContentImage,
   useUploadFile: () => useUploadFile
 });
@@ -1037,7 +1109,7 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
   return EventType2;
 })(EventType || {});
 var isTypeEvent = (event) => {
-  return event._count !== void 0;
+  return event.sessions !== void 0;
 };
 var RegistrationQuestionType = /* @__PURE__ */ ((RegistrationQuestionType2) => {
   RegistrationQuestionType2["text"] = "text";
@@ -1237,6 +1309,27 @@ var EventEmailType = /* @__PURE__ */ ((EventEmailType2) => {
   EventEmailType2["reminder"] = "reminder";
   return EventEmailType2;
 })(EventEmailType || {});
+var ThreadInvitationStatus = /* @__PURE__ */ ((ThreadInvitationStatus2) => {
+  ThreadInvitationStatus2["invited"] = "invited";
+  ThreadInvitationStatus2["rejected"] = "rejected";
+  return ThreadInvitationStatus2;
+})(ThreadInvitationStatus || {});
+var ThreadAccessLevel = /* @__PURE__ */ ((ThreadAccessLevel2) => {
+  ThreadAccessLevel2["public"] = "public";
+  ThreadAccessLevel2["private"] = "private";
+  return ThreadAccessLevel2;
+})(ThreadAccessLevel || {});
+var ThreadMemberRole = /* @__PURE__ */ ((ThreadMemberRole2) => {
+  ThreadMemberRole2["member"] = "member";
+  ThreadMemberRole2["moderator"] = "moderator";
+  return ThreadMemberRole2;
+})(ThreadMemberRole || {});
+var ThreadMessageType = /* @__PURE__ */ ((ThreadMessageType2) => {
+  ThreadMessageType2["user"] = "user";
+  ThreadMessageType2["bot"] = "bot";
+  ThreadMessageType2["system"] = "system";
+  return ThreadMessageType2;
+})(ThreadMessageType || {});
 var SupportedLocale = /* @__PURE__ */ ((SupportedLocale2) => {
   SupportedLocale2["en"] = "en";
   SupportedLocale2["es"] = "es";
@@ -7520,6 +7613,472 @@ var useGetInterests = (params = {}, options = {}) => {
   );
 };
 
+// src/queries/threads/useGetThread.ts
+var THREAD_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), threadId, accountId];
+var SET_THREAD_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [...THREAD_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
+    response,
+    options
+  );
+};
+var GetThread = async ({
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}`);
+  return data;
+};
+var useGetThread = (threadId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_QUERY_KEY(threadId),
+    (params) => GetThread({ threadId, ...params }),
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreads.ts
+var THREADS_QUERY_KEY = (access, groupId) => {
+  const keys = ["THREADS"];
+  if (access) keys.push(access);
+  if (groupId) keys.push(groupId);
+  return keys;
+};
+var SET_THREADS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREADS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreads = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  queryClient,
+  access,
+  groupId,
+  eventId,
+  search,
+  locale,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      access: access || void 0,
+      groupId: groupId || void 0,
+      eventId: eventId || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (threadId) => THREAD_QUERY_KEY(threadId),
+      locale
+    );
+  }
+  return data;
+};
+var useGetThreads = (access = "public", groupId, eventId, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREADS_QUERY_KEY(access, groupId),
+    (params2) => GetThreads({ access, groupId, eventId, ...params2 }),
+    params,
+    {
+      ...options
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMember.ts
+var THREAD_MEMBER_QUERY_KEY = (threadId, accountId) => {
+  return [...THREAD_QUERY_KEY(threadId, accountId)];
+};
+var SET_THREAD_MEMBER_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_MEMBER_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadMember = async ({
+  threadId,
+  accountId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/members/${accountId}`
+  );
+  return data;
+};
+var useGetThreadMember = (threadId, accountId, options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MEMBER_QUERY_KEY(threadId, accountId),
+    (params) => GetThreadMember({ threadId, accountId, ...params }),
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMembers.ts
+var THREAD_MEMBERS_QUERY_KEY = (threadId, role) => {
+  const keys = [...THREAD_QUERY_KEY(threadId), "MEMBERS"];
+  if (role) {
+    keys.push(role);
+  }
+  return keys;
+};
+var SET_THREAD_MEMBERS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MEMBERS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMembers = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  role,
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}/members`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      role: role || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadMembers = (threadId = "", role, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    THREAD_MEMBERS_QUERY_KEY(threadId, role),
+    (params2) => GetThreadMembers({ threadId, role, ...params2 }),
+    params,
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessage.ts
+var THREAD_MESSAGE_QUERY_KEY = (threadId, messageId) => {
+  return [...THREAD_MESSAGES_QUERY_KEY(threadId, messageId)];
+};
+var SET_THREAD_MESSAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGE_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadMessage = async ({
+  threadId,
+  messageId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/messages/${messageId}`
+  );
+  return data;
+};
+var useGetThreadMessage = (threadId, messageId, options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+    (params) => GetThreadMessage({ threadId, messageId, ...params }),
+    {
+      staleTime: Infinity,
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessages.ts
+var THREAD_MESSAGES_QUERY_KEY = (threadId, messageId) => [...THREAD_QUERY_KEY(threadId, messageId), "MESSAGES"];
+var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMessages = async ({
+  threadId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}/messages`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0
+    }
+  });
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (messageId) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+      locale
+    );
+    SET_THREAD_QUERY_DATA(queryClient, [threadId], (old) => ({
+      ...old,
+      data: {
+        ...old.data,
+        read: true
+      }
+    }));
+  }
+  return data;
+};
+var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGES_QUERY_KEY(threadId),
+    (params2) => GetThreadMessages({ ...params2, threadId }),
+    params,
+    {
+      refetchInterval: 5 * 1e3,
+      ...options,
+      enabled: !!authenticated && !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadMessageReplies.ts
+var THREAD_MESSAGE_REPLIES_QUERY_KEY = (threadId, messageId) => [...THREAD_MESSAGE_QUERY_KEY(threadId, messageId), "REPLIES"];
+var SET_THREAD_MESSAGE_REPLIES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+  client.setQueryData(
+    [
+      ...THREAD_MESSAGE_REPLIES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
+  );
+};
+var GetThreadMessageReplies = async ({
+  threadId,
+  messageId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  queryClient,
+  clientApiParams,
+  locale
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(
+    `/threads/${threadId}/messages/${messageId}/replies`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    CacheIndividualQueries(
+      data,
+      queryClient,
+      (messageId2) => THREAD_MESSAGE_QUERY_KEY(threadId, messageId2),
+      locale
+    );
+  }
+  return data;
+};
+var useGetThreadMessageReplies = (threadId = "", messageId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnectedXM();
+  return useConnectedInfiniteQuery(
+    THREAD_MESSAGE_REPLIES_QUERY_KEY(threadId, messageId),
+    (params2) => GetThreadMessageReplies({ ...params2, threadId, messageId }),
+    params,
+    {
+      refetchInterval: 5 * 1e3,
+      ...options,
+      enabled: !!authenticated && !!threadId && !!messageId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadGroups.ts
+var THREAD_GROUPS_QUERY_KEY = (accountId) => [
+  ...THREADS_QUERY_KEY(),
+  "groups",
+  accountId
+];
+var SET_THREAD_GROUPS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_GROUPS_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadGroups = async ({
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/groups`);
+  return data;
+};
+var useGetThreadGroups = (options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_GROUPS_QUERY_KEY(),
+    (params) => GetThreadGroups({ ...params }),
+    {
+      ...options,
+      enabled: options?.enabled ?? true
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadGroup.ts
+var THREAD_GROUP_QUERY_KEY = (groupId) => [
+  ...THREADS_QUERY_KEY(),
+  "group",
+  groupId
+];
+var SET_THREAD_GROUP_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_GROUP_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadGroup = async ({
+  groupId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/groups/${groupId}`);
+  return data;
+};
+var useGetThreadGroup = (groupId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_GROUP_QUERY_KEY(groupId),
+    (params) => GetThreadGroup({ groupId, ...params }),
+    {
+      ...options,
+      enabled: !!groupId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadEvents.ts
+var THREAD_EVENTS_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), "events", threadId, accountId];
+var SET_THREAD_EVENTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_EVENTS_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadEvents = async ({
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}/events`);
+  return data;
+};
+var useGetThreadEvents = (threadId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_EVENTS_QUERY_KEY(threadId),
+    (params) => GetThreadEvents({ threadId, ...params }),
+    {
+      ...options,
+      enabled: !!threadId && (options?.enabled ?? true)
+    }
+  );
+};
+
+// src/queries/threads/useGetThreadEvent.ts
+var THREAD_EVENT_QUERY_KEY = (eventId) => [
+  ...THREADS_QUERY_KEY(),
+  "event",
+  eventId
+];
+var SET_THREAD_EVENT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [
+      ...THREAD_EVENT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
+    ],
+    response,
+    options
+  );
+};
+var GetThreadEvent = async ({
+  eventId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/events/${eventId}`);
+  return data;
+};
+var useGetThreadEvent = (eventId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_EVENT_QUERY_KEY(eventId),
+    (params) => GetThreadEvent({ eventId, ...params }),
+    {
+      ...options,
+      enabled: !!eventId && (options?.enabled ?? true)
+    }
+  );
+};
+
 // src/mutations/useConnectedMutation.ts
 var import_react_query4 = require("@tanstack/react-query");
 var useConnectedMutation = (mutation, options) => {
@@ -10860,6 +11419,349 @@ var UploadFile = async ({
 var useUploadFile = (options = {}) => {
   return useConnectedMutation_default(UploadFile, options);
 };
+
+// src/mutations/threads/useCreateThread.ts
+var CreateThread = async ({
+  thread,
+  accountIds,
+  firstMessage,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads`,
+    {
+      thread,
+      accountIds,
+      firstMessage
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_THREAD_QUERY_DATA(queryClient, [data.data.id], data);
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useCreateThread = (options = {}) => {
+  return useConnectedMutation_default(CreateThread, options);
+};
+
+// src/mutations/threads/useAddThreadMember.ts
+var AddThreadMember = async ({
+  threadId,
+  accountId,
+  role,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/members/${accountId}`,
+    {
+      role
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useAddThreadMember = (options = {}) => {
+  return useConnectedMutation_default(AddThreadMember, options);
+};
+
+// src/mutations/threads/useUpdateThread.ts
+var UpdateThread = async ({
+  threadId,
+  thread,
+  imageDataUri,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.patch(
+    `/threads/${threadId}`,
+    {
+      thread,
+      imageDataUri
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_THREAD_QUERY_DATA(queryClient, [data.data.id], data);
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+  }
+  return data;
+};
+var useUpdateThread = (options = {}) => {
+  return useConnectedMutation_default(UpdateThread, options);
+};
+
+// src/mutations/threads/useUpdateThreadMember.ts
+var UpdateThreadMember = async ({
+  threadId,
+  accountId,
+  role,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.patch(
+    `/threads/${threadId}/members/${accountId}`,
+    {
+      role
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useUpdateThreadMember = (options = {}) => {
+  return useConnectedMutation_default(UpdateThreadMember, options);
+};
+
+// src/mutations/threads/useDeleteThreadMember.ts
+var DeleteThreadMember = async ({
+  threadId,
+  accountId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/members/${accountId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MEMBERS_QUERY_KEY(threadId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREADS_QUERY_KEY()
+    });
+    queryClient.invalidateQueries({
+      queryKey: THREAD_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useDeleteThreadMember = (options = {}) => {
+  return useConnectedMutation_default(DeleteThreadMember, options);
+};
+
+// src/mutations/threads/useMarkUnread.ts
+var MarkUnread = async ({
+  threadId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/unread`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.setQueryData(
+      [...THREAD_QUERY_KEY(threadId), clientApiParams.locale],
+      (oldData) => {
+        if (!oldData) {
+          return oldData;
+        }
+        return {
+          ...oldData,
+          read: false
+        };
+      }
+    );
+  }
+  return data;
+};
+var useMarkUnread = (options = {}) => {
+  return useConnectedMutation_default(MarkUnread, options);
+};
+
+// src/mutations/threads/useCreateThreadMessage.ts
+var CreateThreadMessage = async ({
+  threadId,
+  body,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/messages`,
+    { body }
+  );
+  if (queryClient && data.status === "ok") {
+    AppendInfiniteQuery(
+      queryClient,
+      [
+        ...THREAD_MESSAGES_QUERY_KEY(threadId),
+        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+      ],
+      data.data
+    );
+  }
+  return data;
+};
+var useCreateThreadMessage = (options = {}) => {
+  return useConnectedMutation_default(CreateThreadMessage, options);
+};
+
+// src/mutations/threads/useUpdateThreadMessage.ts
+var UpdateThreadMessage = async ({
+  threadId,
+  messageId,
+  body,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.put(
+    `/threads/${threadId}/messages/${messageId}`,
+    { body }
+  );
+  if (queryClient && data.status === "ok") {
+    SET_THREAD_MESSAGE_QUERY_DATA(queryClient, [threadId, messageId], data, [
+      clientApiParams.locale
+    ]);
+  }
+  return data;
+};
+var useUpdateThreadMessage = (options = {}) => {
+  return useConnectedMutation_default(UpdateThreadMessage, options);
+};
+
+// src/mutations/threads/useDeleteThreadMessage.ts
+var import_immer6 = require("immer");
+var DeleteThreadMessage = async ({
+  threadId,
+  messageId,
+  body,
+  moderator,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/messages/${messageId}`,
+    {
+      data: { body, moderator }
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.setQueryData(
+      [
+        ...THREAD_MESSAGES_QUERY_KEY(threadId),
+        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+      ],
+      (oldData) => {
+        if (!oldData) return oldData;
+        return (0, import_immer6.produce)(oldData, (draft) => {
+          draft.pages.forEach((page) => {
+            const index = page.data.findIndex((m) => m.id === messageId);
+            if (index !== -1) {
+              page.data.splice(index, 1);
+            }
+          });
+        });
+      }
+    );
+  }
+  return data;
+};
+var useDeleteThreadMessage = (options = {}) => {
+  return useConnectedMutation_default(DeleteThreadMessage, options);
+};
+
+// src/mutations/threads/useAddThreadMessageReaction.ts
+var AddThreadMessageReaction = async ({
+  threadId,
+  messageId,
+  emojiName,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(`/threads/${threadId}/messages/${messageId}/reactions`, { emojiName });
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGES_QUERY_KEY(threadId)
+    });
+  }
+  return data;
+};
+var useAddThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation_default(AddThreadMessageReaction, options);
+};
+
+// src/mutations/threads/useRemoveThreadMessageReaction.ts
+var RemoveThreadMessageReaction = async ({
+  threadId,
+  messageId,
+  emojiName,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/threads/${threadId}/messages/${messageId}/reactions`,
+    {
+      data: { emojiName }
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: THREAD_MESSAGE_QUERY_KEY(threadId, messageId)
+    });
+  }
+  return data;
+};
+var useRemoveThreadMessageReaction = (options = {}) => {
+  return useConnectedMutation_default(RemoveThreadMessageReaction, options);
+};
+
+// src/mutations/threads/useAddThreadMessageReply.ts
+var AddThreadMessageReply = async ({
+  threadId,
+  messageId,
+  body,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/threads/${threadId}/messages/${messageId}/replies`,
+    { body }
+  );
+  if (queryClient && data.status === "ok") {
+    AppendInfiniteQuery(
+      queryClient,
+      [
+        ...THREAD_MESSAGE_REPLIES_QUERY_KEY(threadId, messageId),
+        ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+      ],
+      data.data
+    );
+  }
+  return data;
+};
+var useAddThreadMessageReply = (options = {}) => {
+  return useConnectedMutation_default(AddThreadMessageReply, options);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNTS_QUERY_KEY,
@@ -10890,6 +11792,9 @@ var useUploadFile = (options = {}) => {
   AddSelfEventRegistrationPurchaseAddOn,
   AddSelfEventSession,
   AddSelfInterests,
+  AddThreadMember,
+  AddThreadMessageReaction,
+  AddThreadMessageReply,
   AdvertisementType,
   AppendInfiniteQuery,
   BENEFITS_QUERY_KEY,
@@ -10938,6 +11843,8 @@ var useUploadFile = (options = {}) => {
   CreateSubscription,
   CreateSupportTicket,
   CreateTeamAccount,
+  CreateThread,
+  CreateThreadMessage,
   Currency,
   DeactivateGroup,
   DefaultAuthAction,
@@ -10957,6 +11864,8 @@ var useUploadFile = (options = {}) => {
   DeleteSelfChatChannel,
   DeleteSelfChatChannelMessage,
   DeleteSelfPushDevice,
+  DeleteThreadMember,
+  DeleteThreadMessage,
   DemoteGroupModerator,
   EVENTS_FEATURED_QUERY_KEY,
   EVENTS_QUERY_KEY,
@@ -11139,6 +12048,17 @@ var useUploadFile = (options = {}) => {
   GetSeriesList,
   GetSubscribedChannels,
   GetSubscribedContents,
+  GetThread,
+  GetThreadEvent,
+  GetThreadEvents,
+  GetThreadGroup,
+  GetThreadGroups,
+  GetThreadMember,
+  GetThreadMembers,
+  GetThreadMessage,
+  GetThreadMessageReplies,
+  GetThreadMessages,
+  GetThreads,
   GroupAccess,
   GroupInvitationStatus,
   GroupMembershipRole,
@@ -11180,6 +12100,7 @@ var useUploadFile = (options = {}) => {
   MANAGED_CHANNEL_INTERESTS_QUERY_KEY,
   MANAGED_CHANNEL_QUERY_KEY,
   MANAGED_CHANNEL_SUBSCRIBERS_QUERY_KEY,
+  MarkUnread,
   MergeInfinitePages,
   NotificationType,
   ORGANIZATION_EXPLORE_QUERY_KEY,
@@ -11211,6 +12132,7 @@ var useUploadFile = (options = {}) => {
   RemoveSelfEventRegistrationPurchase,
   RemoveSelfEventRegistrationPurchaseAddOn,
   RemoveSelfEventSession,
+  RemoveThreadMessageReaction,
   ReshareActivity,
   SELF_ACTIVITIES_QUERY_KEY,
   SELF_ANNOUNCEMENT_QUERY_KEY,
@@ -11343,6 +12265,17 @@ var useUploadFile = (options = {}) => {
   SET_SERIES_EVENTS_QUERY_DATA,
   SET_SERIES_LIST_QUERY_DATA,
   SET_SERIES_QUERY_DATA,
+  SET_THREADS_QUERY_DATA,
+  SET_THREAD_EVENTS_QUERY_DATA,
+  SET_THREAD_EVENT_QUERY_DATA,
+  SET_THREAD_GROUPS_QUERY_DATA,
+  SET_THREAD_GROUP_QUERY_DATA,
+  SET_THREAD_MEMBERS_QUERY_DATA,
+  SET_THREAD_MEMBER_QUERY_DATA,
+  SET_THREAD_MESSAGES_QUERY_DATA,
+  SET_THREAD_MESSAGE_QUERY_DATA,
+  SET_THREAD_MESSAGE_REPLIES_QUERY_DATA,
+  SET_THREAD_QUERY_DATA,
   SUBSCRIBED_CHANNELS_QUERY_KEY,
   SUBSCRIBED_CONTENTS_QUERY_KEY,
   SelectSelfEventRegistrationCoupon,
@@ -11354,6 +12287,21 @@ var useUploadFile = (options = {}) => {
   SubscriptionStatus,
   SupportTicketType,
   SupportedLocale,
+  THREADS_QUERY_KEY,
+  THREAD_EVENTS_QUERY_KEY,
+  THREAD_EVENT_QUERY_KEY,
+  THREAD_GROUPS_QUERY_KEY,
+  THREAD_GROUP_QUERY_KEY,
+  THREAD_MEMBERS_QUERY_KEY,
+  THREAD_MEMBER_QUERY_KEY,
+  THREAD_MESSAGES_QUERY_KEY,
+  THREAD_MESSAGE_QUERY_KEY,
+  THREAD_MESSAGE_REPLIES_QUERY_KEY,
+  THREAD_QUERY_KEY,
+  ThreadAccessLevel,
+  ThreadInvitationStatus,
+  ThreadMemberRole,
+  ThreadMessageType,
   TicketEventAccessLevel,
   TicketVisibility,
   TransferPurchase,
@@ -11381,6 +12329,9 @@ var useUploadFile = (options = {}) => {
   UpdateSelfNotificationPreferences,
   UpdateSelfPushDevice,
   UpdateSubscriptionPaymentMethod,
+  UpdateThread,
+  UpdateThreadMember,
+  UpdateThreadMessage,
   UploadChannelContentImage,
   UploadFile,
   isListing,
@@ -11438,6 +12389,9 @@ var useUploadFile = (options = {}) => {
   useAddSelfEventRegistrationPurchaseAddOn,
   useAddSelfEventSession,
   useAddSelfInterests,
+  useAddThreadMember,
+  useAddThreadMessageReaction,
+  useAddThreadMessageReply,
   useCancelGroupInvitation,
   useCancelGroupRequest,
   useCancelSubscription,
@@ -11469,6 +12423,8 @@ var useUploadFile = (options = {}) => {
   useCreateSubscription,
   useCreateSupportTicket,
   useCreateTeamAccount,
+  useCreateThread,
+  useCreateThreadMessage,
   useDeactivateGroup,
   useDeleteActivity,
   useDeleteChannel,
@@ -11486,6 +12442,8 @@ var useUploadFile = (options = {}) => {
   useDeleteSelfChatChannel,
   useDeleteSelfChatChannelMessage,
   useDeleteSelfPushDevice,
+  useDeleteThreadMember,
+  useDeleteThreadMessage,
   useDemoteGroupModerator,
   useFollowAccount,
   useGetAccount,
@@ -11628,6 +12586,17 @@ var useUploadFile = (options = {}) => {
   useGetSeriesList,
   useGetSubscribedChannels,
   useGetSubscribedContents,
+  useGetThread,
+  useGetThreadEvent,
+  useGetThreadEvents,
+  useGetThreadGroup,
+  useGetThreadGroups,
+  useGetThreadMember,
+  useGetThreadMembers,
+  useGetThreadMessage,
+  useGetThreadMessageReplies,
+  useGetThreadMessages,
+  useGetThreads,
   useGroupStatus,
   useIsAccountFollowing,
   useIsChannelSubscribed,
@@ -11637,6 +12606,7 @@ var useUploadFile = (options = {}) => {
   useLeaveSelfChatChannel,
   useLikeActivity,
   useLikeContent,
+  useMarkUnread,
   usePromoteGroupMember,
   useReinviteGroupInvitation,
   useRejectGroupInvitation,
@@ -11653,6 +12623,7 @@ var useUploadFile = (options = {}) => {
   useRemoveSelfEventRegistrationPurchase,
   useRemoveSelfEventRegistrationPurchaseAddOn,
   useRemoveSelfEventSession,
+  useRemoveThreadMessageReaction,
   useReshareActivity,
   useSelectSelfEventRegistrationCoupon,
   useSelectSelfEventRegistrationPurchaseReservation,
@@ -11685,6 +12656,9 @@ var useUploadFile = (options = {}) => {
   useUpdateSelfNotificationPreferences,
   useUpdateSelfPushDevice,
   useUpdateSubscriptionPaymentMethod,
+  useUpdateThread,
+  useUpdateThreadMember,
+  useUpdateThreadMessage,
   useUploadChannelContentImage,
   useUploadFile
 });