@amityco/ts-sdk-react-native 7.22.1-f15e84ea.0 → 7.23.0

package/dist/index.esm.js

@@ -15,6 +15,13 @@ var MembershipAcceptanceTypeEnum;
     MembershipAcceptanceTypeEnum["AUTOMATIC"] = "automatic";
     MembershipAcceptanceTypeEnum["INVITATION"] = "invitation";
 })(MembershipAcceptanceTypeEnum || (MembershipAcceptanceTypeEnum = {}));
+var AmityAutoSubscription;
+(function (AmityAutoSubscription) {
+    AmityAutoSubscription["CHAT"] = "chat";
+    AmityAutoSubscription["NETWORK"] = "network";
+    AmityAutoSubscription["LIVESTREAM"] = "livestream";
+    AmityAutoSubscription["BLOCK"] = "block";
+})(AmityAutoSubscription || (AmityAutoSubscription = {}));
 
 var UserTypeEnum;
 (function (UserTypeEnum) {
@@ -61,6 +68,13 @@ var FileAccessTypeEnum;
     FileAccessTypeEnum["NETWORK"] = "network";
 })(FileAccessTypeEnum || (FileAccessTypeEnum = {}));
 
+var AmityChannelNotificationModeEnum;
+(function (AmityChannelNotificationModeEnum) {
+    AmityChannelNotificationModeEnum["Default"] = "default";
+    AmityChannelNotificationModeEnum["Silent"] = "silent";
+    AmityChannelNotificationModeEnum["Subscribe"] = "subscribe";
+})(AmityChannelNotificationModeEnum || (AmityChannelNotificationModeEnum = {}));
+
 const CommunityPostSettings = Object.freeze({
     ONLY_ADMIN_CAN_POST: 'ONLY_ADMIN_CAN_POST',
     ADMIN_REVIEW_POST_REQUIRED: 'ADMIN_REVIEW_POST_REQUIRED',
@@ -236,6 +250,15 @@ var AmityEventOrderOption;
     AmityEventOrderOption["Descending"] = "desc";
 })(AmityEventOrderOption || (AmityEventOrderOption = {}));
 
