@droppii-org/chat-sdk 0.1.72 → 0.1.73

package/dist/src/hooks/search/useSearchMessage.d.ts

@@ -0,0 +1,233 @@
+import { SearchMessageItem, SearchMessageRequest, SearchMessageResponse } from "../../types/dto";
+interface UseSearchMessagePayload {
+    payload: Pick<SearchMessageRequest, "contentType" | "pageSize" | "recvID" | "searchTerm" | "tag">;
+    options?: {
+        pageSize?: number;
+        untilEmptyPage?: boolean;
+    };
+}
+export declare const useSearchMessage: ({ payload, options, }: UseSearchMessagePayload) => {
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    isFetchNextPageError: boolean;
+    isFetchPreviousPageError: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>>;
+    data: import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown> | undefined;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    groupedData: Record<string, SearchMessageItem[]>;
+    dataFlatten: SearchMessageItem[];
+} | {
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>>;
+    data: import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown> | undefined;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    groupedData: Record<string, SearchMessageItem[]>;
+    dataFlatten: SearchMessageItem[];
+} | {
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>>;
+    data: import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown> | undefined;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    groupedData: Record<string, SearchMessageItem[]>;
+    dataFlatten: SearchMessageItem[];
+} | {
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>>;
+    data: import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown> | undefined;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    groupedData: Record<string, SearchMessageItem[]>;
+    dataFlatten: SearchMessageItem[];
+} | {
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>>;
+    data: import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown> | undefined;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    groupedData: Record<string, SearchMessageItem[]>;
+    dataFlatten: SearchMessageItem[];
+} | {
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    isFetchNextPageError: false;
+    isFetchPreviousPageError: false;
+    status: "success";
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasPreviousPage: boolean;
+    isFetchingPreviousPage: boolean;
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>>;
+    data: import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown> | undefined;
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<SearchMessageResponse, unknown>, Error>>;
+    hasNextPage: boolean;
+    isFetchingNextPage: boolean;
+    isLoading: boolean;
+    groupedData: Record<string, SearchMessageItem[]>;
+    dataFlatten: SearchMessageItem[];
+};
+export {};
+//# sourceMappingURL=useSearchMessage.d.ts.map

package/dist/src/hooks/search/useSearchMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSearchMessage.d.ts","sourceRoot":"","sources":["../../../../src/hooks/search/useSearchMessage.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAMrB,UAAU,uBAAuB;IAC/B,OAAO,EAAE,IAAI,CACX,oBAAoB,EACpB,aAAa,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,GAAG,KAAK,CAC7D,CAAC;IACF,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CAC3D;AAED,eAAO,MAAM,gBAAgB,GAAI,uBAG9B,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEzB,CAAC"}

package/dist/src/hooks/search/useSearchMessage.js

