@antzsoft/chat-core 1.4.0 → 1.4.2

package/README.md

@@ -43,7 +43,7 @@ npm install @antzsoft/chat-core
 | Capability | What the SDK provides |
 |---|---|
 | Authentication | Login, register, logout, token refresh (automatic on 401) |
-| Conversations | List, create (group/DM), update, delete, mute, pin, leave, manage members |
+| Conversations | List, create (group/DM), update, delete, mute, pin, mark unread, leave, manage members |
 | Messages | Send, edit, delete, react, star, pin, search, paginate, @mention |
 | Mentions | Group @mentions with `@all` (admin-gated); token parse/build/render helpers; mention pierces mute |
 | File uploads | Presigned URL pipeline — request URL → upload binary (multipart POST for S3/local, PUT for Azure) → confirm. Files ≥ 10 MB on S3 or local use chunked multipart (parallel parts → complete). |
@@ -764,6 +764,7 @@ import { messagesApi } from '@antzsoft/chat-core';
 | `pin` | `(messageId: string) => Promise<Message>` | Pin a message. |
 | `unpin` | `(messageId: string) => Promise<Message>` | Unpin a message. |
 | `getPinned` | `(conversationId: string) => Promise<Message[]>` | List pinned messages in a conversation. |
+| `forward` | `(messageId: string, targetConversationIds: string[]) => Promise<ForwardResult[]>` | Forward a message into one or more conversations (v1.4.2+). Max `MAX_FORWARD_TARGETS` (5) targets per call, reduced to 1 if the source message has `forwardDepth >= 5`. Each target is independent — check `success`/`error` per entry in the returned array. No hard cap on forward count. |
 
 > **Delete permissions** — `delete()` (for everyone) requires either: the message belongs to the current user AND was sent within the delete window, OR the current user is a group admin. The server default window is **216,000 s (60 hours)** when `conversation.settings.messageConfig.deleteWindowSeconds` is not set. DMs have no admin role — only the sender can delete for everyone in a DM. `deleteForMe()` is always allowed for any message. See the [integration guide — Edit & Delete section](docs/integration-guide.html#step-edit) for a ready-to-use `getDeleteOptions()` helper.
 
@@ -812,6 +813,57 @@ await messagesApi.send('conv-abc', {
 const results = await messagesApi.search({ query: 'deployment', conversationId: 'conv-abc' });
 ```
 
+#### Forward Message (v1.4.2+)
+
+Forwarding creates an **independent copy** of a message in each target conversation — never a shared row. Each copy gets its own ID, sequence number, read receipts, and delete lifecycle; deleting one copy never affects another, and none of them affect the original.
+
+| Field / method | Type | Description |
+|---|---|---|
+| `messagesApi.forward(messageId, targetConversationIds)` | `Promise<ForwardResult[]>` | Forwards into up to `MAX_FORWARD_TARGETS` (5) conversations in one call — fewer if the source message is highly forwarded, see Limits below. |
+| `Message.forwardedFrom` | `MessageForwardReference \| undefined` | Present on a message created via forwarding. |
+| `MAX_FORWARD_TARGETS` | `number` | `5` — matches the server's normal-case cap. |
+
+**Limits:**
+
+| Limit | Value | Behavior when exceeded |
+|---|---|---|
+| Targets per call (normal) | 5 (`MAX_FORWARD_TARGETS`) | Client: `ForwardPicker` disables further selection. Server: request rejected with a validation error if bypassed. |
+| Targets per call — highly-forwarded content (`forwardDepth >= 5`) | **1** | Server silently truncates to the first target and reports every dropped target back as an explicit `{ success: false, error }` entry in `ForwardResult[]` — never a validation error, never a fully blocked forward. Matches WhatsApp's actual behavior: reduced fan-out, not a forwarding ban. |
+| Forward API rate limit | 20 calls/min per user | `429` if exceeded (server-side `@Throttle`, not currently surfaced as a distinct client-side pre-check). |
+| Forward-count hard cap | **None** | A message can be forwarded any number of times — there is no "forwarded too many times, blocked" state. Only fan-out width is reduced at high `forwardDepth`; `forwardDepth` itself only ever drives the "Forwarded many times" label. |
+
+Because dropped targets from the highly-forwarded cap come back as regular `ForwardResult` failures, existing "Forwarded to N/M chats" UI (see the example below) needs no special-casing to handle it correctly.
+
+```typescript
+interface MessageForwardReference {
+  originalMessageId: string;        // one hop back only — never the root of a longer chain
+  originalConversationId: string;   // one hop back only
+  originalSenderId: string;         // one hop back only — NOT the original author past 1 hop
+  forwardDepth: number;             // accumulates across the whole chain
+}
+
+interface ForwardResult {
+  conversationId: string;
+  success: boolean;
+  message?: Message;   // present when success is true
+  error?: string;      // present when success is false
+}
+```
+
+```typescript
+const results = await messagesApi.forward(messageId, [convA, convB, convC]);
+const failed = results.filter(r => !r.success);
+if (failed.length > 0) {
+  console.warn(`Forward failed for ${failed.length}/${results.length} conversations`, failed);
+}
+```
+
+**Why only one hop of lineage is kept.** `forwardedFrom` always points at the *immediate* message being forwarded, never the ultimate original — matching WhatsApp: if you forward a message that was itself already forwarded, the new copy's `originalMessageId`/`originalSenderId` reference that intermediate copy, not the very first message in the chain. This is intentional: it keeps the true original author untraceable after more than one hop (privacy), while `forwardDepth` still accumulates across the whole chain. `forwardDepth` drives two things, both purely about slowing spread, never about blocking it: the "Forwarded many times" badge (client convention: `forwardDepth >= 4`), and server-side, the reduced 1-target fan-out cap once `forwardDepth >= 5` (see Limits above). There is no API to walk a message's full forward history — only the immediate parent is ever resolvable, and there is no forward-count ceiling that ever blocks forwarding outright.
+
+**Attachments are never re-uploaded.** A forwarded attachment reuses the same underlying storage object as the source message — only the message row referencing it is new. This is transparent to SDK consumers; `forward()` handles it server-side.
+
+**Rendering:** show a "Forwarded" (or "Forwarded many times" at `forwardDepth >= 4`) label when `message.forwardedFrom` is present — do not render a sender name or content preview for it (unlike `replyTo`), since the message's own `content` already holds what was forwarded. The built-in `MessageItem` component in both `@antzsoft/chat-web-sdk` and `@antzsoft/chat-rn-sdk` already renders this label and exposes a "Forward" action in the message menu — no extra wiring needed if you're using the prebuilt UI.
+
 #### Jump to first unread message
 
 Use `direction: 'after'` with the user's `lastReadMessageId` as the cursor to fetch only the unread messages. This powers a scroll-to-first-unread experience with an "↑ Unread messages" divider.
@@ -945,6 +997,8 @@ import { conversationsApi } from '@antzsoft/chat-core';
 | `unmute` | `(conversationId: string) => Promise<void>` | Unmute a conversation. |
 | `pin` | `(conversationId: string) => Promise<void>` | Pin a conversation to the top of the list. Max 5 pins — server returns `400` if the limit is reached. |
 | `unpin` | `(conversationId: string) => Promise<void>` | Unpin a conversation. |
+| `markUnread` | `(conversationId: string) => Promise<void>` | Manually flag a conversation as unread (`Conversation.isManuallyUnread` becomes `true`), independent of `unreadCount`. |
+| `markRead` | `(conversationId: string) => Promise<void>` | Clear the manual unread flag. Also cleared automatically whenever the conversation is opened/read through the normal mark-as-read flow. |
 | `leave` | `(conversationId: string, andDelete?: boolean) => Promise<void>` | Leave a group conversation. Pass `andDelete: true` to also hide it from the caller's list in one atomic operation ("Exit and Delete"). When the last admin calls `leave()`, the server automatically promotes the longest-standing active member to admin before completing the exit — no client action required. |
 | `getMembers` | `(conversationId: string) => Promise<User[]>` | Fetch full user profiles for all participants. |
 
@@ -1165,6 +1219,44 @@ async function onForeground() {
 
 > **Using `@antzsoft/chat-web-sdk` or `@antzsoft/chat-rn-sdk`?** You don't need any of this — `useConversations()` handles socket subscriptions internally. Just sum `conversations.reduce((s, c) => s + (c.unreadCount ?? 0), 0)` and it updates automatically.
 
+#### Mark as Unread (v1.4.1+)
+
+`isManuallyUnread` is a separate flag from `unreadCount` — it lets a user re-flag a conversation they've already read so it stands out again in the list, without fabricating unread messages or moving the read-receipt cursor. This is the same "mark as unread" behavior as WhatsApp/Telegram: a dot indicator, not a count.
+
+| Field / method | Type | Description |
+|---|---|---|
+| `Conversation.isManuallyUnread` | `boolean \| undefined` | `true` once flagged; `false`/absent otherwise. Independent of `unreadCount` — both can be `true`/`>0` at once, or `isManuallyUnread` can be `true` while `unreadCount` is `0`. |
+| `conversationsApi.markUnread(id)` | `Promise<void>` | Sets the flag. |
+| `conversationsApi.markRead(id)` | `Promise<void>` | Clears the flag. |
+
+```typescript
+// Flag a fully-read conversation as unread
+await conversationsApi.markUnread(conversationId);
+
+// Clear it manually (rarely needed — see auto-clear below)
+await conversationsApi.markRead(conversationId);
+
+// Render: numbered badge takes priority; fall back to a plain dot
+const conv = await conversationsApi.get(conversationId);
+if ((conv.unreadCount ?? 0) > 0) {
+  showBadge(conv.unreadCount);
+} else if (conv.isManuallyUnread) {
+  showDot();
+}
+```
+
+**Auto-clears on read.** Opening the conversation — anything that runs the normal mark-as-read flow (socket `mark_read`, or the REST notification-catchup path) — clears `isManuallyUnread` server-side automatically, same as WhatsApp. You do not need to call `markRead()` yourself after the user opens the chat; it's only for the explicit "un-flag without opening" action (e.g. an X button on the dot).
+
+**Live sync across devices.** Unlike `mute`/`pin` (which currently only take effect on the next fetch), toggling `isManuallyUnread` emits a `conversation_updated` socket event to the caller's other connected sessions immediately:
+
+```typescript
+socket?.on('conversation_updated', (conv) => {
+  // conv.isManuallyUnread reflects the latest state, pushed live
+});
+```
+
+**Web/RN SDK hooks expose named mutations:** `markUnread`, `markRead` (both SDKs) — cache updated optimistically, no manual invalidation needed. The built-in `ConversationList` component already renders the dot and exposes the toggle from its existing Pin/Mute menu.
+
 #### Clear / Delete Chat (v1.2.6+)
 
 `conversationsApi.delete(conversationId)` hides a conversation from the caller's list. Any participant can call it — no admin role required. Other participants are completely unaffected.
@@ -2845,6 +2937,7 @@ interface Conversation {
   isPinned?: boolean;
   isMuted?: boolean;
   mutedUntil?: string;
+  isManuallyUnread?: boolean;  // v1.4.1+ — manually flagged unread, independent of unreadCount
 }
 
 interface ConversationSettings {
@@ -3122,6 +3215,24 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 
 ## Changelog
 
+### v1.4.1
+
+- **New: manual "mark as unread."** A conversation can now be flagged unread independently of `unreadCount` — the same UX as WhatsApp/Telegram's "mark as unread": re-flag a conversation you've already read so it stands out again, without fabricating unread messages.
+  - **New field:** `Conversation.isManuallyUnread?: boolean`. Present on every conversation object returned from `conversationsApi.list/get`, and on `conversation_created`/`conversation_updated` socket payloads that carry a full conversation DTO. `false`/absent for a conversation that has never been manually flagged.
+  - **New API methods:** `conversationsApi.markUnread(conversationId)` and `conversationsApi.markRead(conversationId)` — both `Promise<void>`, following the same shape as `pin`/`unpin`.
+  - **Auto-clears on read.** Opening the conversation (anything that calls the existing mark-as-read flow — socket `mark_read` or the REST notification-catchup path) clears the flag server-side automatically, same as WhatsApp: you don't have to manually un-flag it after reading.
+  - **Live sync.** Toggling the flag emits a `conversation_updated` event to the caller's other connected devices/tabs, so mark-unread/mark-read state stays in sync across sessions immediately — unlike `mute`/`pin`, which currently only take effect on next fetch.
+
+  **Backward compatible, additive-only.** `isManuallyUnread` is optional; an older SDK against a server with this change simply ignores the extra field. **No integration changes required** unless you want to surface the new flag/actions in your own conversation list UI (the RN and web SDKs' built-in `ConversationList` already do, see their changelogs).
+
+### v1.4.0
+
+- **Fix: stale transit encryption key after token refresh, causing continuous `"Transit decryption failed for event: user_online"` spam.** `reconnectSocket()` called `socket.connect()` to apply a refreshed token while preserving the transit session — but socket.io-client's `connect()` is a no-op on an already-connected socket. A token refresh fires while the user is actively on a chat screen (socket still connected), so the new auth was never actually sent; the socket kept running on the stale token until the server eventually dropped it, and the disconnect handler then cleared the transit session, desyncing the client's key from the server's.
+
+  **Fix:** in the transit branch of `reconnectSocket()`, force a real transport re-cycle (disconnect → connect) so the fresh auth (token + `transitSessionId`) is actually sent and the server re-links the *same* session (same key), instead of silently continuing on stale auth. A new internal `_preservingSession` guard stops the disconnect handler from wiping the key being deliberately carried forward. Non-transit and already-disconnected paths are unchanged.
+
+  **Backward compatible.** Only affects transit-encryption deployments that refresh auth tokens while the socket is connected. **No integration changes required** — the fix is entirely internal to `reconnectSocket()`.
+
 ### v1.3.9
 
 - **New: group @mentions.** Tag members in a group message; a mentioned user is notified even if they muted the group (the mention pierces mute). Mentions are stored inline in the message text as self-describing tokens `@[DisplayName](userId)` (and `@[all](all)` for @all), plus a flat, denormalized `mentions: string[]` array on the message for fan-out and "who was mentioned" lookups. No offsets are stored — the token is self-locating and survives edits.

package/dist/chat.store-UVTDBPEC.js

@@ -0,0 +1,7 @@
+import {
+  useChatStore
+} from "./chunk-UIYJAOGL.js";
+export {
+  useChatStore
+};
+//# sourceMappingURL=chat.store-UVTDBPEC.js.map

package/dist/{chunk-EOL5B7GS.js → chunk-UIYJAOGL.js}

@@ -9,11 +9,12 @@ var useChatStore = create((set) => ({
   lastSeen: {},
   replyingTo: null,
   editingMessage: null,
+  forwardingMessage: null,
   isSidebarOpen: true,
   isGroupInfoOpen: false,
   isStarredPanelOpen: false,
   messageInfoId: null,
-  setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null }),
+  setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null, forwardingMessage: null }),
   setPendingTarget: (target) => set({ pendingTarget: target }),
   addTypingUser: (conversationId, user) => set((state) => {
     const existing = state.typingUsers[conversationId] ?? [];
@@ -45,6 +46,7 @@ var useChatStore = create((set) => ({
   }),
   setReplyingTo: (message) => set({ replyingTo: message, editingMessage: null }),
   setEditingMessage: (message) => set({ editingMessage: message, replyingTo: null }),
+  setForwardingMessage: (message) => set({ forwardingMessage: message }),
   toggleSidebar: () => set((state) => ({ isSidebarOpen: !state.isSidebarOpen })),
   setSidebarOpen: (open) => set({ isSidebarOpen: open }),
   toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),
@@ -57,4 +59,4 @@ var useChatStore = create((set) => ({
 export {
   useChatStore
 };
-//# sourceMappingURL=chunk-EOL5B7GS.js.map
+//# sourceMappingURL=chunk-UIYJAOGL.js.map

package/dist/chunk-UIYJAOGL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/stores/chat.store.ts"],"sourcesContent":["import { create } from 'zustand';\nimport type { Message } from '../types/index.js';\n\ninterface TypingUser {\n  userId: string;\n  displayName: string;\n  avatarUrl?: string;\n}\n\nexport interface LastReadEntry {\n  messageId: string;\n  readAt: string;\n}\n\ninterface ChatState {\n  activeConversationId: string | null;\n  pendingTarget: { conversationId: string; messageId: string } | null;\n  typingUsers: Record<string, TypingUser[]>;\n  onlineUsers: string[];\n  /** keyed by conversationId — current user's last read pointer per conversation */\n  lastRead: Record<string, LastReadEntry>;\n  /** keyed by userId — last seen timestamp for each user */\n  lastSeen: Record<string, string>;\n  replyingTo: Message | null;\n  editingMessage: Message | null;\n  /** Message staged in the forward picker, null = picker closed. Unlike replyingTo,\n   * this does not fold into the next composer send — forwarding targets a different\n   * conversation and needs its own conversation-picker UI. */\n  forwardingMessage: Message | null;\n  isSidebarOpen: boolean;\n  isGroupInfoOpen: boolean;\n  isStarredPanelOpen: boolean;\n  /** messageId currently shown in the Message Info panel, null = closed */\n  messageInfoId: string | null;\n\n  setActiveConversation: (id: string | null) => void;\n  setPendingTarget: (target: { conversationId: string; messageId: string } | null) => void;\n  addTypingUser: (conversationId: string, user: TypingUser) => void;\n  removeTypingUser: (conversationId: string, userId: string) => void;\n  setUserOnline: (userId: string) => void;\n  setUserOffline: (userId: string) => void;\n  setOnlineUsers: (userIds: string[]) => void;\n  setLastRead: (conversationId: string, messageId: string, readAt: string) => void;\n  setLastSeen: (userId: string, lastSeenAt: string | null) => void;\n  setReplyingTo: (message: Message | null) => void;\n  setEditingMessage: (message: Message | null) => void;\n  setForwardingMessage: (message: Message | null) => void;\n  toggleSidebar: () => void;\n  setSidebarOpen: (open: boolean) => void;\n  toggleGroupInfo: () => void;\n  setGroupInfoOpen: (open: boolean) => void;\n  toggleStarredPanel: () => void;\n  setStarredPanelOpen: (open: boolean) => void;\n  setMessageInfoId: (id: string | null) => void;\n}\n\nexport const useChatStore = create<ChatState>((set) => ({\n  activeConversationId: null,\n  pendingTarget: null,\n  typingUsers: {},\n  onlineUsers: [],\n  lastRead: {},\n  lastSeen: {},\n  replyingTo: null,\n  editingMessage: null,\n  forwardingMessage: null,\n  isSidebarOpen: true,\n  isGroupInfoOpen: false,\n  isStarredPanelOpen: false,\n  messageInfoId: null,\n\n  setActiveConversation: (id) =>\n    set({ activeConversationId: id, replyingTo: null, editingMessage: null, forwardingMessage: null }),\n\n  setPendingTarget: (target) => set({ pendingTarget: target }),\n\n  addTypingUser: (conversationId, user) =>\n    set((state) => {\n      const existing = state.typingUsers[conversationId] ?? [];\n      const deduped = existing.filter((u) => u.userId !== user.userId);\n      return { typingUsers: { ...state.typingUsers, [conversationId]: [...deduped, user] } };\n    }),\n\n  removeTypingUser: (conversationId, userId) =>\n    set((state) => ({\n      typingUsers: {\n        ...state.typingUsers,\n        [conversationId]: (state.typingUsers[conversationId] ?? []).filter(\n          (u) => u.userId !== userId,\n        ),\n      },\n    })),\n\n  setUserOnline: (userId) =>\n    set((state) => ({\n      onlineUsers: state.onlineUsers.includes(userId)\n        ? state.onlineUsers\n        : [...state.onlineUsers, userId],\n    })),\n\n  setUserOffline: (userId) =>\n    set((state) => ({ onlineUsers: state.onlineUsers.filter((id) => id !== userId) })),\n\n  setOnlineUsers: (userIds) => set({ onlineUsers: userIds }),\n\n  setLastRead: (conversationId, messageId, readAt) =>\n    set((state) => ({\n      lastRead: { ...state.lastRead, [conversationId]: { messageId, readAt } },\n    })),\n\n  setLastSeen: (userId, lastSeenAt) =>\n    set((state) => {\n      if (lastSeenAt === null) {\n        const { [userId]: _, ...rest } = state.lastSeen;\n        return { lastSeen: rest };\n      }\n      return { lastSeen: { ...state.lastSeen, [userId]: lastSeenAt } };\n    }),\n\n  setReplyingTo: (message) => set({ replyingTo: message, editingMessage: null }),\n\n  setEditingMessage: (message) => set({ editingMessage: message, replyingTo: null }),\n\n  setForwardingMessage: (message) => set({ forwardingMessage: message }),\n\n  toggleSidebar: () => set((state) => ({ isSidebarOpen: !state.isSidebarOpen })),\n  setSidebarOpen: (open) => set({ isSidebarOpen: open }),\n\n  toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),\n  setGroupInfoOpen: (open) => set({ isGroupInfoOpen: open }),\n\n  toggleStarredPanel: () => set((state) => ({ isStarredPanelOpen: !state.isStarredPanelOpen })),\n  setStarredPanelOpen: (open) => set({ isStarredPanelOpen: open }),\n\n  setMessageInfoId: (id: string | null) => set({ messageInfoId: id }),\n}));\n"],"mappings":"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","names":[]}

package/dist/index.cjs

@@ -49,11 +49,12 @@ var init_chat_store = __esm({
       lastSeen: {},
       replyingTo: null,
       editingMessage: null,
+      forwardingMessage: null,
       isSidebarOpen: true,
       isGroupInfoOpen: false,
       isStarredPanelOpen: false,
       messageInfoId: null,
-      setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null }),
+      setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null, forwardingMessage: null }),
       setPendingTarget: (target) => set({ pendingTarget: target }),
       addTypingUser: (conversationId, user) => set((state) => {
         const existing = state.typingUsers[conversationId] ?? [];
@@ -85,6 +86,7 @@ var init_chat_store = __esm({
       }),
       setReplyingTo: (message) => set({ replyingTo: message, editingMessage: null }),
       setEditingMessage: (message) => set({ editingMessage: message, replyingTo: null }),
+      setForwardingMessage: (message) => set({ forwardingMessage: message }),
       toggleSidebar: () => set((state) => ({ isSidebarOpen: !state.isSidebarOpen })),
       setSidebarOpen: (open) => set({ isSidebarOpen: open }),
       toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),
@@ -106,6 +108,7 @@ __export(src_exports, {
   AntzChatPermissionError: () => AntzChatPermissionError,
   AntzChatServerError: () => AntzChatServerError,
   AntzChatValidationError: () => AntzChatValidationError,
+  MAX_FORWARD_TARGETS: () => MAX_FORWARD_TARGETS,
   MENTION_ALL_ID: () => MENTION_ALL_ID,
   appConfigApi: () => appConfigApi,
   authApi: () => authApi,
@@ -1010,6 +1013,7 @@ function resolveSystemMessageText(message, currentUserId) {
 }
 
 // src/api/messages.ts
+var MAX_FORWARD_TARGETS = 5;
 var messagesApi = {
   async list(conversationId, params = {}) {
     const { cursor, direction, ...rest } = params;
@@ -1103,6 +1107,19 @@ var messagesApi = {
   async getReceipts(messageId) {
     const { data } = await getApiClient().get(`/messages/${messageId}/receipts`);
     return data;
+  },
+  /**
+   * Forwards a message into one or more target conversations (max MAX_FORWARD_TARGETS
+   * per call, also enforced server-side). Each target is independent — one failing
+   * (e.g. no longer a participant) does not block the others; check `success`/`error`
+   * per entry in the returned array.
+   */
+  async forward(messageId, targetConversationIds) {
+    const { data } = await getApiClient().post(
+      `/messages/${messageId}/forward`,
+      { targetConversationIds }
+    );
+    return data;
   }
 };
 
@@ -1216,6 +1233,12 @@ var conversationsApi = {
   async unpin(conversationId) {
     await getApiClient().post(`/conversations/${conversationId}/unpin`);
   },
+  async markUnread(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unread`);
+  },
+  async markRead(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unread/clear`);
+  },
   async leave(conversationId, andDelete) {
     const url = andDelete ? `/conversations/${conversationId}/leave?delete=true` : `/conversations/${conversationId}/leave`;
     await getApiClient().post(url);
@@ -2090,6 +2113,7 @@ var AntzChatClient = class {
   AntzChatPermissionError,
   AntzChatServerError,
   AntzChatValidationError,
+  MAX_FORWARD_TARGETS,
   MENTION_ALL_ID,
   appConfigApi,
   authApi,