@amityco/ts-sdk 7.26.1-db34ef5c.0 → 7.26.1-e618fbd1.0

package/dist/index.cjs.js

@@ -3842,6 +3842,53 @@ const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpd
         channelUsers });
 };
 
+const channelCacheKey = (channel) => [
+    'channel',
+    'get',
+    getResolver('channel')(channel),
+];
+/**
+ * Find a cached channel by any of its ids (internal, public, or `channelId`).
+ *
+ * The channel cache is keyed by the channel internal id (see `idResolvers.channel`), but
+ * realtime payloads reference channels by different ids: pin events carry the **public**
+ * id, messages carry `channelId`. Try the cheap direct lookup first, then scan.
+ */
+const findCachedChannelByAnyId = (id) => {
+    var _a, _b, _c;
+    if (!id)
+        return undefined;
+    const direct = (_a = pullFromCache(['channel', 'get', id])) === null || _a === void 0 ? void 0 : _a.data;
+    if (direct)
+        return direct;
+    return (_c = (_b = queryCache(['channel', 'get'])) === null || _b === void 0 ? void 0 : _b.find(({ data }) => data.channelInternalId === id || data.channelPublicId === id || data.channelId === id)) === null || _c === void 0 ? void 0 : _c.data;
+};
+/**
+ * Resolve the cached channel a `channel.messagePinned` / `channel.messageUnpinned` event
+ * refers to. `data.channelId` is the channel public id; a pinned message body (present on
+ * `messagePinned` only) also carries the internal id, which is the direct cache key.
+ */
+const findCachedChannelForPin = (payload) => {
+    var _a, _b;
+    return (_b = findCachedChannelByAnyId((_a = payload.pinnedMessage) === null || _a === void 0 ? void 0 : _a.channelId)) !== null && _b !== void 0 ? _b : findCachedChannelByAnyId(payload.channelId);
+};
+/**
+ * Write a new pin snapshot (or `null` to clear) on a cached channel and ingest any
+ * users delivered with it (the pin author and the message author), so the banner can
+ * render a byline without a second fetch.
+ *
+ * Every `messagePinned` payload is a full snapshot — "this is the pin now" — so the last
+ * one received always wins; there is no merging with the previous pin.
+ */
+const updatePinnedMessageCache = (channel, pinnedMessage, users) => {
+    if (users && users.length > 0) {
+        ingestInCache({ users: users.map(convertRawUserToInternalUser) });
+    }
+    const updated = Object.assign(Object.assign({}, channel), { pinnedMessage });
+    pushToCache(channelCacheKey(channel), updated);
+    return updated;
+};
+
 /**
  * ```js
  * import { getSubChannelMarkers } from '@amityco/ts-sdk'
@@ -4123,55 +4170,55 @@ function isEqual(x, y) {
         }));
 }
 
-const callbacks$c = [];
-let mainDisposer$b = null;
-const dispose$c = (cb) => {
-    const index = callbacks$c.indexOf(cb);
+const callbacks$e = [];
+let mainDisposer$d = null;
+const dispose$e = (cb) => {
+    const index = callbacks$e.indexOf(cb);
     if (index > -1) {
-        callbacks$c.splice(index, 1);
+        callbacks$e.splice(index, 1);
     }
-    if (callbacks$c.length === 0) {
-        mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
+    if (callbacks$e.length === 0) {
+        mainDisposer$d === null || mainDisposer$d === void 0 ? void 0 : mainDisposer$d();
     }
 };
 const onChannelCreated = (callback) => {
-    if (callbacks$c.length === 0) {
+    if (callbacks$e.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
             ingestInCache(data);
-            callbacks$c.forEach(cb => cb(data.channels[0]));
+            callbacks$e.forEach(cb => cb(data.channels[0]));
         };
-        mainDisposer$b = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+        mainDisposer$d = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
     }
-    callbacks$c.push(callback);
-    return () => dispose$c(callback);
+    callbacks$e.push(callback);
+    return () => dispose$e(callback);
 };
 
-const callbacks$b = [];
+const callbacks$d = [];
 const mainDisposers = [];
-const dispose$b = (cb) => {
-    const index = callbacks$b.indexOf(cb);
+const dispose$d = (cb) => {
+    const index = callbacks$d.indexOf(cb);
     if (index > -1) {
-        callbacks$b.splice(index, 1);
+        callbacks$d.splice(index, 1);
     }
-    if (callbacks$b.length === 0) {
+    if (callbacks$d.length === 0) {
         mainDisposers.forEach(fn => fn());
     }
 };
 const onChannelUpdated = (callback) => {
     const client = getActiveClient();
-    if (callbacks$b.length === 0) {
+    if (callbacks$d.length === 0) {
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
             ingestInCache(data);
-            callbacks$b.forEach(cb => cb(data.channels[0]));
+            callbacks$d.forEach(cb => cb(data.channels[0]));
         };
         mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
-        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$b.forEach(cb => cb(payload.channels[0]))));
+        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$d.forEach(cb => cb(payload.channels[0]))));
     }
-    callbacks$b.push(callback);
-    return () => dispose$b(callback);
+    callbacks$d.push(callback);
+    return () => dispose$d(callback);
 };
 
 const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId) => {
@@ -4194,19 +4241,19 @@ const deleteChannelUnreadByChannelId = (channelId) => {
     }
 };
 
-const callbacks$a = [];
-let mainDisposer$a = null;
-const dispose$a = (cb) => {
-    const index = callbacks$a.indexOf(cb);
+const callbacks$c = [];
+let mainDisposer$c = null;
+const dispose$c = (cb) => {
+    const index = callbacks$c.indexOf(cb);
     if (index > -1) {
-        callbacks$a.splice(index, 1);
+        callbacks$c.splice(index, 1);
     }
-    if (callbacks$a.length === 0) {
-        mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
+    if (callbacks$c.length === 0) {
+        mainDisposer$c === null || mainDisposer$c === void 0 ? void 0 : mainDisposer$c();
     }
 };
 const onChannelDeleted = (callback) => {
-    if (callbacks$a.length === 0) {
+    if (callbacks$c.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
@@ -4226,53 +4273,53 @@ const onChannelDeleted = (callback) => {
                 }
             });
             ingestInCache(data);
-            callbacks$a.forEach(cb => cb(data.channels[0]));
+            callbacks$c.forEach(cb => cb(data.channels[0]));
         };
-        mainDisposer$a = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+        mainDisposer$c = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
     }
-    callbacks$a.push(callback);
-    return () => dispose$a(callback);
+    callbacks$c.push(callback);
+    return () => dispose$c(callback);
 };
 
-const callbacks$9 = [];
-let mainDisposer$9 = null;
-const dispose$9 = (cb) => {
-    const index = callbacks$9.indexOf(cb);
+const callbacks$b = [];
+let mainDisposer$b = null;
+const dispose$b = (cb) => {
+    const index = callbacks$b.indexOf(cb);
     if (index > -1) {
-        callbacks$9.splice(index, 1);
+        callbacks$b.splice(index, 1);
     }
-    if (callbacks$9.length === 0) {
-        mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
+    if (callbacks$b.length === 0) {
+        mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
     }
 };
 const onChannelJoined = (callback) => {
-    if (callbacks$9.length === 0) {
+    if (callbacks$b.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const preparedPayload = await prepareChannelPayload(payload);
             const { channels, channelUsers } = preparedPayload;
             ingestInCache(preparedPayload);
-            callbacks$9.forEach(cb => cb(channels[0], channelUsers[0]));
+            callbacks$b.forEach(cb => cb(channels[0], channelUsers[0]));
         };
-        mainDisposer$9 = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+        mainDisposer$b = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
     }
-    callbacks$9.push(callback);
-    return () => dispose$9(callback);
+    callbacks$b.push(callback);
+    return () => dispose$b(callback);
 };
 
-const callbacks$8 = [];
-let mainDisposer$8 = null;
-const dispose$8 = (cb) => {
-    const index = callbacks$8.indexOf(cb);
+const callbacks$a = [];
+let mainDisposer$a = null;
+const dispose$a = (cb) => {
+    const index = callbacks$a.indexOf(cb);
     if (index > -1) {
-        callbacks$8.splice(index, 1);
+        callbacks$a.splice(index, 1);
     }
-    if (callbacks$8.length === 0) {
-        mainDisposer$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
+    if (callbacks$a.length === 0) {
+        mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
     }
 };
 const onChannelLeft = (callback) => {
-    if (callbacks$8.length === 0) {
+    if (callbacks$a.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const { userId } = getActiveClient();
@@ -4296,27 +4343,27 @@ const onChannelLeft = (callback) => {
             }
             const { channels, channelUsers } = preparedPayload;
             ingestInCache(preparedPayload);
-            callbacks$8.forEach(cb => cb(channels[0], channelUsers[0]));
+            callbacks$a.forEach(cb => cb(channels[0], channelUsers[0]));
         };
-        mainDisposer$8 = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+        mainDisposer$a = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
     }
-    callbacks$8.push(callback);
-    return () => dispose$8(callback);
+    callbacks$a.push(callback);
+    return () => dispose$a(callback);
 };
 
-const callbacks$7 = [];
-let mainDisposer$7 = null;
-const dispose$7 = (cb) => {
-    const index = callbacks$7.indexOf(cb);
+const callbacks$9 = [];
+let mainDisposer$9 = null;
+const dispose$9 = (cb) => {
+    const index = callbacks$9.indexOf(cb);
     if (index > -1) {
-        callbacks$7.splice(index, 1);
+        callbacks$9.splice(index, 1);
     }
-    if (callbacks$7.length === 0) {
-        mainDisposer$7 === null || mainDisposer$7 === void 0 ? void 0 : mainDisposer$7();
+    if (callbacks$9.length === 0) {
+        mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
     }
 };
 const onChannelSetMuted = (callback) => {
-    if (callbacks$7.length === 0) {
+    if (callbacks$9.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             var _a;
@@ -4331,14 +4378,114 @@ const onChannelSetMuted = (callback) => {
                 payload.channelId,
             ])) === null || _a === void 0 ? void 0 : _a.data;
             if (channel) {
-                callbacks$7.forEach(cb => cb(channel));
+                callbacks$9.forEach(cb => cb(channel));
             }
         };
-        mainDisposer$7 = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
+        mainDisposer$9 = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
+    }
+    callbacks$9.push(callback);
+    return () => dispose$9(callback);
+};
+
+const callbacks$8 = [];
+let mainDisposer$8 = null;
+const dispose$8 = (cb) => {
+    const index = callbacks$8.indexOf(cb);
+    if (index > -1) {
+        callbacks$8.splice(index, 1);
+    }
+    if (callbacks$8.length === 0) {
+        mainDisposer$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
+    }
+};
+/* begin_public_function
+  id: channel.event.message_pinned
+*/
+/**
+ * ```js
+ * import { onChannelMessagePinned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMessagePinned(channel => {
+ *   // channel.pinnedMessage is the new pin
+ * })
+ * ```
+ *
+ * Fired when a message is pinned in a channel (the `channel.messagePinned` realtime
+ * event). Pinning a different message while one is already pinned emits a single
+ * `messagePinned` carrying the replacement — treat every payload as a full snapshot.
+ *
+ * The updated channel is written to cache before the callback runs, so
+ * `ChannelRepository.getChannel` observers see `channel.pinnedMessage` change.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to run when willing to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMessagePinned = (callback) => {
+    if (callbacks$8.length === 0) {
+        const client = getActiveClient();
+        const filter = (payload) => {
+            var _a;
+            const channel = findCachedChannelForPin(payload);
+            if (!channel)
+                return;
+            const updated = updatePinnedMessageCache(channel, (_a = payload.pinnedMessage) !== null && _a !== void 0 ? _a : null, payload.users);
+            callbacks$8.forEach(cb => cb(updated));
+        };
+        mainDisposer$8 = createEventSubscriber(client, 'onChannelMessagePinned', 'channel.messagePinned', filter);
+    }
+    callbacks$8.push(callback);
+    return () => dispose$8(callback);
+};
+/* end_public_function */
+
+const callbacks$7 = [];
+let mainDisposer$7 = null;
+const dispose$7 = (cb) => {
+    const index = callbacks$7.indexOf(cb);
+    if (index > -1) {
+        callbacks$7.splice(index, 1);
+    }
+    if (callbacks$7.length === 0) {
+        mainDisposer$7 === null || mainDisposer$7 === void 0 ? void 0 : mainDisposer$7();
+    }
+};
+/* begin_public_function
+  id: channel.event.message_unpinned
+*/
+/**
+ * ```js
+ * import { onChannelMessageUnpinned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMessageUnpinned(channel => {
+ *   // channel.pinnedMessage is now null
+ * })
+ * ```
+ *
+ * Fired when a channel's pinned message is removed (the `channel.messageUnpinned`
+ * realtime event) — either by an explicit unpin or automatically by the server when the
+ * pinned message is deleted or its author is banned from the channel / globally.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to run when willing to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMessageUnpinned = (callback) => {
+    if (callbacks$7.length === 0) {
+        const client = getActiveClient();
+        const filter = (payload) => {
+            const channel = findCachedChannelForPin(payload);
+            if (!channel)
+                return;
+            const updated = updatePinnedMessageCache(channel, null);
+            callbacks$7.forEach(cb => cb(updated));
+        };
+        mainDisposer$7 = createEventSubscriber(client, 'onChannelMessageUnpinned', 'channel.messageUnpinned', filter);
     }
     callbacks$7.push(callback);
     return () => dispose$7(callback);
 };
+/* end_public_function */
 
 const callbacks$6 = [];
 let mainDisposer$6 = null;
