@amityco/ts-sdk-react-native 6.29.3-669217e.0 → 6.29.3-fe4e045.0

package/dist/index.esm.js

@@ -6,9 +6,8 @@ import HttpAgent, { HttpsAgent } from 'agentkeepalive';
 import io from 'socket.io-client';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import uuid$1 from 'react-native-uuid';
-import { Platform } from 'react-native';
-import mime from 'mime';
 import hash from 'object-hash';
+import mime from 'mime';
 import Hls from 'hls.js';
 
 const FileType = Object.freeze({
@@ -528,6 +527,8 @@ const idResolvers = {
     storyTarget: ({ targetId }) => targetId,
     ad: ({ adId }) => adId,
     advertiser: ({ advertiserId }) => advertiserId,
+    pin: ({ referenceId }) => referenceId,
+    pinTarget: ({ targetId }) => targetId,
 };
 /**
  * Retrieve the id resolver matching a domain name
@@ -577,6 +578,8 @@ const PAYLOAD2MODEL = {
     feeds: 'feed',
     ads: 'ad',
     advertisers: 'advertiser',
+    pinTargets: 'pinTarget',
+    pins: 'pin',
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
@@ -652,18 +655,6 @@ class ASCConnectionError extends ASCError {
             : 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;
@@ -20830,6 +20821,31 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 
+/**
+ * Attach user object to membership model
+ * - If cache is not enabled, set user to undefined ({..., user: undefined})
+ * - If user object is not found in cache, set user to undefined
+ * ({..., user: undefined})
+ * - If a user is found in the cache, it attaches the user from the cache
+ * ({..., user: { userId, displayName,... }})
+ *
+ * @param member The membership model object
+ * @returns The membership model object that is already mapped to user
+ * @hidden
+ */
+const convertRawMembershipToMembership = (member) => {
+    return Object.assign(Object.assign({}, member), { get user() {
+            var _a;
+            const client = getActiveClient();
+            if (!client.cache)
+                return undefined;
+            const userCache = (_a = pullFromCache(['user', 'get', member.userId])) === null || _a === void 0 ? void 0 : _a.data;
+            if (!userCache) {
+                return undefined;
+            }
+            return userCache;
+        } });
+};
 /**
  * Attach user object to membership model
  * - If cache is not enabled, set user to undefined ({..., user: undefined})
@@ -21476,6 +21492,80 @@ const categoryLinkedObject = (category) => {
         } });
 };
 
+/**
+ * ```js
+ * import { isEqual } from '~/utils/isEqual'
+ * const isEqual = isEqual(post1, post2)
+ * ```
+ *
+ * Compares two Amity.Model
+ *
+ * @param x the Amity.Model to compare
+ * @param y the Amity.Model to compare wit x
+ * @returns a boolean based on equality
+ *
+ * @category utility
+ * @private
+ */
+function isEqual(x, y) {
+    if (x === null || x === undefined || y === null || y === undefined) {
+        return x === y;
+    }
+    // after this just checking type of one would be enough
+    if (x.constructor !== y.constructor) {
+        return false;
+    }
+    // if they are functions, they should exactly refer to same one (because of closures)
+    if (x instanceof Function) {
+        return x === y;
+    }
+    // if they are regexps, they should exactly refer to same one
+    if (x instanceof RegExp) {
+        return x === y;
+    }
+    if (x === y || x.valueOf() === y.valueOf()) {
+        return true;
+    }
+    if (Array.isArray(x) && x.length !== y.length) {
+        return false;
+    }
+    // check each element of the array for equality
+    if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length)
+            return false;
+        for (let i = 0; i < x.length; i += 1) {
+            if (!isEqual(x[i], y[i]))
+                return false;
+        }
+        // if all elements are equal, the arrays are equal
+        return true;
+    }
+    // if they are dates, they must had equal valueOf
+    if (x instanceof Date) {
+        return false;
+    }
+    // if they are strictly equal, they both need to be object at least
+    if (!(x instanceof Object)) {
+        return false;
+    }
+    if (!(y instanceof Object)) {
+        return false;
+    }
+    // recursive object equality check
+    const p = Object.keys(x);
+    return (Object.keys(y).every(i => {
+        // @ts-ignore
+        return p.indexOf(i) !== -1;
+    }) &&
+        p.every(i => {
+            return isEqual(x[i], y[i]);
+        }));
+}
+
+function isNonNullable(value) {
+    return value != null;
+}
+
 const commentLinkedObject = (comment) => {
     return Object.assign(Object.assign({}, comment), { get target() {
             const commentTypes = {
@@ -21506,7 +21596,7 @@ const commentLinkedObject = (comment) => {
             return undefined;
         },
         get childrenComment() {
-            return (comment.children
+            return comment.children
                 .map(childCommentId => {
                 const commentCache = pullFromCache([
                     'comment',
@@ -21517,10 +21607,8 @@ const commentLinkedObject = (comment) => {
                     return;
                 return commentCache === null || commentCache === void 0 ? void 0 : commentCache.data;
             })
-                .filter(item => item)
-                // Cannot include this loop in the first loop because
-                // TS always alert returned value is possibly undefined
-                .map(item => commentLinkedObject(item)));
+                .filter(isNonNullable)
+                .map(item => commentLinkedObject(item));
         } });
 };
 
@@ -21943,6 +22031,31 @@ const adLinkedObject = (ad) => {
         } });
 };
 
+const pinnedPostLinkedObject = (pinnedPost) => {
+    var _a;
+    const postCached = pullFromCache(['post', 'get', pinnedPost.referenceId]);
+    const pinnedBy = (_a = queryCache(['user', 'get']).find(cache => {
+        var _a;
+        return ((_a = cache.data) === null || _a === void 0 ? void 0 : _a.userInternalId) === pinnedPost.pinnedBy;
+    })) === null || _a === void 0 ? void 0 : _a.data;
+    return Object.assign(Object.assign({}, pinnedPost), { pinnedBy,
+        get post() {
+            if (!(postCached === null || postCached === void 0 ? void 0 : postCached.data))
+                return;
+            return postLinkedObject(postCached.data);
+        },
+        get target() {
+            const pinTarget = pullFromCache([
+                'pinTarget',
+                'get',
+                postCached === null || postCached === void 0 ? void 0 : postCached.data.targetId,
+            ]);
+            if (!(pinTarget === null || pinTarget === void 0 ? void 0 : pinTarget.data))
+                return;
+            return pinTarget === null || pinTarget === void 0 ? void 0 : pinTarget.data;
+        } });
+};
+
 const LinkedObject = {
     ad: adLinkedObject,
     comment: commentLinkedObject,
@@ -21955,6 +22068,7 @@ const LinkedObject = {
     message: messageLinkedObject,
     reactor: reactorLinkedObject,
     channel: channelLinkedObject,
+    pinnedPost: pinnedPostLinkedObject,
 };
 
 const getChannelMessagePreviewWithUser = (channel) => {
@@ -22323,6 +22437,10 @@ const getChannelIsMentioned = (channel, marker) => {
         : (_d = (_c = getCachedMarker(channel.channelPublicId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
 };
 
+function convertRawUserToInternalUser(rawUser) {
+    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
+}
+
 const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 const isUnreadCountSupport$2 = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
 function convertFromRaw$2(channel, options = { isMessagePreviewUpdated: true }) {
@@ -22380,9 +22498,13 @@ const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpd
     // attach marker to channel
     const channels = rawPayload.channels.map(payload => convertFromRaw$2(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }));
     // user marker to channel users
-    const channelUsers = withUsers(rawPayload.channelUsers);
+    const channelUsers = rawPayload.channelUsers.map(channelUser => {
+        return convertRawMembershipToMembership(channelUser);
+    });
+    const users = rawPayload.users.map(convertRawUserToInternalUser);
     const restRawPayload = __rest(rawPayload, ["messageFeedsInfo", "messagePreviews"]);
-    return Object.assign(Object.assign({}, restRawPayload), { channels,
+    return Object.assign(Object.assign({}, restRawPayload), { users,
+        channels,
         channelUsers });
 };
 
@@ -23819,9 +23941,17 @@ const onChannelMemberBanned = (callback) => {
     return createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
 };
 
+function prepareUserPayload(response) {
+    return {
+        users: response.users.map(convertRawUserToInternalUser),
+        files: response.files,
+    };
+}
+
 const createUserEventSubscriber = (event, callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
+    const filter = (data) => {
+        const payload = prepareUserPayload(data);
         if (client.cache) {
             ingestInCache(payload);
         }
@@ -23845,7 +23975,7 @@ const createUserEventSubscriber = (event, callback) => {
  *
  * @category User Events
  */
-const onUserDeleted = (callback) => createUserEventSubscriber('user.deleted', callback);
+const onUserDeleted$2 = (callback) => createUserEventSubscriber('user.deleted', callback);
 
 var analyticsEngineOnLoginHandler = () => {
     const analyticsEngine = AnalyticsEngine$1.getInstance();
@@ -25122,7 +25252,7 @@ const login = async (params, sessionHandler, config) => {
             terminateClient();
             subscriptions.forEach(fn => fn());
             unsubWatcher();
-        }), onUserDeleted((user) => {
+        }), onUserDeleted$2((user) => {
             if (user.userId === client.userId) {
                 terminateClient("userDeleted" /* Amity.TokenTerminationReason.USER_DELETED */);
                 subscriptions.forEach(fn => fn());
@@ -25404,43 +25534,6 @@ const isConnected = () => {
         client.ws.connected);
 };
 
-const registerPushNotification = async (deviceToken) => {
-    const client = getActiveClient();
-    let platform;
-    if (Platform.OS === 'ios' || Platform.OS === 'android') {
-        platform = Platform.OS;
-    }
-    else {
-        throw new ASCInvalidParameterError('Unsupported platform');
-    }
-    const deviceId = await getDeviceId();
-    const { data: { status, error }, } = await client.http.post('/v1/notification', {
-        userId: client.userId,
-        deviceId,
-        platform,
-        token: deviceToken,
-    }, { headers: { 'X-API-Key': client.apiKey } });
-    if (error) {
-        throw new ASCApiError(error, 500000 /* Amity.ServerError.BUSINESS_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-    }
-    return status === 'success';
-};
-
-const unregisterPushNotification = async () => {
-    const client = getActiveClient();
-    const deviceId = getDeviceId();
-    const { data: { status, error }, } = await client.http.delete('/v1/notification', {
-        data: {
-            deviceId,
-        },
-        headers: { 'X-API-Key': client.apiKey },
-    });
-    if (error) {
-        throw new ASCApiError(error, 500000 /* Amity.ServerError.BUSINESS_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
-    }
-    return status === 'success';
-};
-
 var _GlobalFileAccessType_fileAccessType;
 class GlobalFileAccessType {
     constructor() {
@@ -25711,76 +25804,6 @@ const removeFunctionProperties = (obj) => {
     return Object.fromEntries(entries);
 };
 
-/**
- * ```js
- * import { isEqual } from '~/utils/isEqual'
- * const isEqual = isEqual(post1, post2)
- * ```
- *
- * Compares two Amity.Model
- *
- * @param x the Amity.Model to compare
- * @param y the Amity.Model to compare wit x
- * @returns a boolean based on equality
- *
- * @category utility
- * @private
- */
-function isEqual(x, y) {
-    if (x === null || x === undefined || y === null || y === undefined) {
-        return x === y;
-    }
-    // after this just checking type of one would be enough
-    if (x.constructor !== y.constructor) {
-        return false;
-    }
-    // if they are functions, they should exactly refer to same one (because of closures)
-    if (x instanceof Function) {
-        return x === y;
-    }
-    // if they are regexps, they should exactly refer to same one
-    if (x instanceof RegExp) {
-        return x === y;
-    }
-    if (x === y || x.valueOf() === y.valueOf()) {
-        return true;
-    }
-    if (Array.isArray(x) && x.length !== y.length) {
-        return false;
-    }
-    // check each element of the array for equality
-    if (Array.isArray(x) && Array.isArray(y)) {
-        if (x.length !== y.length)
-            return false;
-        for (let i = 0; i < x.length; i += 1) {
-            if (!isEqual(x[i], y[i]))
-                return false;
-        }
-        // if all elements are equal, the arrays are equal
-        return true;
-    }
-    // if they are dates, they must had equal valueOf
-    if (x instanceof Date) {
-        return false;
-    }
-    // if they are strictly equal, they both need to be object at least
-    if (!(x instanceof Object)) {
-        return false;
-    }
-    if (!(y instanceof Object)) {
-        return false;
-    }
-    // recursive object equality check
-    const p = Object.keys(x);
-    return (Object.keys(y).every(i => {
-        // @ts-ignore
-        return p.indexOf(i) !== -1;
-    }) &&
-        p.every(i => {
-            return isEqual(x[i], y[i]);
-        }));
-}
-
 /**
  * @deprecated This function is deprecated
  */
@@ -25998,8 +26021,6 @@ var index$l = /*#__PURE__*/Object.freeze({
   renewal: renewal,
   markerSync: markerSync,
   enableUnreadCount: enableUnreadCount,
-  registerPushNotification: registerPushNotification,
-  unregisterPushNotification: unregisterPushNotification,
   setUploadedFileAccessType: setUploadedFileAccessType,
   onConnectionError: onConnectionError,
   onClientDisconnected: onClientDisconnected,
@@ -26019,6 +26040,19 @@ var index$l = /*#__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
 */
@@ -26047,7 +26081,8 @@ const blockUser = async (userId) => {
         ingestInCache(followStatus, { cachedAt });
         upsertInCache(['followInfo', 'get', userId], followCounts[0], { cachedAt });
     }
-    fireEvent('follow.unfollowed', followStatus);
+    const payload = prepareFollowStatusPayload(followStatus);
+    fireEvent('local.follow.unfollowed', payload);
     return data;
 };
 /* end_public_function */
@@ -26080,171 +26115,397 @@ const unBlockUser = async (userId) => {
         ingestInCache(followStatus, { cachedAt });
         upsertInCache(['followInfo', 'get', userId], followCounts[0], { cachedAt });
     }
-    fireEvent('follow.created', followStatus);
+    const payload = prepareFollowStatusPayload(followStatus);
+    fireEvent('local.follow.created', payload);
     return data;
 };
 /* end_public_function */
 
+class PaginationController {
+    constructor(queryParams) {
+        const { http } = getActiveClient();
+        this.queryParams = queryParams;
+        this.http = http;
+    }
+    loadFirstPage() {
+        return this.onFetch("first" /* Amity.LiveCollectionPageDirection.FIRST */);
+    }
+    loadNextPage() {
+        return this.onFetch("next" /* Amity.LiveCollectionPageDirection.NEXT */);
+    }
+    loadPreviousPage() {
+        return this.onFetch("prev" /* Amity.LiveCollectionPageDirection.PREV */);
+    }
+    async onFetch(direction = "first" /* Amity.LiveCollectionPageDirection.FIRST */) {
+        var _a, _b, _c, _d;
+        if (direction === 'prev' && !this.previousToken)
+            return;
+        if (direction === 'next' && !this.nextToken)
+            return;
+        let token;
+        if (direction === 'prev')
+            token = this.previousToken;
+        if (direction === 'next')
+            token = this.nextToken;
+        const queryResponse = await this.getRequest(this.queryParams, token);
+        if (direction === 'first') {
+            this.nextToken = (_a = queryResponse.paging) === null || _a === void 0 ? void 0 : _a.next;
+            this.previousToken = (_b = queryResponse.paging) === null || _b === void 0 ? void 0 : _b.previous;
+        }
+        if (direction === 'prev')
+            this.previousToken = (_c = queryResponse.paging) === null || _c === void 0 ? void 0 : _c.previous;
+        if (direction === 'next')
+            this.nextToken = (_d = queryResponse.paging) === null || _d === void 0 ? void 0 : _d.next;
+        return queryResponse;
+    }
+    getNextToken() {
+        return this.nextToken;
+    }
+    getPrevToken() {
+        return this.previousToken;
+    }
+}
+
+class BlockedUserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get('/api/v4/me/user-blocks', {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
+    }
+}
+
+class QueryStreamController {
+    constructor(query, cacheKey) {
+        this.query = query;
+        this.cacheKey = cacheKey;
+    }
+}
+
+class BlockedUserQueryStreamController 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 (followStatus) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            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 PaginationNoPageController {
+    constructor(queryParams) {
+        const { http } = getActiveClient();
+        this.queryParams = queryParams;
+        this.http = http;
+    }
+    async onFetch() {
+        const queryResponse = await this.getRequest(this.queryParams);
+        return queryResponse;
+    }
+}
+
+class LiveCollectionController {
+    constructor(paginationController, queryStreamId, cacheKey, callback) {
+        this.paginationController = paginationController;
+        this.queryStreamId = queryStreamId;
+        this.cacheKey = cacheKey;
+        this.callback = callback;
+    }
+    async refresh() {
+        try {
+            let result;
+            if (this.paginationController instanceof PaginationNoPageController) {
+                result = await this.paginationController.onFetch();
+            }
+            else {
+                result = await this.paginationController.loadFirstPage();
+            }
+            if (!result)
+                return;
+            await this.persistModel(result);
+            this.persistQueryStream({
+                response: result,
+                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
+                refresh: true,
+            });
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
+        }
+        catch (e) {
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
+        }
+    }
+    loadPage({ initial = false, direction = "next" /* Amity.LiveCollectionPageDirection.NEXT */, }) {
+        this.setup();
+        this.notifyChange({ origin: "local" /* Amity.LiveDataOrigin.LOCAL */, loading: true });
+        if (initial) {
+            this.refresh();
+        }
+        else if (direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */) {
+            this.loadPrevPage();
+        }
+        else if (direction === "next" /* Amity.LiveCollectionPageDirection.NEXT */) {
+            this.loadNextPage();
+        }
+    }
+    async loadNextPage() {
+        try {
+            if (this.paginationController instanceof PaginationNoPageController)
+                return;
+            const result = await this.paginationController.loadNextPage();
+            if (!result)
+                return;
+            await this.persistModel(result);
+            this.persistQueryStream({
+                response: result,
+                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
+            });
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
+        }
+        catch (e) {
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
+        }
+    }
+    async loadPrevPage() {
+        try {
+            if (this.paginationController instanceof PaginationNoPageController)
+                return;
+            const result = await this.paginationController.loadPreviousPage();
+            if (!result)
+                return;
+            await this.persistModel(result);
+            this.persistQueryStream({
+                response: result,
+                direction: "prev" /* Amity.LiveCollectionPageDirection.PREV */,
+            });
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
+        }
+        catch (e) {
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
+        }
+    }
+    shouldNotify(data) {
+        const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
+        if (isEqual(this.snapshot, newData))
+            return false;
+        this.snapshot = newData;
+        return true;
+    }
+    getCacheKey() {
+        return this.cacheKey;
+    }
+}
+
+function prepareBlockedUserPayload(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) });
+}
+
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk-react-native'
- * const { data: users, prevPage, nextPage, total } = await UserRepository.queryBlockedUsers({ page: Amity.PageRaw, limit: number })
+ * import { onUserUpdated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserUpdated(user => {
+ *   // ...
+ * })
  * ```
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * Fired when a {@link Amity.InternalUser} has been updated
  *
- * @category Block API
- * @async
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
  */
-const queryBlockedUsers = async (query) => {
-    const client = getActiveClient();
-    let params = {};
-    if (query) {
-        const { token, limit } = query;
-        params = {
-            limit,
-            token,
-        };
-    }
-    client.log('user/queryBlockedUsers');
-    const { data } = await client.http.get('/api/v4/me/user-blocks', {
-        params,
-    });
-    const { paging } = data, blockedUsers = __rest(data, ["paging"]);
-    const { users } = blockedUsers;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(blockedUsers, { cachedAt });
-        const cacheKey = ['blockedUsers', 'query', params];
-        pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
-    }
-    const { next, previous, total } = paging;
-    const nextPage = toPageRaw(next);
-    const prevPage = toPageRaw(previous);
-    return { data: users, prevPage, nextPage, total, cachedAt };
-};
+const onUserUpdated = (callback) => createUserEventSubscriber('user.updated', callback);
+
 /**
  * ```js
- * import { queryBlockedUsers } from '@amityco/ts-sdk-react-native'
- * const { data: users } = queryBlockedUsers.locally({ page: 'page_token' })
+ * import { onUserFlagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFlagged(user => {
+ *   // ...
+ * })
  * ```
  *
- * Queries a paginable list of {@link Amity.User} objects from cache
- * Search is performed by displayName such as `.startsWith(search)`
+ * Fired when a {@link Amity.InternalUser} has been flagged
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.User} objects
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category User Events
+ */
+const onUserFlagged = (callback) => createUserEventSubscriber('user.flagged', callback);
+
+/**
+ * ```js
+ * import { onUserUnflagged } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserUnflagged(user => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a flag has been removed from a {@link Amity.InternalUser}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Block API
+ * @category User Events
  */
-queryBlockedUsers.locally = (query = {}) => {
-    var _a, _b, _c;
-    const client = getActiveClient();
-    client.log('user/queryBlockedUsers.locally');
-    if (!client.cache)
-        return;
-    let params = {};
-    if (query) {
-        const { token, limit } = query;
-        params = {
-            token,
-            limit,
-        };
-    }
-    const cacheKey = ['blockedUsers', 'query', params];
-    const { data, cachedAt } = (_a = pullFromCache(cacheKey)) !== null && _a !== void 0 ? _a : {};
-    const users = (_b = data === null || data === void 0 ? void 0 : data.users.map(userId => pullFromCache(['user', 'get', userId])).filter(Boolean).map(({ data }) => data)) !== null && _b !== void 0 ? _b : [];
-    const nextPage = toPageRaw(data === null || data === void 0 ? void 0 : data.paging.next);
-    const prevPage = toPageRaw(data === null || data === void 0 ? void 0 : data.paging.previous);
-    return users.length > 0 && users.length === ((_c = data === null || data === void 0 ? void 0 : data.users) === null || _c === void 0 ? void 0 : _c.length)
-        ? { data: users, nextPage, prevPage, total: data === null || data === void 0 ? void 0 : data.paging.total, cachedAt }
-        : undefined;
-};
+const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged', callback);
 
-/* eslint-disable no-use-before-define */
-/* begin_public_function
-  id: user.get_blocked_users
-*/
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk-react-native'
- * const unblockedUser = await UserRepository.blockUser('userId')
+ * import { onUserFlagCleared } from '@amityco/ts-sdk-react-native'
+ * const dispose = onUserFlagCleared(user => {
+ *   // ...
+ * })
  * ```
  *
- * Blocks a {@link Amity.InternalUser}
+ * Fired when flags have been cleared for a {@link Amity.InternalUser}
  *
- * @param params The params to get blocked {@link Amity.InternalUser}s
- * @param callback to recieve updates on unblocked {@link Amity.InternalUser}s
- * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Post API
- * @async
+ * @category User Events
  */
-const getBlockedUsers$1 = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
+const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
+
+var EnumUserActions;
+(function (EnumUserActions) {
+    EnumUserActions["OnUserDeleted"] = "onUserDeleted";
+    EnumUserActions["OnUserUpdated"] = "onUserUpdated";
+    EnumUserActions["OnUserFlagged"] = "onUserFlagged";
+    EnumUserActions["OnUserUnflagged"] = "onUserUnflagged";
+    EnumUserActions["OnUserFlagCleared"] = "onUserFlagCleared";
+})(EnumUserActions || (EnumUserActions = {}));
+
+class BlockedUserLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['blockedUsers', 'collection', queryStreamId];
+        const paginationController = new BlockedUserPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new BlockedUserQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareBlockedUserPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
     }
-    const timestamp = Date.now();
-    log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
-    const { limit: queryLimit } = params;
-    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
-    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
-    const disposers = [];
-    const cacheKey = ['blockedUsers', 'collection', {}];
-    const responder = (data) => {
-        var _a, _b;
-        const users = (_a = data.data
-            .map(userId => pullFromCache(['user', 'get', userId]))
-            .filter(Boolean)
-            .map(({ data }) => LinkedObject.user(data))) !== null && _a !== void 0 ? _a : [];
-        callback({
-            onNextPage: onFetch,
-            data: users,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    /*
-     * const realtimeRouter = () => {
-     * @TODO: At the time of creating this api blocked user do not have any
-     * observers
-     *};
-     */
-    const onFetch = (initial = false) => {
+    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,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
         var _a, _b;
-        const collection = (_a = pullFromCache(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 : [];
-        if (!initial && users.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
             return;
-        const query = createQuery(queryBlockedUsers, {
-            limit,
-            token: toToken(!initial ? collection === null || collection === void 0 ? void 0 : collection.params.page : undefined, 'afterbeforeraw'),
+        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,
         });
-        runQuery(query, 
-        // @ts-ignore
-        ({ data: result, loading, error, nextPage: page, total }) => {
-            const data = {
-                loading,
-                error,
-                params: { page, total },
-                data: users,
-            };
-            if (result) {
-                data.data = [...new Set([...users, ...result.map(getResolver('user'))])];
-            }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy, CACHE_SHORTEN_LIFESPAN));
-    };
-    disposers.push(() => {
-        // @TODO -> update once observers added
-    });
-    onFetch(true);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    applyFilter(data) {
+        let users = data;
+        users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+        return users;
+    }
+}
+
+/* begin_public_function
+  id: user.get_blocked_users
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk-react-native'
+ * const unblockedUser = await UserRepository.blockUser('userId')
+ * ```
+ *
+ * Blocks a {@link Amity.InternalUser}
+ *
+ * @param params The params to get blocked {@link Amity.InternalUser}s
+ * @param callback to recieve updates on unblocked {@link Amity.InternalUser}s
+ * @returns {@link Amity.Unsubscriber} to unsubscribe from collection
+ *
+ * @category Post API
+ * @async
+ */
+const getBlockedUsers$1 = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getBlockedUsers(tmpid: ${timestamp}) > listen`);
+    const blockedUserLiveCollection = new BlockedUserLiveCollectionController(params, callback);
+    const disposers = blockedUserLiveCollection.startSubscription();
+    const cacheKey = blockedUserLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
     return () => {
-        log(`getCategories(tmpid: ${timestamp}) > dispose`);
+        log(`getBlockedUsers(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
         dropFromCache(cacheKey);
     };
@@ -26254,7 +26515,7 @@ const getBlockedUsers$1 = (params, callback, config) => {
 /* eslint-disable no-use-before-define */
 const getBlockedUsers = (params, callback, config) => {
     console.log('Deprecation Notice: UserRepository.Relationship.getBlockedUsers will be deprecated on 9th June 2023, please use UserRepository.getBlockedUsers instead.');
-    return getBlockedUsers$1(params, callback, config);
+    return getBlockedUsers$1(params, callback);
 };
 
 /* begin_public_function
@@ -26282,7 +26543,13 @@ const follow = async (userId) => {
     if (client.cache) {
         ingestInCache(data, { cachedAt });
     }
-    fireEvent(data.follows[0].status === 'accepted' ? 'follow.created' : 'follow.requested', data);
+    const payload = prepareFollowStatusPayload(data);
+    if (data.follows[0].status === 'accepted') {
+        fireEvent('local.follow.created', payload);
+    }
+    else {
+        fireEvent('local.follow.requested', payload);
+    }
     return {
         data: data.follows[0],
         cachedAt,
@@ -26314,7 +26581,8 @@ const unfollow = async (userId) => {
     if (client.cache) {
         ingestInCache(data);
     }
-    fireEvent('follow.unfollowed', data);
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.unfollowed', payload);
     return true;
 };
 /* end_public_function */
@@ -26343,7 +26611,8 @@ const acceptFollower = async (userId) => {
     if (client.cache) {
         ingestInCache(data);
     }
-    fireEvent('follow.accepted', data);
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.accepted', payload);
     return true;
 };
 
@@ -26371,7 +26640,8 @@ const acceptMyFollower = async (userId) => {
     if (client.cache) {
         ingestInCache(data);
     }
-    fireEvent('follow.accepted', data);
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.accepted', payload);
     return true;
 };
 /* end_public_function */
@@ -26400,7 +26670,8 @@ const declineFollower = async (userId) => {
     if (client.cache) {
         ingestInCache(data);
     }
-    fireEvent('follow.requestDeclined', data);
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.requestDeclined', payload);
     return true;
 };
 
@@ -26428,29 +26699,35 @@ const declineMyFollower = async (userId) => {
     if (client.cache) {
         ingestInCache(data);
     }
-    fireEvent('follow.requestDeclined', data);
+    const payload = prepareFollowStatusPayload(data);
+    fireEvent('local.follow.requestDeclined', payload);
     return true;
 };
 /* end_public_function */
 
 const createFollowEventSubscriber = (event, callback) => {
     const client = getActiveClient();
-    const filter = (payload) => {
-        var _a, _b;
+    const filter = (data) => {
+        const payload = prepareFollowersPayload(data);
+        if (!client.cache) {
+            callback(payload.follows[0]);
+        }
+        else {
+            ingestInCache(payload);
+            callback(payload.follows[0]);
+        }
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+const createLocalFollowEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const payload = prepareFollowStatusPayload(data);
         if (!client.cache) {
             callback(payload.follows[0]);
         }
         else {
             ingestInCache(payload);
-            const queries = [
-                ...((_a = queryCache(['followers', 'query'])) !== null && _a !== void 0 ? _a : []),
-                ...((_b = queryCache(['followings', 'query'])) !== null && _b !== void 0 ? _b : []),
-            ];
-            queries
-                .filter(({ key }) => 
-            // @ts-ignore
-            key[2].userId === payload.follows[0].from || key[2].userId === payload.follows[0].to)
-                .forEach(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
             callback(payload.follows[0]);
         }
     };
@@ -26669,12 +26946,27 @@ const onFollowInfoUpdated = (callback) => {
         createFollowEventSubscriber('follow.requestCanceled', handler),
         createFollowEventSubscriber('follow.requestDeclined', handler),
         createFollowEventSubscriber('follow.followerDeleted', handler),
+        createLocalFollowEventSubscriber('local.follow.created', handler),
+        createLocalFollowEventSubscriber('local.follow.requested', handler),
+        createLocalFollowEventSubscriber('local.follow.accepted', handler),
+        createLocalFollowEventSubscriber('local.follow.unfollowed', handler),
+        createLocalFollowEventSubscriber('local.follow.requestDeclined', handler),
     ];
     return () => {
         disposers.forEach(fn => fn());
     };
 };
 
+const onLocalUserFollowed = (callback) => createLocalFollowEventSubscriber('local.follow.created', callback);
+
+const onLocalUserUnfollowed = (callback) => createLocalFollowEventSubscriber('local.follow.unfollowed', callback);
+
+const onLocalFollowerRequested = (callback) => createLocalFollowEventSubscriber('local.follow.requested', callback);
+
+const onLocalFollowRequestAccepted = (callback) => createLocalFollowEventSubscriber('local.follow.accepted', callback);
+
+const onLocalFollowRequestDeclined = (callback) => createLocalFollowEventSubscriber('local.follow.requestDeclined', callback);
+
 /**
  * ```js
  * import { observeFollowInfo } from '@amityco/ts-sdk-react-native'
@@ -26747,7 +27039,7 @@ const observeFollowers = (userId, callback) => {
         (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, status);
         (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, status);
     };
-    disposers.push(onFollowerRequested(x => router(x, 'onRequested')), onFollowRequestAccepted(x => router(x, 'onAccepted')), onFollowRequestDeclined(x => router(x, 'onDeclined')), onFollowRequestCanceled(x => router(x, 'onCanceled')), onUserFollowed(x => router(x, 'onFollowed')), onUserUnfollowed(x => router(x, 'onUnfollowed')), onFollowerDeleted(x => router(x, 'onDeleted')));
+    disposers.push(onFollowerRequested(x => router(x, 'onRequested')), onFollowRequestAccepted(x => router(x, 'onAccepted')), onFollowRequestDeclined(x => router(x, 'onDeclined')), onFollowRequestCanceled(x => router(x, 'onCanceled')), onUserFollowed(x => router(x, 'onFollowed')), onUserUnfollowed(x => router(x, 'onUnfollowed')), onFollowerDeleted(x => router(x, 'onDeleted')), onLocalFollowerRequested(x => router(x, 'onRequested')), onLocalFollowRequestAccepted(x => router(x, 'onAccepted')), onLocalFollowRequestDeclined(x => router(x, 'onDeclined')), onLocalUserFollowed(x => router(x, 'onFollowed')), onLocalUserUnfollowed(x => router(x, 'onUnfollowed')));
     return () => {
         log(`observeFollowers(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -26783,92 +27075,190 @@ const observeFollowings = (userId, callback) => {
         (_a = callback.onEvent) === null || _a === void 0 ? void 0 : _a.call(callback, action, status);
         (_b = callback[action]) === null || _b === void 0 ? void 0 : _b.call(callback, status);
     };
-    disposers.push(onFollowerRequested(x => router(x, 'onRequested')), onFollowRequestAccepted(x => router(x, 'onAccepted')), onFollowRequestDeclined(x => router(x, 'onDeclined')), onFollowRequestCanceled(x => router(x, 'onCanceled')), onUserFollowed(x => router(x, 'onFollowed')), onUserUnfollowed(x => router(x, 'onUnfollowed')), onFollowerDeleted(x => router(x, 'onDeleted')));
+    disposers.push(onFollowerRequested(x => router(x, 'onRequested')), onFollowRequestAccepted(x => router(x, 'onAccepted')), onFollowRequestDeclined(x => router(x, 'onDeclined')), onFollowRequestCanceled(x => router(x, 'onCanceled')), onUserFollowed(x => router(x, 'onFollowed')), onUserUnfollowed(x => router(x, 'onUnfollowed')), onFollowerDeleted(x => router(x, 'onDeleted')), onLocalFollowerRequested(x => router(x, 'onRequested')), onLocalFollowRequestAccepted(x => router(x, 'onAccepted')), onLocalFollowRequestDeclined(x => router(x, 'onDeclined')), onLocalUserFollowed(x => router(x, 'onFollowed')), onLocalUserUnfollowed(x => router(x, 'onUnfollowed')));
     return () => {
         log(`observeFollowings(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
     };
 };
 
-const queryFollows = async (key, query) => {
-    const client = getActiveClient();
-    client.log(`follow/queryF${key.substring(1)}`, query);
-    const { userId, page } = query, params = __rest(query, ["userId", "page"]);
-    const { data } = await client.http.get(client.userId === userId ? `/api/v4/me/${key}` : `/api/v4/users/${userId}/${key}`, {
-        params: Object.assign(Object.assign({}, params), { token: toToken(page, 'afterbeforeraw') }),
-    });
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { follows } = payload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(payload, { cachedAt });
-        const cacheKey = [
-            'follow',
-            'query',
-            Object.assign(Object.assign({}, params), { userId, options: Object.assign({}, page), type: key }),
-        ];
-        pushToCache(cacheKey, { follows: follows.map(getResolver('follow')), paging });
+class FollowerPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, userId } = queryParams, params = __rest(queryParams, ["limit", "userId"]);
+        const options = token ? { token } : { limit };
+        const client = getActiveClient();
+        const path = client.userId === userId ? `/api/v4/me/followers` : `/api/v4/users/${userId}/followers`;
+        const { data: queryResponse } = await this.http.get(path, {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
     }
-    const nextPage = toPageRaw(paging.next);
-    const prevPage = toPageRaw(paging.previous);
-    return { data: follows, cachedAt, prevPage, nextPage };
-};
-queryFollows.locally = (key, query) => {
-    var _a, _b;
-    const client = getActiveClient();
-    client.log(`follow/queryF${key.substring(1)}.locally`, query);
-    if (!client.cache)
-        return;
-    const { page } = query, params = __rest(query, ["page"]);
-    const queryKey = [
-        'follow',
-        'query',
-        Object.assign(Object.assign({}, params), { options: Object.assign({}, page), type: key }),
-    ];
-    const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
-    if (!(data === null || data === void 0 ? void 0 : data.follows.length)) {
-        return;
+}
+
+var EnumFollowActions;
+(function (EnumFollowActions) {
+    EnumFollowActions["OnRequested"] = "onRequested";
+    EnumFollowActions["OnAccepted"] = "onAccepted";
+    EnumFollowActions["OnDeclined"] = "onDeclined";
+    EnumFollowActions["OnCanceled"] = "onCanceled";
+    EnumFollowActions["OnFollowed"] = "onFollowed";
+    EnumFollowActions["OnUnfollowed"] = "onUnfollowed";
+    EnumFollowActions["OnDeleted"] = "onDeleted";
+    EnumFollowActions["OnUserDeleted"] = "onUserDeleted";
+})(EnumFollowActions || (EnumFollowActions = {}));
+
+class FollowerQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
     }
-    const follows = data.follows
-        .map(key => pullFromCache(['follow', 'get', key]))
-        .filter(Boolean)
-        .map(({ data }) => data);
-    const prevPage = toPageRaw(data === null || data === void 0 ? void 0 : data.paging.previous);
-    const nextPage = toPageRaw(data === null || data === void 0 ? void 0 : data.paging.next);
-    return follows.length === ((_b = data === null || data === void 0 ? void 0 : data.follows) === null || _b === void 0 ? void 0 : _b.length)
-        ? { data: follows, cachedAt, prevPage, nextPage }
-        : undefined;
+    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.follows.map(getResolver('follow')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const follows = (_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([...follows, ...response.follows.map(getResolver('follow'))])] }));
+        }
+    }
+    reactor(action) {
+        return (followStatus) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (this.query.userId !== followStatus.to || !collection)
+                return;
+            switch (action) {
+                case EnumFollowActions.OnDeclined:
+                case EnumFollowActions.OnCanceled:
+                case EnumFollowActions.OnUnfollowed:
+                case EnumFollowActions.OnDeleted:
+                    collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+                    break;
+                case EnumFollowActions.OnRequested:
+                case EnumFollowActions.OnAccepted:
+                case EnumFollowActions.OnFollowed:
+                    collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+                    break;
+            }
+            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 onFollowerUserDeleted = ({ userId }) => (callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const userPayload = prepareUserPayload(data);
+        ingestInCache(userPayload);
+        const cacheData = pullFromCache([
+            'follow',
+            'get',
+            getResolver('follow')({
+                from: userPayload.users[0].userId,
+                to: userId,
+            }),
+        ]);
+        if (!cacheData)
+            return;
+        callback(cacheData === null || cacheData === void 0 ? void 0 : cacheData.data);
+    };
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
 };
 
-/**
- * ```js
- * import { queryFollowers } from '@amityco/ts-sdk-react-native'
- * const { data: followers, prevPage, nextPage } = await queryFollowers({ userId })
- * ```
- *
- * Queries a paginable list of {@link Amity.FollowStatus}
- *
- * @param query The query parameters
- * @returns followers
- *
- * @category Follow API
- * @async
- */
-const queryFollowers = async (query) => queryFollows('followers', query);
-/**
- * ```js
- * import { queryFollowers } from '@amityco/ts-sdk-react-native'
- * const { data: followers, prevPage, nextPage } = queryFollowers.locally({ userId })
- * ```
- *
- * Queries a paginable list of {@link Amity.FollowStatus} objects from cache
- *
- * @param query The query parameters
- * @returns followers
- *
- * @category Post API
- */
-queryFollowers.locally = (query) => queryFollows.locally('followers', query);
+class FollowerLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['follow', 'collection', queryStreamId];
+        const paginationController = new FollowerPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new FollowerQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareFollowersPayload);
+        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: onUserFollowed, action: EnumFollowActions.OnFollowed },
+            { fn: onUserUnfollowed, action: EnumFollowActions.OnUnfollowed },
+            { fn: onFollowRequestAccepted, action: EnumFollowActions.OnAccepted },
+            { fn: onFollowRequestDeclined, action: EnumFollowActions.OnDeclined },
+            { fn: onFollowRequestCanceled, action: EnumFollowActions.OnCanceled },
+            { fn: onFollowerDeleted, action: EnumFollowActions.OnDeleted },
+            { fn: onLocalFollowRequestAccepted, action: EnumFollowActions.OnAccepted },
+            { fn: onLocalFollowRequestDeclined, action: EnumFollowActions.OnDeclined },
+            { fn: onLocalUserFollowed, action: EnumFollowActions.OnFollowed },
+            { fn: onLocalUserUnfollowed, action: EnumFollowActions.OnUnfollowed },
+            {
+                fn: onFollowerUserDeleted({ userId: this.query.userId }),
+                action: EnumFollowActions.OnUserDeleted,
+            },
+        ]);
+    }
+    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(['follow', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => 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,
+        });
+    }
+    applyFilter(data) {
+        let followers = data;
+        if (this.query.status && this.query.status !== "all" /* Amity.FollowStatusTypeEnum.All */) {
+            followers = followers.filter(follower => follower.status === this.query.status);
+        }
+        followers = followers.filter(follower => {
+            var _a;
+            const fromUser = (_a = pullFromCache(['user', 'get', follower.from])) === null || _a === void 0 ? void 0 : _a.data;
+            return (fromUser === null || fromUser === void 0 ? void 0 : fromUser.isDeleted) == null || (fromUser === null || fromUser === void 0 ? void 0 : fromUser.isDeleted) === false;
+        });
+        return followers;
+    }
+}
 
 /* begin_public_function
   id: user.relationship.query_my_followers, user.relationship.query_followers
@@ -26894,69 +27284,14 @@ queryFollowers.locally = (query) => queryFollows.locally('followers', query);
 const getFollowers = (params, callback, config) => {
     const { log, cache } = getActiveClient();
     if (!cache) {
-        console.log('For using Live Collection feature you need to enable Cache!');
+        console.log(ENABLE_CACHE_MESSAGE);
     }
     const timestamp = Date.now();
     log(`getFollowers(tmpid: ${timestamp}) > listen`);
-    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
-    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
-    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
-    const disposers = [];
-    const cacheKey = ['follow', 'collection', { userId: params.userId, type: 'follower' }];
-    const responder = (data) => {
-        var _a, _b;
-        let followers = (_a = data.data
-            .map(key => pullFromCache(['follow', 'get', key]))
-            .filter(Boolean)
-            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
-        if (params.status && params.status !== 'all') {
-            followers = filterByPropEquality(followers, 'status', params.status);
-        }
-        callback({
-            onNextPage: onFetch,
-            data: followers,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (action) => (followStatus) => {
-        var _a;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (params.userId !== followStatus.to || !collection)
-            return;
-        if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
-            collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
-        }
-        else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
-            collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
-        }
-        pushToCache(cacheKey, collection);
-        responder(collection);
-    };
-    const onFetch = (initial = false) => {
-        var _a, _b, _c, _d;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        const followers = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-        if (!initial && followers.length > 0 && !((_c = collection === null || collection === void 0 ? void 0 : collection.params) === null || _c === void 0 ? void 0 : _c.page))
-            return;
-        const query = createQuery(queryFollowers, Object.assign(Object.assign({}, queryParams), { page: (_d = (!initial ? collection === null || collection === void 0 ? void 0 : collection.params.page : undefined)) !== null && _d !== void 0 ? _d : { limit } }));
-        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
-            const data = {
-                loading,
-                error,
-                params: { page },
-                data: followers,
-            };
-            if (result) {
-                data.data = [...new Set([...followers, ...result.map(getResolver('follow'))])];
-            }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy));
-    };
-    disposers.push(onFollowerRequested(realtimeRouter('onRequested')), onFollowRequestAccepted(realtimeRouter('onAccepted')), onFollowRequestDeclined(realtimeRouter('onDeclined')), onFollowRequestCanceled(realtimeRouter('onCanceled')), onUserFollowed(realtimeRouter('onFollowed')), onUserUnfollowed(realtimeRouter('onUnfollowed')), onFollowerDeleted(realtimeRouter('onDeleted')));
-    onFetch(true);
+    const followerLiveCollection = new FollowerLiveCollectionController(params, callback);
+    const disposers = followerLiveCollection.startSubscription();
+    const cacheKey = followerLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
     return () => {
         log(`getFollowers(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -26964,35 +27299,173 @@ const getFollowers = (params, callback, config) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { queryFollowings } from '@amityco/ts-sdk-react-native'
- * const { data: followings, prevPage, nextPage } = await queryFollowings({ userId })
- * ```
- *
- * Queries a paginable list of {@link Amity.FollowStatus}
- *
- * @param query The query parameters
- * @returns followings
- *
- * @category Follow API
- * @async
- */
-const queryFollowings = async (query) => queryFollows('following', query);
-/**
- * ```js
- * import { queryFollowings } from '@amityco/ts-sdk-react-native'
- * const { data: followings, prevPage, nextPage } = queryFollowings.locally({ userId })
- * ```
- *
- * Queries a paginable list of {@link Amity.FollowStatus} objects from cache
- *
- * @param query The query parameters
- * @returns followings
- *
- * @category Post API
- */
-queryFollowings.locally = (query) => queryFollows.locally('following', query);
+class FollowingPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, userId } = queryParams, params = __rest(queryParams, ["limit", "userId"]);
+        const options = token ? { token } : { limit };
+        const client = getActiveClient();
+        const path = client.userId === userId ? `/api/v4/me/following` : `/api/v4/users/${userId}/following`;
+        const { data: queryResponse } = await this.http.get(path, {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
+    }
+}
+
+class FollowingQueryStreamController 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.follows.map(getResolver('follow')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const follows = (_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([...follows, ...response.follows.map(getResolver('follow'))])] }));
+        }
+    }
+    reactor(action) {
+        return (followStatus) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (this.query.userId !== followStatus.from || !collection)
+                return;
+            switch (action) {
+                case EnumFollowActions.OnDeclined:
+                case EnumFollowActions.OnCanceled:
+                case EnumFollowActions.OnUnfollowed:
+                case EnumFollowActions.OnDeleted:
+                    collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
+                    break;
+                case EnumFollowActions.OnRequested:
+                case EnumFollowActions.OnAccepted:
+                case EnumFollowActions.OnFollowed:
+                    collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
+                    break;
+            }
+            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 onFollowingUserDeleted = ({ userId }) => (callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const userPayload = prepareUserPayload(data);
+        ingestInCache(userPayload);
+        const cacheData = pullFromCache([
+            'follow',
+            'get',
+            getResolver('follow')({
+                from: userId,
+                to: userPayload.users[0].userId,
+            }),
+        ]);
+        if (!cacheData)
+            return;
+        callback(cacheData === null || cacheData === void 0 ? void 0 : cacheData.data);
+    };
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+};
+
+class FollowingLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['follow', 'collection', queryStreamId];
+        const paginationController = new FollowingPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new FollowingQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareFollowingsPayload);
+        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: onFollowerRequested, action: EnumFollowActions.OnRequested },
+            { fn: onFollowRequestAccepted, action: EnumFollowActions.OnAccepted },
+            { fn: onFollowRequestDeclined, action: EnumFollowActions.OnDeclined },
+            { fn: onFollowRequestCanceled, action: EnumFollowActions.OnCanceled },
+            { fn: onUserFollowed, action: EnumFollowActions.OnFollowed },
+            { fn: onUserUnfollowed, action: EnumFollowActions.OnUnfollowed },
+            { fn: onFollowerDeleted, action: EnumFollowActions.OnDeleted },
+            { fn: onLocalFollowerRequested, action: EnumFollowActions.OnRequested },
+            { fn: onLocalFollowRequestAccepted, action: EnumFollowActions.OnAccepted },
+            { fn: onLocalFollowRequestDeclined, action: EnumFollowActions.OnDeclined },
+            { fn: onLocalUserFollowed, action: EnumFollowActions.OnFollowed },
+            { fn: onLocalUserUnfollowed, action: EnumFollowActions.OnUnfollowed },
+            {
+                fn: onFollowingUserDeleted({ userId: this.query.userId }),
+                action: EnumFollowActions.OnUserDeleted,
+            },
+        ]);
+    }
+    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(['follow', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => 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,
+        });
+    }
+    applyFilter(data) {
+        let followings = data;
+        if (this.query.status && this.query.status !== "all" /* Amity.FollowStatusTypeEnum.All */) {
+            followings = followings.filter(following => following.status === this.query.status);
+        }
+        followings = followings.filter(following => {
+            var _a;
+            const toUser = (_a = pullFromCache(['user', 'get', following.to])) === null || _a === void 0 ? void 0 : _a.data;
+            return (toUser === null || toUser === void 0 ? void 0 : toUser.isDeleted) == null || (toUser === null || toUser === void 0 ? void 0 : toUser.isDeleted) === false;
+        });
+        return followings;
+    }
+}
 
 /* begin_public_function
   id: user.relationship.query_my_followings, user.relationship.query_followings
@@ -27022,65 +27495,10 @@ const getFollowings = (params, callback, config) => {
     }
     const timestamp = Date.now();
     log(`getFollowings(tmpid: ${timestamp}) > listen`);
-    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
-    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
-    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
-    const disposers = [];
-    const cacheKey = ['follow', 'collection', { userId: params.userId, type: 'following' }];
-    const responder = (data) => {
-        var _a, _b;
-        let followings = (_a = data.data
-            .map(key => pullFromCache(['follow', 'get', key]))
-            .filter(Boolean)
-            .map(({ data }) => data)) !== null && _a !== void 0 ? _a : [];
-        if (params.status && params.status !== 'all') {
-            followings = filterByPropEquality(followings, 'status', params.status);
-        }
-        callback({
-            onNextPage: onFetch,
-            data: followings,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (action) => (followStatus) => {
-        var _a;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (params.userId !== followStatus.from || !collection)
-            return;
-        if (['onDeclined', 'onCanceled', 'onUnfollowed', 'onDeleted'].includes(action)) {
-            collection.data = collection.data.filter(p => p !== getResolver('follow')(followStatus));
-        }
-        else if (['onRequested', 'onAccepted', 'onFollowed'].includes(action)) {
-            collection.data = [...new Set([getResolver('follow')(followStatus), ...collection.data])];
-        }
-        pushToCache(cacheKey, collection);
-        responder(collection);
-    };
-    const onFetch = (initial = false) => {
-        var _a, _b, _c, _d;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        const followings = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-        if (!initial && followings.length > 0 && !((_c = collection === null || collection === void 0 ? void 0 : collection.params) === null || _c === void 0 ? void 0 : _c.page))
-            return;
-        const query = createQuery(queryFollowings, Object.assign(Object.assign({}, queryParams), { page: (_d = (!initial ? collection === null || collection === void 0 ? void 0 : collection.params.page : undefined)) !== null && _d !== void 0 ? _d : { limit } }));
-        runQuery(query, ({ data: result, error, loading, nextPage: page }) => {
-            const data = {
-                loading,
-                error,
-                params: { page },
-                data: followings,
-            };
-            if (result) {
-                data.data = [...new Set([...followings, ...result.map(getResolver('follow'))])];
-            }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy));
-    };
-    disposers.push(onFollowerRequested(realtimeRouter('onRequested')), onFollowRequestAccepted(realtimeRouter('onAccepted')), onFollowRequestDeclined(realtimeRouter('onDeclined')), onFollowRequestCanceled(realtimeRouter('onCanceled')), onUserFollowed(realtimeRouter('onFollowed')), onUserUnfollowed(realtimeRouter('onUnfollowed')), onFollowerDeleted(realtimeRouter('onDeleted')));
-    onFetch(true);
+    const followingLiveCollection = new FollowingLiveCollectionController(params, callback);
+    const disposers = followingLiveCollection.startSubscription();
+    const cacheKey = followingLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
     return () => {
         log(`getFollowings(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -27168,6 +27586,11 @@ var index$k = /*#__PURE__*/Object.freeze({
   onFollowRequestAccepted: onFollowRequestAccepted,
   onFollowRequestDeclined: onFollowRequestDeclined,
   onFollowInfoUpdated: onFollowInfoUpdated,
+  onLocalUserFollowed: onLocalUserFollowed,
+  onLocalUserUnfollowed: onLocalUserUnfollowed,
+  onLocalFollowerRequested: onLocalFollowerRequested,
+  onLocalFollowRequestAccepted: onLocalFollowRequestAccepted,
+  onLocalFollowRequestDeclined: onLocalFollowRequestDeclined,
   observeFollowInfo: observeFollowInfo,
   observeFollowers: observeFollowers,
   observeFollowings: observeFollowings,
@@ -27202,12 +27625,13 @@ const getUserByIds = async (userIds) => {
     const { data } = await client.http.get(`/api/v3/users/list`, {
         params: { userIds: encodedUserIds },
     });
+    const payload = prepareUserPayload(data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(data, { cachedAt });
+        ingestInCache(payload, { cachedAt });
     fireEvent('user.fetched', data);
     return {
-        data: data.users.map(user => LinkedObject.user(user)),
+        data: payload.users.map(user => LinkedObject.user(user)),
         cachedAt,
     };
 };
@@ -27265,20 +27689,14 @@ getUserByIds.locally = (userIds) => {
 const updateUser = async (userId, patch) => {
     const client = getActiveClient();
     client.log('user/updateUser', userId, patch);
-    // API-FIX: Endpoint is malformed, userId should be a url param.
-    /*
-      const { data } = await client.http.put<Amity.Response<UserPayload>>(
-        `/api/v3/users/${userId}`, patch,
-      )
-    */
     const { data } = await client.http.put(`/api/v3/users/`, Object.assign(Object.assign({ userId }, patch), { createNewUserWhenNotFound: false }));
+    const payload = prepareUserPayload(data);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { users } = data;
+        ingestInCache(payload, { cachedAt });
     fireEvent('user.updated', data);
     return {
-        data: users.find(user => user.userId === userId),
+        data: payload.users.find(user => user.userId === userId),
         cachedAt,
     };
 };
@@ -27302,11 +27720,12 @@ const updateUser = async (userId, patch) => {
 const flagUser = async (userId) => {
     const client = getActiveClient();
     client.log('user/flagUser', userId);
-    const { data: payload } = await client.http.post(`api/v4/me/flags/${encodeURIComponent(userId)}`);
+    const { data } = await client.http.post(`api/v4/me/flags/${encodeURIComponent(userId)}`);
+    const payload = prepareUserPayload(data);
     if (client.cache) {
         ingestInCache(payload);
     }
-    fireEvent('user.flagged', payload);
+    fireEvent('user.flagged', data);
     return !!payload;
 };
 /* end_public_function */
@@ -27329,11 +27748,12 @@ const flagUser = async (userId) => {
 const unflagUser = async (userId) => {
     const client = getActiveClient();
     client.log('user/unflag', userId);
-    const { data: payload } = await client.http.delete(`/api/v4/me/flags/${encodeURIComponent(userId)}`);
+    const { data } = await client.http.delete(`/api/v4/me/flags/${encodeURIComponent(userId)}`);
+    const payload = prepareUserPayload(data);
     if (client.cache) {
         ingestInCache(payload);
     }
-    fireEvent('user.unflagged', payload);
+    fireEvent('user.unflagged', data);
     return !!payload;
 };
 /* end_public_function */
@@ -27361,74 +27781,6 @@ const isUserFlaggedByMe = async (userId) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { onUserUpdated } from '@amityco/ts-sdk-react-native'
- * const dispose = onUserUpdated(user => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalUser} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category User Events
- */
-const onUserUpdated = (callback) => createUserEventSubscriber('user.updated', callback);
-
-/**
- * ```js
- * import { onUserFlagged } from '@amityco/ts-sdk-react-native'
- * const dispose = onUserFlagged(user => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalUser} has been flagged
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category User Events
- */
-const onUserFlagged = (callback) => createUserEventSubscriber('user.flagged', callback);
-
-/**
- * ```js
- * import { onUserUnflagged } from '@amityco/ts-sdk-react-native'
- * const dispose = onUserUnflagged(user => {
- *   // ...
- * })
- * ```
- *
- * Fired when a flag has been removed from a {@link Amity.InternalUser}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category User Events
- */
-const onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged', callback);
-
-/**
- * ```js
- * import { onUserFlagCleared } from '@amityco/ts-sdk-react-native'
- * const dispose = onUserFlagCleared(user => {
- *   // ...
- * })
- * ```
- *
- * Fired when flags have been cleared for a {@link Amity.InternalUser}
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category User Events
- */
-const onUserFlagCleared = (callback) => createUserEventSubscriber('user.flagCleared', callback);
-
 /**
  * ```js
  * import { onUserFetched } from '@amityco/ts-sdk-react-native'
@@ -27464,10 +27816,17 @@ const getUser$2 = async (userId) => {
     const client = getActiveClient();
     client.log('user/getUser', userId);
     isInTombstone('user', userId);
-    let data;
     try {
-        const response = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
-        data = response.data;
+        const { data } = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
+        const cachedAt = client.cache && Date.now();
+        const payload = prepareUserPayload(data);
+        if (client.cache)
+            ingestInCache(payload, { cachedAt });
+        fireEvent('user.fetched', data);
+        return {
+            data: payload.users.find(user => user.userId === userId),
+            cachedAt,
+        };
     }
     catch (error) {
         if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
@@ -27475,15 +27834,6 @@ const getUser$2 = async (userId) => {
         }
         throw error;
     }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { users } = data;
-    fireEvent('user.fetched', data);
-    return {
-        data: users.find(user => user.userId === userId),
-        cachedAt,
-    };
 };
 /**
  * ```js
@@ -27541,7 +27891,7 @@ const getUser$1 = (userId, callback) => {
     return liveObject(userId, reactor, 'userId', getUser$2, [
         onUserFetched,
         onUserUpdated,
-        onUserDeleted,
+        onUserDeleted$2,
         onUserFlagged,
         onUserUnflagged,
         onUserFlagCleared,
@@ -27549,114 +27899,144 @@ const getUser$1 = (userId, callback) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { queryUsers } from '@amityco/ts-sdk-react-native'
- * const { data: users, prevPage, nextPage } = await queryUsers({ displayName: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.InternalUser} objects
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.InternalUser} objects
- *
- * @category User API
- * @async
- */
-const queryUsers = async (query = {}) => {
-    const client = getActiveClient();
-    client.log('user/queryUsers', query);
-    const { page, limit = 10, displayName, filter = 'all', sortBy = 'displayName' } = query, params = __rest(query, ["page", "limit", "displayName", "filter", "sortBy"]);
-    const { data } = await client.http.get(`/api/v3/users`, {
-        params: Object.assign(Object.assign({}, params), { keyword: displayName, filter,
-            sortBy, options: page ? { token: page } : { limit } }),
-    });
-    // unpacking
-    const { paging } = data, payload = __rest(data, ["paging"]);
-    const { users } = payload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(payload, { cachedAt });
-        /*
-         * using a query as a cache key over params because if the keyword, filter, sort
-         * change the API will NOT cache results, when it should
-         */
-        const cacheKey = [
-            'user',
-            'query',
-            Object.assign(Object.assign({}, query), { options: { limit, token: page } }),
-        ];
-        pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
+class UserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName } = queryParams, params = __rest(queryParams, ["limit", "displayName"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v3/users`, {
+            params: Object.assign(Object.assign({}, params), { keyword: displayName, options, isDeleted: false }),
+        });
+        return queryResponse;
     }
-    fireEvent('user.fetched', data);
-    return {
-        data: users,
-        cachedAt,
-        paging,
-    };
-};
-/**
- * ```js
- * import { queryUsers } from '@amityco/ts-sdk-react-native'
- * const { data: users } = queryUsers.locally({ keyword: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.InternalUser} objects from cache
- * Search is performed by displayName such as `.startsWith(search)`
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.InternalUser} objects
- *
- * @category User API
- */
-queryUsers.locally = (query = {}) => {
-    var _a, _b, _c;
-    const client = getActiveClient();
-    client.log('user/queryUsers.locally', query);
-    if (!client.cache)
-        return;
-    const { limit = 10, page } = query !== null && query !== void 0 ? query : {};
-    const cacheKey = [
-        'user',
-        'query',
-        Object.assign(Object.assign({}, query), { options: {
-                limit,
-                token: page,
-            } }),
-    ];
-    const { data, cachedAt } = (_a = pullFromCache(cacheKey)) !== null && _a !== void 0 ? _a : {};
-    const users = (_b = data === null || data === void 0 ? void 0 : data.users.map(userId => pullFromCache(['user', 'get', userId])).filter(Boolean).map(({ data }) => data)) !== null && _b !== void 0 ? _b : [];
-    return users.length > 0 && users.length === ((_c = data === null || data === void 0 ? void 0 : data.users) === null || _c === void 0 ? void 0 : _c.length)
-        ? {
-            data: users,
-            cachedAt,
-            paging: data === null || data === void 0 ? void 0 : data.paging,
+}
+
+class UserQueryStreamController 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 });
         }
-        : undefined;
-};
+    }
+    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;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            /*
+             * Simply update a collection and let responder decide what to do with data
+             */
+            collection.data = [...new Set([user.userId, ...collection.data])];
+            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)));
+    }
+}
 
