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

package/dist/index.cjs.js

@@ -3842,53 +3842,6 @@ 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'
@@ -4170,55 +4123,55 @@ function isEqual(x, y) {
         }));
 }
 
-const callbacks$e = [];
-let mainDisposer$d = null;
-const dispose$e = (cb) => {
-    const index = callbacks$e.indexOf(cb);
+const callbacks$c = [];
+let mainDisposer$b = null;
+const dispose$c = (cb) => {
+    const index = callbacks$c.indexOf(cb);
     if (index > -1) {
-        callbacks$e.splice(index, 1);
+        callbacks$c.splice(index, 1);
     }
-    if (callbacks$e.length === 0) {
-        mainDisposer$d === null || mainDisposer$d === void 0 ? void 0 : mainDisposer$d();
+    if (callbacks$c.length === 0) {
+        mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
     }
 };
 const onChannelCreated = (callback) => {
-    if (callbacks$e.length === 0) {
+    if (callbacks$c.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
             ingestInCache(data);
-            callbacks$e.forEach(cb => cb(data.channels[0]));
+            callbacks$c.forEach(cb => cb(data.channels[0]));
         };
-        mainDisposer$d = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
+        mainDisposer$b = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
     }
-    callbacks$e.push(callback);
-    return () => dispose$e(callback);
+    callbacks$c.push(callback);
+    return () => dispose$c(callback);
 };
 
-const callbacks$d = [];
+const callbacks$b = [];
 const mainDisposers = [];
-const dispose$d = (cb) => {
-    const index = callbacks$d.indexOf(cb);
+const dispose$b = (cb) => {
+    const index = callbacks$b.indexOf(cb);
     if (index > -1) {
-        callbacks$d.splice(index, 1);
+        callbacks$b.splice(index, 1);
     }
-    if (callbacks$d.length === 0) {
+    if (callbacks$b.length === 0) {
         mainDisposers.forEach(fn => fn());
     }
 };
 const onChannelUpdated = (callback) => {
     const client = getActiveClient();
-    if (callbacks$d.length === 0) {
+    if (callbacks$b.length === 0) {
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
             ingestInCache(data);
-            callbacks$d.forEach(cb => cb(data.channels[0]));
+            callbacks$b.forEach(cb => cb(data.channels[0]));
         };
         mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
-        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$d.forEach(cb => cb(payload.channels[0]))));
+        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$b.forEach(cb => cb(payload.channels[0]))));
     }
-    callbacks$d.push(callback);
-    return () => dispose$d(callback);
+    callbacks$b.push(callback);
+    return () => dispose$b(callback);
 };
 
 const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId) => {
@@ -4241,19 +4194,19 @@ const deleteChannelUnreadByChannelId = (channelId) => {
     }
 };
 
-const callbacks$c = [];
-let mainDisposer$c = null;
-const dispose$c = (cb) => {
-    const index = callbacks$c.indexOf(cb);
+const callbacks$a = [];
+let mainDisposer$a = null;
+const dispose$a = (cb) => {
+    const index = callbacks$a.indexOf(cb);
     if (index > -1) {
-        callbacks$c.splice(index, 1);
+        callbacks$a.splice(index, 1);
     }
-    if (callbacks$c.length === 0) {
-        mainDisposer$c === null || mainDisposer$c === void 0 ? void 0 : mainDisposer$c();
+    if (callbacks$a.length === 0) {
+        mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
     }
 };
 const onChannelDeleted = (callback) => {
-    if (callbacks$c.length === 0) {
+    if (callbacks$a.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
@@ -4273,53 +4226,53 @@ const onChannelDeleted = (callback) => {
                 }
             });
             ingestInCache(data);
-            callbacks$c.forEach(cb => cb(data.channels[0]));
+            callbacks$a.forEach(cb => cb(data.channels[0]));
         };
-        mainDisposer$c = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
+        mainDisposer$a = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
     }
-    callbacks$c.push(callback);
-    return () => dispose$c(callback);
+    callbacks$a.push(callback);
+    return () => dispose$a(callback);
 };
 
