@myrjfa/state 0.3.1

package/dist/lib/actions/chat.js

@@ -0,0 +1,741 @@
+import { get, post, patch, put, del } from "./fetcher";
+const BASE_PATH = "/chat";
+const idString = (value) => String(value || "");
+const normalizeActorRef = (actor) => ({
+    actorId: idString(actor?.actorId),
+    actorModel: actor?.actorModel,
+});
+export const normalizeChatMessage = (message) => ({
+    ...message,
+    _id: idString(message?._id),
+    conversationId: idString(message?.conversationId),
+    senderId: idString(message?.senderId),
+    senderModel: message?.senderModel,
+    content: {
+        text: message?.content?.text || "",
+        media: message?.content?.media || [],
+        linkPreview: message?.content?.linkPreview || undefined,
+        referenceId: message?.content?.referenceId,
+        referenceType: message?.content?.referenceType,
+        mentions: (message?.content?.mentions || []).map(normalizeActorRef),
+    },
+    reactions: (message?.reactions || []).map((reaction) => ({
+        ...normalizeActorRef(reaction),
+        emoji: reaction.emoji,
+        createdAt: reaction.createdAt,
+    })),
+    readBy: (message?.readBy || []).map((receipt) => ({
+        ...normalizeActorRef(receipt),
+        readAt: receipt.readAt,
+    })),
+    deliveredTo: (message?.deliveredTo || []).map((receipt) => ({
+        ...normalizeActorRef(receipt),
+        deliveredAt: receipt.deliveredAt,
+    })),
+});
+export const normalizeConversation = (conversation) => ({
+    ...conversation,
+    _id: idString(conversation?._id),
+    type: conversation?.type || "individual",
+    participants: (conversation?.participants || []).map((participant) => ({
+        ...normalizeActorRef(participant),
+        accountType: participant.accountType,
+        username: participant.username || "",
+        displayName: participant.displayName || participant.username || "",
+        profilePic: participant.profilePic || "",
+        chatRole: participant.chatRole || "member",
+        joinedAt: participant.joinedAt || conversation?.createdAt,
+        lastReadAt: participant.lastReadAt || null,
+        unreadCount: Number(participant.unreadCount || 0),
+        restrictedUntil: participant.restrictedUntil || null,
+    })),
+    features: {
+        milestones: Boolean(conversation?.features?.milestones),
+        expenses: Boolean(conversation?.features?.expenses),
+        events: conversation?.features?.events !== false,
+    },
+    groupSettings: {
+        announcementsOnly: Boolean(conversation?.groupSettings?.announcementsOnly),
+        joinApprovalRequired: Boolean(conversation?.groupSettings?.joinApprovalRequired),
+    },
+    context: conversation?.context,
+    lastMessage: conversation?.lastMessage
+        ? {
+            text: conversation.lastMessage.text || "",
+            senderId: idString(conversation.lastMessage.senderId),
+            senderModel: conversation.lastMessage.senderModel,
+            sentAt: conversation.lastMessage.sentAt,
+        }
+        : undefined,
+    preference: {
+        conversationId: idString(conversation?.preference?.conversationId || conversation?._id),
+        actorId: idString(conversation?.preference?.actorId),
+        actorModel: conversation?.preference?.actorModel,
+        pinnedAt: conversation?.preference?.pinnedAt || null,
+        favouritedAt: conversation?.preference?.favouritedAt || null,
+        archivedAt: conversation?.preference?.archivedAt || null,
+        mutedUntil: conversation?.preference?.mutedUntil || null,
+        notificationLevel: conversation?.preference?.notificationLevel || "all",
+        markedUnreadAt: conversation?.preference?.markedUnreadAt || null,
+        draftText: conversation?.preference?.draftText || "",
+        draftUpdatedAt: conversation?.preference?.draftUpdatedAt || null,
+    },
+});
+const normalizePreference = (preference) => ({
+    conversationId: idString(preference?.conversationId),
+    actorId: idString(preference?.actorId),
+    actorModel: preference?.actorModel,
+    pinnedAt: preference?.pinnedAt || null,
+    favouritedAt: preference?.favouritedAt || null,
+    archivedAt: preference?.archivedAt || null,
+    mutedUntil: preference?.mutedUntil || null,
+    notificationLevel: preference?.notificationLevel || "all",
+    markedUnreadAt: preference?.markedUnreadAt || null,
+    draftText: preference?.draftText || "",
+    draftUpdatedAt: preference?.draftUpdatedAt || null,
+});
+const normalizeActorLine = (line) => ({ ...line, ...normalizeActorRef(line) });
+const normalizeBalanceLine = (line) => ({
+    ...normalizeActorLine(line),
+    // Canonical backend balance rows use `balance`; shared UI retains the
+    // established `netBalance` field.
+    netBalance: Number(line?.netBalance ?? line?.balance ?? 0),
+});
+const normalizeExpense = (expense) => ({ ...expense, _id: idString(expense?._id), conversationId: idString(expense?.conversationId), createdBy: normalizeActorRef(expense?.createdBy), paidBy: (expense?.paidBy || []).map(normalizeActorLine), splits: (expense?.splits || []).map(normalizeActorLine) });
+const normalizeMilestone = (milestone) => ({ ...milestone, _id: idString(milestone?._id), conversationId: idString(milestone?.conversationId), createdBy: normalizeActorRef(milestone?.createdBy), checks: (milestone?.checks || []).map(normalizeActorLine) });
+const normalizePoll = (poll) => ({
+    ...poll,
+    _id: idString(poll?._id),
+    conversationId: idString(poll?.conversationId),
+    createdBy: normalizeActorRef(poll?.createdBy),
+    votes: (poll?.votes || []).map(normalizeActorLine),
+});
+const normalizeEvent = (event) => ({
+    ...event,
+    _id: idString(event?._id),
+    conversationId: idString(event?.conversationId),
+    createdBy: normalizeActorRef(event?.createdBy),
+    invitedActors: (event?.invitedActors || []).map(normalizeActorRef),
+    rsvps: (event?.rsvps || []).map(normalizeActorLine),
+});
+export const chatApi = {
+    searchParticipants: async (query) => {
+        const response = await get(`${BASE_PATH}/participants?q=${encodeURIComponent(query)}`);
+        return (response.data || []).map((participant) => ({
+            actorId: idString(participant.actorId),
+            actorModel: participant.actorModel,
+            username: participant.username || "",
+            displayName: participant.displayName || participant.username || "Trippeaze member",
+            profilePic: participant.profilePic || "",
+        }));
+    },
+    createGroup: async (data) => {
+        const response = await post(`${BASE_PATH}/groups`, data);
+        return response.data ? normalizeConversation(response.data) : null;
+    },
+    // Conversations
+    getConversations: async (params) => {
+        try {
+            const query = new URLSearchParams();
+            if (params?.filter)
+                query.set("filter", params.filter);
+            if (params?.q)
+                query.set("q", params.q);
+            if (params?.before)
+                query.set("before", params.before);
+            if (params?.limit)
+                query.set("limit", String(params.limit));
+            const response = await get(`${BASE_PATH}/conversations?${query.toString()}`);
+            return (response.data || []).map(normalizeConversation);
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    },
+    getConversation: async (id) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${id}`);
+            return response.data ? normalizeConversation(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    createConversation: async (data) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations`, data);
+            return response.data ? normalizeConversation(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    updateConversation: async (id, data) => {
+        try {
+            const response = await patch(`${BASE_PATH}/conversations/${id}`, data);
+            return response.data ? normalizeConversation(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    deleteConversation: async (id) => {
+        try {
+            const response = await del(`${BASE_PATH}/conversations/${id}`);
+            return response.data;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    addParticipants: async (id, participantIds) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${id}/participants`, { participantIds });
+            return response.data ? normalizeConversation(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    removeParticipant: async (convId, actorId, actorModel) => {
+        try {
+            const response = await del(`${BASE_PATH}/conversations/${convId}/participants/${actorModel}/${actorId}`);
+            return response.data ? normalizeConversation(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    updateParticipant: async (convId, actorId, actorModel, data) => {
+        try {
+            const response = await patch(`${BASE_PATH}/conversations/${convId}/participants/${actorModel}/${actorId}`, data);
+            return response.data ? normalizeConversation(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    // Messages
+    getMessages: async (convId, params) => {
+        try {
+            const qs = new URLSearchParams();
+            if (params?.limit)
+                qs.set("limit", String(params.limit));
+            if (params?.before)
+                qs.set("before", params.before);
+            if (params?.around)
+                qs.set("around", params.around);
+            if (params?.radius)
+                qs.set("radius", String(params.radius));
+            const response = await get(`${BASE_PATH}/conversations/${convId}/messages?${qs.toString()}`);
+            return (response.data || []).map(normalizeChatMessage);
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    },
+    getMessage: async (convId, id) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/messages/${id}`);
+            return {
+                ...response,
+                data: response.data ? normalizeChatMessage(response.data) : null,
+            };
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    sendMessage: async (convId, data) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${convId}/messages`, data);
+            return response.data ? normalizeChatMessage(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    editMessage: async (id, text) => {
+        try {
+            const response = await patch(`${BASE_PATH}/messages/${id}`, { text });
+            return response.data ? normalizeChatMessage(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    addMessageReaction: async (id, emoji) => {
+        try {
+            const response = await patch(`${BASE_PATH}/messages/${id}/reaction`, { emoji });
+            return response.data ? normalizeChatMessage(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    deleteMessage: async (id) => {
+        try {
+            const response = await del(`${BASE_PATH}/messages/${id}`);
+            return response.data ? normalizeChatMessage(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    addReaction: async (id, emoji) => {
+        try {
+            const response = await patch(`${BASE_PATH}/messages/${id}/reaction`, { emoji });
+            return response.data ? normalizeChatMessage(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    removeReaction: async (id) => {
+        try {
+            const response = await patch(`${BASE_PATH}/messages/${id}/reaction`, { emoji: "" });
+            return response.data ? normalizeChatMessage(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    markRead: async (convId, messageIds) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${convId}/read`, { messageIds });
+            return response.data;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    blockParticipant: async (targetId, targetModel) => {
+        const response = await post(`${BASE_PATH}/blocks/${targetModel}/${targetId}`, {});
+        return response.data;
+    },
+    restrictParticipant: async (convId, actorId, actorModel, restrictedUntil) => {
+        const response = await patch(`${BASE_PATH}/conversations/${convId}/participants/${actorModel}/${actorId}/restriction`, { restrictedUntil });
+        return response.data ? normalizeConversation(response.data) : null;
+    },
+    getConversationPreference: async (id) => {
+        const response = await get(`${BASE_PATH}/conversations/${id}/preferences`);
+        return normalizePreference(response.data);
+    },
+    updateConversationPreference: async (id, data) => {
+        const response = await patch(`${BASE_PATH}/conversations/${id}/preferences`, data);
+        return normalizePreference(response.data);
+    },
+    markConversationUnread: async (id) => {
+        const response = await post(`${BASE_PATH}/conversations/${id}/mark-unread`, {});
+        return normalizePreference(response.data);
+    },
+    unblockParticipant: async (targetId, targetModel) => {
+        const response = await del(`${BASE_PATH}/blocks/${targetModel}/${targetId}`);
+        return response.data;
+    },
+    getBlockStatus: async (targetId, targetModel) => {
+        const response = await get(`${BASE_PATH}/blocks/${targetModel}/${targetId}`);
+        return response.data;
+    },
+    getEvents: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/events`);
+        return (response.data || []).map(normalizeEvent);
+    },
+    createEvent: async (convId, data) => {
+        const response = await post(`${BASE_PATH}/conversations/${convId}/events`, data);
+        return normalizeEvent(response.data);
+    },
+    updateEvent: async (eventId, data) => {
+        const response = await patch(`${BASE_PATH}/events/${eventId}`, data);
+        return normalizeEvent(response.data);
+    },
+    deleteEvent: async (eventId) => {
+        const response = await del(`${BASE_PATH}/events/${eventId}`);
+        return response.data;
+    },
+    rsvpEvent: async (eventId, status) => {
+        const response = await post(`${BASE_PATH}/events/${eventId}/rsvp`, { status });
+        return normalizeEvent(response.data);
+    },
+    getEventCalendarUrl: (eventId) => `${BASE_PATH}/events/${eventId}/calendar`,
+    createGroupInvite: async (convId, data) => {
+        const response = await post(`${BASE_PATH}/conversations/${convId}/invites`, data);
+        return response.data;
+    },
+    getGroupInvites: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/invites`);
+        return response.data || [];
+    },
+    revokeGroupInvite: async (inviteId) => {
+        const response = await del(`${BASE_PATH}/invites/${inviteId}`);
+        return response.data;
+    },
+    joinGroupWithToken: async (token) => {
+        const response = await post(`${BASE_PATH}/join/${encodeURIComponent(token)}`, {});
+        return response.data;
+    },
+    getGroupJoinRequests: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/join-requests`);
+        return response.data || [];
+    },
+    reviewGroupJoinRequest: async (requestId, status) => {
+        const response = await patch(`${BASE_PATH}/join-requests/${requestId}`, { status });
+        return response.data;
+    },
+    moderateMessage: async (messageId, reason) => {
+        const response = await post(`${BASE_PATH}/messages/${messageId}/moderate`, { reason });
+        return normalizeChatMessage(response.data);
+    },
+    reportContent: async (convId, data) => {
+        const response = await post(`${BASE_PATH}/conversations/${convId}/reports`, data);
+        return response.data;
+    },
+    getPaymentProfile: async () => {
+        const response = await get(`${BASE_PATH}/payment-profile`);
+        return response.data;
+    },
+    updatePaymentProfile: async (methods) => {
+        const response = await put(`${BASE_PATH}/payment-profile`, { methods });
+        return response.data;
+    },
+    getSharedPaymentDetails: async (convId, target) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/payment-details/${target.actorModel}/${target.actorId}`);
+        return response.data;
+    },
+    getPaymentIntents: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/payment-intents`);
+        return response.data || [];
+    },
+    createPaymentIntent: async (convId, data) => {
+        const response = await post(`${BASE_PATH}/conversations/${convId}/payment-intents`, data);
+        return response.data;
+    },
+    verifyPaymentIntent: async (paymentIntentId, data) => {
+        const response = await post(`${BASE_PATH}/payment-intents/${paymentIntentId}/verify`, data);
+        return response.data;
+    },
+    confirmPaymentIntent: async (paymentIntentId, disputed = false, reason) => {
+        const response = await post(`${BASE_PATH}/payment-intents/${paymentIntentId}/confirm`, { disputed, reason });
+        return response.data;
+    },
+    getChatBusinessProfile: async () => {
+        const response = await get(`${BASE_PATH}/business-profile`);
+        return response.data;
+    },
+    updateChatBusinessProfile: async (data) => {
+        const response = await put(`${BASE_PATH}/business-profile`, data);
+        return response.data;
+    },
+    getChatQuickReplies: async () => {
+        const response = await get(`${BASE_PATH}/quick-replies`);
+        return response.data;
+    },
+    saveChatQuickReply: async (data, quickReplyId) => {
+        const response = quickReplyId
+            ? await patch(`${BASE_PATH}/quick-replies/${quickReplyId}`, data)
+            : await post(`${BASE_PATH}/quick-replies`, data);
+        return response.data;
+    },
+    deleteChatQuickReply: async (quickReplyId) => {
+        await del(`${BASE_PATH}/quick-replies/${quickReplyId}`);
+    },
+    getHostConversationState: async (conversationId) => {
+        const response = await get(`${BASE_PATH}/conversations/${conversationId}/host-state`);
+        return response.data;
+    },
+    updateHostConversationState: async (conversationId, data) => {
+        const response = await patch(`${BASE_PATH}/conversations/${conversationId}/host-state`, data);
+        return response.data;
+    },
+    getOwnedPublishedChatListings: async (query = "") => {
+        const response = await get(`${BASE_PATH}/owned-listings${query ? `?q=${encodeURIComponent(query)}` : ""}`);
+        return response.data;
+    },
+    requestChatCopilotAssistance: async (conversationId, data) => {
+        const response = await post(`${BASE_PATH}/conversations/${conversationId}/ai/assist`, data);
+        return response.data;
+    },
+    // Deferred Phase 4 methods remain exported for the existing hidden UI.
+    getMilestones: async (convId) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/milestones`);
+            return (response.data || []).map(normalizeMilestone);
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    },
+    createMilestone: async (convId, data) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${convId}/milestones`, data);
+            return { ...response, data: response.data ? normalizeMilestone(response.data) : null };
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    toggleMilestone: async (id, note) => {
+        try {
+            const response = await patch(`${BASE_PATH}/milestones/${id}/toggle`, { note });
+            return { ...response, data: response.data ? normalizeMilestone(response.data) : null };
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    updateMilestone: async (id, data) => {
+        try {
+            const response = await patch(`${BASE_PATH}/milestones/${id}`, data);
+            return { ...response, data: response.data ? normalizeMilestone(response.data) : null };
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    deleteMilestone: async (id) => {
+        try {
+            const response = await del(`${BASE_PATH}/milestones/${id}`);
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    // Expenses
+    getExpenses: async (convId) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/expenses`);
+            return (response.data || []).map(normalizeExpense);
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    },
+    createExpense: async (convId, data) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${convId}/expenses`, data);
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    updateExpense: async (id, data) => {
+        try {
+            const response = await patch(`${BASE_PATH}/expenses/${id}`, data);
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    settleSplit: async (id, targetActorId, amount, targetActorModel) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${id}/settleExpense`, { targetActorId, targetActorModel, amount });
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    deleteExpense: async (id) => {
+        try {
+            const response = await del(`${BASE_PATH}/expenses/${id}`);
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    getBalances: async (convId) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/balances`);
+            return response.data ? {
+                ...response.data,
+                balances: (response.data.balances || []).map(normalizeBalanceLine),
+                settlements: (response.data.settlements || []).map((settlement) => ({
+                    ...settlement,
+                    from: normalizeActorRef(settlement.from),
+                    to: normalizeActorRef(settlement.to),
+                })),
+            } : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    getExpenseCategories: async (convId) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/expense-categories`);
+            return response.data;
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    },
+    uploadFiles: async (formData) => {
+        try {
+            const response = await post(`${BASE_PATH}/upload`, formData);
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    getExpenseAnalytics: async (convId) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/expense-analytics`);
+            return response.data;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    // Polls
+    getPolls: async (convId) => {
+        try {
+            const response = await get(`${BASE_PATH}/conversations/${convId}/polls`);
+            return response.data;
+        }
+        catch (error) {
+            console.error(error);
+            return [];
+        }
+    },
+    getPollById: async (pollId) => {
+        try {
+            const response = await get(`${BASE_PATH}/polls/${pollId}`);
+            return response.data ? normalizePoll(response.data) : null;
+        }
+        catch (error) {
+            console.error(error);
+            return null;
+        }
+    },
+    createPoll: async (convId, data) => {
+        try {
+            const response = await post(`${BASE_PATH}/conversations/${convId}/polls`, data);
+            return response;
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    },
+    updatePoll: async (pollId, data) => {
+        try {
+            const response = await patch(`${BASE_PATH}/polls/${pollId}`, data);
+            return { ...response, data: response.data ? normalizePoll(response.data) : null };
+        }
+        catch (error) {
+            console.error(error);
+            return { error, data: null };
+        }
+    },
+    searchConversationMessages: async (convId, params) => {
+        const qs = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== "")
+                qs.set(key, String(value));
+        });
+        const response = await get(`${BASE_PATH}/conversations/${convId}/search?${qs.toString()}`);
+        return {
+            results: (response.data?.results || []).map((result) => ({
+                message: normalizeChatMessage(result.message),
+                context: result.context || {},
+            })),
+            nextCursor: response.data?.nextCursor || null,
+        };
+    },
+    getSharedContent: async (convId, section, before) => {
+        const qs = new URLSearchParams({ section });
+        if (before)
+            qs.set("before", before);
+        const response = await get(`${BASE_PATH}/conversations/${convId}/shared-content?${qs.toString()}`);
+        const messageSections = new Set(["media", "documents", "links", "locations", "polls", "listings", "bookings"]);
+        return {
+            ...response.data,
+            items: messageSections.has(section)
+                ? (response.data?.items || []).map(normalizeChatMessage)
+                : response.data?.items || [],
+        };
+    },
+    getConversationStorage: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/storage`);
+        return response.data;
+    },
+    starMessage: async (messageId) => {
+        const response = await put(`${BASE_PATH}/messages/${messageId}/star`, {});
+        return response.data;
+    },
+    unstarMessage: async (messageId) => {
+        const response = await del(`${BASE_PATH}/messages/${messageId}/star`);
+        return response.data;
+    },
+    getStarredMessages: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/starred`);
+        return (response.data || []).map((star) => ({
+            ...star,
+            conversationId: idString(star.conversationId),
+            messageId: normalizeChatMessage(star.messageId),
+        }));
+    },
+    pinMessage: async (messageId, expiresAt) => {
+        const response = await post(`${BASE_PATH}/messages/${messageId}/pin`, { expiresAt });
+        return response.data;
+    },
+    unpinMessage: async (messageId) => {
+        const response = await del(`${BASE_PATH}/messages/${messageId}/pin`);
+        return response.data;
+    },
+    getPinnedMessages: async (convId) => {
+        const response = await get(`${BASE_PATH}/conversations/${convId}/pins`);
+        return (response.data || []).map((pin) => ({
+            ...pin,
+            conversationId: idString(pin.conversationId),
+            pinnedBy: normalizeActorRef(pin.pinnedBy),
+            messageId: normalizeChatMessage(pin.messageId),
+        }));
+    },
+    votePoll: async (pollId, optionIndex) => {
+        try {
+            const response = await patch(`${BASE_PATH}/polls/${pollId}/vote`, { optionIndex });
+            return { ...response, data: response.data ? normalizePoll(response.data) : null };
+        }
+        catch (error) {
+            console.error(error);
+            return { error: error, data: null };
+        }
+    }
+};