@@ -7734,19 +7881,21 @@ const renewal = () => {
 
 const validateAccessToken = async ({ token, userId }) => {
     const client = getActiveClient();
-    // Validate token using sessions API
-    await client.http.get('/api/v3/sessions', {
+    // Verify the token and hydrate the caller in a single call.
+    const { data } = await client.http.get('/api/v4/sessions', {
         headers: {
             Authorization: `Bearer ${token.accessToken}`,
         },
     });
-    // Get user details
-    const { data: { users }, } = await client.http.get(`/api/v3/users/${userId}`, {
-        headers: {
-            Authorization: `Bearer ${token.accessToken}`,
-        },
-    });
-    const user = users.find((u) => u.userId === userId);
+    const { users, files, userType } = data;
+    const [user] = users;
+    if (userId && (user === null || user === void 0 ? void 0 : user.userId) && userId !== user.userId) {
+        client.log('client/api/validateAccessToken', {
+            message: 'session userId does not match the token userId; using the server value',
+            tokenUserId: userId,
+            sessionUserId: user.userId,
+        });
+    }
     client.http.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
     client.http.defaults.metadata = {
         tokenExpiry: token.expiresAt,
@@ -7760,6 +7909,8 @@ const validateAccessToken = async ({ token, userId }) => {
         isUserDeleted: false,
     };
     client.token = token;
+    ingestInCache(prepareUserPayload({ users, files }));
+    setCurrentUserType(userType);
     return user;
 };
 
@@ -7842,14 +7993,6 @@ const loginWithAccessToken = async (accessToken) => {
             setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
             throw new ASCError(`User ${userId} has not been found`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
         }
-        if (user.isDeleted) {
-            setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
-            throw new ASCError(`User ${userId} has been deleted`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-        }
-        if (user.isGlobalBanned) {
-            setSessionState("notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */);
-            throw new ASCError(`User ${userId} is globally banned`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-        }
         // Set userId and login method flag
         client.userId = user.userId;
         // Set login method flag to 'accessToken' in platform-specific login session
@@ -8648,21 +8791,13 @@ const resumeSession = async (params, sessionHandler, config) => {
         if (user == null) {
             throw new ASCError(`${params.userId} has not been found`, 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
         }
-        if (user.isDeleted) {
-            terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
-            return false;
-        }
-        if (user.isGlobalBanned) {
-            terminateClient("globalBan" /* Amity.TokenTerminationReason.GLOBAL_BAN */);
-            return false;
-        }
         client.userId = user.userId;
         client.sessionHandler = sessionHandler;
         /*
          * Cannot push to subscriptions as watcher needs to continue working even if
          * token expires
          */
-        unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
+        unsubWatcher = client.accessTokenExpiryWatcher();
         setActiveUser(user);
     }
     catch (error) {
@@ -18256,20 +18391,20 @@ const getArchivedChannelIds = async () => {
 
 /**
  * ```js
- * import { onMessageUpdated } from '@amityco/ts-sdk'
- * const dispose = onMessageUpdated(message => {
+ * import { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} has been updated
+ * Fired when an {@link Amity.Message} was deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
  */
-const onMessageUpdated = (callback) => {
+const onMessageDeleted = (callback) => {
     const client = getActiveClient();
     const filter = async (rawPayload) => {
         const payload = await prepareMessagePayload(rawPayload);
@@ -18277,30 +18412,48 @@ const onMessageUpdated = (callback) => {
         callback(payload.messages[0]);
     };
     const disposers = [
-        createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
-        createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload => callback(payload.messages[0])),
+        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
+        createEventSubscriber(client, 'message/onMessageDeleted', 'local.message.deleted', payload => callback(payload.messages[0])),
     ];
     return () => {
         disposers.forEach(fn => fn());
     };
 };
 
+/**
+ * Defensive clear of `channel.pinnedMessage` when the pinned message itself is deleted.
+ *
+ * The server also emits `channel.messageUnpinned` in this case, but realtime events are
+ * fire-and-forget and their order is not guaranteed. Clearing on `message.deleted`
+ * (MQTT or local) makes the banner disappear even if the unpin event is lost; the
+ * server's own `messageUnpinned` then becomes a no-op.
+ *
+ * Internal — wired into the `getChannel` live object; not exported publicly.
+ */
+const onChannelPinnedMessageDeleted = (callback) => onMessageDeleted(message => {
+    var _a;
+    const channel = findCachedChannelByAnyId(message.channelId);
+    if (!channel || ((_a = channel.pinnedMessage) === null || _a === void 0 ? void 0 : _a.messageId) !== message.messageId)
+        return;
+    callback(updatePinnedMessageCache(channel, null));
+});
+
 /**
  * ```js
- * import { onMessageDeleted } from '@amityco/ts-sdk'
- * const dispose = onMessageDeleted(message => {
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} was deleted
+ * Fired when an {@link Amity.Message} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
  */
-const onMessageDeleted = (callback) => {
+const onMessageUpdated = (callback) => {
     const client = getActiveClient();
     const filter = async (rawPayload) => {
         const payload = await prepareMessagePayload(rawPayload);
@@ -18308,8 +18461,8 @@ const onMessageDeleted = (callback) => {
         callback(payload.messages[0]);
     };
     const disposers = [
-        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
-        createEventSubscriber(client, 'message/onMessageDeleted', 'local.message.deleted', payload => callback(payload.messages[0])),
+        createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
+        createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload => callback(payload.messages[0])),
     ];
     return () => {
         disposers.forEach(fn => fn());
@@ -18890,6 +19043,132 @@ softDeleteMessage.optimistically = (messageId) => {
 };
 /* end_public_function */
 
+/**
+ * Fire-and-forget refresh of `channelUsers[...].permissions` for the channel a
+ * message belongs to. Used by `pinMessage` / `unpinMessage` on `403` so the next
+ * `hasPermission(PIN_MESSAGE).channel(channelId)` reflects a revoked role
+ * ([`pinMessage` REQ-010](../../@types/../..) / [`unpinMessage` REQ-008](../../@types/../..)).
+ *
+ * The API only receives a `messageId`, so the channel is resolved through the
+ * local cache: first the message row, then any cached channel whose current pin
+ * is that message. When nothing matches the refresh is skipped — the next
+ * channel read picks up the fresh permissions anyway.
+ */
+const refreshChannelPermissionsForMessage = (messageId) => {
+    var _a, _b, _c;
+    const cachedMessage = (_a = getMessage$1.locally(messageId)) === null || _a === void 0 ? void 0 : _a.data;
+    let channelId = cachedMessage === null || cachedMessage === void 0 ? void 0 : cachedMessage.channelId;
+    if (!channelId) {
+        channelId = (_c = (_b = queryCache(['channel', 'get'])) === null || _b === void 0 ? void 0 : _b.find(({ data }) => { var _a; return ((_a = data.pinnedMessage) === null || _a === void 0 ? void 0 : _a.messageId) === messageId; })) === null || _c === void 0 ? void 0 : _c.data.channelId;
+    }
+    if (!channelId)
+        return;
+    getChannel$1(channelId).catch(() => {
+        /* silent per spec; UIKit renders no error toast */
+    });
+};
+
+/* begin_public_function
+  id: message.pin
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const channel = await MessageRepository.pinMessage(messageId)
+ * console.log(channel.pinnedMessage)
+ * ```
+ *
+ * Pins a {@link Amity.Message} in its livestream (`live`) channel. A channel holds at
+ * most one pinned message: pinning a different message replaces the current pin in a
+ * single step — no unpin is needed first. Pinning the message that is already pinned is
+ * rejected by the server (400).
+ *
+ * The caller must hold the `PIN_MESSAGE` permission in the channel (or be an admin with
+ * `ModerateChannel`). The server also rejects pinning a deleted message, a message whose
+ * author is banned from the channel or globally banned, and pinning in any channel type
+ * other than `live`. On any error the pin state is left unchanged.
+ *
+ * The response is the affected channel; it is ingested into cache and fires
+ * `local.channel.updated`, so `ChannelRepository.getChannel` observers update without
+ * waiting for the `channel.messagePinned` realtime event.
+ *
+ * @param messageId the **internal** ID of the {@link Amity.Message} to pin
+ * @returns the updated {@link Amity.Channel}, with `pinnedMessage` set
+ *
+ * @category Message API
+ * @async
+ */
+const pinMessage = async (messageId) => {
+    const client = getActiveClient();
+    client.log('message/pinMessage', messageId);
+    let payload;
+    try {
+        ({ data: payload } = await client.http.post(`/api/v5/messages/${encodeURIComponent(messageId)}/pin`));
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 400301 /* Amity.ServerError.PERMISSION_DENIED */) {
+            refreshChannelPermissionsForMessage(messageId);
+        }
+        throw error;
+    }
+    const data = await prepareChannelPayload(payload);
+    if (client.cache)
+        ingestInCache(data);
+    fireEvent('local.channel.updated', data);
+    return constructChannelObject(data.channels[0]);
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: message.unpin
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const channel = await MessageRepository.unpinMessage(messageId)
+ * console.log(channel.pinnedMessage) // null
+ * ```
+ *
+ * Removes the pin from a {@link Amity.Message}. `messageId` must be the message that is
+ * **currently** pinned in its channel; otherwise the server answers 400 — this is
+ * deliberate, so a stale client cannot clear a pin that someone else has since replaced.
+ * On that error, re-read the channel (or rely on the `channel.messagePinned` event) to
+ * get the current pin.
+ *
+ * The caller must hold the `PIN_MESSAGE` permission in the channel (or be an admin with
+ * `ModerateChannel`). Unpinning is allowed regardless of channel type and stream state.
+ *
+ * The response is the affected channel; it is ingested into cache and fires
+ * `local.channel.updated`, so `ChannelRepository.getChannel` observers update without
+ * waiting for the `channel.messageUnpinned` realtime event.
+ *
+ * @param messageId the **internal** ID of the currently pinned {@link Amity.Message}
+ * @returns the updated {@link Amity.Channel}, with `pinnedMessage` cleared
+ *
+ * @category Message API
+ * @async
+ */
+const unpinMessage = async (messageId) => {
+    const client = getActiveClient();
+    client.log('message/unpinMessage', messageId);
+    let payload;
+    try {
+        ({ data: payload } = await client.http.delete(`/api/v5/messages/${encodeURIComponent(messageId)}/pin`));
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 400301 /* Amity.ServerError.PERMISSION_DENIED */) {
+            refreshChannelPermissionsForMessage(messageId);
+        }
+        throw error;
+    }
+    const data = await prepareChannelPayload(payload);
+    if (client.cache)
+        ingestInCache(data);
+    fireEvent('local.channel.updated', data);
+    return constructChannelObject(data.channels[0]);
+};
+/* end_public_function */
+
 /**
  * ```js
  * import { MessageRepository } from '@amityco/ts-sdk'
@@ -19793,6 +20072,8 @@ var index$n = /*#__PURE__*/Object.freeze({
     editMessage: editMessage,
     deleteMessage: deleteMessage,
     softDeleteMessage: softDeleteMessage,
+    pinMessage: pinMessage,
+    unpinMessage: unpinMessage,
     markAsDelivered: markAsDelivered,
     getReadUsers: getReadUsers,
     getDeliveredUsers: getDeliveredUsers,
@@ -20430,6 +20711,9 @@ const getChannel = (channelId, callback) => {
         onChannelMemberBanned,
         onChannelMemberUnbanned,
         onChannelSetMuted,
+        onChannelMessagePinned,
+        onChannelMessageUnpinned,
+        onChannelPinnedMessageDeleted,
         convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
         convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
         convertEventPayload((callback) => {
@@ -22526,6 +22810,8 @@ var index$j = /*#__PURE__*/Object.freeze({
     onChannelJoined: onChannelJoined,
     onChannelLeft: onChannelLeft,
     onChannelSetMuted: onChannelSetMuted,
+    onChannelMessagePinned: onChannelMessagePinned,
+    onChannelMessageUnpinned: onChannelMessageUnpinned,
     onChannelMemberAdded: onChannelMemberAdded,
     onChannelMemberRemoved: onChannelMemberRemoved,
     onChannelMemberBanned: onChannelMemberBanned,
@@ -22543,7 +22829,10 @@ var index$j = /*#__PURE__*/Object.freeze({
     isUnreadCountSupport: isUnreadCountSupport,
     convertFromRaw: convertFromRaw,
     preUpdateChannelCache: preUpdateChannelCache,
-    prepareChannelPayload: prepareChannelPayload
+    prepareChannelPayload: prepareChannelPayload,
+    findCachedChannelByAnyId: findCachedChannelByAnyId,
+    findCachedChannelForPin: findCachedChannelForPin,
+    updatePinnedMessageCache: updatePinnedMessageCache
 });
 
 const saveCommunityUsers = (communities, communityUsers) => {