@@ -0,0 +1,72 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useInfiniteQuery } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { useMemo } from "react";
+import dayjs from "dayjs";
+import useAuthStore from "../../store/auth";
+import { PAGE_SIZE } from "../../constants";
+export const useSearchMessage = ({ payload, options, }) => {
+    const _a = useInfiniteQuery({
+        initialPageParam: 1,
+        queryKey: [QUERY_KEYS.SEARCH_MESSAGE, payload, options],
+        queryFn: async ({ pageParam = 1 }) => {
+            const params = Object.assign(Object.assign({ pageSize: (options === null || options === void 0 ? void 0 : options.pageSize) || PAGE_SIZE.small }, payload), { page: pageParam, applicationType: useAuthStore.getState().applicationType });
+            const res = await apiInstance.post(ENDPOINTS.chatService.searchMessage, params);
+            return res.data;
+        },
+        getNextPageParam: (lastPage) => {
+            var _a, _b;
+            const currentPage = ((_a = lastPage === null || lastPage === void 0 ? void 0 : lastPage.pageable) === null || _a === void 0 ? void 0 : _a.pageNumber) || 1;
+            const dataLength = ((_b = lastPage === null || lastPage === void 0 ? void 0 : lastPage.data) === null || _b === void 0 ? void 0 : _b.length) || 0;
+            if (options === null || options === void 0 ? void 0 : options.untilEmptyPage) {
+                return dataLength > 0 ? currentPage + 1 : undefined;
+            }
+            const pageSize = (options === null || options === void 0 ? void 0 : options.pageSize) || PAGE_SIZE.small;
+            return dataLength < pageSize ? undefined : currentPage + 1;
+        },
+        enabled: hasValidFilter(payload),
+    }), { data, fetchNextPage, hasNextPage, isFetchingNextPage, isLoading } = _a, rest = __rest(_a, ["data", "fetchNextPage", "hasNextPage", "isFetchingNextPage", "isLoading"]);
+    const { groupedData, dataFlatten } = useMemo(() => {
+        var _a, _b;
+        if (!data)
+            return {
+                groupedData: {},
+                dataFlatten: [],
+            };
+        const allItems = ((_b = (_a = data === null || data === void 0 ? void 0 : data.pages) === null || _a === void 0 ? void 0 : _a.flatMap) === null || _b === void 0 ? void 0 : _b.call(_a, (page) => page.data)) || [];
+        const mGroupeddata = allItems.reduce((acc, item) => {
+            const dateKey = dayjs(item.chatLog.sendTime).format("YYYY-MM-DD");
+            if (!acc[dateKey])
+                acc[dateKey] = [];
+            acc[dateKey].push(item);
+            return acc;
+        }, {});
+        return {
+            groupedData: mGroupeddata,
+            dataFlatten: allItems,
+        };
+    }, [data]);
+    return Object.assign({ data,
+        fetchNextPage,
+        hasNextPage,
+        isFetchingNextPage,
+        isLoading,
+        groupedData,
+        dataFlatten }, rest);
+};
+const hasValidFilter = (filter) => {
+    const { searchTerm, recvID } = filter;
+    return Boolean(searchTerm === null || searchTerm === void 0 ? void 0 : searchTerm.trim()) || Boolean(recvID === null || recvID === void 0 ? void 0 : recvID.trim());
+};

package/dist/src/hooks/session/useAssignSession.d.ts

@@ -0,0 +1,12 @@
+import { BaseResponse } from "../../types/dto";
+interface AssignSessionParams {
+    sessionId: string;
+    supporterId: string;
+}
+export declare const useAssignSession: () => import("@tanstack/react-query").UseMutationResult<BaseResponse<boolean>, Error, AssignSessionParams, unknown>;
+interface AutoAssignSessionParams {
+    sessionId: string;
+}
+export declare const useAutoAssignSession: () => import("@tanstack/react-query").UseMutationResult<BaseResponse<boolean>, Error, AutoAssignSessionParams, unknown>;
+export {};
+//# sourceMappingURL=useAssignSession.d.ts.map

package/dist/src/hooks/session/useAssignSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssignSession.d.ts","sourceRoot":"","sources":["../../../../src/hooks/session/useAssignSession.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAM3C,UAAU,mBAAmB;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,gBAAgB,qHA0B5B,CAAC;AAEF,UAAU,uBAAuB;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,oBAAoB,yHAqBhC,CAAC"}

package/dist/src/hooks/session/useAssignSession.js

@@ -0,0 +1,48 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import useAuthStore from "../../store/auth";
+import useConversationStore from "../../store/conversation";
+import { invalidateSessionQueries } from "../../utils/queryHelpers";
+import { useSyncGroupStateAfterJoin } from "./useSyncGroupStateAfterJoin";
+export const useAssignSession = () => {
+    const queryClient = useQueryClient();
+    const authUserID = useAuthStore((state) => state.userID);
+    const groupId = useConversationStore((state) => { var _a; return (_a = state.conversationData) === null || _a === void 0 ? void 0 : _a.groupID; });
+    const { syncGroupStateAfterJoin } = useSyncGroupStateAfterJoin({ groupId });
+    return useMutation({
+        mutationKey: [QUERY_KEYS.ASSIGN_SESSION],
+        mutationFn: async ({ sessionId, supporterId }) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.assignSession(sessionId), {
+                applicationType: useAuthStore.getState().applicationType,
+                supporterId,
+            });
+            return res === null || res === void 0 ? void 0 : res.data;
+        },
+        onSuccess: async (_, variables) => {
+            invalidateSessionQueries(queryClient);
+            if (variables.supporterId === authUserID) {
+                await syncGroupStateAfterJoin();
+            }
+        },
+    });
+};
+export const useAutoAssignSession = () => {
+    const queryClient = useQueryClient();
+    const groupId = useConversationStore((state) => { var _a; return (_a = state.conversationData) === null || _a === void 0 ? void 0 : _a.groupID; });
+    const { syncGroupStateAfterJoin } = useSyncGroupStateAfterJoin({ groupId });
+    return useMutation({
+        mutationKey: [QUERY_KEYS.AUTO_ASSIGN_SESSION],
+        mutationFn: async ({ sessionId }) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.autoAssignSession(sessionId), {
+                applicationType: useAuthStore.getState().applicationType,
+            });
+            return res === null || res === void 0 ? void 0 : res.data;
+        },
+        onSuccess: async () => {
+            invalidateSessionQueries(queryClient);
+            await syncGroupStateAfterJoin();
+        },
+    });
+};