-/*
- * Exported for testing
- * @hidden
- */
-const applyFilter$2 = (data, params) => {
-    let users = filterByStringComparePartially(data, 'displayName', params.displayName);
-    switch (params.sortBy) {
-        case 'firstCreated':
-            users = users.sort(sortByFirstCreated);
-            break;
-        case 'lastCreated':
-            users = users.sort(sortByLastCreated);
-            break;
-        default:
-            users = users
-                // this needs to be aligned with the backend data type
-                .map(u => (u.displayName ? u : Object.assign(Object.assign({}, u), { displayName: '' })))
-                .sort(sortByDisplayName);
+class UserLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['user', 'collection', queryStreamId];
+        const paginationController = new UserPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new UserQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareUserPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
     }
-    return users;
-};
+    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: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+            { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+            { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+            { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+        ]);
+    }
+    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;
+        if (!this.query.displayName) {
+            const sortFn = (() => {
+                switch (this.query.sortBy) {
+                    case 'firstCreated':
+                        return sortByFirstCreated;
+                    case 'lastCreated':
+                        return sortByLastCreated;
+                    case 'displayName':
+                        return sortByDisplayName;
+                    default:
+                        return sortByLastCreated;
+                }
+            })();
+            users = users.sort(sortFn);
+        }
+        if (this.query.filter === 'flagged') {
+            users = users.filter(user => !!user.hashFlag);
+        }
+        users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+        return users;
+    }
+}
+
 /* begin_public_function
   id: user.query
 */
