@connectedxm/client 7.1.0 → 7.1.2

package/dist/index.js

@@ -6756,236 +6756,386 @@ var useGetLevelSponsors = (levelId = "", params = {}, options = {}) => {
   );
 };
 
-// src/queries/storage/useGetVideo.ts
-var VIDEO_QUERY_KEY = (videoId) => [
-  "VIDEO",
-  videoId
-];
-var SET_VIDEO_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/useConnectedCursorQuery.ts
+import {
+  useInfiniteQuery as useInfiniteQuery2
+} from "@tanstack/react-query";
+var useConnectedCursorQuery = (queryKeys, queryFn, params = {}, options = {
+  shouldRedirect: false
+}) => {
+  if (typeof params.pageSize === "undefined") params.pageSize = 25;
+  const {
+    locale,
+    onModuleForbidden,
+    onNotAuthorized,
+    onNotFound,
+    apiUrl,
+    getToken,
+    organizationId,
+    getExecuteAs,
+    queryClient
+  } = useConnected();
+  const getNextPageParam = (lastPage) => {
+    if (lastPage.cursor) {
+      return lastPage.cursor;
+    }
+    return null;
+  };
+  return useInfiniteQuery2({
+    staleTime: 60 * 1e3,
+    // 60 Seconds
+    retry: (failureCount, error) => {
+      if (error.response?.status === 404) {
+        if (onNotFound) onNotFound(error, queryKeys, options.shouldRedirect || false);
+        return false;
+      }
+      if (error.response?.status === 403 || !!error.response?.status && CUSTOM_ERROR_CODES.includes(error.response.status)) {
+        if (onModuleForbidden) onModuleForbidden(error, queryKeys, options.shouldRedirect || false);
+        return false;
+      }
+      if (error.response?.status === 401) {
+        if (onNotAuthorized) onNotAuthorized(error, queryKeys, options.shouldRedirect || false);
+        return false;
+      }
+      if (failureCount < 3) return true;
+      return false;
+    },
+    ...options,
+    queryKey: [
+      ...queryKeys,
+      ...GetBaseInfiniteQueryKeys(params?.locale || locale, params?.search)
+    ],
+    queryFn: ({ pageParam }) => queryFn({
+      ...params,
+      pageSize: params.pageSize || 25,
+      locale: params.locale || locale,
+      cursor: pageParam,
+      queryClient,
+      clientApiParams: {
+        apiUrl,
+        getToken,
+        organizationId,
+        getExecuteAs,
+        locale
+      }
+    }),
+    initialPageParam: null,
+    getNextPageParam
+  });
+};
+
+// src/queries/streams/useGetStreamChatMessages.ts
+var STREAM_CHAT_MESSAGES_QUERY_KEY = (streamId, sessionId) => ["STREAMS", streamId, sessionId, "MESSAGES"];
+var SET_STREAM_CHAT_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
-    [...VIDEO_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
-    response
+    [
+      ...STREAM_CHAT_MESSAGES_QUERY_KEY(keyParams[0], keyParams[1]),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
   );
 };
-var GetVideo = async ({
-  videoId,
+var GetStreamChatMessages = async ({
+  streamId,
+  sessionId,
+  cursor,
+  pageSize,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/storage/videos/${videoId}`);
+  const { data } = await clientApi.get(
+    `/streams/${streamId}/sessions/${sessionId}/messages`,
+    {
+      params: {
+        cursor: cursor || void 0,
+        pageSize: pageSize || void 0
+      }
+    }
+  );
   return data;
 };
-var useGetVideo = (videoId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    VIDEO_QUERY_KEY(videoId),
-    (_params) => GetVideo({ videoId, ..._params }),
+var useGetStreamChatMessages = (streamId = "", sessionId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnected();
+  return useConnectedCursorQuery(
+    STREAM_CHAT_MESSAGES_QUERY_KEY(streamId, sessionId),
+    (params2) => GetStreamChatMessages({ ...params2, streamId, sessionId }),
+    params,
     {
       ...options,
-      enabled: !!videoId && (options?.enabled ?? true)
+      enabled: !!authenticated && !!streamId && !!sessionId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/storage/useGetImage.ts
-var IMAGE_QUERY_KEY = (imageId) => [
-  "IMAGE",
-  imageId
+// src/queries/threads/useGetThreadCircles.ts
+var THREADS_QUERY_KEY = () => ["THREADS"];
+var THREAD_CIRCLES_QUERY_KEY = () => [
+  ...THREADS_QUERY_KEY(),
+  "CIRCLES"
 ];
-var SET_IMAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_THREAD_CIRCLES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
-    [...IMAGE_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
-    response
+    [
+      ...THREAD_CIRCLES_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
+    ],
+    setFirstPageData(response)
   );
 };
-var GetImage = async ({
-  imageId,
+var GetThreadCircles = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  type,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/storage/images/${imageId}`);
+  const { data } = await clientApi.get(`/threads/circles`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      type: type || void 0
+    }
+  });
   return data;
 };