package/dist/src/hooks/session/useCloseSession.d.ts

@@ -0,0 +1,3 @@
+import { BaseResponse } from "../../types/dto";
+export declare const useCloseSession: () => import("@tanstack/react-query").UseMutationResult<BaseResponse<boolean>, Error, string, unknown>;
+//# sourceMappingURL=useCloseSession.d.ts.map

package/dist/src/hooks/session/useCloseSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCloseSession.d.ts","sourceRoot":"","sources":["../../../../src/hooks/session/useCloseSession.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,eAAO,MAAM,eAAe,wGAqB3B,CAAC"}

package/dist/src/hooks/session/useCloseSession.js

@@ -0,0 +1,23 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import useAuthStore from "../../store/auth";
+import { invalidateSessionQueries } from "../../utils/queryHelpers";
+export const useCloseSession = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationKey: [QUERY_KEYS.CLOSE_SESSION],
+        mutationFn: async (sessionId) => {
+            const res = await apiInstance.post(ENDPOINTS.chatService.closeSession(sessionId), null, {
+                params: {
+                    applicationType: useAuthStore.getState().applicationType,
+                },
+            });
+            return res === null || res === void 0 ? void 0 : res.data;
+        },
+        onSuccess: async () => {
+            await invalidateSessionQueries(queryClient);
+        },
+    });
+};

package/dist/src/hooks/session/useConversationSessionState.d.ts

@@ -0,0 +1,14 @@
+import { SessionType } from "@openim/wasm-client-sdk";
+interface UseConversationSessionStateParams {
+    conversationId: string;
+    conversationType?: SessionType;
+    groupId?: string;
+}
+export declare const useConversationSessionState: ({ conversationId, conversationType, groupId, }: UseConversationSessionStateParams) => {
+    groupId: string | undefined;
+    latestConversationSession: import("../../types/dto").ISessionResponse | undefined;
+    customerUserID: string;
+    refetchConversationSessions: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<import("../../types/dto").ISessionResponse[], Error>>;
+};
+export {};
+//# sourceMappingURL=useConversationSessionState.d.ts.map

package/dist/src/hooks/session/useConversationSessionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationSessionState.d.ts","sourceRoot":"","sources":["../../../../src/hooks/session/useConversationSessionState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAItD,UAAU,iCAAiC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,2BAA2B,GAAI,gDAIzC,iCAAiC;;;;;CAmBnC,CAAC"}

package/dist/src/hooks/session/useConversationSessionState.js

@@ -0,0 +1,18 @@
+"use client";
+import { useGetListSessionByConversation } from "./useGetListSessionByConversation";
+import { isGroupSession } from "../../utils/imCommon";
+export const useConversationSessionState = ({ conversationId, conversationType, groupId, }) => {
+    var _a;
+    const isGroupConversation = isGroupSession(conversationType);
+    const currentGroupId = isGroupConversation ? groupId : undefined;
+    const { data: conversationSessions, refetch: refetchConversationSessions, } = useGetListSessionByConversation({
+        conversationId,
+    });
+    const latestConversationSession = conversationSessions === null || conversationSessions === void 0 ? void 0 : conversationSessions[0];
+    return {
+        groupId: currentGroupId,
+        latestConversationSession,
+        customerUserID: (_a = latestConversationSession === null || latestConversationSession === void 0 ? void 0 : latestConversationSession.ownerId) !== null && _a !== void 0 ? _a : "",
+        refetchConversationSessions,
+    };
+};

package/dist/src/hooks/session/useCreateNote.d.ts

@@ -0,0 +1,7 @@
+import { BaseResponse } from "../../types/dto";
+export declare const useCreateNote: () => import("@tanstack/react-query").UseMutationResult<BaseResponse<boolean>, Error, {
+    conversationId: string;
+    content: string;
+    targetId: string;
+}, unknown>;
+//# sourceMappingURL=useCreateNote.d.ts.map