@@ -27684,63 +28064,10 @@ const getUsers = (params, callback, config) => {
     }
     const timestamp = Date.now();
     log(`liveUsers(tmpid: ${timestamp}) > listen`);
-    const { limit: queryLimit } = params, queryParams = __rest(params, ["limit"]);
-    const limit = queryLimit !== null && queryLimit !== void 0 ? queryLimit : COLLECTION_DEFAULT_PAGINATION_LIMIT;
-    const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config !== null && config !== void 0 ? config : {};
-    const disposers = [];
-    const cacheKey = ['user', 'collection', uuid()];
-    const responder = (data, isEventModel = false) => {
-        var _a, _b;
-        const users = (_a = data.data
-            .map(userId => pullFromCache(['user', 'get', userId]))
-            .filter(Boolean)
-            .map(({ data }) => LinkedObject.user(data))) !== null && _a !== void 0 ? _a : [];
-        callback({
-            onNextPage: onFetch,
-            /*
-             * Only apply filter to RTE Model
-             */
-            data: isEventModel ? applyFilter$2(users, params) : users,
-            hasNextPage: !!((_b = data.params) === null || _b === void 0 ? void 0 : _b.page),
-            loading: data.loading,
-            error: data.error,
-        });
-    };
-    const realtimeRouter = (_) => (user) => {
-        var _a;
-        const collection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        collection.data = [...new Set([user.userId, ...collection.data])];
-        pushToCache(cacheKey, collection);
-        responder(collection, true);
-    };
-    const onFetch = (initial = false) => {
-        var _a, _b;
-        const collection = (_a = pullFromCache(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 : [];
-        if (!initial && users.length > 0 && !(collection === null || collection === void 0 ? void 0 : collection.params.page))
-            return;
-        const pagingCondition = initial ? { limit } : { page: collection === null || collection === void 0 ? void 0 : collection.params.page };
-        const query = createQuery(queryUsers, Object.assign(Object.assign({}, queryParams), pagingCondition));
-        runQuery(query, ({ data: result, error, loading, paging }) => {
-            const data = {
-                loading,
-                error,
-                params: { page: paging === null || paging === void 0 ? void 0 : paging.next },
-                data: users,
-            };
-            if (result) {
-                data.data = initial
-                    ? result.map(getResolver('user'))
-                    : [...new Set([...users, ...result.map(getResolver('user'))])];
-            }
-            pushToCache(cacheKey, data);
-            responder(data);
-        }, queryOptions(policy));
-    };
-    disposers.push(onUserUpdated(realtimeRouter()), onUserDeleted(realtimeRouter()), onUserFlagged(realtimeRouter()), onUserUnflagged(realtimeRouter()), onUserFlagCleared(realtimeRouter()));
-    onFetch(true);
+    const usersLiveCollection = new UserLiveCollectionController(params, callback);
+    const disposers = usersLiveCollection.startSubscription();
+    const cacheKey = usersLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
     return () => {
         log(`liveUsers(tmpid: ${timestamp}) > dispose`);
         disposers.forEach(fn => fn());
@@ -27763,27 +28090,9 @@ const getUsers = (params, callback, config) => {
  * @async
  */
 const getUser = async (userId) => {
-    const client = getActiveClient();
-    client.log('user/getUser', userId);
-    isInTombstone('user', userId);
-    let data;
-    try {
-        const response = await client.http.get(`/api/v3/users/${encodeURIComponent(userId)}`);
-        data = response.data;
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('user', userId);
-        }
-        throw error;
-    }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { users } = data;
-    fireEvent('user.fetched', data);
+    const { data, cachedAt } = await getUser$2(userId);
     return {
-        data: LinkedObject.user(users.find(user => user.userId === userId)),
+        data: LinkedObject.user(data),
         cachedAt,
     };
 };
@@ -27801,11 +28110,7 @@ const getUser = async (userId) => {
  * @category User API
  */
 getUser.locally = (userId) => {
-    const client = getActiveClient();
-    client.log('user/getUser.locally', userId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['user', 'get', userId]);
+    const cached = getUser$2.locally(userId);
     if (!cached)
         return;
     return {
@@ -27847,7 +28152,7 @@ const observeUser = (userId, callback) => {
         (_c = callback[action]) === null || _c === void 0 ? void 0 : _c.call(callback, newResult);
     };
     const disposers = [];
-    disposers.push(onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onUserDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')), onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')), onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared')));
+    disposers.push(onUserUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')), onUserDeleted$2(data => router({ data, loading: false, origin: 'event' }, 'onDelete')), onUserFlagged(data => router({ data, loading: false, origin: 'event' }, 'onFlagged')), onUserUnflagged(data => router({ data, loading: false, origin: 'event' }, 'onUnflagged')), onUserFlagCleared(data => router({ data, loading: false, origin: 'event' }, 'onFlagCleared')));
     runQuery(createQuery(getUser, userId), result => result.data && router(result, 'onFetch'));
     return () => {
         log(`observeUser(tmpid: ${timestamp}) > dispose`);
@@ -27855,6 +28160,130 @@ const observeUser = (userId, callback) => {
     };
 };
 
+class SearchUserPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName } = queryParams, params = __rest(queryParams, ["limit", "displayName"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v3/users`, {
+            params: Object.assign(Object.assign({}, params), { keyword: displayName, options, isDeleted: false }),
+        });
+        return queryResponse;
+    }
+}
+
+class SearchUserQueryStreamController 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;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            /*
+             * Simply update a collection and let responder decide what to do with data
+             */
+            collection.data = [...new Set([user.userId, ...collection.data])];
+            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 SearchUserLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        var _a;
+        const queryStreamId = hash(query);
+        const cacheKey = ['user', 'collection', queryStreamId];
+        const paginationController = new SearchUserPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = Object.assign(Object.assign({}, query), { filter: (_a = query.filter) !== null && _a !== void 0 ? _a : 'all' });
+        this.queryStreamController = new SearchUserQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareUserPayload);
+        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: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+            { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+            { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+            { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+        ]);
+    }
+    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;
+        if (this.query.filter === 'flagged') {
+            users = users.filter(user => !!user.hashFlag);
+        }
+        users = users.filter(user => user.isDeleted == null || user.isDeleted === false);
+        return users;
+    }
+}
+
 /* begin_public_function
   id: user.search
 */
@@ -27876,7 +28305,21 @@ const observeUser = (userId, callback) => {
  * @category Category Live Collection
  */
 const searchUserByDisplayName = (params, callback, config) => {
-    return getUsers(Object.assign(Object.assign({}, params), { filter: 'all' }), callback, config);
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        // eslint-disable-next-line no-console
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`liveSearchUsers(tmpid: ${timestamp}) > listen`);
+    const searchUsersLiveCollection = new SearchUserLiveCollectionController(params, callback);
+    const disposers = searchUsersLiveCollection.startSubscription();
+    const cacheKey = searchUsersLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`liveSearchUsers(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
 };
 /* end_public_function */
 
@@ -28045,7 +28488,7 @@ var index$j = /*#__PURE__*/Object.freeze({
   unflagUser: unflagUser,
   isUserFlaggedByMe: isUserFlaggedByMe,
   onUserUpdated: onUserUpdated,
-  onUserDeleted: onUserDeleted,
+  onUserDeleted: onUserDeleted$2,
   onUserFlagged: onUserFlagged,
   onUserUnflagged: onUserUnflagged,
   onUserFlagCleared: onUserFlagCleared,
@@ -28967,6 +29410,7 @@ const prepareCommentFromFlaggedEvent = (payload) => {
  * @async
  * */
 const addReaction = async (referenceType, referenceId, reactionName) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('reaction/createReaction', {
         referenceId,
@@ -28985,8 +29429,21 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
             'get',
             referenceId,
         ]);
-        (model === null || model === void 0 ? void 0 : model.data) &&
-            pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+        if (!model)
+            return true;
+        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_a = model.data.myReactions) !== null && _a !== void 0 ? _a : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_b = model.data.reactions[reactionName]) !== null && _b !== void 0 ? _b : 0) + 1 }) });
+        if (referenceType === 'comment') {
+            fireEvent('local.comment.addReaction', {
+                comment: updatedModel,
+            });
+            return true;
+        }
+        if (referenceType === 'post') {
+            fireEvent('local.post.addReaction', {
+                post: updatedModel,
+            });
+            return true;
+        }
     }
     return true;
 };
@@ -29051,6 +29508,7 @@ addReaction.optimistically = (referenceType, referenceId, reactionName) => {
  * @async
  * */
 const removeReaction = async (referenceType, referenceId, reactionName) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('reaction/removeReaction', {
         referenceId,
@@ -29071,8 +29529,21 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
             'get',
             referenceId,
         ]);
-        (model === null || model === void 0 ? void 0 : model.data) &&
-            pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+        if (!model)
+            return true;
+        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: Math.max(0, model.data.reactionsCount - 1), myReactions: ((_a = model.data.myReactions) !== null && _a !== void 0 ? _a : []).filter(item => item !== reactionName), reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: Math.max(0, ((_b = model.data.reactions[reactionName]) !== null && _b !== void 0 ? _b : 0) - 1) }) });
+        if (referenceType === 'comment') {
+            fireEvent('local.comment.removeReaction', {
+                comment: updatedModel,
+            });
+            return true;
+        }
+        if (referenceType === 'post') {
+            fireEvent('local.post.removeReaction', {
+                post: updatedModel,
+            });
+            return true;
+        }
     }
     return true;
 };