+var AmitySharableContentType;
+(function (AmitySharableContentType) {
+    AmitySharableContentType["POST"] = "post";
+    AmitySharableContentType["COMMUNITY"] = "community";
+    AmitySharableContentType["USER"] = "user";
+    AmitySharableContentType["LIVESTREAM"] = "livestream";
+    AmitySharableContentType["EVENT"] = "event";
+})(AmitySharableContentType || (AmitySharableContentType = {}));
+
 var AnalyticsSourceTypeEnum;
 (function (AnalyticsSourceTypeEnum) {
     AnalyticsSourceTypeEnum["POST"] = "post";
@@ -277,8 +300,8 @@ var NotificationRolesFilterTypeEnum;
 
 function getVersion() {
     try {
-        // the string ''v7.22.0-esm'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.22.0-esm';
+        // the string ''v7.23.0-esm'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.23.0-esm';
     }
     catch (error) {
         return '__dev__';
@@ -287,6 +310,7 @@ function getVersion() {
 const VERSION = getVersion();
 
 const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+const COLLECTION_DEFAULT_PAGINATION_SIZE = 20;
 const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
 const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
 const LIVE_OBJECT_ENABLE_CACHE_MESSAGE = 'For using Live Object feature you need to enable Cache!';
@@ -299,6 +323,9 @@ const DAY = 24 * HOUR;
 const WEEK = 7 * DAY;
 const YEAR = 365 * DAY;
 const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;
+const API_ENDPOINTS = {
+    forYouFeed: '/api/v1/feeds/for-you',
+};
 
 // cache constants
 const CACHE_KEY_GET = 'get';
@@ -679,6 +706,107 @@ function createSnapshot(data, options) {
     return Object.assign(Object.assign({}, options), { data });
 }
 
+/* eslint-disable max-classes-per-file */
+/**
+ * Generic ASC error
+ * @category Errors
+ */
+class ASCError extends Error {
+    /**
+     * @param message A custom error message
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(message, code, level) {
+        super(`Amity SDK (${code}): ${message}`);
+        this.code = code;
+        this.level = level;
+        this.type = 'ASC';
+        this.timestamp = Date.now();
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(this, ASCError);
+    }
+}
+/**
+ * API level error
+ * @category Errors
+ */
+class ASCApiError extends ASCError {
+    /**
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    // eslint-disable-next-line no-useless-constructor
+    constructor(message, code, level) {
+        super(message, code, level);
+    }
+}
+/**
+ * Unexpected error
+ * @category Errors
+ */
+class ASCUnknownError extends ASCError {
+    /**
+     * @param code A normalized error code
+     * @param level A normalized failure level descriptor
+     */
+    constructor(code = 800000 /* Amity.ClientError.UNKNOWN_ERROR */, level = "fatal" /* Amity.ErrorLevel.FATAL */) {
+        super('Unexpected error', code, level);
+    }
+}
+/**
+ * Network related error
+ * @category Errors
+ */
+class ASCConnectionError extends ASCError {
+    /**
+     * @param message A custom error message
+     */
+    constructor(event, message = 'SDK client is having connection issues') {
+        super(`${message} (${event})`, event === 'disconnected'
+            ? 800211 /* Amity.ClientError.DISCONNECTED */
+            : 800210 /* Amity.ClientError.CONNECTION_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        this.event = event;
+    }
+}
+/**
+ * Input sanitization related error
+ * @category Errors
+ */
+class ASCInvalidParameterError extends ASCError {
+    /**
+     * @param message A custom error message
+     */
+    constructor(message) {
+        super(message, 800110 /* Amity.ClientError.INVALID_PARAMETERS */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+}
+
+let activeClient = null;
+/**
+ * Get the active client
+ *
+ * @returns the active client instance
+ *
+ * @hidden
+ */
+const getActiveClient = () => {
+    if (!activeClient) {
+        throw new ASCError('There is no active client', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
+    }
+    return activeClient;
+};
+/**
+ * Sets the active client
+ *
+ * @param client the client to assume as currently active client
+ *
+ * @hidden
+ */
+const setActiveClient = (client) => {
+    activeClient = client;
+};
+
 /** @hidden */
 const idResolvers = {
     user: ({ userId }) => userId,
@@ -687,6 +815,7 @@ const idResolvers = {
     channel: ({ channelInternalId }) => channelInternalId,
     subChannel: ({ subChannelId }) => subChannelId,
     channelUsers: ({ channelId, userId }) => `${channelId}#${userId}`,
+    archivedChannel: ({ channelId }) => channelId,
     message: ({ messageId, referenceId }) => referenceId !== null && referenceId !== void 0 ? referenceId : messageId,
     messagePreviewChannel: ({ channelId }) => `${channelId}`,
     messagePreviewSubChannel: ({ subChannelId }) => `${subChannelId}`,
@@ -728,6 +857,7 @@ const idResolvers = {
     event: ({ eventId }) => eventId,
     eventResponse: ({ userId }) => userId,
     product: ({ productId }) => productId,
+    feedMetadata: ({ postId }) => postId,
 };
 /**
  * Retrieve the id resolver matching a domain name
@@ -750,6 +880,7 @@ const PAYLOAD2MODEL = {
     channels: 'channel',
     messageFeeds: 'subChannel',
     channelUsers: 'channelUsers',
+    archives: 'archivedChannel',
     messages: 'message',
     messagePreviewChannel: 'messagePreviewChannel',
     messagePreviewSubChannel: 'messagePreviewSubChannel',
@@ -788,6 +919,7 @@ const PAYLOAD2MODEL = {
     viewers: 'viewer',
     eventResponses: 'eventResponse',
     products: 'product',
+    feedMetadata: 'feedMetadata',
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
@@ -802,107 +934,6 @@ function getFutureDate(date = new Date().toISOString()) {
     return new Date(new Date(date).getTime() + 1).toISOString();
 }
 
-/* eslint-disable max-classes-per-file */
-/**
- * Generic ASC error
- * @category Errors
- */
-class ASCError extends Error {
-    /**
-     * @param message A custom error message
-     * @param code A normalized error code
-     * @param level A normalized failure level descriptor
-     */
-    constructor(message, code, level) {
-        super(`Amity SDK (${code}): ${message}`);
-        this.code = code;
-        this.level = level;
-        this.type = 'ASC';
-        this.timestamp = Date.now();
-        if (Error.captureStackTrace)
-            Error.captureStackTrace(this, ASCError);
-    }
-}
-/**
- * API level error
- * @category Errors
- */
-class ASCApiError extends ASCError {
-    /**
-     * @param code A normalized error code
-     * @param level A normalized failure level descriptor
-     */
-    // eslint-disable-next-line no-useless-constructor
-    constructor(message, code, level) {
-        super(message, code, level);
-    }
-}
-/**
- * Unexpected error
- * @category Errors
- */
-class ASCUnknownError extends ASCError {
-    /**
-     * @param code A normalized error code
-     * @param level A normalized failure level descriptor
-     */
-    constructor(code = 800000 /* Amity.ClientError.UNKNOWN_ERROR */, level = "fatal" /* Amity.ErrorLevel.FATAL */) {
-        super('Unexpected error', code, level);
-    }
-}
-/**
- * Network related error
- * @category Errors
- */
-class ASCConnectionError extends ASCError {
-    /**
-     * @param message A custom error message
-     */
-    constructor(event, message = 'SDK client is having connection issues') {
-        super(`${message} (${event})`, event === 'disconnected'
-            ? 800211 /* Amity.ClientError.DISCONNECTED */
-            : 800210 /* Amity.ClientError.CONNECTION_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-        this.event = event;
-    }
-}
-/**
- * Input sanitization related error
- * @category Errors
- */
-class ASCInvalidParameterError extends ASCError {
-    /**
-     * @param message A custom error message
-     */
-    constructor(message) {
-        super(message, 800110 /* Amity.ClientError.INVALID_PARAMETERS */, "error" /* Amity.ErrorLevel.ERROR */);
-    }
-}
-
-let activeClient = null;
-/**
- * Get the active client
- *
- * @returns the active client instance
- *
- * @hidden
- */
-const getActiveClient = () => {
-    if (!activeClient) {
-        throw new ASCError('There is no active client', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "fatal" /* Amity.ErrorLevel.FATAL */);
-    }
-    return activeClient;
-};
-/**
- * Sets the active client
- *
- * @param client the client to assume as currently active client
- *
- * @hidden
- */
-const setActiveClient = (client) => {
-    activeClient = client;
-};
-
 /**
  * ```js
  * import { enableCache } from '@amityco/ts-sdk-react-native'
@@ -1410,6 +1441,65 @@ const filterBySearchTerm = (collection, searchTerm) => {
         return m.user && ((_a = m.user.displayName) === null || _a === void 0 ? void 0 : _a.match(containsMatcher));
     });
 };
+/**
+ * The ids of users in a block relationship with the current user — in BOTH
+ * directions — derived synchronously from the local follow cache. For every
+ * `status === 'blocked'` row that involves the current user, the OTHER party
+ * is collected: `from === me` (users I blocked, outgoing) contributes `to`;
+ * `to === me` (users who blocked me, incoming) contributes `from`.
+ *
+ * @returns a set of block-related user ids (both directions)
+ *
+ * @hidden
+ */
+const getBlockUsersId = () => {
+    var _a;
+    const { userId } = getActiveClient();
+    const ids = new Set();
+    ((_a = queryCache(['follow', 'get'])) !== null && _a !== void 0 ? _a : [])
+        .map(entry => entry.data)
+        .filter(follow => (follow === null || follow === void 0 ? void 0 : follow.status) === 'blocked' && (follow.from === userId || follow.to === userId))
+        .forEach(follow => {
+        ids.add(follow.from === userId ? follow.to : follow.from);
+    });
+    return ids;
+};
+/**
+ * Filter out posts whose author or any mentionee is in a block relationship
+ * with the current user, in either direction (see {@link getBlockUsersId}).
+ *
+ * @param collection the post collection to filter
+ * @returns a filtered collection excluding posts involving block-related users
+ *
+ * @hidden
+ */
+const filterPostsByBlockUsers = (collection) => {
+    const blockUsersId = getBlockUsersId();
+    if (blockUsersId.size === 0)
+        return collection;
+    return collection.filter(post => {
+        var _a, _b;
+        if (blockUsersId.has(post.postedUserId))
+            return false;
+        const mentionedUserIds = (_b = (_a = post.mentionees) === null || _a === void 0 ? void 0 : _a.flatMap(mention => (mention.type === 'user' ? mention.userIds : []))) !== null && _b !== void 0 ? _b : [];
+        return !mentionedUserIds.some(id => blockUsersId.has(id));
+    });
+};
+/**
+ * Filter out comments whose creator is in a block relationship with the
+ * current user, in either direction (see {@link getBlockUsersId}).
+ *
+ * @param collection the comment collection to filter
+ * @returns a filtered collection excluding comments from block-related users
+ *
+ * @hidden
+ */
+const filterCommentsByBlockUsers = (collection) => {
+    const blockUsersId = getBlockUsersId();
+    if (blockUsersId.size === 0)
+        return collection;
+    return collection.filter(comment => !blockUsersId.has(comment.userId));
+};
 
 // Note:
 // this file should contain a suite of sorting utilities to help the
@@ -1880,13 +1970,13 @@ class NetworkActivitiesWatcher {
         this._listener.clear();
     }
 }
-let instance$9;
+let instance$b;
 var NetworkActivitiesWatcher$1 = {
     getInstance: () => {
-        if (!instance$9) {
-            instance$9 = new NetworkActivitiesWatcher();
+        if (!instance$b) {
+            instance$b = new NetworkActivitiesWatcher();
         }
-        return instance$9;
+        return instance$b;
     },
 };
 
@@ -20725,18 +20815,149 @@ var mqtt$1 = {exports: {}};
 
 var mqtt = /*@__PURE__*/getDefaultExportFromCjs(mqtt$1.exports);
 
+class SessionWatcher {
+    constructor() {
+        this._sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
+        this._listener = new Map();
+    }
+    onSessionStateChange(callback) {
+        this._listener.set(callback, callback);
+        return () => {
+            this._listener.delete(callback);
+        };
+    }
+    setSessionState(state, reason) {
+        if (this._sessionState === state)
+            return;
+        this._sessionState = state;
+        this._listener.forEach(cb => cb(state, reason));
+    }
+    destroy() {
+        this._listener.clear();
+    }
+}
+let instance$a;
+var SessionWatcher$1 = {
+    getInstance: () => {
+        if (!instance$a) {
+            instance$a = new SessionWatcher();
+        }
+        return instance$a;
+    },
+};
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk-react-native'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onSessionStateChange = (callback) => SessionWatcher$1.getInstance().onSessionStateChange(callback);
+
+const TOPICS = {
+    [AmityAutoSubscription.NETWORK]: [getNetworkTopic],
+    [AmityAutoSubscription.CHAT]: [
+        getSmartFeedChannelTopic,
+        getSmartFeedSubChannelTopic,
+        getSmartFeedMessageTopic,
+    ],
+    [AmityAutoSubscription.LIVESTREAM]: [getLiveStreamTopic],
+    [AmityAutoSubscription.BLOCK]: [getMyFollowersTopic, getMyFollowingsTopic],
+};
+const DEFAULT_TOPICS = [
+    AmityAutoSubscription.CHAT,
+    AmityAutoSubscription.NETWORK,
+    AmityAutoSubscription.LIVESTREAM,
+    AmityAutoSubscription.BLOCK,
+];
+const ALL_FEATURES = Object.values(AmityAutoSubscription);
+/** Ref-counted, reconnect-resilient registry of the managed auto-subscriptions. */
+class AutoSubscriptionManager {
+    constructor() {
+        this.refCountByFeature = new Map();
+        this.disposers = new Map();
+        this.seed();
+    }
+    seed() {
+        this.refCountByFeature.clear();
+        DEFAULT_TOPICS.forEach(feature => this.refCountByFeature.set(feature, 1));
+    }
+    isActive(feature) {
+        var _a;
+        return ((_a = this.refCountByFeature.get(feature)) !== null && _a !== void 0 ? _a : 0) > 0;
+    }
+    subscribeTopics(feature) {
+        this.unsubscribeTopics(feature);
+        this.disposers.set(feature, TOPICS[feature].map(buildTopic => subscribeTopic(buildTopic())));
+    }
+    unsubscribeTopics(feature) {
+        var _a;
+        ((_a = this.disposers.get(feature)) !== null && _a !== void 0 ? _a : []).forEach(dispose => dispose());
+        this.disposers.delete(feature);
+    }
+    /** Subscribe every enabled handle's topics, converging the broker to the registry. Called on each (re)connect. */
+    initialize() {
+        ALL_FEATURES.forEach(feature => {
+            if (this.isActive(feature))
+                this.subscribeTopics(feature);
+        });
+    }
+    subscribe(feature) {
+        var _a;
+        const next = ((_a = this.refCountByFeature.get(feature)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.refCountByFeature.set(feature, next);
+        if (next === 1)
+            this.subscribeTopics(feature);
+    }
+    unsubscribe(feature) {
+        var _a;
+        const next = Math.max(0, ((_a = this.refCountByFeature.get(feature)) !== null && _a !== void 0 ? _a : 0) - 1);
+        this.refCountByFeature.set(feature, next);
+        if (next === 0)
+            this.unsubscribeTopics(feature);
+    }
+    subscriptions() {
+        return ALL_FEATURES.map(feature => ({
+            feature,
+            isActive: this.isActive(feature),
+            isSystem: true,
+            topicCount: TOPICS[feature].length,
+        }));
+    }
+    reset() {
+        ALL_FEATURES.forEach(feature => this.unsubscribeTopics(feature));
+        this.disposers.clear();
+        this.seed();
+    }
+}
+let instance$9 = null;
+const getAutoSubscriptionManager = () => {
+    if (!instance$9)
+        instance$9 = new AutoSubscriptionManager();
+    return instance$9;
+};
+/** Resets the registry to its default baseline when the session ends. */
+const resetAutoSubscriptionsOnLogout = () => onSessionStateChange(state => {
+    if (state !== "established" /* Amity.SessionStates.ESTABLISHED */)
+        getAutoSubscriptionManager().reset();
+});
+
+/**
+ * (Re)subscribes the managed auto-subscription registry on every (re)connect.
+ * The hardcoded topic list was promoted to the toggleable, ref-counted registry
+ * in {@link getAutoSubscriptionManager} — see `client.manageAutoSubscriptions`.
+ */
 const subscribeGlobalTopic = () => {
-    const disposers = [
-        subscribeTopic(getNetworkTopic()),
-        subscribeTopic(getSmartFeedChannelTopic()),
-        subscribeTopic(getSmartFeedSubChannelTopic()),
-        subscribeTopic(getSmartFeedMessageTopic()),
-        // subscribing to user topic is necessary to handle ban event
-        subscribeTopic(getUserTopic(getActiveUser())),
-        subscribeTopic(getMarkerUserFeedTopic()),
-        subscribeTopic(getLiveStreamTopic()),
-    ];
-    return () => disposers.forEach(fn => fn());
+    getAutoSubscriptionManager().initialize();
 };
 
 class OnMemoryStorage {
@@ -21309,8 +21530,12 @@ const getChannelMessagePreviewWithUser = (channel) => {
     return Object.assign(Object.assign({}, channel), { messagePreview: messagePreviewWithUser });
 };
 
+const convertDateStringToTimestamp = (dateString) => {
+    return new Date(dateString).getTime();
+};
+
 const updateChannelMessagePreviewCache = (rawPayload) => {
-    var _a, _b;
+    var _a;
     const withMessageFeedInfo = (messagePreview) => {
         var _a;
         const messageFeedInfo = (_a = rawPayload.messageFeedsInfo) === null || _a === void 0 ? void 0 : _a.find(messageFeed => {
@@ -21332,10 +21557,26 @@ const updateChannelMessagePreviewCache = (rawPayload) => {
             subChannelUpdatedAt: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.updatedAt,
         };
     };
-    const newData = {
-        messagePreviewChannel: (_b = (_a = rawPayload.messagePreviews) === null || _a === void 0 ? void 0 : _a.map(messagePreview => withMessageFeedInfo(messagePreview))) !== null && _b !== void 0 ? _b : [],
-    };
-    ingestInCache(newData);
+    // Skip server previews older than what's cached — the cache may carry a newer
+    // preview written by handleMessageCreated from an MQTT message that the server
+    // payload hasn't surfaced yet. Mirrors isLastestMessageOnChannel.
+    const newPreviews = ((_a = rawPayload.messagePreviews) !== null && _a !== void 0 ? _a : [])
+        .map(withMessageFeedInfo)
+        .filter(preview => {
+        var _a;
+        const cached = (_a = pullFromCache([
+            'messagePreviewChannel',
+            'get',
+            preview.channelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (!cached)
+            return true;
+        return (convertDateStringToTimestamp(cached.createdAt) <=
+            convertDateStringToTimestamp(preview.createdAt));
+    });
+    if (newPreviews.length === 0)
+        return;
+    ingestInCache({ messagePreviewChannel: newPreviews });
 };
 
 const getSubChannelMessagePreview = (subChannelId) => {
@@ -21963,11 +22204,7 @@ getSubChannel$1.locally = (subChannelId) => {
     };
 };
 
-const convertDateStringToTimestamp = (dateString) => {
-    return new Date(dateString).getTime();
-};
-
-const getMessagePreviewSetting$1 = async () => {
+const getMessagePreviewSetting$2 = async () => {
     const client = getActiveClient();
     return client.getMessagePreviewSetting(false);
 };
@@ -22002,7 +22239,7 @@ const isLastestMessageOnChannel = (message) => {
         convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
 };
 const handleMessageCreatedOnSubChannel = async (message) => {
-    const messagePreviewSetting = await getMessagePreviewSetting$1();
+    const messagePreviewSetting = await getMessagePreviewSetting$2();
     const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
     // 1. get subChannel from cache, if not exist fetch from server
     const subChannelCache = await getSubChannelCache(subChannelId);
@@ -22174,24 +22411,41 @@ const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated:
     });
 };
 const updateChannelUnread = ({ currentUserId, channels, channelUsers, }) => {
+    var _a, _b;
     const channelsUnread = [];
     for (let i = 0; i < channels.length; i += 1) {
         if (isUnreadCountSupport(channels[i])) {
             const cacheKey = ['channelUnread', 'get', channels[i].channelId];
             const channelUser = channelUsers.find(channelUser => channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId);
-            let unreadCount = 0;
+            // readToSegment, lastMentionedSegment and lastSegment are monotonically non-decreasing;
+            // prefer cached values when ahead of the server so a refetch returning stale data cannot
+            const cached = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const lastSegment = Math.max((_b = cached === null || cached === void 0 ? void 0 : cached.lastSegment) !== null && _b !== void 0 ? _b : 0, channels[i].messageCount);
             let readToSegment = null;
             let lastMentionedSegment = null;
+            let unreadCount = 0;
             let isMentioned = false;
             if (channelUser) {
-                readToSegment = channelUser.readToSegment;
-                lastMentionedSegment = channelUser.lastMentionedSegment;
-                unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
-                isMentioned = lastMentionedSegment > readToSegment;
+                const serverRead = channelUser.readToSegment;
+                const serverMention = channelUser.lastMentionedSegment;
+                readToSegment =
+                    typeof (cached === null || cached === void 0 ? void 0 : cached.readToSegment) === 'number' &&
+                        (typeof serverRead !== 'number' || cached.readToSegment > serverRead)
+                        ? cached.readToSegment
+                        : serverRead !== null && serverRead !== void 0 ? serverRead : null;
+                lastMentionedSegment =
+                    typeof (cached === null || cached === void 0 ? void 0 : cached.lastMentionedSegment) === 'number' &&
+                        (typeof serverMention !== 'number' || cached.lastMentionedSegment > serverMention)
+                        ? cached.lastMentionedSegment
+                        : serverMention !== null && serverMention !== void 0 ? serverMention : null;
+                const readForCalc = readToSegment !== null && readToSegment !== void 0 ? readToSegment : 0;
+                unreadCount = Math.max(lastSegment - readForCalc, 0);
+                isMentioned =
+                    typeof lastMentionedSegment === 'number' && readForCalc < lastMentionedSegment;
             }
             const cacheChannelUnread = {
                 channelId: channels[i].channelId,
-                lastSegment: channels[i].messageCount,
+                lastSegment,
                 readToSegment,
                 lastMentionedSegment,
                 unreadCount,
@@ -22201,6 +22455,8 @@ const updateChannelUnread = ({ currentUserId, channels, channelUsers, }) => {
             pushToCache(cacheKey, cacheChannelUnread);
             channelsUnread.push(cacheChannelUnread);
         }
+    }
+    if (channelsUnread.length > 0) {
         fireEvent('local.channelUnread.updated', channelsUnread);
     }
 };
@@ -22900,7 +23156,7 @@ const onChannelMemberRoleRemoved = (callback) => {
         const client = getActiveClient();
         const filter = async (payload) => {
             const { channels, channelUsers } = payload;
-            callback(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member'));
+            callbacks$1.forEach(cb => cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')));
         };
         mainDisposer$1 = createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', filter);
     }
@@ -22908,6 +23164,39 @@ const onChannelMemberRoleRemoved = (callback) => {
     return () => dispose$1(callback);
 };
 
+/**
+ * Fired when a {@link Amity.Channel} has been archived by the active user.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelArchived = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        callback(payload);
+    };
+    return createEventSubscriber(client, 'onChannelArchived', 'local.channel.archived', filter);
+};
+
+/**
+ * Fired when a previously archived {@link Amity.Channel} has been unarchived
+ * by the active user.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelUnarchived = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        callback(payload);
+    };
+    return createEventSubscriber(client, 'onChannelUnarchived', 'local.channel.unarchived', filter);
+};
+
 const callbacks = [];
 let mainDisposer = null;
 const dispose = (cb) => {
@@ -23021,6 +23310,17 @@ const channelLinkedObject = (channel) => {
         markAsRead: () => markAsRead(channel.channelInternalId),
         previewMembers,
         myMembership: (callback) => getMyMembership(channel.channelId, callback),
+        get avatar() {
+            var _a;
+            if (!channel.avatarFileId)
+                return undefined;
+            const avatar = (_a = pullFromCache([
+                'file',
+                'get',
+                `${channel.avatarFileId}`,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            return avatar;
+        },
     });
 };
 
@@ -23119,54 +23419,6 @@ getChannelByIds$1.locally = (channelIds) => {
     };
 };
 
-class SessionWatcher {
-    constructor() {
-        this._sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
-        this._listener = new Map();
-    }
-    onSessionStateChange(callback) {
-        this._listener.set(callback, callback);
-        return () => {
-            this._listener.delete(callback);
-        };
-    }
-    setSessionState(state, reason) {
-        if (this._sessionState === state)
-            return;
-        this._sessionState = state;
-        this._listener.forEach(cb => cb(state, reason));
-    }
-    destroy() {
-        this._listener.clear();
-    }
-}
-let instance$8;
-var SessionWatcher$1 = {
-    getInstance: () => {
-        if (!instance$8) {
-            instance$8 = new SessionWatcher();
-        }
-        return instance$8;
-    },
-};
-
-/**
- * ```js
- * import { onSessionStateChange } from '@amityco/ts-sdk-react-native'
- * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Client} has a session state change
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Client Events
- */
-const onSessionStateChange = (callback) => SessionWatcher$1.getInstance().onSessionStateChange(callback);
-
 const setIntervalTask = (handler, timeout) => {
     const timer = setInterval(handler, timeout);
     return () => clearInterval(timer);
@@ -23338,7 +23590,7 @@ const convertMessagePreviewSetting = (chatSetting) => {
  * @category private
  * @async
  */
-const getMessagePreviewSetting = async (refresh = true) => {
+const getMessagePreviewSetting$1 = async (refresh = true) => {
     var _a;
     const messagePreviewSetting = (_a = pullFromCache([
         'MessagePreviewSetting',
@@ -23359,7 +23611,7 @@ const getMessagePreviewSetting = async (refresh = true) => {
  */
 const initializeMessagePreviewSetting = async () => {
     var _a;
-    const newMessagePreviewSetting = await getMessagePreviewSetting();
+    const newMessagePreviewSetting = await getMessagePreviewSetting$1();
     const messagePreviewSetting = (_a = pullFromCache([
         'MessagePreviewSetting',
     ])) === null || _a === void 0 ? void 0 : _a.data;
@@ -23430,6 +23682,26 @@ const getSocialSettings = async () => {
     return data.socialNetworkSetting;
 };
 
+/**
+ * ```js
+ * import { createClient } from '@amityco/ts-sdk'
+ * const client = createClient(apiKey, apiRegion)
+ * const userSettings = await client.getCoreUserSettings()
+ * ```
+ *
+ * Fetches a {@link Amity.CoreUserSettings} object
+ *
+ * @returns A Promise of {@link Amity.CoreUserSettings} object
+ *
+ * @category Client API
+ * @async
+ */
+const getCoreUserSettings = async () => {
+    const client = getActiveClient();
+    const { data } = await client.http.get(`/api/v3/network-settings/users`);
+    return data;
+};
+
 /* begin_public_function
   id: client.getProductCatalogueSetting
 */
@@ -23453,6 +23725,33 @@ const getProductCatalogueSetting = async () => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: client.getForYouFeedSetting
+*/
+/**
+ * ```js
+ * import { Client } from '@amityco/ts-sdk'
+ * const forYouFeedSetting = await Client.getForYouFeedSetting()
+ * ```
+ *
+ * Fetches the network-level {@link Amity.ForYouFeedSetting} — whether the For You
+ * feed feature is enabled for the current network. Use `forYouFeed.enabled` as a
+ * feature gate before querying {@link getForYouFeed}.
+ *
+ * @returns A Promise of {@link Amity.ForYouFeedSetting} object
+ *
+ * @category Client API
+ * @async
+ */
+const getForYouFeedSetting = async () => {
+    var _a, _b;
+    const client = getActiveClient();
+    const { data } = await client.http.get(`/api/v3/network-settings/for-you-feed`);
+    // Surface only `enabled`; ignore server-side ranking config (scoringConfig, etc.)
+    return { forYouFeed: { enabled: (_b = (_a = data.forYouFeed) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false } };
+};
+/* end_public_function */
+
 const checkUserPermission = (userId, permission) => {
     var _a;
     const user = (_a = pullFromCache(['user', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
@@ -23960,7 +24259,7 @@ class AnalyticsEventSyncer {
 
 class AnalyticsEventCapturer {
     constructor() {
-        this._expireTime = 5 * MINUTE;
+        this._expireTime = 5 * SECOND$1;
         this._poolLimit = 1000;
         this._recentViewed = {};
         this._recentHighPriorityViewed = {};
@@ -24014,12 +24313,36 @@ class AnalyticsEventCapturer {
     }
     markPostAsViewed(postId) {
         this.markAs({
-            uniqueId: postId,
+            uniqueId: `post.${postId}`,
             contentId: postId,
             contentType: "post" /* Amity.AnalyticEventContentType.Post */,
             activityType: "view" /* Amity.AnalyticEventActivityType.View */,
         });
     }
+    markPostAsMeaningfullyViewed(postId, feedRenderPosition) {
+        var _a;
+        const cached = (_a = pullFromCache(['feedMetadata', 'get', postId])) === null || _a === void 0 ? void 0 : _a.data;
+        const metadata = {};
+        if (feedRenderPosition !== undefined)
+            metadata.feedRenderPosition = feedRenderPosition;
+        if (cached) {
+            metadata.feedSnapshotPosition = cached.feedSnapshotPosition;
+            metadata.feedInjectionType = cached.feedInjectionType;
+            metadata.feedRelevanceScore = cached.feedRelevanceScore;
+            metadata.feedPopularityScore = cached.feedPopularityScore;
+            metadata.feedFreshnessScore = cached.feedFreshnessScore;
+            metadata.feedAffinityScore = cached.feedAffinityScore;
+            metadata.feedFinalScore = cached.feedFinalScore;
+            metadata.feedMmrPenalty = cached.feedMmrPenalty;
+        }
+        this.markAs({
+            uniqueId: `post.${postId}.meaningfulView`,
+            contentId: postId,
+            contentType: "post" /* Amity.AnalyticEventContentType.Post */,
+            activityType: "meaningfulView" /* Amity.AnalyticEventActivityType.MeaningfulView */,
+            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        });
+    }
     markStory(story, activityType) {
         if (!story.expiresAt)
             return;
@@ -24159,6 +24482,12 @@ class AnalyticsEngine {
             this._eventCapturer.markPostAsViewed(postId);
         }
     }
+    markPostAsMeaningfullyViewed(postId, feedRenderPosition) {
+        if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
+            this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            this._eventCapturer.markPostAsMeaningfullyViewed(postId, feedRenderPosition);
+        }
+    }
     markStoryAsViewed(story) {
         if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
             this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */ // For case token_expired, we assume token is expired and gonna re-connect soon
@@ -24210,13 +24539,13 @@ class AnalyticsEngine {
         this._eventCapturer.resetAllBuckets();
     }
 }
-let instance$7;
+let instance$8;
 var AnalyticsEngine$1 = {
     getInstance: () => {
-        if (!instance$7) {
-            instance$7 = new AnalyticsEngine();
+        if (!instance$8) {
+            instance$8 = new AnalyticsEngine();
         }
-        return instance$7;
+        return instance$8;
     },
 };
 
@@ -24383,9 +24712,8 @@ class MessageReadReceiptSyncEngine {
         // Step 1: Optimistic update of channelUnread.readToSegment to message.segment and update unreadCount value
         const cacheKey = ['channelUnread', 'get', channelId];
         const channelUnread = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (typeof (channelUnread === null || channelUnread === void 0 ? void 0 : channelUnread.readToSegment) === 'number' &&
-            channelUnread &&
-            segment > channelUnread.readToSegment) {
+        if (channelUnread &&
+            (typeof channelUnread.readToSegment !== 'number' || segment > channelUnread.readToSegment)) {
             channelUnread.readToSegment = segment;
             channelUnread.unreadCount = Math.max(channelUnread.lastSegment - segment, 0);
             pushToCache(cacheKey, channelUnread);
@@ -24444,12 +24772,12 @@ class MessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$6 = null;
+let instance$7 = null;
 var ReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$6)
-            instance$6 = new MessageReadReceiptSyncEngine();
-        return instance$6;
+        if (!instance$7)
+            instance$7 = new MessageReadReceiptSyncEngine();
+        return instance$7;
     },
 };
 
@@ -24703,12 +25031,12 @@ class LegacyMessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$5 = null;
+let instance$6 = null;
 var LegacyReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$5)
-            instance$5 = new LegacyMessageReadReceiptSyncEngine();
-        return instance$5;
+        if (!instance$6)
+            instance$6 = new LegacyMessageReadReceiptSyncEngine();
+        return instance$6;
     },
 };
 
@@ -24984,12 +25312,12 @@ class ObjectResolverEngine {
         this.stopResolver();
     }
 }
-let instance$4 = null;
+let instance$5 = null;
 var ObjectResolverEngine$1 = {
     getInstance: () => {
-        if (!instance$4)
-            instance$4 = new ObjectResolverEngine();
-        return instance$4;
+        if (!instance$5)
+            instance$5 = new ObjectResolverEngine();
+        return instance$5;
     },
 };
 
@@ -25139,13 +25467,13 @@ class LiveReactionSyncEngine {
         this.stopReactionsSync();
     }
 }
-let instance$3;
+let instance$4;
 var ReactionSyncEngine = {
     getInstance: () => {
-        if (!instance$3) {
-            instance$3 = new LiveReactionSyncEngine();
+        if (!instance$4) {
+            instance$4 = new LiveReactionSyncEngine();
         }
-        return instance$3;
+        return instance$4;
     },
 };
 
@@ -25175,19 +25503,20 @@ function prepareBlockedUserPayload(response) {
         }), users: users.map(convertRawUserToInternalUser) });
 }
 
-const BLOCK_LIST_LIMIT = 100;
-const TTL_MS = 5 * 60 * 1000; // 5 minutes
+const BLOCK_LIST_LIMIT$1 = 100;
+const TTL_MS$1 = 5 * 60 * 1000; // 5 minutes
 /**
  * Session-scoped singleton engine that manages TTL-based fetching and caching
  * of blocked users. Provides a lazy `ensureFetched()` gate for the
  * `getAllBlockedUsers()` API.
  *
  * Key behaviours:
- * - `establish()` is a no-op — fetch is lazy, triggered only by consumer call
- * - `destroy()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `onSessionEstablished()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `onSessionDestroyed()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
  * - `ensureFetched()` fetches from server only when cache is expired or never fetched
  * - `lastFetchedAt` is only updated on successful fetch
- * - `blockedUserIds` is kept in sync with each successful fetch
+ * - reads query the follow cache live, so block/unblock changes are reflected
+ *   even within the TTL window
  *
  * @internal
  */
@@ -25195,12 +25524,7 @@ class BlockedUserSyncEngine {
     constructor() {
         /** Epoch ms of last successful fetch. null = never fetched in this session. */
         this.lastFetchedAt = null;
-        /** Ordered list of userId strings from the most recent successful fetch. */
-        this.blockedUserIds = [];
     }
-    // ---------------------------------------------------------------------------
-    // SessionComponent lifecycle
-    // ---------------------------------------------------------------------------
     /** No-op — fetch is lazy, triggered by consumer calling getAllBlockedUsers(). */
     // eslint-disable-next-line class-methods-use-this
     onSessionEstablished() {
@@ -25209,24 +25533,17 @@ class BlockedUserSyncEngine {
     /** Resets state so the next session starts with a cold cache. */
     onSessionDestroyed() {
         this.lastFetchedAt = null;
-        this.blockedUserIds = [];
     }
     /** No-op for this engine. */
     // eslint-disable-next-line class-methods-use-this
     onTokenExpired() {
         // intentionally empty
     }
-    // ---------------------------------------------------------------------------
-    // Cache helpers
-    // ---------------------------------------------------------------------------
     isCacheExpired() {
         if (this.lastFetchedAt === null)
             return true;
-        return Date.now() - this.lastFetchedAt > TTL_MS;
+        return Date.now() - this.lastFetchedAt > TTL_MS$1;
     }
-    // ---------------------------------------------------------------------------
-    // Core fetch gate
-    // ---------------------------------------------------------------------------
     /**
      * Ensures the local store is populated with fresh blocked-user data.
      *
@@ -25242,52 +25559,50 @@ class BlockedUserSyncEngine {
         if (!this.isCacheExpired())
             return;
         const client = getActiveClient();
-        const { data } = await client.http.get('/api/v4/me/user-blocks', { params: { options: { limit: BLOCK_LIST_LIMIT }, isDeleted: false } });
+        const { data } = await client.http.get('/api/v4/me/user-blocks', { params: { options: { limit: BLOCK_LIST_LIMIT$1 }, isDeleted: false } });
         const cachedAt = client.cache && Date.now();
         const payload = prepareBlockedUserPayload(data);
         if (client.cache) {
             ingestInCache(payload, { cachedAt });
         }
-        // Keep the ordered list of blocked user IDs for getCachedUsers()
-        this.blockedUserIds = payload.users.map(u => u.userId);
         // Only update timestamp on success — failure leaves it unchanged so the
         // next call retries.
         this.lastFetchedAt = Date.now();
     }
-    // ---------------------------------------------------------------------------
-    // Local store read
-    // ---------------------------------------------------------------------------
     /**
-     * Returns blocked {@link Amity.InternalUser} objects from the in-memory cache.
-     *
-     * Applies the spec-mandated filter:
-     *  - Only users whose `isDeleted` is false or null
-     *  - Hard limit of 100 results
+     * Returns the blocked users by querying the follow cache live — the outgoing
+     * direction (`from === me`, `status === 'blocked'`). Reading the cache (not a
+     * fetched snapshot) means `blockUser()` / `unblockUser()` changes are reflected
+     * even within the TTL window.
      *
-     * This always reads the latest local state, so changes made by `blockUser()`
-     * and `unblockUser()` are reflected even within the TTL window.
+     * Applies the spec-mandated query:
+     *  - filter `from === currentUserId`, `status === 'blocked'`, blocked user not deleted
+     *  - sort by `updatedAt` DESC
+     *  - hard limit of 100 results
      */
+    // eslint-disable-next-line class-methods-use-this
     getCachedUsers() {
+        var _a;
         const client = getActiveClient();
-        if (!client.cache) {
-            // No cache available — fall back to the in-memory list from the last fetch
+        if (!client.cache)
             return [];
-        }
-        return this.blockedUserIds
-            .map(id => { var _a; return (_a = pullFromCache(['user', 'get', id])) === null || _a === void 0 ? void 0 : _a.data; })
+        const { userId } = client;
+        return ((_a = queryCache(['follow', 'get'])) !== null && _a !== void 0 ? _a : [])
+            .map(entry => entry.data)
+            .filter(follow => (follow === null || follow === void 0 ? void 0 : follow.status) === 'blocked' && follow.from === userId)
+            .sort((a, b) => { var _a, _b; return (((_a = a.updatedAt) !== null && _a !== void 0 ? _a : '') < ((_b = b.updatedAt) !== null && _b !== void 0 ? _b : '') ? 1 : -1); })
+            .map(follow => { var _a; return (_a = pullFromCache(['user', 'get', follow.to])) === null || _a === void 0 ? void 0 : _a.data; })
             .filter((user) => user != null && user.isDeleted !== true)
-            .slice(0, BLOCK_LIST_LIMIT);
+            .slice(0, BLOCK_LIST_LIMIT$1)
+            .map(userLinkedObject);
     }
 }
-// ---------------------------------------------------------------------------
-// Module-level singleton
-// ---------------------------------------------------------------------------
-let instance$2 = null;
+let instance$3 = null;
 var BlockedUserSyncEngine$1 = {
     getInstance: () => {
-        if (!instance$2)
-            instance$2 = new BlockedUserSyncEngine();
-        return instance$2;
+        if (!instance$3)
+            instance$3 = new BlockedUserSyncEngine();
+        return instance$3;
     },
 };
 
@@ -25309,6 +25624,290 @@ var blockedUserSyncEngineOnLoginHandler = () => {
     };
 };
 
+function prepareBlockingUserPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows: follows.map(follow => {
+            const followUser = users.find(user => user.userId === follow.from);
+            return Object.assign(Object.assign({}, follow), { user: convertRawUserToInternalUser(followUser) });
+        }), users: users.map(convertRawUserToInternalUser) });
+}
+
+const BLOCK_LIST_LIMIT = 100;
+const TTL_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Session-scoped singleton engine that manages TTL-based fetching and caching
+ * of blocking users (the "blocked-by" list — users who blocked the current
+ * user). Provides a lazy `ensureFetched()` gate for the `getAllBlockingUsers()`
+ * API. Directional inverse of {@link BlockedUserSyncEngine}.
+ *
+ * Key behaviours:
+ * - `onSessionEstablished()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `onSessionDestroyed()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `ensureFetched()` fetches from server only when cache is expired or never fetched
+ * - `lastFetchedAt` is only updated on successful fetch
+ * - reads query the follow cache live, so block/unblock changes are reflected
+ *   even within the TTL window
+ *
+ * @internal
+ */
+class BlockingUserSyncEngine {
+    constructor() {
+        /** Epoch ms of last successful fetch. null = never fetched in this session. */
+        this.lastFetchedAt = null;
+    }
+    /** No-op — fetch is lazy, triggered by consumer calling getAllBlockingUsers(). */
+    // eslint-disable-next-line class-methods-use-this
+    onSessionEstablished() {
+        // intentionally empty
+    }
+    /** Resets state so the next session starts with a cold cache. */
+    onSessionDestroyed() {
+        this.lastFetchedAt = null;
+    }
+    /** No-op for this engine. */
+    // eslint-disable-next-line class-methods-use-this
+    onTokenExpired() {
+        // intentionally empty
+    }
+    isCacheExpired() {
+        if (this.lastFetchedAt === null)
+            return true;
+        return Date.now() - this.lastFetchedAt > TTL_MS;
+    }
+    /**
+     * Ensures the local store is populated with fresh blocking-user data.
+     *
+     * - If the cache is still within the 5-minute TTL window: resolves immediately
+     *   (no server call).
+     * - If the cache is expired (or never fetched): fetches from the server,
+     *   persists the payload to the cache, and updates `lastFetchedAt`.
+     *
+     * On failure the error propagates to the caller and `lastFetchedAt` is NOT
+     * updated, so the next call will retry.
+     */
+    async ensureFetched() {
+        if (!this.isCacheExpired())
+            return;
+        const client = getActiveClient();
+        const { data } = await client.http.get('/api/v4/me/blockers', { params: { options: { limit: BLOCK_LIST_LIMIT }, isDeleted: false } });
+        const cachedAt = client.cache && Date.now();
+        const payload = prepareBlockingUserPayload(data);
+        if (client.cache) {
+            ingestInCache(payload, { cachedAt });
+        }
+        // Only update timestamp on success — failure leaves it unchanged so the
+        // next call retries.
+        this.lastFetchedAt = Date.now();
+    }
+    /**
+     * Returns the "blocked-by" users by querying the follow cache live — the
+     * incoming direction (`to === me`, `status === 'blocked'`). Reading the cache
+     * (not a fetched snapshot) means RTE `user.didBlock` / `user.didUnblock`
+     * changes are reflected even within the TTL window.
+     *
+     * Applies the spec-mandated query (REQ-012/013/014):
+     *  - filter `to === currentUserId`, `status === 'blocked'`, blocker not deleted
+     *  - sort by `updatedAt` DESC
+     *  - hard limit of 100 results
+     */
+    // eslint-disable-next-line class-methods-use-this
+    getCachedUsers() {
+        var _a;
+        const client = getActiveClient();
+        if (!client.cache)
+            return [];
+        const { userId } = client;
+        return ((_a = queryCache(['follow', 'get'])) !== null && _a !== void 0 ? _a : [])
+            .map(entry => entry.data)
+            .filter(follow => (follow === null || follow === void 0 ? void 0 : follow.status) === 'blocked' && follow.to === userId)
+            .sort((a, b) => { var _a, _b; return (((_a = a.updatedAt) !== null && _a !== void 0 ? _a : '') < ((_b = b.updatedAt) !== null && _b !== void 0 ? _b : '') ? 1 : -1); })
+            .map(follow => { var _a; return (_a = pullFromCache(['user', 'get', follow.from])) === null || _a === void 0 ? void 0 : _a.data; })
+            .filter((user) => user != null && user.isDeleted !== true)
+            .slice(0, BLOCK_LIST_LIMIT)
+            .map(userLinkedObject);
+    }
+}
+let instance$2 = null;
+var BlockingUserSyncEngine$1 = {
+    getInstance: () => {
+        if (!instance$2)
+            instance$2 = new BlockingUserSyncEngine();
+        return instance$2;
+    },
+};
+
+var blockingUserSyncEngineOnLoginHandler = () => {
+    const blockingUserSyncEngine = BlockingUserSyncEngine$1.getInstance();
+    onSessionStateChange(state => {
+        if (state === "established" /* Amity.SessionStates.ESTABLISHED */) {
+            blockingUserSyncEngine.onSessionEstablished();
+        }
+        else if (state === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            blockingUserSyncEngine.onTokenExpired();
+        }
+        else {
+            blockingUserSyncEngine.onSessionDestroyed();
+        }
+    });
+    return () => {
+        blockingUserSyncEngine.onSessionDestroyed();
+    };
+};
+
+function prepareFollowersPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
+}
+function prepareFollowingsPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
+}
+function prepareFollowStatusPayload(response) {
+    const { follows } = response, rest = __rest(response, ["follows"]);
+    return Object.assign(Object.assign({}, rest), { follows });
+}
+
+/**
+ * Subscribes to a block MQTT event (`user.didBlock` / `user.didUnblock`),
+ * ingests the carried `FollowersPayload` (follows + users) into the cache so
+ * the block-relationship rows (`['follow', 'get', from#to]`) and user rows are
+ * kept current, then forwards the affected {@link Amity.FollowStatus} to the
+ * caller.
+ *
+ * @hidden
+ */
+const createBlockEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const payload = prepareFollowersPayload(data);
+        if (client.cache) {
+            ingestInCache(payload);
+        }
+        callback(payload.follows[0]);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
+/**
+ * ```js
+ * import { onUserDidBlock } from '@amityco/ts-sdk'
+ * const dispose = onUserDidBlock(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a block relationship is created in real time — either a user
+ * blocks the current user (incoming) or the current user blocks someone on
+ * another device (outgoing). The local block-relationship store is updated
+ * before the callback runs.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Block Events
+ */
+const onUserDidBlock = (callback) => createBlockEventSubscriber('user.didBlock', callback);
+
+/**
+ * ```js
+ * import { onUserDidUnblock } from '@amityco/ts-sdk'
+ * const dispose = onUserDidUnblock(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a block relationship is removed in real time — either a user
+ * unblocks the current user (incoming) or the current user unblocks someone on
+ * another device (outgoing). The local block-relationship store is updated
+ * before the callback runs.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Block Events
+ */
+const onUserDidUnblock = (callback) => createBlockEventSubscriber('user.didUnblock', callback);
+
+/**
+ * Keeps the follow cache current for incoming/outgoing block changes for the
+ * whole session — the ingest happens as a side effect inside
+ * createBlockEventSubscriber, so the one-shot `getAllBlockedUsers()` /
+ * `getAllBlockingUsers()` reflect RTE block/unblock within the TTL window.
+ *
+ * Registered via `setupLoginSubscriptions`; the returned unsubscriber is torn
+ * down on logout.
+ */
+var blockRealtimeOnLoginHandler = () => {
+    const disposers = [onUserDidBlock(() => { }), onUserDidUnblock(() => { })];
+    return () => disposers.forEach(dispose => dispose());
+};
+
+class CursorController {
+    constructor(networkId, userId) {
+        this.networkId = networkId;
+        this.userId = userId;
+    }
+    static current() {
+        try {
+            const user = getCurrentUser();
+            if (!user)
+                return null;
+            const networkId = getNetworkId(user);
+            const { userId } = user;
+            return networkId && userId ? new CursorController(networkId, userId) : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    static isExpired(expiredAt) {
+        return Date.now() >= expiredAt;
+    }
+    static clearOnLogout() {
+        return onSessionStateChange(state => {
+            var _a;
+            if (state === "terminated" /* Amity.SessionStates.TERMINATED */)
+                (_a = CursorController.current()) === null || _a === void 0 ? void 0 : _a.clear();
+        });
+    }
+    get key() {
+        return `amity:forYouFeed:cursor:${this.networkId}:${this.userId}`;
+    }
+    async get() {
+        const raw = await getItem(this.key);
+        if (!raw)
+            return null;
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof (parsed === null || parsed === void 0 ? void 0 : parsed.cursor) !== 'string' || typeof (parsed === null || parsed === void 0 ? void 0 : parsed.expiredAt) !== 'number')
+                return null;
+            return {
+                cursor: parsed.cursor,
+                expiredAt: parsed.expiredAt,
+                reachedEndOfFeed: parsed.reachedEndOfFeed === true,
+            };
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    async set(value) {
+        await setItem(this.key, JSON.stringify(value));
+    }
+    async markReachedEndOfFeed(expiredAt) {
+        var _a;
+        const stored = await this.get();
+        await this.set({
+            cursor: (_a = stored === null || stored === void 0 ? void 0 : stored.cursor) !== null && _a !== void 0 ? _a : '',
+            expiredAt,
+            reachedEndOfFeed: true,
+        });
+    }
+    async clear() {
+        await setItem(this.key, '');
+    }
+}
+
 const EVENTS = [
     'disconnected',
     'error',
@@ -25498,7 +26097,7 @@ const setupLoginSubscriptions = (unsubWatcher) => {
     // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
     // the channel because currently backend can't handle this, so every time a user is banned from
     // a channel or the channel is deleted the channel's unread count will not be reset to zero
-    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -26197,16 +26796,13 @@ const onMessageCreatedMqtt = (callback) => {
         }
         if (client.useLegacyUnreadCount) {
             rawPayload.messages.forEach(message => {
-                var _a, _b;
+                var _a, _b, _c;
                 const channelUnread = (_a = pullFromCache([
                     'channelUnread',
                     'get',
                     message.channelId,
                 ])) === null || _a === void 0 ? void 0 : _a.data;
-                if (!channelUnread ||
-                    channelUnread.lastSegment >= message.segment ||
-                    typeof channelUnread.readToSegment !== 'number' ||
-                    typeof channelUnread.lastMentionedSegment !== 'number')
+                if (!channelUnread || channelUnread.lastSegment >= message.segment)
                     return;
                 const lastSegment = message.segment;
                 const isMentionedInMessage = (_b = message.mentionedUsers) === null || _b === void 0 ? void 0 : _b.some(mention => {
@@ -26218,7 +26814,8 @@ const onMessageCreatedMqtt = (callback) => {
                 const lastMentionedSegment = isMentionedInMessage
                     ? message.segment
                     : channelUnread.lastMentionedSegment;
-                const updatedChannelUnread = Object.assign(Object.assign({}, channelUnread), { lastSegment, unreadCount: Math.max(lastSegment - channelUnread.readToSegment, 0), lastMentionedSegment, isMentioned: !(channelUnread.readToSegment >= lastMentionedSegment) });
+                const readToSegment = (_c = channelUnread.readToSegment) !== null && _c !== void 0 ? _c : 0;
+                const updatedChannelUnread = Object.assign(Object.assign({}, channelUnread), { lastSegment, unreadCount: Math.max(lastSegment - readToSegment, 0), lastMentionedSegment, isMentioned: typeof lastMentionedSegment === 'number' && readToSegment < lastMentionedSegment });
                 pushToCache(['channelUnread', 'get', message.channelId], updatedChannelUnread);
                 fireEvent('local.channelUnread.updated', [updatedChannelUnread]);
             });
@@ -26601,15 +27198,18 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         validateUrls,
         validateTexts,
         getFeedSettings,
+        getCoreUserSettings,
         getSocialSettings,
+        getChatSettings,
         getVisitorDeviceId: getDeviceId,
-        getMessagePreviewSetting,
+        getMessagePreviewSetting: getMessagePreviewSetting$1,
         onRTEConnectionStateChange,
         use: () => setActiveClient(client),
         isUnreadCountEnabled,
         useLegacyUnreadCount,
         getMarkerSyncConsistentMode,
         getProductCatalogueSetting,
+        getForYouFeedSetting,
         /**
          * Prefix for the deviceId key in the local storage or async storage.
          * This is allow user to have multiple SDK client and Mqtt client within the same app.
@@ -26921,6 +27521,13 @@ const getLinkPreviewMetadata = async (url) => {
     return data;
 };
 
+const CONTENT_TYPE_CONFIG = {
+    [AmitySharableContentType.POST]: { key: 'posts', placeholder: 'postId' },
+    [AmitySharableContentType.COMMUNITY]: { key: 'communities', placeholder: 'communityId' },
+    [AmitySharableContentType.USER]: { key: 'users', placeholder: 'userId' },
+    [AmitySharableContentType.LIVESTREAM]: { key: 'livestream', placeholder: 'livestream' },
+    [AmitySharableContentType.EVENT]: { key: 'events', placeholder: 'eventId' },
+};
 /**
  * ```js
  * import Client from '@amityco/ts-sdk-react-native'
@@ -26936,9 +27543,29 @@ const getLinkPreviewMetadata = async (url) => {
  * @async
  */
 const getShareableLinkConfiguration = async () => {
+    var _a, _b;
     const client = getActiveClient();
     const { data } = await client.http.get(`/api/v3/network-settings/shareable-deep-links`);
-    return data;
+    const domain = (_a = data.domain) !== null && _a !== void 0 ? _a : '';
+    const patterns = (_b = data.patterns) !== null && _b !== void 0 ? _b : {};
+    return {
+        domain,
+        patterns,
+        isEnabled(contentType) {
+            const { key } = CONTENT_TYPE_CONFIG[contentType];
+            return !!domain && !!patterns[key];
+        },
+        getPattern(contentType) {
+            const { key } = CONTENT_TYPE_CONFIG[contentType];
+            return patterns[key] || null;
+        },
+        generateLink(contentType, referenceId) {
+            const { key, placeholder } = CONTENT_TYPE_CONFIG[contentType];
+            if (!domain || !patterns[key])
+                return null;
+            return domain + patterns[key].replace(`{${placeholder}}`, referenceId);
+        },
+    };
 };
 
 /**
@@ -27263,6 +27890,71 @@ class Notifications {
 }
 const notifications = () => new Notifications();
 
+/* begin_public_function
+  id: client.enable_auto_subscriptions
+*/
+/**
+ * ```js
+ * import { Client, AmityAutoSubscription } from '@amityco/ts-sdk'
+ * Client.enableAutoSubscriptions([AmityAutoSubscription.BLOCK])
+ * ```
+ *
+ * Enables one or more managed auto-subscription handles. Managed handles are
+ * re-applied on every (re)connect and ref-counted. All handles are on by
+ * default; use this to re-enable handles previously turned off via
+ * {@link disableAutoSubscriptions}. Synchronous fire-and-forget — the registry
+ * updates immediately and the broker subscribe is retried on reconnect.
+ *
+ * @param features the {@link AmityAutoSubscription} handles to enable
+ *
+ * @category Client API
+ */
+const enableAutoSubscriptions = (features) => {
+    const manager = getAutoSubscriptionManager();
+    features.forEach(feature => manager.subscribe(feature));
+};
+/* end_public_function */
+/* begin_public_function
+  id: client.disable_auto_subscriptions
+*/
+/**
+ * ```js
+ * import { Client, AmityAutoSubscription } from '@amityco/ts-sdk'
+ * Client.disableAutoSubscriptions([AmityAutoSubscription.LIVESTREAM])
+ * ```
+ *
+ * Disables one or more managed auto-subscription handles. The change persists
+ * across reconnect (it is not silently re-enabled) until
+ * {@link enableAutoSubscriptions} is called again. Synchronous fire-and-forget.
+ *
+ * @param features the {@link AmityAutoSubscription} handles to disable
+ *
+ * @category Client API
+ */
+const disableAutoSubscriptions = (features) => {
+    const manager = getAutoSubscriptionManager();
+    features.forEach(feature => manager.unsubscribe(feature));
+};
+/* end_public_function */
+/* begin_public_function
+  id: client.auto_subscriptions
+*/
+/**
+ * ```js
+ * import { Client } from '@amityco/ts-sdk'
+ * Client.autoSubscriptions().forEach(s => console.log(s.feature, s.isActive, s.topicCount))
+ * ```
+ *
+ * Inspects the managed auto-subscription registry — each handle's `isActive`,
+ * `isSystem`, and `topicCount`.
+ *
+ * @returns a snapshot of the managed subscription registry
+ *
+ * @category Client API
+ */
+const autoSubscriptions = () => getAutoSubscriptionManager().subscriptions();
+/* end_public_function */
+
 /**
  * ```js
  * import { onChannelMarkerFetched } from '@amityco/ts-sdk-react-native'
@@ -27640,13 +28332,19 @@ var index$s = /*#__PURE__*/Object.freeze({
     getSocialSettings: getSocialSettings,
     getShareableLinkConfiguration: getShareableLinkConfiguration,
     getProductCatalogueSetting: getProductCatalogueSetting,
+    getForYouFeedSetting: getForYouFeedSetting,
     loginAsVisitor: loginAsVisitor,
     loginAsBot: loginAsBot,
     getCurrentUser: getCurrentUser,
     getCurrentUserType: getCurrentUserType,
     setCurrentUserType: setCurrentUserType,
     setAccessTokenHandler: setAccessTokenHandler,
+    getChatSettings: getChatSettings,
+    getCoreUserSettings: getCoreUserSettings,
     notifications: notifications,
+    enableAutoSubscriptions: enableAutoSubscriptions,
+    disableAutoSubscriptions: disableAutoSubscriptions,
+    autoSubscriptions: autoSubscriptions,
     onConnectionError: onConnectionError,
     onClientDisconnected: onClientDisconnected,
     onClientBanned: onClientBanned,
@@ -27664,19 +28362,6 @@ var index$s = /*#__PURE__*/Object.freeze({
     getMarkerSyncConsistentMode: getMarkerSyncConsistentMode
 });
 
-function prepareFollowersPayload(response) {
-    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
-    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
-}
-function prepareFollowingsPayload(response) {
-    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
-    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
-}
-function prepareFollowStatusPayload(response) {
-    const { follows } = response, rest = __rest(response, ["follows"]);
-    return Object.assign(Object.assign({}, rest), { follows });
-}
-
 /* begin_public_function
   id: user.relationship.block
 */
@@ -28854,6 +29539,8 @@ var index$r = /*#__PURE__*/Object.freeze({
     __proto__: null,
     blockUser: blockUser,
     unBlockUser: unBlockUser,
+    onUserDidBlock: onUserDidBlock,
+    onUserDidUnblock: onUserDidUnblock,
     follow: follow,
     unfollow: unfollow,
     acceptMyFollower: acceptMyFollower,
@@ -29683,7 +30370,7 @@ const getWatchSessionStorage = () => {
     return storageInstance;
 };
 
-const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDAARz+hmBgi8pJ\nQb8LeY41gtHhk+ACMwRfhsn7GqpqRQNG2qU0755mzZuVDUqjQMGSo8THJB7O+OJs\nflbZRkFXlFoFOVNw1UpNOgwEQZ6wB9oRwzepTJAfF1sVhm/o/ixvXh1zDFNDy6yZ\npXyiiJHUVxqyjllZhxnwdvjoVtDs6hW6awG09bB9nh/TTejlUKXoAgzqVwu/1QMu\nUVViET495elEe19aUarEy+oL2iKeXCEvqda/pWNBdbieFyJvvZ08HN8dPuT88wq2\njZLEAth1vrwQ2IAa4ktaLcBQdLJgIkrbDvAiVZ8lQAjS/bq5vXQikTGvoPlC5bbn\nvuOM/3eLAgMBAAECggEAVZ+peHAghq2QVj71nX5lxsNCKaCyYwixSJBpfouTt7Rz\nE6PpzMOXFi1W1o+I22jDakuSM2SOQKqI/u0QefB0r0O/KVk5NrZHXk0mkrdYtxOp\nUgaGyf8UvmjB+8VqHrNKyZdk9qtmbnNj01kTTcAtmE4H39zPR7eR/8Rul94vaZbs\nwCnKJS3mLT3JxyGug6lxanveKkjG+CKC1nJQYWaxCJxaFSzbwXQPvDhB+TvrIbee\npd5v4EAyEJohpr+T9oDGGJkb/KARBZCtwLyB976PKJwwBA8MRVL1i5QwawuMiMq5\nUtnOnbGKtCeFzaLbNU0Qi8bqyims84EQxC6DOu1fkQKBgQDdvsoBsEhsOXV7hlIJ\naEd0eSJZVkdqimxH8uGoMM2FeNaOrcB6yBXqTSP0R3OIyf8eaY6yjRvP30ZNXcll\n/gD3O1Mu6YmWQdt1W2WA6pKOsUuPXasf0pdOF7IiFZKlSabz5YHXFqwVuqm8loaj\nsXel3YWqPVdHiankE7tz+3ssnQKBgQDdqi4TNdD1MdEpihx19jr0QjUiXW3939FK\nqp30HESPEGDGQzXdmJgif9HhZb+cJSuWaHEbjgBrYahvgCF+y6LbEpOD+D/dmT+s\nDEAQaR84sah6dokwPjV8fjBSrcVFjCS+doxv0d3p/9OUEeyUhFrY03nxtIEYkLIE\n/Zvn37b4RwKBgQCLENVFe9XfsaVhQ5r9dV2iyTlmh7qgMZG5CbTFs12hQGhm8McO\n+Z7s41YSJCFr/yq1WwP4LJDtrBw99vyQr1zRsG35tNLp3gGRNzGQSQyC2uQFVHw2\np+7mNewsfhUK/gbrXNsyFnDz6635rPlhfbII3sWuP2wWXFqkxE9CbMwR7QKBgQC6\nawDMzxmo2/iYArrkyevSuEuPVxvFwpF1RgAI6C0QVCnPE38dmdN4UB7mfHekje4W\nVEercMURidPp0cxZolCYBQtilUjAyL0vqC3In1/Ogjq6oy3FEMxSop1pKxMY5j+Q\nnoqFD+6deLUrddeNH7J3X4LSr4dSbX4JjG+tlgt+yQKBgQCuwTL4hA6KqeInQ0Ta\n9VQX5Qr8hFlqJz1gpymi/k63tW/Ob8yedbg3WWNWyShwRMFYyY9S81ITFWM95uL6\nvF3x9rmRjwElJw9PMwVu6dmf/CO0Z1wzXSp2VVD12gbrUD/0/d7MUoJ9LgC8X8f/\nn0txLHYGHbx+nf95+JUg6lV3hg==\n-----END PRIVATE KEY-----";
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
 /*
  * The crypto algorithm used for importing key and signing string
  */
@@ -31005,6 +31692,10 @@ const postLinkedObject = (post) => {
                 const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
                 analyticsEngineInstance.markPostAsViewed(post.postId);
             },
+            markAsMeaningfullyViewed: (feedRenderPosition) => {
+                const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
+                analyticsEngineInstance.markPostAsMeaningfullyViewed(post.postId, feedRenderPosition);
+            },
         },
         get productTags() {
             var _a, _b;
@@ -31194,6 +31885,11 @@ const addReaction$1 = async (referenceType, referenceId, reactionName, reference
             });
             return true;
         }
+        if (referenceType === 'message') {
+            upsertInCache(['message', 'get', referenceId], updatedModel);
+            fireEvent('local.message.updated', { messages: [updatedModel] });
+            return true;
+        }
     }
     return true;
 };
@@ -31272,7 +31968,7 @@ const removeReaction$1 = async (referenceType, referenceId, reactionName, refere
             return true;
         }
         if (referenceType === 'story') {
-            fireEvent('local.story.reactionAdded', {
+            fireEvent('local.story.reactionRemoved', {
                 story: updatedModel,
                 reactor: {
                     userId: client.userId,
@@ -31282,6 +31978,11 @@ const removeReaction$1 = async (referenceType, referenceId, reactionName, refere
             });
             return true;
         }
+        if (referenceType === 'message') {
+            upsertInCache(['message', 'get', referenceId], updatedModel);
+            fireEvent('local.message.updated', { messages: [updatedModel] });
+            return true;
+        }
     }
     return true;
 };
@@ -31554,7 +32255,7 @@ const createEventResponseSubscriber = (event, callback) => {
             const eventResponse = pullFromCache([
                 'eventResponse',
                 'get',
-                payload.eventResponses[0].eventId,
+                unpackedPayload.eventResponses[0].userId,
             ]);
             callback(eventResponse.data);
         }
@@ -32218,7 +32919,38 @@ const getAllBlockedUsers = async () => {
     const engine = BlockedUserSyncEngine$1.getInstance();
     // Ensure data is fetched (no-op if cache is fresh)
     await engine.ensureFetched();
-    // Read from the engine's bounded ID list — O(blocked users) not O(cache size)
+    return engine.getCachedUsers();
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: user.get_all_blocking_users
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const blockingUsers = await UserRepository.getAllBlockingUsers()
+ * ```
+ *
+ * Returns all users who have blocked the current user
+ * non-paginated list (limit 100) with TTL-based caching (5-minute window). Within the
+ * TTL window, subsequent calls resolve instantly from the local store without any
+ * server call. After the TTL expires, the next call triggers a fresh server fetch.
+ *
+ * The directional inverse of {@link getAllBlockedUsers}.
+ *
+ * @returns A promise that resolves to an array of blocking {@link Amity.User} objects
+ *
+ * @category Block API
+ * @async
+ */
+const getAllBlockingUsers = async () => {
+    const client = getActiveClient();
+    client.log('user/getAllBlockingUsers');
+    const engine = BlockingUserSyncEngine$1.getInstance();
+    // Ensure data is fetched (no-op if cache is fresh)
+    await engine.ensureFetched();
+    // Read from the engine's bounded ID list — O(blocking users) not O(cache size)
     return engine.getCachedUsers();
 };
 /* end_public_function */
@@ -32601,6 +33333,12 @@ class BlockedUserPaginationController extends PaginationController {
     }
 }
 
+var EnumBlockActions;
+(function (EnumBlockActions) {
+    EnumBlockActions["OnBlocked"] = "onBlocked";
+    EnumBlockActions["OnUnblocked"] = "onUnblocked";
+})(EnumBlockActions || (EnumBlockActions = {}));
+
 class BlockedUserQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -32630,11 +33368,16 @@ class BlockedUserQueryStreamController extends QueryStreamController {
     }
     reactor(action) {
         return (targetUser) => {
-            var _a;
-            if (action === EnumFollowActions.OnFollowed) {
+            var _a, _b;
+            const isRemoval = action === EnumFollowActions.OnFollowed || action === EnumBlockActions.OnUnblocked;
+            const isAddition = action === EnumBlockActions.OnBlocked;
+            if (isRemoval || isAddition) {
                 const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                const updatedCollection = collection === null || collection === void 0 ? void 0 : collection.data.filter(id => id !== targetUser.userId);
-                pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: updatedCollection }));
+                const ids = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+                const data = isAddition
+                    ? [...new Set([...ids, targetUser.userId])]
+                    : ids.filter(id => id !== targetUser.userId);
+                pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data }));
             }
             this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
         };
@@ -32689,7 +33432,6 @@ class BlockedUserLiveCollectionController extends LiveCollectionController {
                 fn: onUserDeleted$2,
                 action: EnumUserActions.OnUserDeleted,
             },
-            // In the case of unblocking a user, we need to subscribe to the follow events
             {
                 fn: convertEventPayload(onLocalUserFollowed, 'to', 'user'),
                 action: EnumFollowActions.OnFollowed,
@@ -32698,6 +33440,28 @@ class BlockedUserLiveCollectionController extends LiveCollectionController {
                 fn: convertEventPayload(onUserFollowed, 'to', 'user'),
                 action: EnumFollowActions.OnFollowed,
             },
+            {
+                fn: (reactor) => onUserDidBlock(status => {
+                    var _a;
+                    if (status.from !== getActiveClient().userId)
+                        return;
+                    const blocked = (_a = pullFromCache(['user', 'get', status.to])) === null || _a === void 0 ? void 0 : _a.data;
+                    if (blocked)
+                        reactor(blocked);
+                }),
+                action: EnumBlockActions.OnBlocked,
+            },
+            {
+                fn: (reactor) => onUserDidUnblock(status => {
+                    var _a;
+                    if (status.from !== getActiveClient().userId)
+                        return;
+                    const blocked = (_a = pullFromCache(['user', 'get', status.to])) === null || _a === void 0 ? void 0 : _a.data;
+                    if (blocked)
+                        reactor(blocked);
+                }),
+                action: EnumBlockActions.OnUnblocked,
+            },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -32765,6 +33529,184 @@ const getBlockedUsers = (params, callback, config) => {
 };
 /* end_public_function */
 
+class BlockingUserQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.users.map(getResolver('user')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const users = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...users, ...response.users.map(getResolver('user'))])] }));
+        }
+    }
+    reactor(action) {
+        return (user) => {
+            var _a, _b;
+            if (user &&
+                (action === EnumBlockActions.OnBlocked || action === EnumBlockActions.OnUnblocked)) {
+                const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                const ids = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+                const data = action === EnumBlockActions.OnBlocked
+                    ? [...new Set([...ids, user.userId])]
+                    : ids.filter(id => id !== user.userId);
+                pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data }));
+            }
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+class BlockingUserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_SIZE } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get('/api/v4/me/blockers', {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
+    }
+}
+
+class BlockingUserLiveCollectionController extends LiveCollectionController {
+    constructor(callback) {
+        const queryStreamId = `blocking-users-${getActiveClient().userId}`;
+        const query = {};
+        const cacheKey = ['blockingUsers', 'collection', queryStreamId];
+        const paginationController = new BlockingUserPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.queryStreamController = new BlockingUserQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this), prepareBlockingUserPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: onUserDeleted$2,
+                action: EnumUserActions.OnUserDeleted,
+            },
+            {
+                fn: (reactor) => onUserDidBlock(status => {
+                    var _a;
+                    if (status.to !== getActiveClient().userId)
+                        return;
+                    const blocker = (_a = pullFromCache(['user', 'get', status.from])) === null || _a === void 0 ? void 0 : _a.data;
+                    if (blocker)
+                        reactor(blocker);
+                }),
+                action: EnumBlockActions.OnBlocked,
+            },
+            {
+                fn: (reactor) => onUserDidUnblock(status => {
+                    var _a;
+                    if (status.to !== getActiveClient().userId)
+                        return;
+                    const blocker = (_a = pullFromCache(['user', 'get', status.from])) === null || _a === void 0 ? void 0 : _a.data;
+                    if (blocker)
+                        reactor(blocker);
+                }),
+                action: EnumBlockActions.OnUnblocked,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter((_b = collection.data
+            .map(id => pullFromCache(['user', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)
+            .map(LinkedObject.user)) !== null && _b !== void 0 ? _b : []);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let users = data;
+        users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+        return users;
+    }
+}
+
+/* begin_public_function
+  id: user.get_blocking_users
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const unsubscribe = UserRepository.getBlockingUsers(({ data: users }) => {
+ *   console.log(users)
+ * })
+ * ```
+ *
+ * Observe the {@link Amity.User}s who have blocked the current user
+ *
+ * @param callback to receive updates on the blocking {@link Amity.User}s
+ * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
+ *
+ * @category User API
+ */
+const getBlockingUsers = (callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        console.log(ENABLE_CACHE_MESSAGE);
+    const timestamp = Date.now();
+    log(`getBlockingUsers(tmpid: ${timestamp}) > listen`);
+    const blockingUserLiveCollection = new BlockingUserLiveCollectionController(callback);
+    const disposers = blockingUserLiveCollection.startSubscription();
+    const cacheKey = blockingUserLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getBlockingUsers(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+        dropFromCache(cacheKey);
+    };
+};
+/* end_public_function */
+
 class SearchUserPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
         const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName } = queryParams, params = __rest(queryParams, ["limit", "displayName"]);
@@ -33031,6 +33973,7 @@ var index$q = /*#__PURE__*/Object.freeze({
     unflagUser: unflagUser,
     isUserFlaggedByMe: isUserFlaggedByMe,
     getAllBlockedUsers: getAllBlockedUsers,
+    getAllBlockingUsers: getAllBlockingUsers,
     onUserUpdated: onUserUpdated,
     onUserDeleted: onUserDeleted$2,
     onUserFlagged: onUserFlagged,
@@ -33039,6 +33982,7 @@ var index$q = /*#__PURE__*/Object.freeze({
     getUser: getUser,
     getUsers: getUsers,
     getBlockedUsers: getBlockedUsers,
+    getBlockingUsers: getBlockingUsers,
     searchUserByDisplayName: searchUserByDisplayName,
     getReachedUsers: getReachedUsers,
     get AmityUserSearchMatchType () { return AmityUserSearchMatchType; }
@@ -34205,7 +35149,7 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
             return true;
         }
         if (referenceType === 'story') {
-            fireEvent('local.story.reactionAdded', {
+            fireEvent('local.story.reactionRemoved', {
                 story: updatedModel,
                 reactor: {
                     userId: client.userId,
@@ -35789,6 +36733,104 @@ const unmuteChannel = async (channelId) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: channel.archive
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk'
+ * const success = await ChannelRepository.archiveChannel('foobar')
+ * ```
+ *
+ * Archive a {@link Amity.Channel}.
+ *
+ * @param channelId The id of the {@link Amity.Channel} to archive
+ * @returns A success boolean
+ *
+ * @category Channel API
+ * @async
+ */
+const archiveChannel = async (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/archiveChannel', channelId);
+    await client.http.post(`/api/v1/archives/channels/${encodeURIComponent(channelId)}`);
+    const archive = {
+        channelId,
+        archivedAt: new Date().toISOString(),
+    };
+    if (client.cache) {
+        pushToCache(['archivedChannel', 'get', getResolver('archivedChannel')(archive)], archive);
+    }
+    fireEvent('local.channel.archived', { archives: [archive] });
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: channel.unarchive
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk'
+ * const success = await ChannelRepository.unarchiveChannel('foobar')
+ * ```
+ *
+ * Unarchive a previously archived {@link Amity.Channel}.
+ *
+ * @param channelId The id of the {@link Amity.Channel} to unarchive
+ * @returns A success boolean
+ *
+ * @category Channel API
+ * @async
+ */
+const unarchiveChannel = async (channelId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/unarchiveChannel', channelId);
+    await client.http.delete(`/api/v1/archives/channels/${encodeURIComponent(channelId)}`);
+    const cached = (_a = pullFromCache(['archivedChannel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+    const archive = cached !== null && cached !== void 0 ? cached : {
+        channelId,
+        archivedAt: new Date().toISOString(),
+    };
+    if (client.cache) {
+        dropFromCache(['archivedChannel', 'get', channelId], true);
+    }
+    fireEvent('local.channel.unarchived', { archives: [archive] });
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: channel.archive.ids
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk'
+ * const ids = await ChannelRepository.getArchivedChannelIds()
+ * ```
+ *
+ * @returns A list of archived channel ids sorted by `archivedAt` descending.
+ *
+ * @category Channel API
+ * @async
+ */
+const getArchivedChannelIds = async () => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/getArchivedChannelIds');
+    const { data: payload } = await client.http.get(`/api/v1/archives/channels`);
+    const archives = (_a = payload.archives) !== null && _a !== void 0 ? _a : [];
+    if (client.cache) {
+        dropFromCache(['archivedChannel', 'get']);
+        archives.forEach(archive => {
+            if (!archive.channelId)
+                return;
+            pushToCache(['archivedChannel', 'get', archive.channelId], archive);
+        });
+    }
+    return archives.map(entry => entry.channelId).filter(channelId => !!channelId);
+};
+/* end_public_function */
+
 /**
  * ```js
  * import { onMessageUpdated } from '@amityco/ts-sdk-react-native'
@@ -37167,6 +38209,160 @@ const getMessages = (params, callback, config) => {
 };
 /* end_public_function */
 
+class SearchMessagePaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { query, exactMatch, channelId, messageFeedId, userIds, tags, types, sortBy, orderBy, limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, } = queryParams;
+        const options = token ? { token } : { limit, sortBy, orderBy };
+        const { data: queryResponse } = await this.http.get(`/api/v2/search/messages`, {
+            params: {
+                query,
+                exactMatch,
+                channelId,
+                messageFeedId,
+                userIds,
+                tags,
+                types,
+                options,
+            },
+        });
+        return queryResponse;
+    }
+}
+
+class SearchMessageQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+    }
+    async saveToMainDB(response) {
+        var _a;
+        const processedPayload = await prepareMessagePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+            if ((_a = response.channels) === null || _a === void 0 ? void 0 : _a.length) {
+                response.channels.forEach(channel => {
+                    pushToCache(['channel', 'get', channel.channelId], channel, { cachedAt });
+                });
+            }
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.messages.map(getResolver('message')),
+            });
+            return;
+        }
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const existing = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        const incoming = response.messages.map(getResolver('message'));
+        pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */
+                ? [...new Set([...incoming, ...existing])]
+                : [...new Set([...existing, ...incoming])] }));
+    }
+}
+
+class SearchMessageLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['message', 'search', queryStreamId];
+        const paginationController = new SearchMessagePaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.queryStreamController = new SearchMessageQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this));
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    startSubscription() {
+        return [];
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = (_b = collection.data
+            .map(messageId => getMessageFromMainDB(messageId))
+            .filter(isNonNullable)
+            .map(message => LinkedObject.message(message))) !== null && _b !== void 0 ? _b : [];
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(response) {
+        await this.queryStreamController.saveToMainDB(response);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+}
+
+/* begin_public_function
+  id: message.search
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk';
+ *
+ * let messages = [];
+ *
+ * const unsubscribe = MessageRepository.searchMessage(
+ *   { query: 'hello' },
+ *   response => merge(messages, response.data),
+ * );
+ * ```
+ *
+ * Live collection of {@link Amity.Message}s matching the search query. Backed
+ * by `GET /api/v2/search/messages`. The first emission delivers the first
+ * page; pagination is driven by `response.onNextPage()`.
+ *
+ * @param params Search parameters. `query` is required.
+ * @param callback Called whenever new data are available.
+ * @returns An {@link Amity.Unsubscriber} function to stop observing.
+ *
+ * @category Message Live Collection
+ */
+const searchMessage = (params, callback) => {
+    if (!params.query || params.query.trim().length === 0) {
+        throw new Error('Query is required for message search');
+    }
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`searchMessage(tmpid: ${timestamp}) > listen`);
+    const controller = new SearchMessageLiveCollectionController(params, callback);
+    const disposers = controller.startSubscription();
+    const cacheKey = controller.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`searchMessage(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
 var index$n = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createMessage: createMessage,
@@ -37192,6 +38388,7 @@ var index$n = /*#__PURE__*/Object.freeze({
     onMessageFetched: onMessageFetched,
     getMessage: getMessage,
     getMessages: getMessages,
+    searchMessage: searchMessage,
     convertFromRaw: convertFromRaw$1,
     prepareMessagePayload: prepareMessagePayload,
     convertParams: convertParams,
@@ -38039,6 +39236,7 @@ class ChannelQueryStreamController extends QueryStreamController {
                 "onCreate" /* Amity.ChannelActionType.OnCreate */,
                 "onJoin" /* Amity.ChannelActionType.OnJoin */,
                 "onResolveChannel" /* Amity.ChannelActionType.OnResolveChannel */,
+                "onUnarchived" /* Amity.ChannelActionType.OnUnarchived */,
             ].includes(action)) {
                 if (Array.isArray(payload)) {
                     collection.data = [
@@ -38048,6 +39246,12 @@ class ChannelQueryStreamController extends QueryStreamController {
                 else
                     collection.data = [...new Set([payload.channelInternalId, ...collection.data])];
             }
+            if (action === "onArchived" /* Amity.ChannelActionType.OnArchived */) {
+                const ids = Array.isArray(payload)
+                    ? payload.map(getResolver('channel'))
+                    : [getResolver('channel')(payload)];
+                collection.data = collection.data.filter(channelInternalId => !ids.includes(channelInternalId));
+            }
             pushToCache(this.cacheKey, collection);
             this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
         };
@@ -38314,6 +39518,32 @@ class ChannelLiveCollectionController extends LiveCollectionController {
             },
             { fn: onChannelMemberAdded, action: "onMemberAdded" /* Amity.ChannelActionType.OnMemberAdded */ },
             { fn: onChannelMemberRemoved, action: "onMemberRemoved" /* Amity.ChannelActionType.OnMemberRemoved */ },
+            {
+                fn: (reactor) => onChannelArchived(payload => {
+                    const channels = payload.archives
+                        .map(archive => {
+                        var _a;
+                        return (_a = pullFromCache(['channel', 'get', archive.channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                    })
+                        .filter((c) => Boolean(c));
+                    if (channels.length > 0)
+                        reactor(channels);
+                }),
+                action: "onArchived" /* Amity.ChannelActionType.OnArchived */,
+            },
+            {
+                fn: (reactor) => onChannelUnarchived(payload => {
+                    const channels = payload.archives
+                        .map(archive => {
+                        var _a;
+                        return (_a = pullFromCache(['channel', 'get', archive.channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                    })
+                        .filter((c) => Boolean(c));
+                    if (channels.length > 0)
+                        reactor(channels);
+                }),
+                action: "onUnarchived" /* Amity.ChannelActionType.OnUnarchived */,
+            },
             {
                 fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
                 action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
@@ -38492,181 +39722,766 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                 action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
             },
         ];
-        if (this.paginationController instanceof PaginationController) {
-            return [
-                ...subscriptions,
-                {
-                    fn: (callback) => {
-                        return onChannelCreated(channel => {
-                            resolveUnreadInfoOnChannelEvent(channel);
-                            callback(channel);
-                        });
-                    },
-                    action: "onCreate" /* Amity.ChannelActionType.OnCreate */,
-                },
-            ];
-        }
-        return subscriptions;
+        if (this.paginationController instanceof PaginationController) {
+            return [
+                ...subscriptions,
+                {
+                    fn: (callback) => {
+                        return onChannelCreated(channel => {
+                            resolveUnreadInfoOnChannelEvent(channel);
+                            callback(channel);
+                        });
+                    },
+                    action: "onCreate" /* Amity.ChannelActionType.OnCreate */,
+                },
+            ];
+        }
+        return subscriptions;
+    }
+}
+
+/* eslint-disable no-use-before-define */
+/* begin_public_function
+  id: channel.query
+*/
+/**
+ * ```js
+ * import { getChannels } from '@amityco/ts-sdk-react-native'
+ *
+ * let channels = []
+ * const unsub = getChannels({
+ *   displayName: Amity.Channel['displayName'],
+ * }, response => merge(channels, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel}s
+ *
+ * @param params for querying channels
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channels
+ *
+ * @category Channel Live Collection
+ */
+const getChannels = (params, callback, config) => {
+    const { log, cache, userId } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getChannels(tmpid: ${timestamp}) > listen`);
+    const channelLiveCollection = new ChannelLiveCollectionController(params, callback);
+    const disposers = channelLiveCollection.startSubscription();
+    const cacheKey = channelLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+/**
+ *
+ * Calculate user unread from {@link Amity.ChannelUnread} objects
+ *
+ * @returns the {@link Amity.UserUnread} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getTotalChannelsUnread$1 = () => {
+    var _a;
+    const client = getActiveClient();
+    client.log('channel/getTotalChannelsUnread.locally');
+    const cachedChannelsUnread = ((_a = queryCache(['channelUnread', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
+        return !data.isDeleted;
+    })) || [];
+    const totalChannelsUnread = (cachedChannelsUnread === null || cachedChannelsUnread === void 0 ? void 0 : cachedChannelsUnread.reduce((acc, { data }) => {
+        acc.unreadCount += data.unreadCount;
+        acc.isMentioned = acc.isMentioned || data.isMentioned;
+        return acc;
+    }, { unreadCount: 0, isMentioned: false })) || { unreadCount: 0, isMentioned: false };
+    const cachedAt = client.cache && Date.now();
+    return {
+        data: totalChannelsUnread,
+        cachedAt,
+    };
+};
+
+/* begin_public_function
+  id: totalChannelsUnread.get
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk-react-native';
+ *
+ * let totalChannelsUnread;
+ *
+ * const unsubscribe = ChannelRepository.getTotalChannelsUnread(response => {
+ *   unread = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.UserUnread}
+ *
+ * @returns An {@link Amity.UserUnread} function to run when willing to stop observing the message
+ *
+ * @category User Unread Live Object
+ *
+ */
+const getTotalChannelsUnread = (callback) => {
+    const { _id: userId } = getActiveUser();
+    if (!userId)
+        throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Object feature you need to enable Cache!');
+    }
+    const timestamp = Date.now();
+    log(`liveTotalChannelsUnread(tmpid: ${timestamp}) > listen`);
+    const disposers = [];
+    let isUnsyncedModel = false; // for messages
+    let model;
+    const dispatcher = (data) => {
+        const { data: userUnread } = data;
+        const callbackModel = userUnread
+            ? {
+                unreadCount: userUnread.unreadCount,
+                isMentioned: userUnread.isMentioned,
+            }
+            : undefined;
+        model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
+        callback({
+            data: callbackModel
+                ? Object.assign(Object.assign({}, callbackModel), { isMentioned: callbackModel.isMentioned }) : callbackModel,
+            loading: data.loading,
+            error: data.error,
+        });
+    };
+    const realtimeRouter = (_) => {
+        const { data: userUnread } = getTotalChannelsUnread$1();
+        if (isEqual(model, userUnread))
+            return;
+        dispatcher({
+            loading: false,
+            data: userUnread,
+        });
+    };
+    const onFetch = () => {
+        const query = createQuery(async () => getTotalChannelsUnread$1());
+        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
+            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
+                dispatcher({
+                    data,
+                    origin,
+                    loading: false,
+                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
+                });
+                isUnsyncedModel = true;
+                disposers.forEach(fn => fn());
+            }
+            else if (!isUnsyncedModel) {
+                dispatcher({ loading, data, origin, error });
+            }
+            if (error) {
+                disposers.forEach(fn => fn());
+            }
+        });
+    };
+    disposers.push(onChannelUnreadUpdatedLocal(realtimeRouter));
+    onFetch();
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+class ArchivedChannelPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        var _a, _b;
+        const limit = (_a = queryParams.limit) !== null && _a !== void 0 ? _a : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+        const pageIndex = token ? Number.parseInt(token, 10) : 0;
+        if (pageIndex === 0) {
+            await getArchivedChannelIds();
+        }
+        const cached = (_b = queryCache(['archivedChannel', 'get'])) !== null && _b !== void 0 ? _b : [];
+        const archives = cached
+            .map(entry => entry.data)
+            .slice()
+            .sort((a, b) => Number(new Date(b.archivedAt)) - Number(new Date(a.archivedAt)));
+        const start = pageIndex * limit;
+        const end = start + limit;
+        const slice = archives.slice(start, end);
+        const hasMore = end < archives.length;
+        if (slice.length > 0) {
+            await getChannelByIds$1(slice.map(archive => archive.channelId));
+        }
+        return {
+            archives: slice,
+            paging: {
+                next: hasMore ? String(pageIndex + 1) : undefined,
+                previous: undefined,
+            },
+        };
+    }
+}
+
+class ArchivedChannelQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+    }
+    async saveToMainDB(_response) {
+        //
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        const channelIds = response.archives.map(archive => archive.channelId);
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: channelIds,
+                params: {},
+            });
+            return;
+        }
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const existing = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */
+                ? [...new Set([...channelIds, ...existing])]
+                : [...new Set([...existing, ...channelIds])] }));
+    }
+    reactor(action) {
+        return (channelIds) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === "onArchived" /* Amity.ChannelActionType.OnArchived */) {
+                const filtered = collection.data.filter(id => !channelIds.includes(id));
+                collection.data = [...channelIds, ...filtered];
+            }
+            if (action === "onUnarchived" /* Amity.ChannelActionType.OnUnarchived */ ||
+                action === "onDelete" /* Amity.ChannelActionType.OnDelete */) {
+                collection.data = collection.data.filter(id => !channelIds.includes(id));
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+class ArchivedChannelLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['archivedChannel', 'collection', queryStreamId];
+        const paginationController = new ArchivedChannelPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.queryStreamController = new ArchivedChannelQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this));
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(response) {
+        await this.queryStreamController.saveToMainDB(response);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: reactor => onChannelArchived(payload => reactor(payload.archives.map(archive => archive.channelId))),
+                action: "onArchived" /* Amity.ChannelActionType.OnArchived */,
+            },
+            {
+                fn: reactor => onChannelUnarchived(payload => reactor(payload.archives.map(archive => archive.channelId))),
+                action: "onUnarchived" /* Amity.ChannelActionType.OnUnarchived */,
+            },
+            {
+                fn: reactor => onChannelUpdated(channel => reactor([channel.channelId])),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: reactor => onChannelDeleted(channel => reactor([channel.channelId])),
+                action: "onDelete" /* Amity.ChannelActionType.OnDelete */,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = (_b = collection.data
+            .map(channelId => pullFromCache(['channel', 'get', channelId]))
+            .filter((entry) => Boolean(entry))
+            .map(({ data: channel }) => channel)
+            .map(constructChannelObject)) !== null && _b !== void 0 ? _b : [];
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: channel.archive.collection
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = ChannelRepository.getArchivedChannels(params, response => merge(channels, response.data))
+ * ```
+ *
+ * Live collection of {@link Amity.Channel}s archived by the active user.
+ *
+ * @param params Live collection parameters (only `limit` is honored; the
+ * archive list takes no other filters).
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to
+ * stop observing.
+ *
+ * @category Channel Live Collection
+ */
+const getArchivedChannels = (params, callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getArchivedChannels(tmpid: ${timestamp}) > listen`);
+    const controller = new ArchivedChannelLiveCollectionController(params, callback);
+    const disposers = controller.startSubscription();
+    const cacheKey = controller.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getArchivedChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+class SearchChannelPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { query, exactMatch, isMemberOnly, types, tags, sortBy, orderBy, limit = COLLECTION_DEFAULT_PAGINATION_SIZE, } = queryParams;
+        const options = token ? { token } : { limit: Math.min(100, Math.max(1, limit)) };
+        const { data: queryResponse } = await this.http.get(`/api/v2/search/channels`, {
+            params: {
+                query,
+                exactMatch,
+                isMemberOnly,
+                types,
+                tags,
+                sortBy,
+                orderBy,
+                options,
+            },
+        });
+        return queryResponse;
+    }
+}
+
+class SearchChannelQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await prepareChannelPayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.channels.map(getResolver('channel')),
+            });
+            return;
+        }
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const existing = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        const incoming = response.channels.map(getResolver('channel'));
+        pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */
+                ? [...new Set([...incoming, ...existing])]
+                : [...new Set([...existing, ...incoming])] }));
+    }
+    reactor() {
+        return () => this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor()));
+    }
+}
+
+/* eslint-disable no-use-before-define */
+const getMessagePreviewSetting = () => {
+    const client = getActiveClient();
+    return client.getMessagePreviewSetting(false);
+};
+class SearchChannelLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['channel', 'search', queryStreamId];
+        const paginationController = new SearchChannelPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.queryStreamController = new SearchChannelQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this));
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(this.getSubscriptions());
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = (_b = collection.data
+            .map(channelId => pullFromCache(['channel', 'get', channelId]))
+            .filter(Boolean)
+            .map(cached => constructChannelObject(cached.data))) !== null && _b !== void 0 ? _b : [];
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(response) {
+        await this.queryStreamController.saveToMainDB(response);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    shouldAbort(targetChannelId) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return true;
+        return !collection.data.find(channelId => channelId === targetChannelId);
+    }
+    getSubscriptions() {
+        return [
+            {
+                fn: convertEventPayload((callback) => {
+                    return onMessageCreatedMqtt(message => {
+                        var _a;
+                        const cacheData = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!cacheData)
+                            return;
+                        updateChannelCache(cacheData, {
+                            lastActivity: message.createdAt,
+                        });
+                        callback(message);
+                    });
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    return onMessageCreatedLocal(message => {
+                        var _a;
+                        const cacheData = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!cacheData)
+                            return;
+                        updateChannelCache(cacheData, {
+                            lastActivity: message.createdAt,
+                        });
+                        callback(message);
+                    });
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            { fn: onChannelDeleted, action: "onDelete" /* Amity.ChannelActionType.OnDelete */ },
+            { fn: onChannelUpdated, action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */ },
+            { fn: onChannelSetMuted, action: "onMute" /* Amity.ChannelActionType.OnMute */ },
+            {
+                fn: (reactor) => onChannelArchived(payload => {
+                    const channels = payload.archives
+                        .map(archive => {
+                        var _a;
+                        return (_a = pullFromCache(['channel', 'get', archive.channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                    })
+                        .filter((c) => Boolean(c));
+                    if (channels.length > 0)
+                        reactor(channels);
+                }),
+                action: "onArchived" /* Amity.ChannelActionType.OnArchived */,
+            },
+            {
+                fn: (reactor) => onChannelUnarchived(payload => {
+                    const channels = payload.archives
+                        .map(archive => {
+                        var _a;
+                        return (_a = pullFromCache(['channel', 'get', archive.channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                    })
+                        .filter((c) => Boolean(c));
+                    if (channels.length > 0)
+                        reactor(channels);
+                }),
+                action: "onUnarchived" /* Amity.ChannelActionType.OnUnarchived */,
+            },
+            {
+                fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        var _a;
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageCreated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        const channel = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!channel)
+                            return;
+                        updateChannelCache(channel, {
+                            messagePreviewId: message.messageId,
+                        });
+                        callback(message);
+                    };
+                    return onMessageCreatedMqtt(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        var _a;
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageCreated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        const channel = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!channel)
+                            return;
+                        updateChannelCache(channel, {
+                            messagePreviewId: message.messageId,
+                        });
+                        callback(message);
+                    };
+                    return onMessageCreatedLocal(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageUpdated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        callback(message);
+                    };
+                    return onMessageUpdated(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        if (messagePreviewSetting ===
+                            "message-preview-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED */)
+                            await handleMessageUpdated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        if (messagePreviewSetting ===
+                            "message-preview-not-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED */) {
+                            await getChannel$1(message.channelId);
+                        }
+                        callback(message);
+                    };
+                    return onMessageDeleted(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (subChannel) => {
+                        var _a;
+                        const collections = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!collections)
+                            return;
+                        const channelId = collections.data.find(channel => {
+                            const messagePreviewCache = getChannelMessagePreview(channel);
+                            return (messagePreviewCache === null || messagePreviewCache === void 0 ? void 0 : messagePreviewCache.subChannelId) === subChannel.subChannelId;
+                        });
+                        if (!channelId)
+                            return;
+                        await getChannel$1(subChannel.channelId);
+                        callback(subChannel);
+                    };
+                    return onSubChannelDeleted(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (subChannel) => {
+                        var _a;
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        const collections = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!collections)
+                            return;
+                        await handleSubChannelUpdated(subChannel);
+                        if (this.shouldAbort(subChannel.channelId))
+                            return;
+                        callback(subChannel);
+                    };
+                    return onSubChannelUpdated(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: (callback) => {
+                    const handleUserFeedMarkerResolved = async (marker) => {
+                        if (marker.feedMarkers) {
+                            const channels = marker.feedMarkers
+                                .map(feedMarker => {
+                                var _a;
+                                return (_a = pullFromCache([
+                                    'channel',
+                                    'get',
+                                    feedMarker.entityId,
+                                ])) === null || _a === void 0 ? void 0 : _a.data;
+                            })
+                                .filter(Boolean);
+                            callback(channels);
+                        }
+                    };
+                    return onUserMessageFeedMarkerResolved(handleUserFeedMarkerResolved);
+                },
+                action: "OnResolveUnread" /* Amity.ChannelActionType.OnResolveUnread */,
+            },
+            {
+                fn: convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const processPayload = (payloads) => {
+                        payloads.forEach(callback);
+                    };
+                    return onChannelUnreadUpdatedLocal(processPayload);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+        ];
     }
 }
 
-/* eslint-disable no-use-before-define */
 /* begin_public_function
-  id: channel.query
+  id: channel.search
 */
 /**
  * ```js
- * import { getChannels } from '@amityco/ts-sdk-react-native'
+ * import { ChannelRepository } from '@amityco/ts-sdk';
  *
- * let channels = []
- * const unsub = getChannels({
- *   displayName: Amity.Channel['displayName'],
- * }, response => merge(channels, response.data))
+ * const unsubscribe = ChannelRepository.searchChannels(
+ *   { query: 'hello' },
+ *   response => response.data,
+ * );
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Channel}s
+ * Live collection of {@link Amity.Channel}s matching the search query. Backed by
+ * `GET /api/v2/search/channels`.
  *
- * @param params for querying channels
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channels
+ * @param params Search parameters.
+ * @param callback Called whenever new data are available.
+ * @returns An {@link Amity.Unsubscriber} function to stop observing.
  *
  * @category Channel Live Collection
  */
-const getChannels = (params, callback, config) => {
-    const { log, cache, userId } = getActiveClient();
-    if (!cache) {
+const searchChannels = (params, callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
         console.log(ENABLE_CACHE_MESSAGE);
-    }
     const timestamp = Date.now();
-    log(`getChannels(tmpid: ${timestamp}) > listen`);
-    const channelLiveCollection = new ChannelLiveCollectionController(params, callback);
-    const disposers = channelLiveCollection.startSubscription();
-    const cacheKey = channelLiveCollection.getCacheKey();
+    log(`searchChannels(tmpid: ${timestamp}) > listen`);
+    const searchChannelLiveCollection = new SearchChannelLiveCollectionController(params, callback);
+    const disposers = searchChannelLiveCollection.startSubscription();
+    const cacheKey = searchChannelLiveCollection.getCacheKey();
     disposers.push(() => {
         dropFromCache(cacheKey);
     });
     return () => {
-        log(`getChannels(tmpid: ${timestamp}) > dispose`);
+        log(`searchChannels(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
 /* end_public_function */
 
-/**
- *
- * Calculate user unread from {@link Amity.ChannelUnread} objects
- *
- * @returns the {@link Amity.UserUnread} objects
- *
- * @category Channel API
- * @async
- */
-const getTotalChannelsUnread$1 = () => {
-    var _a;
-    const client = getActiveClient();
-    client.log('channel/getTotalChannelsUnread.locally');
-    const cachedChannelsUnread = ((_a = queryCache(['channelUnread', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
-        return !data.isDeleted;
-    })) || [];
-    const totalChannelsUnread = (cachedChannelsUnread === null || cachedChannelsUnread === void 0 ? void 0 : cachedChannelsUnread.reduce((acc, { data }) => {
-        acc.unreadCount += data.unreadCount;
-        acc.isMentioned = acc.isMentioned || data.isMentioned;
-        return acc;
-    }, { unreadCount: 0, isMentioned: false })) || { unreadCount: 0, isMentioned: false };
-    const cachedAt = client.cache && Date.now();
-    return {
-        data: totalChannelsUnread,
-        cachedAt,
-    };
-};
-
-/* begin_public_function
-  id: totalChannelsUnread.get
-*/
-/**
- * ```js
- * import { ChannelRepository } from '@amityco/ts-sdk-react-native';
- *
- * let totalChannelsUnread;
- *
- * const unsubscribe = ChannelRepository.getTotalChannelsUnread(response => {
- *   unread = response.data;
- * });
- * ```
- *
- * Observe all mutation on a given {@link Amity.UserUnread}
- *
- * @returns An {@link Amity.UserUnread} function to run when willing to stop observing the message
- *
- * @category User Unread Live Object
- *
- */
-const getTotalChannelsUnread = (callback) => {
-    const { _id: userId } = getActiveUser();
-    if (!userId)
-        throw new ASCError('The _id has not been defined in ActiveUser', 800000 /* Amity.ClientError.UNKNOWN_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log('For using Live Object feature you need to enable Cache!');
-    }
-    const timestamp = Date.now();
-    log(`liveTotalChannelsUnread(tmpid: ${timestamp}) > listen`);
-    const disposers = [];
-    let isUnsyncedModel = false; // for messages
-    let model;
-    const dispatcher = (data) => {
-        const { data: userUnread } = data;
-        const callbackModel = userUnread
-            ? {
-                unreadCount: userUnread.unreadCount,
-                isMentioned: userUnread.isMentioned,
-            }
-            : undefined;
-        model = callbackModel ? convertGetterPropsToStatic(callbackModel) : callbackModel;
-        callback({
-            data: callbackModel
-                ? Object.assign(Object.assign({}, callbackModel), { isMentioned: callbackModel.isMentioned }) : callbackModel,
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (_) => {
-        const { data: userUnread } = getTotalChannelsUnread$1();
-        if (isEqual(model, userUnread))
-            return;
-        dispatcher({
-            loading: false,
-            data: userUnread,
-        });
-    };
-    const onFetch = () => {
-        const query = createQuery(async () => getTotalChannelsUnread$1());
-        runQuery(query, ({ error, data, loading, origin, cachedAt }) => {
-            if (cachedAt === UNSYNCED_OBJECT_CACHED_AT_VALUE) {
-                dispatcher({
-                    data,
-                    origin,
-                    loading: false,
-                    error: new ASCApiError(UNSYNCED_OBJECT_CACHED_AT_MESSAGE, 800800 /* Amity.ClientError.DISALOOW_UNSYNCED_OBJECT */, "error" /* Amity.ErrorLevel.ERROR */),
-                });
-                isUnsyncedModel = true;
-                disposers.forEach(fn => fn());
-            }
-            else if (!isUnsyncedModel) {
-                dispatcher({ loading, data, origin, error });
-            }
-            if (error) {
-                disposers.forEach(fn => fn());
-            }
-        });
-    };
-    disposers.push(onChannelUnreadUpdatedLocal(realtimeRouter));
-    onFetch();
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
 /* begin_public_function
   id: channel.member.add
 */
@@ -38798,7 +40613,9 @@ class ChannelMemberQueryStreamController extends QueryStreamController {
                 channelId: this.query.channelId,
                 userId: channelMember.userId,
             });
-            if (channelMember.membership === 'none') {
+            const membershipFilter = this.query.memberships;
+            const isInFilter = !membershipFilter || membershipFilter.includes(channelMember.membership);
+            if (channelMember.membership === 'none' || !isInFilter) {
                 collection.data = collection.data.filter(m => m !== channelMemberCacheId);
             }
             else if (!collection.data.includes(channelMemberCacheId)) {
@@ -39134,6 +40951,7 @@ const banMembers$1 = async (channelId, userIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(preparedPayload, { cachedAt });
+    fireEvent('channel.banned', payload);
     return {
         data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'banned'),
         cachedAt,
@@ -39168,6 +40986,7 @@ const unbanMembers$1 = async (channelId, userIds) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(preparedPayload, { cachedAt });
+    fireEvent('channel.unbanned', payload);
     const { channelUsers } = preparedPayload;
     return {
         data: channelUsers === null || channelUsers === void 0 ? void 0 : channelUsers.filter(user => user.membership === 'member'),
@@ -39196,6 +41015,7 @@ const MUTE_FOREVER = -1;
  * @async
  * */
 const muteMembers = async (channelId, userIds, mutePeriod = MUTE_FOREVER) => {
+    var _a;
     const client = getActiveClient();
     client.log('channel/muteMembers', { userIds, channelId, mutePeriod });
     const { data } = await client.http.put(`/api/v2/channel/${channelId}/users/mute`, {
@@ -39203,6 +41023,15 @@ const muteMembers = async (channelId, userIds, mutePeriod = MUTE_FOREVER) => {
         mutePeriod: mutePeriod === MUTE_FOREVER ? mutePeriod : mutePeriod * 1000,
     });
     const { success } = data;
+    const muteTimeout = mutePeriod === MUTE_FOREVER
+        ? new Date('9999-12-31T23:59:59.999Z').toISOString()
+        : new Date(Date.now() + mutePeriod * 1000).toISOString();
+    fireEvent('channel.setMutedUsers', {
+        channelId,
+        userIds,
+        muteTimeout,
+        actor: (_a = client.userId) !== null && _a !== void 0 ? _a : '',
+    });
     return success;
 };
 /* end_public_function */
@@ -39225,6 +41054,7 @@ const muteMembers = async (channelId, userIds, mutePeriod = MUTE_FOREVER) => {
  * @async
  * */
 const unmuteMembers = async (channelId, userIds) => {
+    var _a;
     const client = getActiveClient();
     client.log('channel/unmuteMembers', { userIds, channelId });
     const { data } = await client.http.put(`/api/v2/channel/${encodeURIComponent(channelId)}/users/mute`, {
@@ -39232,6 +41062,12 @@ const unmuteMembers = async (channelId, userIds) => {
         mutePeriod: 0,
     });
     const { success } = data;
+    fireEvent('channel.setMutedUsers', {
+        channelId,
+        userIds,
+        muteTimeout: new Date(0).toISOString(),
+        actor: (_a = client.userId) !== null && _a !== void 0 ? _a : '',
+    });
     return success;
 };
 /* end_public_function */
@@ -39258,6 +41094,9 @@ var index$j = /*#__PURE__*/Object.freeze({
     leaveChannel: leaveChannel,
     muteChannel: muteChannel,
     unmuteChannel: unmuteChannel,
+    archiveChannel: archiveChannel,
+    unarchiveChannel: unarchiveChannel,
+    getArchivedChannelIds: getArchivedChannelIds,
     onChannelCreated: onChannelCreated,
     onChannelUpdated: onChannelUpdated,
     onChannelDeleted: onChannelDeleted,
@@ -39270,9 +41109,13 @@ var index$j = /*#__PURE__*/Object.freeze({
     onChannelMemberUnbanned: onChannelMemberUnbanned,
     onChannelMemberRoleAdded: onChannelMemberRoleAdded,
     onChannelMemberRoleRemoved: onChannelMemberRoleRemoved,
+    onChannelArchived: onChannelArchived,
+    onChannelUnarchived: onChannelUnarchived,
     getChannel: getChannel,
     getChannels: getChannels,
     getTotalChannelsUnread: getTotalChannelsUnread,
+    getArchivedChannels: getArchivedChannels,
+    searchChannels: searchChannels,
     MARKER_INCLUDED_CHANNEL_TYPE: MARKER_INCLUDED_CHANNEL_TYPE,
     isUnreadCountSupport: isUnreadCountSupport,
     convertFromRaw: convertFromRaw,
@@ -43169,7 +45012,7 @@ class CommentLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE([
+        const disposers = this.queryStreamController.subscribeRTE([
             { fn: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
             { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
             { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
@@ -43182,6 +45025,11 @@ class CommentLiveCollectionController extends LiveCollectionController {
             { fn: onLocalCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
             { fn: onLocalCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
         ]);
+        if (this.query.excludeBlockUserComments) {
+            const refresh = () => this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            disposers.push(onUserDidBlock(refresh), onUserDidUnblock(refresh));
+        }
+        return disposers;
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -43234,6 +45082,9 @@ class CommentLiveCollectionController extends LiveCollectionController {
                 comments = comments.filter(comment => { var _a; return (_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.some(value => { var _a; return (_a = comment.dataTypes) === null || _a === void 0 ? void 0 : _a.includes(value); }); });
             }
         }
+        if (this.query.excludeBlockUserComments) {
+            comments = filterCommentsByBlockUsers(comments);
+        }
         switch (this.query.sortBy) {
             case 'firstCreated':
                 comments = comments.sort(sortByFirstCreated);
@@ -44319,13 +46170,253 @@ const getCommunityFeed = (params, callback, config) => {
 };
 /* end_public_function */
 
+/**
+ * Thrown by `getForYouFeed` when the network has the For You feature
+ * disabled. Mapped from HTTP 404 NOT_FOUND. Distinct from a generic
+ * not-found so consumers can hide the For You tab without retrying.
+ *
+ * @category Errors
+ */
+class AmityForYouFeedDisabledError extends ASCApiError {
+    constructor(message = 'For You feed is not enabled for this network') {
+        super(message, 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
+        this.type = 'AmityForYouFeedDisabledError';
+    }
+}
+
+class ForYouFeedPaginationController extends PaginationController {
+    constructor(query) {
+        super(query);
+        this.checkedDisk = false;
+        this.hasDeliveredPost = false;
+        this.cursor = CursorController.current();
+    }
+    async getRequest(_queryParams, token) {
+        var _a, _b, _c, _d, _e;
+        const isFirstPage = token === undefined;
+        let stored = null;
+        // On the first page of a fresh collection, load the saved cursor from disk once.
+        // Drop it if the snapshot has already expired so we start fresh.
+        if (isFirstPage && !this.checkedDisk && this.cursor) {
+            this.checkedDisk = true;
+            stored = await this.cursor.get();
+            if (stored && CursorController.isExpired(stored.expiredAt)) {
+                await this.cursor.clear();
+                stored = null;
+            }
+        }
+        // Already paged to the end before. Ask the BE fresh (no cursor) and check if it's
+        // still the same snapshot the user finished.
+        if (isFirstPage && (stored === null || stored === void 0 ? void 0 : stored.reachedEndOfFeed)) {
+            const fresh = await this.fetch();
+            const freshExpiredAt = Date.parse((_b = (_a = fresh.paging) === null || _a === void 0 ? void 0 : _a.expiredAt) !== null && _b !== void 0 ? _b : '');
+            const rolledOver = !Number.isNaN(freshExpiredAt) && freshExpiredAt !== stored.expiredAt;
+            // New snapshot → serve it. Same snapshot → user has seen it all, show empty.
+            if (rolledOver) {
+                await this.persistCursor(fresh);
+                if (fresh.posts.length > 0)
+                    this.hasDeliveredPost = true;
+                return fresh;
+            }
+            return Object.assign(Object.assign({}, fresh), { posts: [], paging: {} });
+        }
+        // Resume from the saved cursor on re-entry; otherwise use the live-collection token.
+        const effectiveToken = isFirstPage && stored ? stored.cursor : token;
+        const response = await this.fetch(effectiveToken);
+        if (response.posts.length > 0)
+            this.hasDeliveredPost = true;
+        if ((_c = response.paging) === null || _c === void 0 ? void 0 : _c.next) {
+            // More pages left → advance the saved cursor.
+            await this.persistCursor(response);
+        }
+        else if (this.hasDeliveredPost && this.cursor) {
+            // Reached the end and mark end of feed
+            const expiredAt = Date.parse((_e = (_d = response.paging) === null || _d === void 0 ? void 0 : _d.expiredAt) !== null && _e !== void 0 ? _e : '');
+            if (!Number.isNaN(expiredAt))
+                await this.cursor.markReachedEndOfFeed(expiredAt);
+        }
+        return response;
+    }
+    async fetch(token) {
+        const options = { limit: COLLECTION_DEFAULT_PAGINATION_SIZE };
+        if (token)
+            options.token = token;
+        try {
+            const { data } = await this.http.get(API_ENDPOINTS.forYouFeed, {
+                params: { options },
+            });
+            return data;
+        }
+        catch (error) {
+            if (error instanceof ASCApiError && error.code === 400300 /* Amity.ServerError.FORBIDDEN */) {
+                throw new AmityForYouFeedDisabledError();
+            }
+            const recoverable = error instanceof ASCApiError && error.code === 400322 /* Amity.ServerError.FEED_SNAPSHOT_EXPIRED */;
+            if (recoverable && token !== undefined) {
+                if (this.cursor)
+                    await this.cursor.clear();
+                const { data } = await this.http.get(API_ENDPOINTS.forYouFeed, {
+                    params: { options: { limit: COLLECTION_DEFAULT_PAGINATION_SIZE } },
+                });
+                return data;
+            }
+            throw error;
+        }
+    }
+    async persistCursor(response) {
+        var _a, _b;
+        if (!this.cursor)
+            return;
+        const cursor = (_a = response.paging) === null || _a === void 0 ? void 0 : _a.next;
+        const expiredAtIso = (_b = response.paging) === null || _b === void 0 ? void 0 : _b.expiredAt;
+        if (!cursor || !expiredAtIso)
+            return;
+        const expiredAt = Date.parse(expiredAtIso);
+        if (Number.isNaN(expiredAt))
+            return;
+        await this.cursor.set({ cursor, expiredAt });
+    }
+}
+
+class ForYouFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache)
+            ingestInCache(processedPayload, { cachedAt });
+    }
+    appendToQueryStream(response, _direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && !collection.data.includes(post.parentPostId))
+                return;
+            if (action === EnumPostActions.OnPostDeleted || action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+const FOR_YOU_FEED_CACHE_KEY = ['forYouFeed', 'collection'];
+class ForYouFeedLiveCollectionController extends LiveCollectionController {
+    constructor(callback) {
+        const queryStreamId = `for-you-feed-${getActiveClient().userId}`;
+        const query = {};
+        const paginationController = new ForYouFeedPaginationController(query);
+        super(paginationController, queryStreamId, FOR_YOU_FEED_CACHE_KEY, callback);
+        this.queryStreamController = new ForYouFeedQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            pushToCache(this.cacheKey, { data: [], params: {} });
+    }
+    async persistModel(payload) {
+        await this.queryStreamController.saveToMainDB(payload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: feed.query.for_you_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * const unsub = FeedRepository.getForYouFeed(({ data, loading, error, hasNextPage, onNextPage }) => {
+ *   // render posts; call onNextPage() to load the next page (20 posts)
+ * })
+ * ```
+ *
+ * Observe the For You feed — a personalized, server-ranked
+ * {@link Amity.LiveCollection} of {@link Amity.Post}.
+ *
+ * @param callback the function to call when new data is available
+ * @returns an {@link Amity.Unsubscriber} function to stop observing
+ *
+ * @category Posts Live Collection
+ */
+const getForYouFeed = (callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        console.log(ENABLE_CACHE_MESSAGE);
+    const timestamp = Date.now();
+    log(`getForYouFeed(tmpid: ${timestamp}) > listen`);
+    const forYouFeedLiveCollection = new ForYouFeedLiveCollectionController(callback);
+    const disposers = forYouFeedLiveCollection.startSubscription();
+    const cacheKey = forYouFeedLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getForYouFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
 var index$d = /*#__PURE__*/Object.freeze({
     __proto__: null,
     queryGlobalFeed: queryGlobalFeed,
     getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
     getGlobalFeed: getGlobalFeed,
     getUserFeed: getUserFeed,
-    getCommunityFeed: getCommunityFeed
+    getCommunityFeed: getCommunityFeed,
+    getForYouFeed: getForYouFeed,
+    AmityForYouFeedDisabledError: AmityForYouFeedDisabledError
 });
 
 /* begin_public_function
@@ -45338,7 +47429,12 @@ class PostLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
+        const disposers = this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
+        if (this.query.excludeBlockUserPosts) {
+            const refresh = () => this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            disposers.push(onUserDidBlock(refresh), onUserDidUnblock(refresh));
+        }
+        return disposers;
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -45384,6 +47480,9 @@ class PostLiveCollectionController extends LiveCollectionController {
             const sortBy = this.query.sortBy || 'lastCreated';
             posts = posts.filter(post => !exceedsUntilAtBoundary(post.createdAt, validatedUntilAt, sortBy));
         }
+        if (this.query.excludeBlockUserPosts) {
+            posts = filterPostsByBlockUsers(posts);
+        }
         switch (this.query.sortBy) {
             case 'firstCreated':
                 posts = posts.sort(sortByFirstCreated);
@@ -52041,4 +54140,4 @@ class AmityAttachmentProductTags {
     }
 }
 
-export { API_REGIONS, index$5 as AdRepository, AmityAttachmentProductTags, AmityCommunityType, AmityEventOrderOption, AmityEventOriginType, AmityEventResponseStatus, AmityEventSortOption, AmityEventStatus, AmityEventType, AnalyticsSourceTypeEnum, index$f as CategoryRepository, index$j as ChannelRepository, index$s as Client, index$e as CommentRepository, CommunityNotificationEventNameEnum, CommunityPostSettingMaps, CommunityPostSettings, index$g as CommunityRepository, ContentFeedType, ContentFlagReasonEnum, DefaultCommunityPostSetting, index$1 as EventRepository, FeedDataTypeEnum, index$d as FeedRepository, FeedSortByEnum, FeedSourceEnum, FeedTypeEnum, FileAccessTypeEnum, index$p as FileRepository, FileType, GET_WATCHER_URLS, index$3 as InvitationRepository, InvitationSortByEnum, InvitationStatusEnum, InvitationTargetTypeEnum, InvitationTypeEnum, JoinRequestStatusEnum, JoinResultStatusEnum, index$2 as LiveReactionRepository, index$7 as LiveStreamPlayer, MembershipAcceptanceTypeEnum, MessageContentType, index$n as MessageRepository, NotificationRolesFilterTypeEnum, NotificationSettingsLevelEnum, index$8 as PollRepository, PostContentType, index$b as PostRepository, PostStructureType, index as ProductRepository, index$o as ReactionRepository, index$9 as RoomPresenceRepository, index$c as RoomRepository, SearchUsersByEnum, index$6 as StoryRepository, index$a as StreamRepository, index$m as SubChannelRepository, SubscriptionLevels, UserNotificationModuleNameEnum, index$q as UserRepository, UserTypeEnum, VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, backupCache, createQuery, createReport, createUserToken, deleteReport, disableCache, dropFromCache, enableCache, exceedsUntilAtBoundary, filterByChannelMembership, filterByCommunityMembership, filterByFeedType, filterByPostDataTypes, filterByPropEquality, filterByPropInclusion, filterByPropIntersection, filterBySearchTerm, filterByStringComparePartially, filterByUntilAt, getChannelTopic, getCommentTopic, getCommunityStoriesTopic, getCommunityTopic, getLiveReactionTopic, getLiveStreamTopic, getMarkedMessageTopic, getMarkerUserFeedTopic, getMessageTopic, getMyFollowersTopic, getMyFollowingsTopic, getNetworkTopic, getPostTopic, getRole, getRoomStreamerTopic, getRoomWatcherTopic, getSmartFeedChannelTopic, getSmartFeedMessageTopic, getSmartFeedSubChannelTopic, getStoryTopic, getSubChannelTopic, getUserTopic, isAfterBefore, isAfterBeforeRaw, isCachable, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkip, mergeInCache, index$4 as notificationTray, onChannelMarkerFetched, onFeedMarkerFetched, onFeedMarkerUpdated, onMessageMarked, onMessageMarkerFetched, onSubChannelMarkerFetched, onSubChannelMarkerUpdated, onUserMarkerFetched, onUserMarkerFetchedLegacy, pullFromCache, pushToCache, queryCache, queryOptions, queryRoles, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByFirstUpdated, sortByLastActivity, sortByLastCreated, sortByLastUpdated, sortByLocalSortingDate, sortByName, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, upsertInCache, validateUntilAt, wipeCache };
+export { API_REGIONS, index$5 as AdRepository, AmityAttachmentProductTags, AmityAutoSubscription, AmityChannelNotificationModeEnum, AmityCommunityType, AmityEventOrderOption, AmityEventOriginType, AmityEventResponseStatus, AmityEventSortOption, AmityEventStatus, AmityEventType, AmitySharableContentType, AnalyticsSourceTypeEnum, index$f as CategoryRepository, index$j as ChannelRepository, index$s as Client, index$e as CommentRepository, CommunityNotificationEventNameEnum, CommunityPostSettingMaps, CommunityPostSettings, index$g as CommunityRepository, ContentFeedType, ContentFlagReasonEnum, DefaultCommunityPostSetting, index$1 as EventRepository, FeedDataTypeEnum, index$d as FeedRepository, FeedSortByEnum, FeedSourceEnum, FeedTypeEnum, FileAccessTypeEnum, index$p as FileRepository, FileType, GET_WATCHER_URLS, index$3 as InvitationRepository, InvitationSortByEnum, InvitationStatusEnum, InvitationTargetTypeEnum, InvitationTypeEnum, JoinRequestStatusEnum, JoinResultStatusEnum, index$2 as LiveReactionRepository, index$7 as LiveStreamPlayer, MembershipAcceptanceTypeEnum, MessageContentType, index$n as MessageRepository, NotificationRolesFilterTypeEnum, NotificationSettingsLevelEnum, index$8 as PollRepository, PostContentType, index$b as PostRepository, PostStructureType, index as ProductRepository, index$o as ReactionRepository, index$9 as RoomPresenceRepository, index$c as RoomRepository, SearchUsersByEnum, index$6 as StoryRepository, index$a as StreamRepository, index$m as SubChannelRepository, SubscriptionLevels, UserNotificationModuleNameEnum, index$q as UserRepository, UserTypeEnum, VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, backupCache, createQuery, createReport, createUserToken, deleteReport, disableCache, dropFromCache, enableCache, exceedsUntilAtBoundary, filterByChannelMembership, filterByCommunityMembership, filterByFeedType, filterByPostDataTypes, filterByPropEquality, filterByPropInclusion, filterByPropIntersection, filterBySearchTerm, filterByStringComparePartially, filterByUntilAt, filterCommentsByBlockUsers, filterPostsByBlockUsers, getBlockUsersId, getChannelTopic, getCommentTopic, getCommunityStoriesTopic, getCommunityTopic, getLiveReactionTopic, getLiveStreamTopic, getMarkedMessageTopic, getMarkerUserFeedTopic, getMessageTopic, getMyFollowersTopic, getMyFollowingsTopic, getNetworkId, getNetworkTopic, getPostTopic, getRole, getRoomStreamerTopic, getRoomWatcherTopic, getSmartFeedChannelTopic, getSmartFeedMessageTopic, getSmartFeedSubChannelTopic, getStoryTopic, getSubChannelTopic, getUserTopic, isAfterBefore, isAfterBeforeRaw, isCachable, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkip, mergeInCache, index$4 as notificationTray, onChannelMarkerFetched, onFeedMarkerFetched, onFeedMarkerUpdated, onMessageMarked, onMessageMarkerFetched, onSubChannelMarkerFetched, onSubChannelMarkerUpdated, onUserMarkerFetched, onUserMarkerFetchedLegacy, pullFromCache, pushToCache, queryCache, queryOptions, queryRoles, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByFirstUpdated, sortByLastActivity, sortByLastCreated, sortByLastUpdated, sortByLocalSortingDate, sortByName, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, upsertInCache, validateUntilAt, wipeCache };