package/dist/src/hooks/session/useCreateNote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateNote.d.ts","sourceRoot":"","sources":["../../../../src/hooks/session/useCreateNote.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,eAAO,MAAM,aAAa;oBAQJ,MAAM;aACb,MAAM;cACL,MAAM;WAkBlB,CAAC"}

package/dist/src/hooks/session/useCreateNote.js

@@ -0,0 +1,21 @@
+import { useMutation } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import useAuthStore from "../../store/auth";
+export const useCreateNote = () => useMutation({
+    mutationKey: [QUERY_KEYS.CREATE_NOTE],
+    mutationFn: async ({ conversationId, content, targetId, }) => {
+        const res = await apiInstance.post(ENDPOINTS.chatService.createNote, {
+            conversationId,
+            content,
+            targetId,
+            targetType: "USER",
+        }, {
+            params: {
+                applicationType: useAuthStore.getState().applicationType,
+            },
+        });
+        return res === null || res === void 0 ? void 0 : res.data;
+    },
+});

package/dist/src/hooks/session/useGetLabelSession.d.ts

@@ -0,0 +1,3 @@
+import { ILabelResponse } from "../../types/dto";
+export declare const useGetLabelSession: () => import("@tanstack/react-query").UseQueryResult<ILabelResponse[], Error>;
+//# sourceMappingURL=useGetLabelSession.d.ts.map

package/dist/src/hooks/session/useGetLabelSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGetLabelSession.d.ts","sourceRoot":"","sources":["../../../../src/hooks/session/useGetLabelSession.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,cAAc,EAAE,MAAM,aAAa,CAAC;AAG3D,eAAO,MAAM,kBAAkB,+EAiB9B,CAAC"}

package/dist/src/hooks/session/useGetLabelSession.js

@@ -0,0 +1,20 @@
+import { useQuery } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import useAuthStore from "../../store/auth";
+export const useGetLabelSession = () => {
+    const applicationType = useAuthStore((state) => state.applicationType);
+    return useQuery({
+        queryKey: [QUERY_KEYS.GET_LABEL_SESSION, applicationType],
+        queryFn: async () => {
+            var _a;
+            const res = await apiInstance.get(ENDPOINTS.chatService.getLabelSession, {
+                params: {
+                    applicationType,
+                },
+            });
+            return (_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.data;
+        },
+    });
+};

package/dist/src/hooks/session/useGetListSessionByConversation.d.ts

@@ -0,0 +1,9 @@
+import { ISessionResponse } from "../../types/dto";
+interface GetListSessionParams {
+    conversationId: string;
+    page?: number;
+    pageSize?: number;
+}
+export declare const useGetListSessionByConversation: ({ conversationId, page, pageSize, }: GetListSessionParams) => import("@tanstack/react-query").UseQueryResult<ISessionResponse[], Error>;
+export {};
+//# sourceMappingURL=useGetListSessionByConversation.d.ts.map

package/dist/src/hooks/session/useGetListSessionByConversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGetListSessionByConversation.d.ts","sourceRoot":"","sources":["../../../../src/hooks/session/useGetListSessionByConversation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAgB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAI7D,UAAU,oBAAoB;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,+BAA+B,GAAI,qCAI7C,oBAAoB,8EAyBtB,CAAC"}

package/dist/src/hooks/session/useGetListSessionByConversation.js

@@ -0,0 +1,29 @@
+import { useQuery } from "@tanstack/react-query";
+import { QUERY_KEYS } from "../../services/query";
+import { apiInstance } from "../../services/api";
+import { ENDPOINTS } from "../../services/routes";
+import { PAGE_SIZE } from "../../constants";
+import useAuthStore from "../../store/auth";
+export const useGetListSessionByConversation = ({ conversationId, page = 1, pageSize = PAGE_SIZE.large, }) => {
+    const applicationType = useAuthStore((state) => state.applicationType);
+    return useQuery({
+        queryKey: [
+            QUERY_KEYS.GET_LIST_SESSION_BY_CONVERSATION,
+            applicationType,
+            conversationId,
+            { page, pageSize },
+        ],
+        queryFn: async () => {
+            var _a;
+            const res = await apiInstance.get(ENDPOINTS.chatService.listSessionByConversation(conversationId), {
+                params: {
+                    applicationType,
+                    page,
+                    pageSize,
+                },
+            });
+            return (_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        enabled: !!conversationId,
+    });
+};