@@ -29117,6 +29588,66 @@ removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
     return (_e = !((_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName))) !== null && _e !== void 0 ? _e : false;
 };
 
+const getMatchPostSetting = (value) => {
+    var _a;
+    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
+};
+function addPostSetting({ communities }) {
+    return communities.map((_a) => {
+        var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
+        return (Object.assign({ postSetting: getMatchPostSetting({
+                needApprovalOnPostCreation,
+                onlyAdminCanPost,
+            }) }, restCommunityPayload));
+    });
+}
+const prepareCommunityPayload = (rawPayload) => {
+    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+    // map users with community
+    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
+        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareCommunityMembershipPayload = (rawPayload) => {
+    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+    // map users with community
+    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
+        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareCommunityRequest = (params) => {
+    const { postSetting = undefined, storySetting } = params, restParam = __rest(params, ["postSetting", "storySetting"]);
+    return Object.assign(Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)), { 
+        // Convert story setting to the actual value. (Allow by default)
+        allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
+};
+
+const preparePostPayload = (postPayload) => {
+    // Unpack community payload by mapping payload field to postSetting value.
+    const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
+    // map users with community
+    const mappedCommunityUsers = postPayload.communityUsers.map(communityUser => {
+        const user = postPayload.users.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    // feed type
+    const posts = postPayload.posts.map(post => {
+        var _a;
+        const feedType = (_a = postPayload.feeds.find(feed => feed.feedId === post.feedId)) === null || _a === void 0 ? void 0 : _a.feedType;
+        return Object.assign(Object.assign({}, post), { feedType });
+    });
+    return Object.assign(Object.assign({}, postPayload), { posts, communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+
 const createPostEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
@@ -29125,8 +29656,8 @@ const createPostEventSubscriber = (event, callback) => {
             callback(payload.posts[0]);
         }
         else {
-            const { communities } = payload, others = __rest(payload, ["communities"]);
-            const data = prepareMembershipPayload(others, 'communityUsers');
+            const data = preparePostPayload(payload);
+            const { communities } = data;
             ingestInCache(data);
             if ((communities === null || communities === void 0 ? void 0 : communities[0]) && !['post.updated'].includes(event)) {
                 fireEvent('community.updated', {
@@ -29153,7 +29684,7 @@ const createPostEventSubscriber = (event, callback) => {
                 // But if it is hard delete, it will pushed into tombstone before fire an event to BE. it means it will stay in tombstone already
                 // and will got skip to notify in a previous code block
                 if (postedUserId !== client.userId) {
-                    pushToTombstone('post', postId);
+                    dropFromCache(['post', 'get', postId]);
                 }
                 return callback(payload.posts[0]);
             }
@@ -29170,6 +29701,32 @@ const createPostEventSubscriber = (event, callback) => {
         }
     };
     return createEventSubscriber(client, event, event, filter);
+};
+const createLocalPostEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        if (!client.cache) {
+            callback(payload.posts[0]);
+        }
+        else {
+            const data = preparePostPayload(payload);
+            const { communities } = data;
+            ingestInCache(data);
+            if ((communities === null || communities === void 0 ? void 0 : communities[0]) && !['local.post.updated'].includes(event)) {
+                fireEvent('community.updated', {
+                    communities,
+                    categories: [],
+                    communityUsers: data.communityUsers,
+                    feeds: [],
+                    files: [],
+                    users: [],
+                });
+            }
+            const post = pullFromCache(['post', 'get', payload.posts[0].postId]);
+            callback(post.data);
+        }
+    };
+    return createEventSubscriber(client, event, event, filter);
 };
 
 /**
@@ -29376,6 +29933,9 @@ const createCommentEventSubscriber = (event, callback) => {
                     comments[0].commentId,
                 ]);
                 if (['comment.created'].includes(event)) {
+                    // NOTE: skip adding comment to parent comment children if it's the same user since we use the local event to update instead.
+                    if (event === 'comment.created' && comment.data.userId === client.userId)
+                        return;
                     if (comments[0].parentId) {
                         const parentComment = pullFromCache([
                             'comment',
@@ -29397,6 +29957,58 @@ const createCommentEventSubscriber = (event, callback) => {
         }
     };
     return createEventSubscriber(client, event, event, filter);
+};
+const createLocalCommentEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a;
+        if (!client.cache) {
+            // TODO: here we are missing specific properties here!
+            callback(LinkedObject.comment(payload.comments[0]));
+        }
+        else {
+            const processed = payload;
+            ingestInCache(processed);
+            const { comments } = processed;
+            if (comments.length > 0) {
+                const comment = pullFromCache([
+                    'comment',
+                    'get',
+                    comments[0].commentId,
+                ]);
+                if (['local.comment.created'].includes(event)) {
+                    if (comments[0].parentId) {
+                        const parentComment = pullFromCache([
+                            'comment',
+                            'get',
+                            comments[0].parentId,
+                        ]);
+                        if (parentComment === null || parentComment === void 0 ? void 0 : parentComment.data) {
+                            // Skip to update parent childComment if current comment already exists
+                            if (!parentComment.data.children.includes(comments[0].commentId)) {
+                                const newParentComment = Object.assign(Object.assign({}, parentComment.data), { childrenNumber: parentComment.data.childrenNumber + 1, children: [...new Set([...parentComment.data.children, comments[0].commentId])] });
+                                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
+                                setTimeout(() => {
+                                    // NOTE: This is workaround solution for emitting event not work properly.
+                                    fireEvent('comment.updated', {
+                                        comments: [newParentComment],
+                                        commentChildren: [],
+                                        files: [],
+                                        users: [],
+                                        communityUsers: [],
+                                    });
+                                }, 200);
+                            }
+                        }
+                    }
+                    const queries = (_a = queryCache(['comment', 'query'])) === null || _a === void 0 ? void 0 : _a.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
+                    queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
+                }
+                callback(LinkedObject.comment(comment.data));
+            }
+        }
+    };
+    return createEventSubscriber(client, event, event, filter);
 };
 
 /**
@@ -29956,29 +30568,53 @@ var index$h = /*#__PURE__*/Object.freeze({
   getReactions: getReactions
 });
 
-var REFERENCE_TYPES = {
-    post: {
-        domainName: 'posts',
-        eventName: 'v3/post.isflagbyme',
-        primaryKey: 'postId',
-    },
-    comment: {
-        domainName: 'comments',
-        eventName: 'v3/comment.isflagbyme',
-        primaryKey: 'commentId',
-    },
-    message: {
-        domainName: 'messages',
-        eventName: 'v3/message.isFlaggedByMe',
-        primaryKey: 'messageId',
-    },
-    user: {
-        domainName: 'users',
-        eventName: 'user.isFlagByMe',
-        primaryKey: 'userId',
-    },
-};
+function prepareCommentPayload(commentPayload) {
+    const { comments } = commentPayload;
+    return Object.assign(Object.assign({}, commentPayload), { comments: comments.map(comment => {
+            if (comment.hasOwnProperty('myReactions'))
+                return comment;
+            // Sometimes `myReactions` field will not come with BE response because that field is empty
+            // We need to put it with an empty array manually to make it show up in client side
+            return Object.assign({ myReactions: [] }, comment);
+        }) });
+}
 
+const createMessageReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.post(`/api/v5/messages/${encodeURIComponent(referenceId)}/flags`);
+    if (client.cache) {
+        const messagePayload = await prepareMessagePayload(payload);
+        ingestInCache(messagePayload);
+    }
+    fireEvent(`message.flagged`, payload);
+    return !!payload;
+};
+const createPostReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.post(`/api/v3/post/${encodeURIComponent(referenceId)}/flag`);
+    if (client.cache) {
+        const postPayload = await preparePostPayload(payload);
+        ingestInCache(postPayload);
+    }
+    fireEvent(`post.flagged`, payload);
+    return !!payload;
+};
+const createUserReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.post(`/api/v4/me/flags/${encodeURIComponent(referenceId)}`);
+    if (client.cache) {
+        const userPayload = await prepareUserPayload(payload);
+        ingestInCache(userPayload);
+    }
+    fireEvent(`user.flagged`, payload);
+    return !!payload;
+};
+const createCommentReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.post(`/api/v3/comment/${encodeURIComponent(referenceId)}/flag`);
+    if (client.cache) {
+        const commentPayload = await prepareCommentPayload(payload);
+        ingestInCache(commentPayload);
+    }
+    fireEvent(`comment.flagged`, payload);
+    return !!payload;
+};
 /**
  * ```js
  * import { createReport } from '@amityco/ts-sdk-react-native'
@@ -29995,33 +30631,57 @@ var REFERENCE_TYPES = {
 const createReport = async (referenceType, referenceId) => {
     const client = getActiveClient();
     client.log('report/createReport', { referenceType, referenceId });
-    const getAPIUrl = () => {
-        if (referenceType === 'user') {
-            return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
-        }
-        if (referenceType === 'message') {
-            return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
-        }
-        const { domainName } = REFERENCE_TYPES[referenceType];
-        return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
-    };
-    const { data: payload } = await client.http.post(getAPIUrl());
-    if (client.cache) {
-        if (referenceType === 'message') {
-            const messagePayload = await prepareMessagePayload(payload);
-            ingestInCache(messagePayload);
-        }
-        else if (referenceType === 'post') {
-            ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
-        }
-        else {
-            ingestInCache(payload);
-        }
+    if (referenceType === 'user') {
+        return createUserReport({ client, referenceId });
     }
-    fireEvent(`${referenceType}.flagged`, payload);
-    return !!payload;
+    if (referenceType === 'message') {
+        return createMessageReport({ client, referenceId });
+    }
+    if (referenceType === 'post') {
+        return createPostReport({ client, referenceId });
+    }
+    if (referenceType === 'comment') {
+        return createCommentReport({ client, referenceId });
+    }
+    return false;
 };
 
+const deleteMessageReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.delete(`/api/v5/messages/${encodeURIComponent(referenceId)}/flags`);
+    if (client.cache) {
+        const messagePayload = await prepareMessagePayload(payload);
+        ingestInCache(messagePayload);
+    }
+    fireEvent(`message.unflagged`, payload);
+    return !!payload;
+};
+const deletePostReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.delete(`/api/v3/post/${encodeURIComponent(referenceId)}/flag`);
+    if (client.cache) {
+        const postPayload = await preparePostPayload(payload);
+        ingestInCache(postPayload);
+    }
+    fireEvent(`post.unflagged`, payload);
+    return !!payload;
+};
+const deleteUserReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.delete(`/api/v4/me/flags/${encodeURIComponent(referenceId)}`);
+    if (client.cache) {
+        const userPayload = await prepareUserPayload(payload);
+        ingestInCache(userPayload);
+    }
+    fireEvent(`user.unflagged`, payload);
+    return !!payload;
+};
+const deleteCommentReport = async ({ client, referenceId, }) => {
+    const { data: payload } = await client.http.delete(`/api/v3/comment/${encodeURIComponent(referenceId)}/flag`);
+    if (client.cache) {
+        const commentPayload = await prepareCommentPayload(payload);
+        ingestInCache(commentPayload);
+    }
+    fireEvent(`comment.unflagged`, payload);
+    return !!payload;
+};
 /**
  * ```js
  * import { deleteReport } from '@amityco/ts-sdk-react-native'
@@ -30038,34 +30698,45 @@ const createReport = async (referenceType, referenceId) => {
 const deleteReport = async (referenceType, referenceId) => {
     const client = getActiveClient();
     client.log('report/deleteReport', { referenceType, referenceId });
-    const getAPIUrl = () => {
-        if (referenceType === 'user') {
-            return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
-        }
-        if (referenceType === 'message') {
-            return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
-        }
-        const { domainName } = REFERENCE_TYPES[referenceType];
-        return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/unflag`;
-    };
-    const { data: payload } = await client.http.delete(getAPIUrl());
-    if (client.cache) {
-        if (referenceType === 'message') {
-            const messagePayload = await prepareMessagePayload(payload);
-            ingestInCache(messagePayload);
-        }
-        else if (referenceType === 'post') {
-            ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
-        }
-        else {
-            ingestInCache(payload);
-        }
+    if (referenceType === 'user') {
+        return deleteUserReport({ client, referenceId });
     }
-    // @ts-ignore
-    fireEvent(`${referenceType}.unflagged`, payload);
-    return !!payload;
+    if (referenceType === 'message') {
+        return deleteMessageReport({ client, referenceId });
+    }
+    if (referenceType === 'post') {
+        return deletePostReport({ client, referenceId });
+    }
+    if (referenceType === 'comment') {
+        return deleteCommentReport({ client, referenceId });
+    }
+    return false;
 };
 
+const getMessageReport = async ({ client, referenceId, }) => {
+    var _a;
+    const { data } = await client.http.get(`/api/v5/messages/${encodeURIComponent(referenceId)}/flags`);
+    const { result, isFlagByMe } = data !== null && data !== void 0 ? data : {};
+    return (_a = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _a !== void 0 ? _a : false;
+};
+const getPostReport = async ({ client, referenceId, }) => {
+    var _a;
+    const { data } = await client.http.get(`/api/v3/user/${referenceId}/isflagbyme`);
+    const { result, isFlagByMe } = data !== null && data !== void 0 ? data : {};
+    return (_a = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _a !== void 0 ? _a : false;
+};
+const getUserReport = async ({ client, referenceId, }) => {
+    var _a;
+    const { data } = await client.http.get(`/api/v3/user/${referenceId}/isflagbyme`);
+    const { result, isFlagByMe } = data !== null && data !== void 0 ? data : {};
+    return (_a = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _a !== void 0 ? _a : false;
+};
+const getCommentReport = async ({ client, referenceId, }) => {
+    var _a;
+    const { data } = await client.http.get(`/api/v3/comment/${referenceId}/isflagbyme`);
+    const { result, isFlagByMe } = data !== null && data !== void 0 ? data : {};
+    return (_a = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _a !== void 0 ? _a : false;
+};
 /**
  * ```js
  * import { isReportedByMe } from '@amityco/ts-sdk-react-native'
@@ -30080,17 +30751,21 @@ const deleteReport = async (referenceType, referenceId) => {
  * @async
  * */
 const isReportedByMe = async (referenceType, referenceId) => {
-    var _a;
     const client = getActiveClient();
     client.log('report/isReportedByMe', { referenceType, referenceId });
-    const { domainName } = REFERENCE_TYPES[referenceType];
+    if (referenceType === 'user') {
+        return getUserReport({ client, referenceId });
+    }
     if (referenceType === 'message') {
-        const { data } = await client.http.get(`/api/v5/messages/${encodeURIComponent(referenceId)}/flags`);
-        return data.result;
+        return getMessageReport({ client, referenceId });
     }
-    const { data } = await client.http.get(`/api/v3/${domainName}/${referenceId}/isflagbyme`);
-    const { result, isFlagByMe } = data !== null && data !== void 0 ? data : {};
-    return (_a = result !== null && result !== void 0 ? result : isFlagByMe) !== null && _a !== void 0 ? _a : false;
+    if (referenceType === 'post') {
+        return getPostReport({ client, referenceId });
+    }
+    if (referenceType === 'comment') {
+        return getCommentReport({ client, referenceId });
+    }
+    return false;
 };
 
 /* begin_public_function
@@ -31611,116 +32286,6 @@ const getMessage$1 = (messageId, callback) => {
 };
 /* end_public_function */
 
-class PaginationNoPageController {
-    constructor(queryParams) {
-        const { http } = getActiveClient();
-        this.queryParams = queryParams;
-        this.http = http;
-    }
-    async onFetch() {
-        const queryResponse = await this.getRequest(this.queryParams);
-        return queryResponse;
-    }
-}
-
-class LiveCollectionController {
-    constructor(paginationController, queryStreamId, cacheKey, callback) {
-        this.paginationController = paginationController;
-        this.queryStreamId = queryStreamId;
-        this.cacheKey = cacheKey;
-        this.callback = callback;
-    }
-    async refresh() {
-        try {
-            let result;
-            if (this.paginationController instanceof PaginationNoPageController) {
-                result = await this.paginationController.onFetch();
-            }
-            else {
-                result = await this.paginationController.loadFirstPage();
-            }
-            if (!result)
-                return;
-            await this.persistModel(result);
-            this.persistQueryStream({
-                response: result,
-                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
-                refresh: true,
-            });
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
-        }
-        catch (e) {
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
-        }
-    }
-    loadPage({ initial = false, direction = "next" /* Amity.LiveCollectionPageDirection.NEXT */, }) {
-        this.setup();
-        this.notifyChange({ origin: "local" /* Amity.LiveDataOrigin.LOCAL */, loading: true });
-        if (initial) {
-            this.refresh();
-        }
-        else if (direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */) {
-            this.loadPrevPage();
-        }
-        else if (direction === "next" /* Amity.LiveCollectionPageDirection.NEXT */) {
-            this.loadNextPage();
-        }
-    }
-    async loadNextPage() {
-        try {
-            if (this.paginationController instanceof PaginationNoPageController)
-                return;
-            const result = await this.paginationController.loadNextPage();
-            if (!result)
-                return;
-            await this.persistModel(result);
-            this.persistQueryStream({
-                response: result,
-                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
-            });
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
-        }
-        catch (e) {
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
-        }
-    }
-    async loadPrevPage() {
-        try {
-            if (this.paginationController instanceof PaginationNoPageController)
-                return;
-            const result = await this.paginationController.loadPreviousPage();
-            if (!result)
-                return;
-            await this.persistModel(result);
-            this.persistQueryStream({
-                response: result,
-                direction: "prev" /* Amity.LiveCollectionPageDirection.PREV */,
-            });
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
-        }
-        catch (e) {
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
-        }
-    }
-    shouldNotify(data) {
-        const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
-        if (isEqual(this.snapshot, newData))
-            return false;
-        this.snapshot = newData;
-        return true;
-    }
-    getCacheKey() {
-        return this.cacheKey;
-    }
-}
-
-class QueryStreamController {
-    constructor(query, cacheKey) {
-        this.query = query;
-        this.cacheKey = cacheKey;
-    }
-}
-
 /* eslint-disable no-use-before-define */
 class MessageQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload, paginationController) {
@@ -31803,51 +32368,6 @@ class MessageQueryStreamController extends QueryStreamController {
     }
 }
 
-class PaginationController {
-    constructor(queryParams) {
-        const { http } = getActiveClient();
-        this.queryParams = queryParams;
-        this.http = http;
-    }
-    loadFirstPage() {
-        return this.onFetch("first" /* Amity.LiveCollectionPageDirection.FIRST */);
-    }
-    loadNextPage() {
-        return this.onFetch("next" /* Amity.LiveCollectionPageDirection.NEXT */);
-    }
-    loadPreviousPage() {
-        return this.onFetch("prev" /* Amity.LiveCollectionPageDirection.PREV */);
-    }
-    async onFetch(direction = "first" /* Amity.LiveCollectionPageDirection.FIRST */) {
-        var _a, _b, _c, _d;
-        if (direction === 'prev' && !this.previousToken)
-            return;
-        if (direction === 'next' && !this.nextToken)
-            return;
-        let token;
-        if (direction === 'prev')
-            token = this.previousToken;
-        if (direction === 'next')
-            token = this.nextToken;
-        const queryResponse = await this.getRequest(this.queryParams, token);
-        if (direction === 'first') {
-            this.nextToken = (_a = queryResponse.paging) === null || _a === void 0 ? void 0 : _a.next;
-            this.previousToken = (_b = queryResponse.paging) === null || _b === void 0 ? void 0 : _b.previous;
-        }
-        if (direction === 'prev')
-            this.previousToken = (_c = queryResponse.paging) === null || _c === void 0 ? void 0 : _c.previous;
-        if (direction === 'next')
-            this.nextToken = (_d = queryResponse.paging) === null || _d === void 0 ? void 0 : _d.next;
-        return queryResponse;
-    }
-    getNextToken() {
-        return this.nextToken;
-    }
-    getPrevToken() {
-        return this.previousToken;
-    }
-}
-
 /* eslint-disable no-use-before-define */
 /**
  * TODO: handle cache receive cache option, and cache policy
@@ -33639,10 +34159,12 @@ const removeMembers$1 = async (channelId, userIds) => {
  */
 class ChannelMemberPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
         const options = token ? { token } : { limit };
+        const isDeleted = includeDeleted === false ? false : undefined;
         const { data: queryResponse } = await this.http.get(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
-            params: Object.assign(Object.assign({}, params), { options }),
+            params: Object.assign(Object.assign({}, params), { options,
+                isDeleted }),
         });
         return queryResponse;
     }