-var useGetImage = (imageId = "", options = {}) => {
-  return useConnectedSingleQuery(
-    IMAGE_QUERY_KEY(imageId),
-    (_params) => GetImage({ imageId, ..._params }),
+var useGetThreadCircles = (params = {}, options = {}) => {
+  const { authenticated } = useConnected();
+  return useConnectedInfiniteQuery(
+    THREAD_CIRCLES_QUERY_KEY(),
+    (params2) => GetThreadCircles(params2),
+    params,
     {
       ...options,
-      enabled: !!imageId && (options?.enabled ?? true)
+      enabled: !!authenticated && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/supportTickets/useGetSupportTicket.ts
-var SUPPORT_TICKET_QUERY_KEY = (supportTicketId) => [
-  "SUPPORT_TICKETS",
-  supportTicketId
+// src/queries/threads/useGetThreadCircle.ts
+var THREAD_CIRCLE_QUERY_KEY = (circleId) => [
+  ...THREAD_CIRCLES_QUERY_KEY(),
+  circleId
 ];
-var SET_SUPPORT_TICKET_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_THREAD_CIRCLE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
   client.setQueryData(
     [
-      ...SUPPORT_TICKET_QUERY_KEY(...keyParams),
+      ...THREAD_CIRCLE_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
-    response
+    response,
+    options
   );
 };
-var GetSupportTicket = async ({
-  supportTicketId,
+var GetThreadCircle = async ({
+  circleId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/supportTickets/${supportTicketId}`);
+  const { data } = await clientApi.get(`/threads/circles/${circleId}`);
   return data;
 };
-var useGetSupportTicket = (supportTicketId = "", options = {}) => {
+var useGetThreadCircle = (circleId = "", options = {}) => {
   return useConnectedSingleQuery(
-    SUPPORT_TICKET_QUERY_KEY(supportTicketId),
-    (params) => GetSupportTicket({ supportTicketId, ...params }),
+    THREAD_CIRCLE_QUERY_KEY(circleId),
+    (params) => GetThreadCircle({ circleId, ...params }),
     {
       ...options,
-      enabled: !!supportTicketId && (options?.enabled ?? true)
+      enabled: !!circleId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/supportTickets/useGetSupportTickets.ts
-var SUPPORT_TICKETS_QUERY_KEY = (type, state) => [...SELF_QUERY_KEY(), "SUPPORT_TICKETS", type, state];
-var SET_SUPPORT_TICKETS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/threads/useGetThreadCircleAccounts.ts
+var THREAD_CIRCLE_ACCOUNTS_QUERY_KEY = (circleId) => [...THREAD_CIRCLE_QUERY_KEY(circleId), "ACCOUNTS"];
+var SET_THREAD_CIRCLE_ACCOUNTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SUPPORT_TICKETS_QUERY_KEY(...keyParams),
+      ...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetSupportTickets = async ({
+var GetThreadCircleAccounts = async ({
+  circleId,
   pageParam,
   pageSize,
   orderBy,
   search,
-  type,
-  state,
+  role,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/supportTickets`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0,
-      type: type || void 0,
-      state: state || void 0
+  const { data } = await clientApi.get(
+    `/threads/circles/${circleId}/accounts`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0,
+        role: role || void 0
+      }
     }
-  });
+  );
   return data;
 };
-var useGetSupportTickets = (type, state, params = {}, options = {}) => {
+var useGetThreadCircleAccounts = (circleId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnected();
   return useConnectedInfiniteQuery(
-    SUPPORT_TICKETS_QUERY_KEY(type, state),
-    (params2) => GetSupportTickets({ type, state, ...params2 }),
+    THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId),
+    (params2) => GetThreadCircleAccounts({ ...params2, circleId }),
     params,
-    options
+    {
+      ...options,
+      enabled: !!authenticated && !!circleId && (options?.enabled ?? true)
+    }
   );
 };
 
-// src/queries/supportTickets/useGetSupportTicketMessages.ts
-var SUPPORT_TICKET_MESSAGES_QUERY_KEY = (supportTicketId) => [
-  ...SUPPORT_TICKET_QUERY_KEY(supportTicketId),
-  "MESSAGES"
-];
-var SET_SUPPORT_TICKET_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/threads/useGetThreadCircleAccount.ts
+var THREAD_CIRCLE_ACCOUNT_QUERY_KEY = (circleId, accountId) => [...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId), accountId];
+var SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
   client.setQueryData(
     [
-      ...SUPPORT_TICKET_MESSAGES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
+      ...THREAD_CIRCLE_ACCOUNT_QUERY_KEY(...keyParams),
+      ...GetBaseSingleQueryKeys(...baseKeys)
     ],
-    setFirstPageData(response)
+    response,
+    options
   );
 };
-var GetSupportTicketMessages = async ({
-  supportTicketId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
+var GetThreadCircleAccount = async ({
+  circleId,
+  accountId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/supportTickets/${supportTicketId}/messages`,
+    `/threads/circles/${circleId}/accounts/${accountId}`
+  );
+  return data;
+};
+var useGetThreadCircleAccount = (circleId = "", accountId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_CIRCLE_ACCOUNT_QUERY_KEY(circleId, accountId),
+    (params) => GetThreadCircleAccount({ circleId, accountId, ...params }),
     {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+      ...options,
+      enabled: !!circleId && !!accountId && (options?.enabled ?? true)
     }
   );
+};
+
+// src/queries/threads/useGetThread.ts
+var THREAD_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), threadId, accountId];
+var SET_THREAD_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+  client.setQueryData(
+    [...THREAD_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
+    response,
+    options
+  );
+};
+var GetThread = async ({
+  threadId,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/threads/${threadId}`);
   return data;
 };
-var useGetSupportTicketMessages = (supportTicketId = "", params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    SUPPORT_TICKET_MESSAGES_QUERY_KEY(supportTicketId),
-    (params2) => GetSupportTicketMessages({
-      supportTicketId,
-      ...params2
-    }),
-    params,
+var useGetThread = (threadId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_QUERY_KEY(threadId),
+    (params) => GetThread({ threadId, ...params }),
     {
       ...options,
-      enabled: !!supportTicketId && (options?.enabled ?? true)
+      enabled: !!threadId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/supportTickets/useGetSupportTicketActivityLogs.ts
-var SUPPORT_TICKET_ACTIVITY_LOG_QUERY_KEY = (supportTicketId) => [...SUPPORT_TICKET_QUERY_KEY(supportTicketId), "ACTIVITY_LOG"];
-var SET_SUPPORT_TICKET_ACTIVITY_LOG_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+// src/queries/threads/useGetThreadMessages.ts
+var THREAD_MESSAGES_QUERY_KEY = (threadId) => [
+  ...THREAD_QUERY_KEY(threadId),
+  "MESSAGES"
+];
+var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...SUPPORT_TICKET_ACTIVITY_LOG_QUERY_KEY(...keyParams),
+      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetSupportTicketActivityLog = async ({
-  supportTicketId,
-  pageParam,
+var GetThreadMessages = async ({
+  threadId,
+  cursor,
   pageSize,
-  orderBy,
   search,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/supportTickets/${supportTicketId}/activityLog`,
+  const { data } = await clientApi.get(`/threads/${threadId}/messages`, {
+    params: {
+      cursor: cursor || void 0,
+      pageSize: pageSize || void 0,
+      search: search || void 0
+    }
+  });
+  return data;
+};
+var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
+  const { authenticated } = useConnected();
+  return useConnectedCursorQuery(
+    THREAD_MESSAGES_QUERY_KEY(threadId),
+    (params2) => GetThreadMessages({ ...params2, threadId }),
+    params,
     {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0
-      }
+      ...options,
+      enabled: !!authenticated && !!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 useGetSupportTicketActivityLog = (supportTicketId = "", params = {}, options = {}) => {
-  return useConnectedInfiniteQuery(
-    SUPPORT_TICKET_ACTIVITY_LOG_QUERY_KEY(supportTicketId),
-    (params2) => GetSupportTicketActivityLog({
-      supportTicketId,
-      ...params2
-    }),
-    params,
+var useGetThreadMessage = (threadId, messageId, options = {}) => {
+  return useConnectedSingleQuery(
+    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
+    (params) => GetThreadMessage({ threadId, messageId, ...params }),
     {
+      staleTime: Infinity,
       ...options,
-      enabled: !!supportTicketId && (options?.enabled ?? true)
+      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
     }
   );
 };
@@ -7161,343 +7311,236 @@ var useGetSurveySubmissionSections = (surveyId, submissionId, options = {}) => {
   );
 };
 
-// src/queries/threads/useGetThreadCircles.ts
-var THREADS_QUERY_KEY = () => ["THREADS"];
-var THREAD_CIRCLES_QUERY_KEY = () => [
-  ...THREADS_QUERY_KEY(),
-  "CIRCLES"
+// src/queries/storage/useGetVideo.ts
+var VIDEO_QUERY_KEY = (videoId) => [
+  "VIDEO",
+  videoId
 ];
-var SET_THREAD_CIRCLES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_VIDEO_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
-    [
-      ...THREAD_CIRCLES_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
+    [...VIDEO_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
+    response
   );
 };
-var GetThreadCircles = async ({
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  type,
+var GetVideo = async ({
+  videoId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/circles`, {
-    params: {
-      page: pageParam || void 0,
-      pageSize: pageSize || void 0,
-      orderBy: orderBy || void 0,
-      search: search || void 0,
-      type: type || void 0
-    }
-  });
+  const { data } = await clientApi.get(`/storage/videos/${videoId}`);
   return data;
 };
-var useGetThreadCircles = (params = {}, options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedInfiniteQuery(
-    THREAD_CIRCLES_QUERY_KEY(),
-    (params2) => GetThreadCircles(params2),
-    params,
+var useGetVideo = (videoId = "", options = {}) => {
+  return useConnectedSingleQuery(
+    VIDEO_QUERY_KEY(videoId),
+    (_params) => GetVideo({ videoId, ..._params }),
     {
       ...options,
-      enabled: !!authenticated && (options?.enabled ?? true)
+      enabled: !!videoId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/threads/useGetThreadCircle.ts
-var THREAD_CIRCLE_QUERY_KEY = (circleId) => [
-  ...THREAD_CIRCLES_QUERY_KEY(),
-  circleId
+// src/queries/storage/useGetImage.ts
+var IMAGE_QUERY_KEY = (imageId) => [
+  "IMAGE",
+  imageId
 ];
-var SET_THREAD_CIRCLE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+var SET_IMAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
-    [
-      ...THREAD_CIRCLE_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
-    ],
-    response,
-    options
+    [...IMAGE_QUERY_KEY(...keyParams), ...GetBaseSingleQueryKeys(...baseKeys)],
+    response
   );
 };
-var GetThreadCircle = async ({
-  circleId,
+var GetImage = async ({
+  imageId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/circles/${circleId}`);
+  const { data } = await clientApi.get(`/storage/images/${imageId}`);
   return data;
 };
-var useGetThreadCircle = (circleId = "", options = {}) => {
+var useGetImage = (imageId = "", options = {}) => {
   return useConnectedSingleQuery(
-    THREAD_CIRCLE_QUERY_KEY(circleId),
-    (params) => GetThreadCircle({ circleId, ...params }),
-    {
-      ...options,
-      enabled: !!circleId && (options?.enabled ?? true)
-    }
-  );
-};
-
-// src/queries/threads/useGetThreadCircleAccounts.ts
-var THREAD_CIRCLE_ACCOUNTS_QUERY_KEY = (circleId) => [...THREAD_CIRCLE_QUERY_KEY(circleId), "ACCOUNTS"];
-var SET_THREAD_CIRCLE_ACCOUNTS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
-  client.setQueryData(
-    [
-      ...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(...keyParams),
-      ...GetBaseInfiniteQueryKeys(...baseKeys)
-    ],
-    setFirstPageData(response)
-  );
-};
-var GetThreadCircleAccounts = async ({
-  circleId,
-  pageParam,
-  pageSize,
-  orderBy,
-  search,
-  role,
-  clientApiParams
-}) => {
-  const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/threads/circles/${circleId}/accounts`,
-    {
-      params: {
-        page: pageParam || void 0,
-        pageSize: pageSize || void 0,
-        orderBy: orderBy || void 0,
-        search: search || void 0,
-        role: role || void 0
-      }
-    }
-  );
-  return data;
-};
-var useGetThreadCircleAccounts = (circleId = "", params = {}, options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedInfiniteQuery(
-    THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId),
-    (params2) => GetThreadCircleAccounts({ ...params2, circleId }),
-    params,
+    IMAGE_QUERY_KEY(imageId),
+    (_params) => GetImage({ imageId, ..._params }),
     {
       ...options,
-      enabled: !!authenticated && !!circleId && (options?.enabled ?? true)
+      enabled: !!imageId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/threads/useGetThreadCircleAccount.ts
-var THREAD_CIRCLE_ACCOUNT_QUERY_KEY = (circleId, accountId) => [...THREAD_CIRCLE_ACCOUNTS_QUERY_KEY(circleId), accountId];
-var SET_THREAD_CIRCLE_ACCOUNT_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+// src/queries/supportTickets/useGetSupportTicket.ts
+var SUPPORT_TICKET_QUERY_KEY = (supportTicketId) => [
+  "SUPPORT_TICKETS",
+  supportTicketId
+];
+var SET_SUPPORT_TICKET_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...THREAD_CIRCLE_ACCOUNT_QUERY_KEY(...keyParams),
+      ...SUPPORT_TICKET_QUERY_KEY(...keyParams),
       ...GetBaseSingleQueryKeys(...baseKeys)
     ],
-    response,
-    options
+    response
   );
 };
-var GetThreadCircleAccount = async ({
-  circleId,
-  accountId,
+var GetSupportTicket = async ({
+  supportTicketId,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(
-    `/threads/circles/${circleId}/accounts/${accountId}`
-  );
+  const { data } = await clientApi.get(`/supportTickets/${supportTicketId}`);
   return data;
 };
-var useGetThreadCircleAccount = (circleId = "", accountId = "", options = {}) => {
+var useGetSupportTicket = (supportTicketId = "", options = {}) => {
   return useConnectedSingleQuery(
-    THREAD_CIRCLE_ACCOUNT_QUERY_KEY(circleId, accountId),
-    (params) => GetThreadCircleAccount({ circleId, accountId, ...params }),
+    SUPPORT_TICKET_QUERY_KEY(supportTicketId),
+    (params) => GetSupportTicket({ supportTicketId, ...params }),
     {
       ...options,
-      enabled: !!circleId && !!accountId && (options?.enabled ?? true)
+      enabled: !!supportTicketId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/threads/useGetThread.ts
-var THREAD_QUERY_KEY = (threadId, accountId) => [...THREADS_QUERY_KEY(), threadId, accountId];
-var SET_THREAD_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+// src/queries/supportTickets/useGetSupportTickets.ts
+var SUPPORT_TICKETS_QUERY_KEY = (type, state) => [...SELF_QUERY_KEY(), "SUPPORT_TICKETS", type, state];
+var SET_SUPPORT_TICKETS_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   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/useConnectedCursorQuery.ts
-import {
-  useInfiniteQuery as useInfiniteQuery2
-} from "@tanstack/react-query";
-var useConnectedCursorQuery = (queryKeys, queryFn, params = {}, options = {
-  shouldRedirect: false
-}) => {
-  if (typeof params.pageSize === "undefined") params.pageSize = 25;
-  const {
-    locale,
-    onModuleForbidden,
-    onNotAuthorized,
-    onNotFound,
-    apiUrl,
-    getToken,
-    organizationId,
-    getExecuteAs,
-    queryClient
-  } = useConnected();
-  const getNextPageParam = (lastPage) => {
-    if (lastPage.cursor) {
-      return lastPage.cursor;
-    }
-    return null;
-  };
-  return useInfiniteQuery2({
-    staleTime: 60 * 1e3,
-    // 60 Seconds
-    retry: (failureCount, error) => {
-      if (error.response?.status === 404) {
-        if (onNotFound) onNotFound(error, queryKeys, options.shouldRedirect || false);
-        return false;
-      }
-      if (error.response?.status === 403 || !!error.response?.status && CUSTOM_ERROR_CODES.includes(error.response.status)) {
-        if (onModuleForbidden) onModuleForbidden(error, queryKeys, options.shouldRedirect || false);
-        return false;
-      }
-      if (error.response?.status === 401) {
-        if (onNotAuthorized) onNotAuthorized(error, queryKeys, options.shouldRedirect || false);
-        return false;
-      }
-      if (failureCount < 3) return true;
-      return false;
-    },
-    ...options,
-    queryKey: [
-      ...queryKeys,
-      ...GetBaseInfiniteQueryKeys(params?.locale || locale, params?.search)
+    [
+      ...SUPPORT_TICKETS_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
-    queryFn: ({ pageParam }) => queryFn({
-      ...params,
-      pageSize: params.pageSize || 25,
-      locale: params.locale || locale,
-      cursor: pageParam,
-      queryClient,
-      clientApiParams: {
-        apiUrl,
-        getToken,
-        organizationId,
-        getExecuteAs,
-        locale
-      }
-    }),
-    initialPageParam: null,
-    getNextPageParam
+    setFirstPageData(response)
+  );
+};
+var GetSupportTickets = async ({
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
+  type,
+  state,
+  clientApiParams
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.get(`/supportTickets`, {
+    params: {
+      page: pageParam || void 0,
+      pageSize: pageSize || void 0,
+      orderBy: orderBy || void 0,
+      search: search || void 0,
+      type: type || void 0,
+      state: state || void 0
+    }
   });
+  return data;
+};
+var useGetSupportTickets = (type, state, params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    SUPPORT_TICKETS_QUERY_KEY(type, state),
+    (params2) => GetSupportTickets({ type, state, ...params2 }),
+    params,
+    options
+  );
 };
 
-// src/queries/threads/useGetThreadMessages.ts
-var THREAD_MESSAGES_QUERY_KEY = (threadId) => [
-  ...THREAD_QUERY_KEY(threadId),
+// src/queries/supportTickets/useGetSupportTicketMessages.ts
+var SUPPORT_TICKET_MESSAGES_QUERY_KEY = (supportTicketId) => [
+  ...SUPPORT_TICKET_QUERY_KEY(supportTicketId),
   "MESSAGES"
 ];
-var SET_THREAD_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
+var SET_SUPPORT_TICKET_MESSAGES_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...THREAD_MESSAGES_QUERY_KEY(...keyParams),
+      ...SUPPORT_TICKET_MESSAGES_QUERY_KEY(...keyParams),
       ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
     setFirstPageData(response)
   );
 };
-var GetThreadMessages = async ({
-  threadId,
-  cursor,
+var GetSupportTicketMessages = async ({
+  supportTicketId,
+  pageParam,
   pageSize,
+  orderBy,
   search,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
-  const { data } = await clientApi.get(`/threads/${threadId}/messages`, {
-    params: {
-      cursor: cursor || void 0,
-      pageSize: pageSize || void 0,
-      search: search || void 0
+  const { data } = await clientApi.get(
+    `/supportTickets/${supportTicketId}/messages`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
     }
-  });
+  );
   return data;
 };
-var useGetThreadMessages = (threadId = "", params = {}, options = {}) => {
-  const { authenticated } = useConnected();
-  return useConnectedCursorQuery(
-    THREAD_MESSAGES_QUERY_KEY(threadId),
-    (params2) => GetThreadMessages({ ...params2, threadId }),
+var useGetSupportTicketMessages = (supportTicketId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    SUPPORT_TICKET_MESSAGES_QUERY_KEY(supportTicketId),
+    (params2) => GetSupportTicketMessages({
+      supportTicketId,
+      ...params2
+    }),
     params,
     {
       ...options,
-      enabled: !!authenticated && !!threadId && (options?.enabled ?? true)
+      enabled: !!supportTicketId && (options?.enabled ?? true)
     }
   );
 };
 
-// src/queries/threads/useGetThreadMessage.ts
-var THREAD_MESSAGE_QUERY_KEY = (threadId, messageId) => {
-  return [...THREAD_MESSAGES_QUERY_KEY(threadId), messageId];
-};
-var SET_THREAD_MESSAGE_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"], options) => {
+// src/queries/supportTickets/useGetSupportTicketActivityLogs.ts
+var SUPPORT_TICKET_ACTIVITY_LOG_QUERY_KEY = (supportTicketId) => [...SUPPORT_TICKET_QUERY_KEY(supportTicketId), "ACTIVITY_LOG"];
+var SET_SUPPORT_TICKET_ACTIVITY_LOG_QUERY_DATA = (client, keyParams, response, baseKeys = ["en"]) => {
   client.setQueryData(
     [
-      ...THREAD_MESSAGE_QUERY_KEY(...keyParams),
-      ...GetBaseSingleQueryKeys(...baseKeys)
+      ...SUPPORT_TICKET_ACTIVITY_LOG_QUERY_KEY(...keyParams),
+      ...GetBaseInfiniteQueryKeys(...baseKeys)
     ],
-    response,
-    options
+    setFirstPageData(response)
   );
 };
-var GetThreadMessage = async ({
-  threadId,
-  messageId,
+var GetSupportTicketActivityLog = async ({
+  supportTicketId,
+  pageParam,
+  pageSize,
+  orderBy,
+  search,
   clientApiParams
 }) => {
   const clientApi = await GetClientAPI(clientApiParams);
   const { data } = await clientApi.get(
-    `/threads/${threadId}/messages/${messageId}`
+    `/supportTickets/${supportTicketId}/activityLog`,
+    {
+      params: {
+        page: pageParam || void 0,
+        pageSize: pageSize || void 0,
+        orderBy: orderBy || void 0,
+        search: search || void 0
+      }
+    }
   );
   return data;
 };
-var useGetThreadMessage = (threadId, messageId, options = {}) => {
-  return useConnectedSingleQuery(
-    THREAD_MESSAGE_QUERY_KEY(threadId, messageId),
-    (params) => GetThreadMessage({ threadId, messageId, ...params }),
+var useGetSupportTicketActivityLog = (supportTicketId = "", params = {}, options = {}) => {
+  return useConnectedInfiniteQuery(
+    SUPPORT_TICKET_ACTIVITY_LOG_QUERY_KEY(supportTicketId),
+    (params2) => GetSupportTicketActivityLog({
+      supportTicketId,
+      ...params2
+    }),
+    params,
     {
-      staleTime: Infinity,
       ...options,
-      enabled: !!threadId && !!messageId && (options?.enabled ?? true)
+      enabled: !!supportTicketId && (options?.enabled ?? true)
     }
   );
 };
@@ -7536,12 +7579,112 @@ var ThreadMessageUpdated = (_queryClient, _locale, _message) => {
 };
 var ThreadMessageUpdated_default = ThreadMessageUpdated;
 
+// src/websockets/stream/StreamChatCreated.ts
+var StreamChatCreated = (queryClient, locale, message) => {
+  const QueryKey4 = [
+    ...STREAM_CHAT_MESSAGES_QUERY_KEY(
+      message.body.streamId,
+      message.body.sessionId
+    ),
+    ...GetBaseInfiniteQueryKeys(locale || "en")
+  ];
+  const existingMessages = queryClient.getQueryData(QueryKey4);
+  const exists = existingMessages ? MergeInfinitePages(existingMessages).find(
+    (msg) => msg.messageId === message.body.message.messageId
+  ) : false;
+  if (!exists) {
+    AppendInfiniteQuery(queryClient, QueryKey4, message.body.message);
+  }
+};
+var StreamChatCreated_default = StreamChatCreated;
+
+// src/websockets/stream/StreamChatDeleted.ts
+import { produce as produce2 } from "immer";
+var StreamChatDeleted = (queryClient, locale, message) => {
+  const QueryKey4 = [
+    ...STREAM_CHAT_MESSAGES_QUERY_KEY(
+      message.body.streamId,
+      message.body.sessionId
+    ),
+    ...GetBaseInfiniteQueryKeys(locale || "en")
+  ];
+  queryClient.setQueryData(
+    QueryKey4,
+    (oldData) => {
+      return produce2(oldData, (draft) => {
+        if (draft?.pages) {
+          for (const page of draft.pages) {
+            if (page?.data) {
+              page.data = page.data.filter(
+                (msg) => msg.messageId !== message.body.messageId
+              );
+            }
+          }
+        }
+      });
+    }
+  );
+};
+var StreamChatDeleted_default = StreamChatDeleted;
+
+// src/websockets/stream/StreamChatUpdated.ts
+import { produce as produce3 } from "immer";
+var StreamChatUpdated = (queryClient, locale, message) => {
+  const QueryKey4 = [
+    ...STREAM_CHAT_MESSAGES_QUERY_KEY(
+      message.body.streamId,
+      message.body.sessionId
+    ),
+    ...GetBaseInfiniteQueryKeys(locale || "en")
+  ];
+  queryClient.setQueryData(
+    QueryKey4,
+    (oldData) => {
+      return produce3(oldData, (draft) => {
+        if (draft?.pages) {
+          for (const page of draft.pages) {
+            if (page?.data) {
+              const index = page.data.findIndex(
+                (msg) => msg.messageId === message.body.message.messageId
+              );
+              if (index !== -1) {
+                page.data[index] = message.body.message;
+                break;
+              }
+            }
+          }
+        }
+      });
+    }
+  );
+};
+var StreamChatUpdated_default = StreamChatUpdated;
+
+// src/websockets/stream/StreamConnected.ts
+var StreamConnected = (_queryClient, _locale, _message) => {
+  return;
+};
+var StreamConnected_default = StreamConnected;
+
+// src/websockets/stream/StreamDisconnected.ts
+var StreamDisconnected = (_queryClient, _locale, _message) => {
+  return;
+};
+var StreamDisconnected_default = StreamDisconnected;
+
+// src/websockets/PulseMessage.ts
+var PulseMessage = (_queryClient, _locale, _message) => {
+  return;
+};
+var PulseMessage_default = PulseMessage;
+
 // src/websockets/useConnectedWebsocket.tsx
 import { useQueryClient } from "@tanstack/react-query";
 var useConnectedWebsocket = (useWebSocket, {
   authenticated,
   locale,
   getToken,
+  getExecuteAs,
   websocketUrl,
   organizationId
 }) => {
@@ -7553,8 +7696,14 @@ var useConnectedWebsocket = (useWebSocket, {
     const getSocketUrl = async () => {
       const token = await getToken();
       if (!token) return null;
+      const executeAs = getExecuteAs ? await getExecuteAs() : void 0;
+      if (!executeAs) return null;
       setSocketUrl(
-        `${websocketUrl}?organization=${organizationId}&authorization=${token}`
+        `${websocketUrl}?organization=${encodeURIComponent(
+          organizationId
+        )}&authorization=${encodeURIComponent(
+          token
+        )}&executeas=${encodeURIComponent(executeAs)}`
       );
     };
     if (authenticated) {
@@ -7562,7 +7711,7 @@ var useConnectedWebsocket = (useWebSocket, {
     } else {
       setSocketUrl(null);
     }
-  }, [authenticated, getToken, websocketUrl, organizationId]);
+  }, [authenticated, getToken, getExecuteAs, websocketUrl, organizationId]);
   const { sendJsonMessage, lastMessage } = useWebSocket(
     socketUrl,
     {
@@ -7603,6 +7752,18 @@ var useConnectedWebsocket = (useWebSocket, {
       ThreadMessageUpdated_default(queryClient, locale, lastWSMessage);
     } else if (lastWSMessage.type === "thread.message.deleted") {
       ThreadMessageDeleted_default(queryClient, locale, lastWSMessage);
+    } else if (lastWSMessage.type === "stream.chat.created") {
+      StreamChatCreated_default(queryClient, locale, lastWSMessage);
+    } else if (lastWSMessage.type === "stream.chat.deleted") {
+      StreamChatDeleted_default(queryClient, locale, lastWSMessage);
+    } else if (lastWSMessage.type === "stream.chat.updated") {
+      StreamChatUpdated_default(queryClient, locale, lastWSMessage);
+    } else if (lastWSMessage.type === "stream.connected") {
+      StreamConnected_default(queryClient, locale, lastWSMessage);
+    } else if (lastWSMessage.type === "stream.disconnected") {
+      StreamDisconnected_default(queryClient, locale, lastWSMessage);
+    } else if (lastWSMessage.type === "pulse") {
+      PulseMessage_default(queryClient, locale, lastWSMessage);
     }
   });
   return { sendWSMessage, lastWSMessage };
@@ -8168,7 +8329,7 @@ var useConnectedMutation = (mutation, options) => {
 var useConnectedMutation_default = useConnectedMutation;
 
 // src/mutations/accounts/useFollowAccount.ts
-import { produce as produce2 } from "immer";
+import { produce as produce4 } from "immer";
 var FollowAccount = async ({
   accountId,
   clientApiParams,
@@ -8181,7 +8342,7 @@ var FollowAccount = async ({
   if (queryClient && data.status === "ok") {
     queryClient.setQueryData(
       [...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.id), clientApiParams.locale],
-      (prev) => produce2(prev, (data2) => {
+      (prev) => produce4(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers + 1;
         }
@@ -8192,7 +8353,7 @@ var FollowAccount = async ({
         ...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.username),
         clientApiParams.locale
       ],
-      (prev) => produce2(prev, (data2) => {
+      (prev) => produce4(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers + 1;
         }
@@ -8215,7 +8376,7 @@ var useFollowAccount = (options = {}) => {
 };
 
 // src/mutations/accounts/useUnfollowAccount.ts
-import { produce as produce3 } from "immer";
+import { produce as produce5 } from "immer";
 var UnfollowAccount = async ({
   accountId,
   clientApiParams,
@@ -8228,7 +8389,7 @@ var UnfollowAccount = async ({
   if (queryClient && data.status === "ok") {
     queryClient.setQueryData(
       [...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.id), clientApiParams.locale],
-      (prev) => produce3(prev, (data2) => {
+      (prev) => produce5(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers - 1;
         }
@@ -8239,7 +8400,7 @@ var UnfollowAccount = async ({
         ...ACCOUNT_FOLLOW_STATS_QUERY_KEY(data.data.username),
         clientApiParams.locale
       ],
-      (prev) => produce3(prev, (data2) => {
+      (prev) => produce5(prev, (data2) => {
         if (data2?.data) {
           data2.data.followers = data2.data.followers - 1;
         }
@@ -8310,11 +8471,11 @@ var useUnblockAccount = (options = {}) => {
 };
 
 // src/mutations/activities/optimistic/UpdateComments.ts
-import { produce as produce4 } from "immer";
+import { produce as produce6 } from "immer";
 var UpdateCommentsSingle = (increment, queryClient, KEY) => {
   queryClient.setQueryData(
     KEY,
-    (originalData) => produce4(originalData, (draft) => {
+    (originalData) => produce6(originalData, (draft) => {
       if (!draft?.data) {
         return;
       }
@@ -8326,7 +8487,7 @@ var UpdateCommentsSingle = (increment, queryClient, KEY) => {
 var UpdateCommentsInfinite = (increment, queryClient, KEY, activityId) => {
   queryClient.setQueriesData(
     { queryKey: KEY, exact: false },
-    (originalData) => produce4(originalData, (draft) => {
+    (originalData) => produce6(originalData, (draft) => {
       if (!draft?.pages || draft.pages.length === 0) {
         return;
       }
@@ -8510,11 +8671,11 @@ var useDeleteActivity = (options = {}) => {
 };
 
 // src/mutations/activities/optimistic/UpdateLikes.ts
-import { produce as produce5 } from "immer";
+import { produce as produce7 } from "immer";
 var UpdateLikesSingle = (increment, queryClient, KEY) => {
   queryClient.setQueryData(
     KEY,
-    (originalData) => produce5(originalData, (draft) => {
+    (originalData) => produce7(originalData, (draft) => {
       if (!draft?.data) {
         return;
       }
@@ -8526,7 +8687,7 @@ var UpdateLikesSingle = (increment, queryClient, KEY) => {
 var UpdateLikesInfinite = (increment, queryClient, KEY, activityId) => {
   queryClient.setQueriesData(
     { queryKey: KEY, exact: false },
-    (originalData) => produce5(originalData, (draft) => {
+    (originalData) => produce7(originalData, (draft) => {
       if (!draft?.pages || draft.pages.length === 0) {
         return;
       }
@@ -11950,6 +12111,106 @@ var useUploadImage = (options = {}) => {
   return useConnectedMutation_default(UploadImage, options);
 };
 
+// src/mutations/streams/useCreateStreamChatMessage.ts
+var CreateStreamChatMessage = async ({
+  streamId,
+  sessionId,
+  message,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.post(
+    `/streams/${streamId}/sessions/${sessionId}/messages`,
+    {
+      message
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    const QueryKey4 = [
+      ...STREAM_CHAT_MESSAGES_QUERY_KEY(streamId, sessionId),
+      ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+    ];
+    AppendInfiniteQuery(queryClient, QueryKey4, data.data);
+  }
+  return data;
+};
+var useCreateStreamChatMessage = (options = {}) => {
+  return useConnectedMutation(CreateStreamChatMessage, options);
+};
+
+// src/mutations/streams/useUpdateStreamChatMessage.ts
+import { produce as produce8 } from "immer";
+var UpdateStreamChatMessage = async ({
+  streamId,
+  sessionId,
+  messageId,
+  message,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.put(
+    `/streams/${streamId}/sessions/${sessionId}/messages/${messageId}`,
+    {
+      message
+    }
+  );
+  if (queryClient && data.status === "ok") {
+    const QueryKey4 = [
+      ...STREAM_CHAT_MESSAGES_QUERY_KEY(streamId, sessionId),
+      ...GetBaseInfiniteQueryKeys(clientApiParams.locale)
+    ];
+    queryClient.setQueryData(
+      QueryKey4,
+      (oldData) => {
+        return produce8(oldData, (draft) => {
+          if (draft?.pages) {
+            for (const page of draft.pages) {
+              if (page?.data) {
+                const index = page.data.findIndex(
+                  (msg) => msg.messageId === messageId
+                );
+                if (index !== -1) {
+                  page.data[index] = data.data;
+                  break;
+                }
+              }
+            }
+          }
+        });
+      }
+    );
+  }
+  return data;
+};
+var useUpdateStreamChatMessage = (options = {}) => {
+  return useConnectedMutation(UpdateStreamChatMessage, options);
+};
+
+// src/mutations/streams/useDeleteStreamChatMessage.ts
+var DeleteStreamChatMessage = async ({
+  streamId,
+  sessionId,
+  messageId,
+  clientApiParams,
+  queryClient
+}) => {
+  const clientApi = await GetClientAPI(clientApiParams);
+  const { data } = await clientApi.delete(
+    `/streams/${streamId}/sessions/${sessionId}/messages/${messageId}`
+  );
+  if (queryClient && data.status === "ok") {
+    queryClient.invalidateQueries({
+      queryKey: STREAM_CHAT_MESSAGES_QUERY_KEY(streamId, sessionId)
+    });
+  }
+  return data;
+};
+var useDeleteStreamChatMessage = (options = {}) => {
+  return useConnectedMutation(DeleteStreamChatMessage, options);
+};
+
 // src/mutations/threads/useUpdateThread.ts
 var UpdateThread = async ({
   threadId,
@@ -12452,6 +12713,7 @@ export {
   CreateSelfChatChannel,
   CreateSelfChatChannelMessage,
   CreateSelfLead,
+  CreateStreamChatMessage,
   CreateSupportTicket,
   CreateSupportTicketMessage,
   CreateThreadMessage,
@@ -12476,6 +12738,7 @@ export {
   DeleteSelfChatChannelMessage,
   DeleteSelfLead,
   DeleteSelfPushDevice,
+  DeleteStreamChatMessage,
   DeleteThreadCircleAccount,
   DeleteThreadMessage,
   DemoteGroupModerator,
@@ -12709,6 +12972,7 @@ export {
   GetSeries,
   GetSeriesEvents,
   GetSeriesList,
+  GetStreamChatMessages,
   GetSubscribedChannels,
   GetSubscribedContents,
   GetSupportTicket,
@@ -12981,6 +13245,7 @@ export {
   SET_SERIES_EVENTS_QUERY_DATA,
   SET_SERIES_LIST_QUERY_DATA,
   SET_SERIES_QUERY_DATA,
+  SET_STREAM_CHAT_MESSAGES_QUERY_DATA,
   SET_SUPPORT_TICKETS_QUERY_DATA,
   SET_SUPPORT_TICKET_ACTIVITY_LOG_QUERY_DATA,
   SET_SUPPORT_TICKET_MESSAGES_QUERY_DATA,
@@ -12997,6 +13262,7 @@ export {
   SET_TRANSFER_ACCOUNTS_QUERY_DATA,
   SET_USERNAME_AVAILABILITY_QUERY_DATA,
   SET_VIDEO_QUERY_DATA,
+  STREAM_CHAT_MESSAGES_QUERY_KEY,
   SUBSCRIBED_CHANNELS_QUERY_KEY,
   SUBSCRIBED_CONTENTS_QUERY_KEY,
   SUPPORT_TICKETS_QUERY_KEY,
@@ -13073,6 +13339,7 @@ export {
   UpdateSelfLead,
   UpdateSelfNotificationPreferences,
   UpdateSelfPushDevice,
+  UpdateStreamChatMessage,
   UpdateSurveyResponse,
   UpdateSurveySearchListResponse,
   UpdateThread,
@@ -13169,6 +13436,7 @@ export {
   useCreateSelfChatChannel,
   useCreateSelfChatChannelMessage,
   useCreateSelfLead,
+  useCreateStreamChatMessage,
   useCreateSupportTicket,
   useCreateSupportTicketMessage,
   useCreateThreadMessage,
@@ -13191,6 +13459,7 @@ export {
   useDeleteSelfChatChannelMessage,
   useDeleteSelfLead,
   useDeleteSelfPushDevice,
+  useDeleteStreamChatMessage,
   useDeleteThreadCircleAccount,
   useDeleteThreadMessage,
   useDemoteGroupModerator,
@@ -13366,6 +13635,7 @@ export {
   useGetSeries,
   useGetSeriesEvents,
   useGetSeriesList,
+  useGetStreamChatMessages,
   useGetSubscribedChannels,
   useGetSubscribedContents,
   useGetSupportTicket,
@@ -13459,6 +13729,7 @@ export {
   useUpdateSelfLead,
   useUpdateSelfNotificationPreferences,
   useUpdateSelfPushDevice,
+  useUpdateStreamChatMessage,
   useUpdateSurveyResponse,
   useUpdateSurveySearchListResponse,
   useUpdateThread,