-const callbacks$b = [];
-let mainDisposer$b = null;
-const dispose$b = (cb) => {
-    const index = callbacks$b.indexOf(cb);
+const callbacks$9 = [];
+let mainDisposer$9 = null;
+const dispose$9 = (cb) => {
+    const index = callbacks$9.indexOf(cb);
     if (index > -1) {
-        callbacks$b.splice(index, 1);
+        callbacks$9.splice(index, 1);
     }
-    if (callbacks$b.length === 0) {
-        mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
+    if (callbacks$9.length === 0) {
+        mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
     }
 };
 const onChannelJoined = (callback) => {
-    if (callbacks$b.length === 0) {
+    if (callbacks$9.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const preparedPayload = await prepareChannelPayload(payload);
             const { channels, channelUsers } = preparedPayload;
             ingestInCache(preparedPayload);
-            callbacks$b.forEach(cb => cb(channels[0], channelUsers[0]));
+            callbacks$9.forEach(cb => cb(channels[0], channelUsers[0]));
         };
-        mainDisposer$b = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
+        mainDisposer$9 = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
     }
-    callbacks$b.push(callback);
-    return () => dispose$b(callback);
+    callbacks$9.push(callback);
+    return () => dispose$9(callback);
 };
 
-const callbacks$a = [];
-let mainDisposer$a = null;
-const dispose$a = (cb) => {
-    const index = callbacks$a.indexOf(cb);
+const callbacks$8 = [];
+let mainDisposer$8 = null;
+const dispose$8 = (cb) => {
+    const index = callbacks$8.indexOf(cb);
     if (index > -1) {
-        callbacks$a.splice(index, 1);
+        callbacks$8.splice(index, 1);
     }
-    if (callbacks$a.length === 0) {
-        mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
+    if (callbacks$8.length === 0) {
+        mainDisposer$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
     }
 };
 const onChannelLeft = (callback) => {
-    if (callbacks$a.length === 0) {
+    if (callbacks$8.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const { userId } = getActiveClient();
@@ -4343,27 +4296,27 @@ const onChannelLeft = (callback) => {
             }
             const { channels, channelUsers } = preparedPayload;
             ingestInCache(preparedPayload);
-            callbacks$a.forEach(cb => cb(channels[0], channelUsers[0]));
+            callbacks$8.forEach(cb => cb(channels[0], channelUsers[0]));
         };
-        mainDisposer$a = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
+        mainDisposer$8 = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
     }
-    callbacks$a.push(callback);
-    return () => dispose$a(callback);
+    callbacks$8.push(callback);
+    return () => dispose$8(callback);
 };
 
-const callbacks$9 = [];
-let mainDisposer$9 = null;
-const dispose$9 = (cb) => {
-    const index = callbacks$9.indexOf(cb);
+const callbacks$7 = [];
+let mainDisposer$7 = null;
+const dispose$7 = (cb) => {
+    const index = callbacks$7.indexOf(cb);
     if (index > -1) {
-        callbacks$9.splice(index, 1);
+        callbacks$7.splice(index, 1);
     }
-    if (callbacks$9.length === 0) {
-        mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
+    if (callbacks$7.length === 0) {
+        mainDisposer$7 === null || mainDisposer$7 === void 0 ? void 0 : mainDisposer$7();
     }
 };
 const onChannelSetMuted = (callback) => {
-    if (callbacks$9.length === 0) {
+    if (callbacks$7.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             var _a;
@@ -4378,114 +4331,14 @@ const onChannelSetMuted = (callback) => {
                 payload.channelId,
             ])) === null || _a === void 0 ? void 0 : _a.data;
             if (channel) {
-                callbacks$9.forEach(cb => cb(channel));
+                callbacks$7.forEach(cb => cb(channel));
             }
         };
-        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);
+        mainDisposer$7 = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
     }
     callbacks$7.push(callback);
     return () => dispose$7(callback);
 };
-/* end_public_function */
 
 const callbacks$6 = [];
 let mainDisposer$6 = null;
@@ -7881,21 +7734,19 @@ const renewal = () => {
 
 const validateAccessToken = async ({ token, userId }) => {
     const client = getActiveClient();
-    // Verify the token and hydrate the caller in a single call.
-    const { data } = await client.http.get('/api/v4/sessions', {
+    // Validate token using sessions API
+    await client.http.get('/api/v3/sessions', {
         headers: {
             Authorization: `Bearer ${token.accessToken}`,
         },
     });
-    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,
-        });
-    }
+    // 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);
     client.http.defaults.headers.common.Authorization = `Bearer ${token.accessToken}`;
     client.http.defaults.metadata = {
         tokenExpiry: token.expiresAt,
@@ -7909,8 +7760,6 @@ const validateAccessToken = async ({ token, userId }) => {
         isUserDeleted: false,
     };
     client.token = token;
-    ingestInCache(prepareUserPayload({ users, files }));
-    setCurrentUserType(userType);
     return user;
 };
 
@@ -7993,6 +7842,14 @@ 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
@@ -8791,13 +8648,21 @@ 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();
+        unsubWatcher = client.accessTokenExpiryWatcher(sessionHandler);
         setActiveUser(user);
     }
     catch (error) {
@@ -18391,20 +18256,20 @@ const getArchivedChannelIds = async () => {
 
 /**
  * ```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);
@@ -18412,48 +18277,30 @@ 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());
     };
 };
 
-/**
- * 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 { 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);
@@ -18461,8 +18308,8 @@ 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());
@@ -19043,132 +18890,6 @@ 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'
@@ -20072,8 +19793,6 @@ var index$n = /*#__PURE__*/Object.freeze({
     editMessage: editMessage,
     deleteMessage: deleteMessage,
     softDeleteMessage: softDeleteMessage,
-    pinMessage: pinMessage,
-    unpinMessage: unpinMessage,
     markAsDelivered: markAsDelivered,
     getReadUsers: getReadUsers,
     getDeliveredUsers: getDeliveredUsers,
@@ -20711,9 +20430,6 @@ const getChannel = (channelId, callback) => {
         onChannelMemberBanned,
         onChannelMemberUnbanned,
         onChannelSetMuted,
-        onChannelMessagePinned,
-        onChannelMessageUnpinned,
-        onChannelPinnedMessageDeleted,
         convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
         convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
         convertEventPayload((callback) => {
@@ -22810,8 +22526,6 @@ var index$j = /*#__PURE__*/Object.freeze({
     onChannelJoined: onChannelJoined,
     onChannelLeft: onChannelLeft,
     onChannelSetMuted: onChannelSetMuted,
-    onChannelMessagePinned: onChannelMessagePinned,
-    onChannelMessageUnpinned: onChannelMessageUnpinned,
     onChannelMemberAdded: onChannelMemberAdded,
     onChannelMemberRemoved: onChannelMemberRemoved,
     onChannelMemberBanned: onChannelMemberBanned,
@@ -22829,10 +22543,7 @@ var index$j = /*#__PURE__*/Object.freeze({
     isUnreadCountSupport: isUnreadCountSupport,
     convertFromRaw: convertFromRaw,
     preUpdateChannelCache: preUpdateChannelCache,
-    prepareChannelPayload: prepareChannelPayload,
-    findCachedChannelByAnyId: findCachedChannelByAnyId,
-    findCachedChannelForPin: findCachedChannelForPin,
-    updatePinnedMessageCache: updatePinnedMessageCache
+    prepareChannelPayload: prepareChannelPayload
 });
 
 const saveCommunityUsers = (communities, communityUsers) => {