@@ -33708,6 +34230,33 @@ class ChannelMemberQueryStreamController extends QueryStreamController {
     }
 }
 
+const onUserDeleted$1 = (channelId) => (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const userPayload = prepareUserPayload(payload);
+        if (userPayload.users.length === 0)
+            return;
+        const user = userPayload.users[0];
+        ingestInCache(userPayload);
+        const channelUserCacheKey = getResolver('channelUsers')({
+            channelId,
+            userId: user.userId,
+        });
+        const cacheData = (_a = pullFromCache([
+            'channelUsers',
+            'get',
+            channelUserCacheKey,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        upsertInCache(['channelUsers', 'get', channelUserCacheKey], Object.assign(Object.assign({}, cacheData), { user }));
+        const channel = (_b = pullFromCache(['channel', 'get', channelId])) === null || _b === void 0 ? void 0 : _b.data;
+        if (!channel)
+            return;
+        callback(channel, cacheData);
+    };
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+};
+
 /* eslint-disable no-use-before-define */
 class ChannelMemberLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
@@ -33746,6 +34295,7 @@ class ChannelMemberLiveCollectionController extends LiveCollectionController {
             { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
             { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
             { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+            { fn: onUserDeleted$1(this.query.channelId), action: 'onChannelMemberChanged' },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -33792,6 +34342,9 @@ class ChannelMemberLiveCollectionController extends LiveCollectionController {
             console.warn('`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.');
             channelMembers = filterBySearchTerm(channelMembers, this.query.search);
         }
+        if (this.query.includeDeleted === false) {
+            channelMembers = channelMembers.filter(member => { var _a; return ((_a = member.user) === null || _a === void 0 ? void 0 : _a.isDeleted) !== true; });
+        }
         // sort, 'lastCreated' is the default sort order
         const sortBy = this.query.sortBy ? this.query.sortBy : 'lastCreated';
         channelMembers = channelMembers.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
@@ -34159,57 +34712,6 @@ const saveCommunityUsers = (communities, communityUsers) => {
     });
 };
 
-const getMatchPostSetting = (value) => {
-    var _a;
-    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
-        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
-        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
-};
-const convertCommunityUsersToUniqueObject = (communityUsers) => {
-    if (!communityUsers)
-        return communityUsers;
-    const result = {};
-    communityUsers.forEach(user => {
-        result[`${user.userId}#${user.communityId}`] = user;
-    });
-    return result;
-};
-const convertCommunityPayload = (rawPayload) => {
-    // Unpack community payload by mapping payload field to postSetting value.
-    const communities = rawPayload.communities.map((_a) => {
-        var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
-        return (Object.assign({ postSetting: getMatchPostSetting({
-                needApprovalOnPostCreation,
-                onlyAdminCanPost,
-            }) }, restCommunityPayload));
-    });
-    const mergeCommunityUsers = communities.reduce((acc, { communityId }) => {
-        var _a;
-        const users = (_a = pullFromCache([
-            'communityUsers',
-            'collection',
-            communityId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (!users)
-            return acc;
-        return Object.assign(Object.assign({}, convertCommunityUsersToUniqueObject(users)), acc);
-    }, convertCommunityUsersToUniqueObject(rawPayload.communityUsers));
-    const communityUsers = withUsers(Object.values(mergeCommunityUsers));
-    const communityWithMembershipStatus = updateMembershipStatus(communities, communityUsers);
-    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers });
-};
-const prepareCommunityPayload = (rawPayload) => {
-    const { communities, communityUsers } = convertCommunityPayload(rawPayload);
-    return Object.assign(Object.assign({}, rawPayload), { communities,
-        communityUsers });
-};
-const prepareCommunityRequest = (params) => {
-    const { postSetting = undefined, storySetting } = params, restParam = __rest(params, ["postSetting", "storySetting"]);
-    return Object.assign(Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)), { 
-        // Convert story setting to the actual value. (Allow by default)
-        allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
-};
-
 /**
  * ```js
  * import { getCommunities } from '@amityco/ts-sdk-react-native'
@@ -34645,10 +35147,6 @@ const onCommunityUpdated = (callback) => createCommunityEventSubscriber('communi
  */
 const onCommunityDeleted = (callback) => createCommunityEventSubscriber('community.deleted', callback);
 
-function isNonNullable(value) {
-    return value != null;
-}
-
 function hasPermission(member, payload, permission) {
     if (member.permissions.some(x => x === permission)) {
         return true;
@@ -34663,7 +35161,7 @@ function getEventRelatedMember(event, payload) {
     }
     // NOTE: backend returns the one who took the action and the one on whom
     // the action was taken. We need the 2nd one
-    if (event === 'community.userRemoved') {
+    if (event === 'community.userRemoved' || event === 'local.community.userRemoved') {
         return payload.communityUsers.filter(x => x.communityMembership === 'none');
     }
     if (event === 'community.userBanned') {
@@ -34711,6 +35209,43 @@ const createCommunityMemberEventSubscriber = (event, callback) => {
         }
     };
     return createEventSubscriber(client, event, event, filter);
+};
+const createLocalCommunityMemberEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        const preparedPayload = prepareCommunityPayload(payload);
+        const { communities, communityUsers } = preparedPayload;
+        /*
+         * community.isJoined is not part of the communityMembership payload, and needs
+         * to be calculated based on the communityMembership value
+         */
+        const communitiesWithMembership = updateMembershipStatus(communities, communityUsers);
+        preparedPayload.communities = communitiesWithMembership;
+        if (!client.cache) {
+            // TODO: here we are missing specific properties here!
+            callback(preparedPayload.communities[0], getEventRelatedMember(event, preparedPayload));
+        }
+        else {
+            ingestInCache(preparedPayload);
+            const community = pullFromCache([
+                'community',
+                'get',
+                preparedPayload.communities[0].communityId,
+            ]);
+            const members = getEventRelatedMember(event, preparedPayload)
+                .map(member => {
+                const memberCache = pullFromCache([
+                    'communityUsers',
+                    'get',
+                    getResolver('communityUsers')(member),
+                ]);
+                return memberCache === null || memberCache === void 0 ? void 0 : memberCache.data;
+            })
+                .filter(isNonNullable);
+            callback(community.data, members);
+        }
+    };
+    return createEventSubscriber(client, event, event, filter);
 };
 
 /**
@@ -34832,6 +35367,40 @@ const onCommunityUserRoleAdded = (callback) => createCommunityMemberEventSubscri
  */
 const onCommunityUserRoleRemoved = (callback) => createCommunityMemberEventSubscriber('community.roleRemoved', callback);
 
+/**
+ * ```js
+ * import { onLocalCommunityUserAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityUserAdded((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been added to a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onLocalCommunityUserAdded = (callback) => createLocalCommunityMemberEventSubscriber('local.community.userAdded', callback);
+
+/**
+ * ```js
+ * import { onLocalCommunityUserRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityUserRemoved((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a user has been removed from a {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onLocalCommunityUserRemoved = (callback) => createLocalCommunityMemberEventSubscriber('local.community.userRemoved', callback);
+
 /**
  * ```js
  * import { onCommunityJoined } from '@amityco/ts-sdk-react-native'
@@ -34984,6 +35553,9 @@ var EnumCommunityMemberActions$1;
     EnumCommunityMemberActions["OnCommunityUserRoleRemoved"] = "onCommunityUserRoleRemoved";
     EnumCommunityMemberActions["OnCommunityUserUnbanned"] = "onCommunityUserUnbanned";
     EnumCommunityMemberActions["OnMemberCountChanged"] = "OnMemberCountChanged";
+    EnumCommunityMemberActions["OnCommunityUserAdded"] = "OnCommunityUserAdded";
+    EnumCommunityMemberActions["onCommunityUserRemoved"] = "onCommunityUserRemoved";
+    EnumCommunityMemberActions["OnUserDeleted"] = "OnUserDeleted";
 })(EnumCommunityMemberActions$1 || (EnumCommunityMemberActions$1 = {}));
 
 /* begin_public_function
@@ -35008,7 +35580,7 @@ const addMembers = async (communityId, userIds) => {
     const client = getActiveClient();
     client.log('community/moderation/addMembers', communityId, userIds);
     const { data: payload } = await client.http.post(`/api/v3/communities/${communityId}/users`, { communityId, userIds });
-    fireEvent('community.userAdded', payload);
+    fireEvent('local.community.userAdded', payload);
     const data = prepareMembershipPayload(payload, 'communityUsers');
     if (client.cache)
         ingestInCache(data);
@@ -35039,7 +35611,7 @@ const removeMembers = async (communityId, userIds) => {
     const client = getActiveClient();
     client.log('community/moderation/removeMembers', communityId, userIds);
     const { data: payload } = await client.http.delete(`/api/v3/communities/${communityId}/users`, { data: { communityId, userIds } });
-    fireEvent('community.userRemoved', payload);
+    fireEvent('local.community.userRemoved', payload);
     const data = prepareMembershipPayload(payload, 'communityUsers');
     if (client.cache)
         ingestInCache(data);
@@ -35054,10 +35626,12 @@ const removeMembers = async (communityId, userIds) => {
  */
 class CommunityMembersPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
         const options = token ? { token } : { limit };
+        const isDeleted = includeDeleted === false ? false : undefined;
         const { data: queryResponse } = await this.http.get(`/api/v3/communities/${params.communityId}/users`, {
-            params: Object.assign(Object.assign({}, params), { options }),
+            params: Object.assign(Object.assign({}, params), { options,
+                isDeleted }),
         });
         return queryResponse;
     }
@@ -35126,6 +35700,96 @@ class CommunityMembersQueryStreamController extends QueryStreamController {
     }
 }
 
+/**
+ * ```js
+ * import { onLocalCommunityRoleRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityRoleRemoved((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.communityUsers} 's role has been added to any {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onLocalCommunityRoleRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        const { communities, communityUsers } = payload;
+        callback(communities[0], communityUsers.filter(communityUser => communityUser.communityMembership === 'member'));
+    };
+    return createEventSubscriber(client, 'onLocalCommunityRoleRemoved', 'local.community.roleRemoved', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalCommunityRoleAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommunityRoleAdded((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.communityUsers} 's role has been added to any {@link Amity.Community}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onLocalCommunityRoleAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = async (payload) => {
+        const { communities, communityUsers } = payload;
+        callback(communities[0], communityUsers.filter(communityUser => communityUser.communityMembership === 'member'));
+    };
+    return createEventSubscriber(client, 'onLocalCommunityRoleAdded', 'local.community.roleAdded', filter);
+};
+
+/**
+ * ```js
+ * import { onUserDeleted } from '@amityco/ts-sdk'
+ * const dispose = onUserDeleted((community, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been joined
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+const onUserDeleted = (communityId) => (callback) => {
+    const client = getActiveClient();
+    const filter = (payload) => {
+        var _a, _b;
+        const userPayload = prepareUserPayload(payload);
+        if (userPayload.users.length === 0)
+            return;
+        const user = userPayload.users[0];
+        ingestInCache(userPayload);
+        const communityUserCacheKey = getResolver('communityUsers')({
+            communityId,
+            userId: user.userId,
+        });
+        const cacheData = (_a = pullFromCache([
+            'communityUsers',
+            'get',
+            communityUserCacheKey,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        pushToCache(['communityUsers', 'get', communityUserCacheKey], Object.assign(Object.assign({}, cacheData), { user }));
+        const community = (_b = pullFromCache(['community', 'get', communityId])) === null || _b === void 0 ? void 0 : _b.data;
+        callback(community, [
+            Object.assign(Object.assign({}, cacheData), { user }),
+        ]);
+    };
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+};
+
 class CommunityMembersLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         const queryStreamId = hash(query);
@@ -35164,7 +35828,274 @@ class CommunityMembersLiveCollectionController extends LiveCollectionController
                 fn: onCommunityUserRoleRemoved,
                 action: EnumCommunityMemberActions$1.OnCommunityUserRoleRemoved,
             },
+            {
+                fn: onLocalCommunityRoleAdded,
+                action: EnumCommunityMemberActions$1.OnCommunityUserRoleAdded,
+            },
+            {
+                fn: onLocalCommunityRoleRemoved,
+                action: EnumCommunityMemberActions$1.OnCommunityUserRoleRemoved,
+            },
             { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions$1.OnCommunityUserUnbanned },
+            { fn: onLocalCommunityUserAdded, action: EnumCommunityMemberActions$1.OnCommunityUserAdded },
+            {
+                fn: onLocalCommunityUserRemoved,
+                action: EnumCommunityMemberActions$1.onCommunityUserRemoved,
+            },
+            {
+                fn: onUserDeleted(this.query.communityId),
+                action: EnumCommunityMemberActions$1.OnCommunityUserChanged,
+            },
+        ]);
+    }
+    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(['communityUsers', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => 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,
+        });
+    }
+    applyFilter(data) {
+        let communityMembers = filterByPropIntersection(data, 'roles', this.query.roles);
+        if (this.query.memberships) {
+            communityMembers = communityMembers.filter(({ communityMembership }) => {
+                const memberships = this.query.memberships || [];
+                return memberships.includes(communityMembership);
+            });
+        }
+        if (this.query.search) {
+            communityMembers = filterBySearchTerm(communityMembers, this.query.search);
+        }
+        if (this.query.includeDeleted === false) {
+            communityMembers = communityMembers.filter(({ user }) => (user === null || user === void 0 ? void 0 : user.isDeleted) !== true);
+        }
+        switch (this.query.sortBy) {
+            case 'firstCreated':
+                communityMembers = communityMembers.sort(sortByFirstCreated);
+                break;
+            case 'displayName':
+                communityMembers = communityMembers.sort((a, b) => {
+                    var _a, _b, _c, _d;
+                    if (((_a = a === null || a === void 0 ? void 0 : a.user) === null || _a === void 0 ? void 0 : _a.displayName) && ((_b = b === null || b === void 0 ? void 0 : b.user) === null || _b === void 0 ? void 0 : _b.displayName)) {
+                        return (_c = a === null || a === void 0 ? void 0 : a.user) === null || _c === void 0 ? void 0 : _c.displayName.localeCompare((_d = b === null || b === void 0 ? void 0 : b.user) === null || _d === void 0 ? void 0 : _d.displayName);
+                    }
+                    return 0;
+                });
+                break;
+            case 'lastCreated':
+            default:
+                communityMembers = communityMembers.sort(sortByLastCreated);
+                break;
+        }
+        return communityMembers;
+    }
+}
+
+/*
+ * Exported for testing
+ * @hidden
+ */
+const applyFilter = (data, params) => {
+    let communityMembers = filterByPropIntersection(data, 'roles', params.roles);
+    if (params.memberships) {
+        communityMembers = communityMembers.filter(({ communityMembership }) => {
+            const membership = params.memberships;
+            return membership.includes(communityMembership);
+        });
+    }
+    if (params.search) {
+        communityMembers = filterBySearchTerm(communityMembers, params.search);
+    }
+    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+    communityMembers = communityMembers.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+    return communityMembers;
+};
+/* begin_public_function
+  id: community.membership.query
+*/
+/**
+ * ```js
+ * import { getMembers } from '@amityco/ts-sdk-react-native'
+ *
+ * let communityMembers = []
+ * const unsub = getMembers({
+ *   communityId: Amity.Community['communityId'],
+ * }, response => merge(communityMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.CommunityUser}s
+ *
+ * @param params for querying community users
+ * @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 community users
+ *
+ * @category Community Live Collection
+ */
+const getMembers = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getMembers(tmpid: ${timestamp}) > listen`);
+    const communityMemberLiveCollection = new CommunityMembersLiveCollectionController(params, resp => {
+        callback(resp);
+    });
+    const disposers = communityMemberLiveCollection.startSubscription();
+    const cacheKey = communityMemberLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getMembers(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+class SearchCommunityMembersPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
+        const options = token ? { token } : { limit };
+        const isDeleted = includeDeleted === false ? false : undefined;
+        const { data: queryResponse } = await this.http.get(`/api/v3/communities/${params.communityId}/users`, {
+            params: Object.assign(Object.assign({}, params), { options,
+                isDeleted }),
+        });
+        return queryResponse;
+    }
+}
+
+class SearchCommunityMembersQueryStreamController 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.communityUsers.map(({ communityId, userId }) => getResolver('communityUsers')({ communityId, userId })),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const communityUsers = (_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([
+                        ...communityUsers,
+                        ...response.communityUsers.map(({ communityId, userId }) => getResolver('communityUsers')({ communityId, userId })),
+                    ]),
+                ] }));
+        }
+    }
+    reactor(action) {
+        return (community, communityMembers) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            communityMembers.forEach(communityMember => {
+                const communityMemberCacheId = getResolver('communityUsers')({
+                    communityId: this.query.communityId,
+                    userId: communityMember.userId,
+                });
+                if (communityMember.communityMembership === 'none') {
+                    collection.data = collection.data.filter(m => m !== communityMemberCacheId);
+                }
+            });
+            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)));
+    }
+}
+
+var EnumCommunityMemberActions;
+(function (EnumCommunityMemberActions) {
+    EnumCommunityMemberActions["OnCommunityJoined"] = "onCommunityJoined";
+    EnumCommunityMemberActions["OnCommunityLeft"] = "onCommunityLeft";
+    EnumCommunityMemberActions["OnCommunityUserBanned"] = "onCommunityUserBanned";
+    EnumCommunityMemberActions["OnCommunityUserChanged"] = "onCommunityUserChanged";
+    EnumCommunityMemberActions["OnCommunityUserRoleAdded"] = "onCommunityUserRoleAdded";
+    EnumCommunityMemberActions["OnCommunityUserRoleRemoved"] = "onCommunityUserRoleRemoved";
+    EnumCommunityMemberActions["OnCommunityUserUnbanned"] = "onCommunityUserUnbanned";
+})(EnumCommunityMemberActions || (EnumCommunityMemberActions = {}));
+
+/* eslint-disable no-use-before-define */
+class SearchCommunityMembersLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['communityUsers', 'collection', queryStreamId];
+        const paginationController = new SearchCommunityMembersPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new SearchCommunityMembersQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommunityPayload);
+        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: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
+            { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
+            { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
+            { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
+            {
+                fn: onLocalCommunityRoleRemoved,
+                action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
+            },
+            {
+                fn: onCommunityUserRoleRemoved,
+                action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
+            },
+            { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions.OnCommunityUserUnbanned },
+            {
+                fn: onUserDeleted(this.query.communityId),
+                action: EnumCommunityMemberActions.OnCommunityUserChanged,
+            },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -35197,242 +36128,8 @@ class CommunityMembersLiveCollectionController extends LiveCollectionController
         if (this.query.search) {
             communityMembers = filterBySearchTerm(communityMembers, this.query.search);
         }
-        switch (this.query.sortBy) {
-            case 'firstCreated':
-                communityMembers = communityMembers.sort(sortByFirstCreated);
-                break;
-            case 'displayName':
-                communityMembers = communityMembers.sort((a, b) => {
-                    var _a, _b, _c, _d;
-                    if (((_a = a === null || a === void 0 ? void 0 : a.user) === null || _a === void 0 ? void 0 : _a.displayName) && ((_b = b === null || b === void 0 ? void 0 : b.user) === null || _b === void 0 ? void 0 : _b.displayName)) {
-                        return (_c = a === null || a === void 0 ? void 0 : a.user) === null || _c === void 0 ? void 0 : _c.displayName.localeCompare((_d = b === null || b === void 0 ? void 0 : b.user) === null || _d === void 0 ? void 0 : _d.displayName);
-                    }
-                    return 0;
-                });
-                break;
-            case 'lastCreated':
-            default:
-                communityMembers = communityMembers.sort(sortByLastCreated);
-                break;
-        }
-        return communityMembers;
-    }
-}
-
-/*
- * Exported for testing
- * @hidden
- */
-const applyFilter = (data, params) => {
-    let communityMembers = filterByPropIntersection(data, 'roles', params.roles);
-    if (params.memberships) {
-        communityMembers = communityMembers.filter(({ communityMembership }) => {
-            const membership = params.memberships;
-            return membership.includes(communityMembership);
-        });
-    }
-    if (params.search) {
-        communityMembers = filterBySearchTerm(communityMembers, params.search);
-    }
-    const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
-    communityMembers = communityMembers.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
-    return communityMembers;
-};
-/* begin_public_function
-  id: community.membership.query
-*/
-/**
- * ```js
- * import { getMembers } from '@amityco/ts-sdk-react-native'
- *
- * let communityMembers = []
- * const unsub = getMembers({
- *   communityId: Amity.Community['communityId'],
- * }, response => merge(communityMembers, response.data))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.CommunityUser}s
- *
- * @param params for querying community users
- * @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 community users
- *
- * @category Community Live Collection
- */
-const getMembers = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
-    }
-    const timestamp = Date.now();
-    log(`getMembers(tmpid: ${timestamp}) > listen`);
-    const communityMemberLiveCollection = new CommunityMembersLiveCollectionController(params, resp => {
-        callback(resp);
-    });
-    const disposers = communityMemberLiveCollection.startSubscription();
-    const cacheKey = communityMemberLiveCollection.getCacheKey();
-    disposers.push(() => {
-        dropFromCache(cacheKey);
-    });
-    return () => {
-        log(`getMembers(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
-};
-/* end_public_function */
-
-/**
- * TODO: handle cache receive cache option, and cache policy
- * TODO: check if querybyIds is supported
- */
-class SearchCommunityMembersPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
-        const options = token ? { token } : { limit };
-        const { data: queryResponse } = await this.http.get(`/api/v3/communities/${params.communityId}/users`, {
-            params: Object.assign(Object.assign({}, params), { options }),
-        });
-        return queryResponse;
-    }
-}
-
-class SearchCommunityMembersQueryStreamController 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.communityUsers.map(({ communityId, userId }) => getResolver('communityUsers')({ communityId, userId })),
-            });
-        }
-        else {
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            const communityUsers = (_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([
-                        ...communityUsers,
-                        ...response.communityUsers.map(({ communityId, userId }) => getResolver('communityUsers')({ communityId, userId })),
-                    ]),
-                ] }));
-        }
-    }
-    reactor(action) {
-        return (community, communityMembers) => {
-            var _a;
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            if (!collection)
-                return;
-            communityMembers.forEach(communityMember => {
-                const communityMemberCacheId = getResolver('communityUsers')({
-                    communityId: this.query.communityId,
-                    userId: communityMember.userId,
-                });
-                if (communityMember.communityMembership === 'none') {
-                    collection.data = collection.data.filter(m => m !== communityMemberCacheId);
-                }
-            });
-            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)));
-    }
-}
-
-var EnumCommunityMemberActions;
-(function (EnumCommunityMemberActions) {
-    EnumCommunityMemberActions["OnCommunityJoined"] = "onCommunityJoined";
-    EnumCommunityMemberActions["OnCommunityLeft"] = "onCommunityLeft";
-    EnumCommunityMemberActions["OnCommunityUserBanned"] = "onCommunityUserBanned";
-    EnumCommunityMemberActions["OnCommunityUserChanged"] = "onCommunityUserChanged";
-    EnumCommunityMemberActions["OnCommunityUserRoleAdded"] = "onCommunityUserRoleAdded";
-    EnumCommunityMemberActions["OnCommunityUserRoleRemoved"] = "onCommunityUserRoleRemoved";
-    EnumCommunityMemberActions["OnCommunityUserUnbanned"] = "onCommunityUserUnbanned";
-})(EnumCommunityMemberActions || (EnumCommunityMemberActions = {}));
-
-/* eslint-disable no-use-before-define */
-class SearchCommunityMembersLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash(query);
-        const cacheKey = ['communityUsers', 'collection', queryStreamId];
-        const paginationController = new SearchCommunityMembersPaginationController(query);
-        super(paginationController, queryStreamId, cacheKey, callback);
-        this.query = query;
-        this.queryStreamController = new SearchCommunityMembersQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommunityPayload);
-        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: onCommunityJoined, action: EnumCommunityMemberActions.OnCommunityJoined },
-            { fn: onCommunityLeft, action: EnumCommunityMemberActions.OnCommunityLeft },
-            { fn: onCommunityUserBanned, action: EnumCommunityMemberActions.OnCommunityUserBanned },
-            { fn: onCommunityUserChanged, action: EnumCommunityMemberActions.OnCommunityUserChanged },
-            {
-                fn: onCommunityUserRoleRemoved,
-                action: EnumCommunityMemberActions.OnCommunityUserRoleRemoved,
-            },
-            { fn: onCommunityUserUnbanned, action: EnumCommunityMemberActions.OnCommunityUserUnbanned },
-        ]);
-    }
-    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(['communityUsers', 'get', id]))
-            .filter(isNonNullable)
-            .map(({ data }) => 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,
-        });
-    }
-    applyFilter(data) {
-        let communityMembers = filterByPropIntersection(data, 'roles', this.query.roles);
-        if (this.query.memberships) {
-            communityMembers = communityMembers.filter(({ communityMembership }) => {
-                const memberships = this.query.memberships || [];
-                return memberships.includes(communityMembership);
-            });
-        }
-        if (this.query.search) {
-            communityMembers = filterBySearchTerm(communityMembers, this.query.search);
+        if (this.query.includeDeleted === false) {
+            communityMembers = communityMembers.filter(({ user }) => (user === null || user === void 0 ? void 0 : user.isDeleted) !== true);
         }
         return communityMembers;
     }
@@ -35495,6 +36192,8 @@ var index$b = /*#__PURE__*/Object.freeze({
   onCommunityUserUnbanned: onCommunityUserUnbanned,
   onCommunityUserRoleAdded: onCommunityUserRoleAdded,
   onCommunityUserRoleRemoved: onCommunityUserRoleRemoved,
+  onLocalCommunityUserAdded: onLocalCommunityUserAdded,
+  onLocalCommunityUserRemoved: onLocalCommunityUserRemoved,
   onCommunityJoined: onCommunityJoined,
   onCommunityLeft: onCommunityLeft
 });
@@ -36151,9 +36850,10 @@ const addRoles = async (communityId, roleIds, userIds) => {
     const client = getActiveClient();
     client.log('community/moderation/addRoles', communityId, roleIds, userIds);
     const { data: payload } = await client.http.post(`/api/v4/communities/${communityId}/users/roles`, { communityId, roles: roleIds, userIds });
-    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const data = prepareCommunityMembershipPayload(payload);
     if (client.cache)
         ingestInCache(data);
+    fireEvent('local.community.roleAdded', data);
     const { communityUsers } = data;
     return !!communityUsers.find(communityUser => communityUser.communityId === communityId &&
         roleIds.some(role => communityUser.roles.includes(role)));
@@ -36183,9 +36883,10 @@ const removeRoles = async (communityId, roleIds, userIds) => {
     const client = getActiveClient();
     client.log('community/moderation/removeRoles', communityId, roleIds, userIds);
     const { data: payload } = await client.http.delete(`/api/v4/communities/${communityId}/users/roles`, { data: { communityId, roles: roleIds, userIds } });
-    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const data = prepareCommunityMembershipPayload(payload);
     if (client.cache)
         ingestInCache(data);
+    fireEvent('local.community.roleRemoved', data);
     const { communityUsers } = data;
     return !!communityUsers.find(communityUser => communityUser.communityId === communityId &&
         !roleIds.some(role => communityUser.roles.includes(role)));
@@ -36872,7 +37573,7 @@ const updatePost = async (postId, patch) => {
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    fireEvent('local.post.updated', data);
+    fireEvent('local.post.updated', payload);
     const { posts } = data;
     return {
         data: LinkedObject.post(posts.find(post => post.postId === postId)),
@@ -36972,7 +37673,15 @@ const deletePost = async (postId, permanent = false) => {
     }
     // to support hard deletion
     const deleted = Object.assign(Object.assign({}, post.data), { isDeleted: true });
-    fireEvent('post.deleted', {
+    if (permanent) {
+        setTimeout(() => {
+            pushToTombstone('post', postId);
+        }, 0);
+    }
+    else {
+        upsertInCache(['post', 'get', postId], { isDeleted: true });
+    }
+    fireEvent('local.post.deleted', {
         posts: [deleted],
         categories: [],
         comments: [],
@@ -36983,14 +37692,6 @@ const deletePost = async (postId, permanent = false) => {
         postChildren: [],
         users: [],
     });
-    if (permanent) {
-        setTimeout(() => {
-            pushToTombstone('post', postId);
-        }, 0);
-    }
-    else {
-        upsertInCache(['post', 'get', postId], { isDeleted: true });
-    }
     return LinkedObject.post(deleted);
 };
 
@@ -37378,6 +38079,7 @@ getCommentByIds.locally = (commentIds) => {
  * @async
  */
 const createComment = async (bundle) => {
+    var _a;
     const client = getActiveClient();
     client.log('comment/createComment', bundle);
     const { data } = await client.http.post('/api/v3/comments', bundle);
@@ -37389,18 +38091,21 @@ const createComment = async (bundle) => {
     if (client.cache)
         ingestInCache(data, { cachedAt });
     if (['post', 'content'].includes(bundle.referenceType)) {
-        const post = await getPost$2(bundle.referenceId);
-        fireEvent('local.post.updated', {
-            posts: [post.data],
-            categories: [],
-            comments: [],
-            communities: [],
-            communityUsers: [],
-            feeds: [],
-            files: [],
-            postChildren: [],
-            users: [],
-        });
+        const post = (_a = pullFromCache(['post', 'get', bundle.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+        if (post) {
+            post.commentsCount += 1;
+            fireEvent('local.post.updated', {
+                posts: [post],
+                categories: [],
+                comments: [],
+                communities: [],
+                communityUsers: data.communityUsers,
+                feeds: [],
+                files: data.files,
+                postChildren: [],
+                users: data.users,
+            });
+        }
     }
     else if (bundle.referenceType === 'story') {
         const storyIndex = pullFromCache([
@@ -37559,6 +38264,7 @@ getStoryByStoryId$1.locally = (storyId) => {
  * @async
  */
 const deleteComment = async (commentId, permanent = false) => {
+    var _a;
     const client = getActiveClient();
     const comment = await getComment$2(commentId);
     // API-FIX: This endpoint has not been implemented yet.
@@ -37583,18 +38289,28 @@ const deleteComment = async (commentId, permanent = false) => {
         });
     }
     else {
-        const post = await getPost$2(comment.data.referenceId);
-        fireEvent('local.post.updated', {
-            posts: [post.data],
-            categories: [],
-            comments: [],
-            communities: [],
-            communityUsers: [],
-            feeds: [],
-            files: [],
-            postChildren: [],
-            users: [],
-        });
+        const post = (_a = pullFromCache(['post', 'get', comment.data.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+        if (post) {
+            let removeCount;
+            if (!deleted.parentId) {
+                // NOTE: delete the parent comment will remove all children comments
+                removeCount = deleted.childrenNumber + 1;
+            }
+            else
+                removeCount = 1;
+            post.commentsCount -= removeCount;
+            fireEvent('local.post.updated', {
+                posts: [post],
+                categories: [],
+                comments: [],
+                communities: [],
+                communityUsers: [],
+                feeds: [],
+                files: [],
+                postChildren: [],
+                users: [],
+            });
+        }
     }
     fireEvent('local.comment.deleted', {
         comments: [deleted],
@@ -37860,6 +38576,81 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
     };
 };
 
+/**
+ * ```js
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk-react-native'
+ * const dispose = onCommentDeleteLocal(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
+
+/**
+ * ```js
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onLocalCommentReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
+        }
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
+        }
+    };
+    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onLocalCommentReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
+        }
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
+        }
+    };
+    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
+};
+
 /* begin_public_function
   id: comment.get
 */
@@ -37884,26 +38675,15 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
  */
 const getComment = (commentId, callback) => {
     return liveObject(commentId, callback, 'commentId', getComment$1, [
+        onCommentDeleteLocal,
         onCommentDeleted,
         onCommentFlagged,
         onCommentReactionAdded,
         onCommentReactionRemoved,
         onCommentUnflagged,
         onCommentUpdated,
-        (callback) => {
-            return onCommentCreated((comment) => {
-                if (comment.parentId !== commentId)
-                    return;
-                const cacheParent = pullFromCache([
-                    'comment',
-                    'get',
-                    comment.parentId,
-                ]);
-                if (!(cacheParent === null || cacheParent === void 0 ? void 0 : cacheParent.data))
-                    return;
-                callback(Object.assign(Object.assign({}, cacheParent.data), { childrenNumber: cacheParent.data.childrenNumber + 1, children: [...new Set([...cacheParent.data.children, comment.commentId])] }));
-            });
-        },
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
     ]);
 };
 /* end_public_function */
@@ -37987,16 +38767,24 @@ class CommentQueryStreamController extends QueryStreamController {
     }
 }
 
-function prepareCommentPayload(commentPayload) {
-    const { comments } = commentPayload;
-    return Object.assign(Object.assign({}, commentPayload), { comments: comments.map(comment => {
-            if (comment.hasOwnProperty('myReactions'))
-                return comment;
-            // Sometimes `myReactions` field will not come with BE response because that field is empty
-            // We need to put it with an empty array manually to make it show up in client side
-            return Object.assign({ myReactions: [] }, comment);
-        }) });
-}
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentCreatedLocal = (callback) => {
+    return createLocalCommentEventSubscriber('local.comment.created', callback);
+};
 
 class CommentLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
@@ -38027,6 +38815,8 @@ class CommentLiveCollectionController extends LiveCollectionController {
     }
     startSubscription() {
         return this.queryStreamController.subscribeRTE([
+            { fn: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
+            { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
             { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
             { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
             { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
@@ -38034,6 +38824,8 @@ class CommentLiveCollectionController extends LiveCollectionController {
             { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
             { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
             { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+            { fn: onLocalCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+            { fn: onLocalCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -38165,6 +38957,98 @@ var index$6 = /*#__PURE__*/Object.freeze({
   getComments: getComments
 });
 
+/**
+ * ```js
+ * import { onPostUpdatedLocal } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPostUpdatedLocal(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+
+/**
+ * ```js
+ * import { onLocalPostReactionAdded } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ post }) => {
+        if (!client.cache) {
+            callback(post);
+        }
+        else {
+            upsertInCache(['post', 'get', post.postId], post);
+            callback(post);
+        }
+    };
+    return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk-react-native'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ post }) => {
+        if (!client.cache) {
+            callback(post);
+        }
+        else {
+            upsertInCache(['post', 'get', post.postId], post);
+            callback(post);
+        }
+    };
+    return createEventSubscriber(client, 'local.post.removeReaction', 'local.post.removeReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalPostDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
+
 /* begin_public_function
   id: post.get
 */
@@ -38195,6 +39079,8 @@ const getPost$1 = (postId, callback) => {
     return liveObject(postId, responder, 'postId', getPost$2, [
         onPostApproved,
         onPostDeclined,
+        onLocalPostReactionAdded,
+        onLocalPostReactionRemoved,
         (callback) => {
             return onPostDeleted((post) => {
                 var _a;
@@ -38229,6 +39115,8 @@ const getPost$1 = (postId, callback) => {
         },
         onPostUnflagged,
         onPostUpdated,
+        onPostUpdatedLocal,
+        onLocalPostDeleted,
         convertEventPayload((callback) => {
             return onCommentCreated(async (comment) => {
                 if (comment.referenceId === postId) {
@@ -38350,17 +39238,6 @@ class PostQueryStreamController extends QueryStreamController {
     }
 }
 
-const preparePostPayload = (postPayload) => {
-    const { posts } = postPayload;
-    const { communities, communityUsers } = convertCommunityPayload({
-        communities: postPayload.communities,
-        communityUsers: postPayload.communityUsers,
-    });
-    return Object.assign(Object.assign({}, postPayload), { posts,
-        communities,
-        communityUsers });
-};
-
 const getPost = async (postId) => {
     const client = getActiveClient();
     client.log('post/getPost', postId);
@@ -38433,6 +39310,7 @@ class PostLiveCollectionController extends LiveCollectionController {
         return this.queryStreamController.subscribeRTE([
             { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
             { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+            { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
             { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
             { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
             { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
@@ -38440,6 +39318,9 @@ class PostLiveCollectionController extends LiveCollectionController {
             { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
             { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
             { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+            { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+            { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+            { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
             {
                 fn: convertEventPayload((callback) => {
                     return onCommentCreated(async (comment) => {
@@ -38557,6 +39438,138 @@ const getPosts = (params, callback, config) => {
 };
 /* end_public_function */
 
+class PinnedPostPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const params = __rest(queryParams, ["limit"]);
+        const { communityId, placement } = params;
+        const path = placement
+            ? `/api/v1/pinned-posts/communities/${communityId}/${placement}`
+            : `/api/v1/pinned-posts/communities/${communityId}`;
+        const { data: queryResponse } = await this.http.get(path);
+        return queryResponse;
+    }
+}
+
+class PinnedPostQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    async saveToMainDB(response) {
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(response, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.pins.map(getResolver('pin')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const pinnedPosts = (_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([...pinnedPosts, ...response.pins.map(getResolver('pin'))])] }));
+            this.notifyChange({
+                origin: "server" /* Amity.LiveDataOrigin.SERVER */,
+                loading: false,
+            });
+        }
+    }
+}
+
+class PinnedPostLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['pinnedPosts', 'collection', queryStreamId];
+        const paginationController = new PinnedPostPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new PinnedPostQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), response => response);
+        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);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    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;
+        let data = ((_b = collection.data
+            .map(id => pullFromCache(['pin', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.pinnedPost);
+        data = this.applyFilter(data);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            data,
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let pinnedPost = data;
+        switch (this.query.sortBy) {
+            case 'lastCreated':
+                pinnedPost = pinnedPost.sort(({ post: postA }, { post: postB }) => sortByLastCreated({ createdAt: postA === null || postA === void 0 ? void 0 : postA.createdAt }, { createdAt: postB === null || postB === void 0 ? void 0 : postB.createdAt }));
+                break;
+        }
+        return pinnedPost;
+    }
+}
+
+/**
+ * Get pinned posts for a community
+ *
+ * @param communityId the ID of the community
+ * @param placement the placement of the pinned post ('announcement' or 'default'), or null to fetch all pinned posts
+ * @returns the associated pinned post(s)
+ *
+ * @category Pined Posts Live Collection
+ *
+ */
+const getPinnedPosts = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getPinnedPosts(tmpid: ${timestamp}) > listen`);
+    const pinnedPostLiveCollection = new PinnedPostLiveCollectionController(params, callback);
+    const disposers = pinnedPostLiveCollection.startSubscription();
+    const cacheKey = pinnedPostLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getPinnedPosts(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
 var index$5 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getPostByIds: getPostByIds,
@@ -38583,7 +39596,8 @@ var index$5 = /*#__PURE__*/Object.freeze({
   observePosts: observePosts,
   observePost: observePost,
   getPost: getPost$1,
-  getPosts: getPosts
+  getPosts: getPosts,
+  getPinnedPosts: getPinnedPosts
 });
 
 /* begin_public_function