@amityco/ts-sdk 6.29.3-b60ec74.0 → 6.29.3-bd024fd.0

package/dist/index.esm.js

@@ -525,7 +525,7 @@ const idResolvers = {
     storyTarget: ({ targetId }) => targetId,
     ad: ({ adId }) => adId,
     advertiser: ({ advertiserId }) => advertiserId,
-    pin: ({ referenceId }) => referenceId,
+    pin: ({ placement, referenceId }) => `${placement}#${referenceId}`,
     pinTarget: ({ targetId }) => targetId,
 };
 /**
@@ -21482,6 +21482,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 = {
@@ -21512,7 +21586,7 @@ const commentLinkedObject = (comment) => {
             return undefined;
         },
         get childrenComment() {
-            return (comment.children
+            return comment.children
                 .map(childCommentId => {
                 const commentCache = pullFromCache([
                     'comment',
@@ -21523,46 +21597,18 @@ 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));
         } });
 };
 
-const pinPost = async ({ communityId, placement, postId, }) => {
-    const client = getActiveClient();
-    client.log('post/getPost', postId);
-    const { data } = await client.http.post(`/api/v1/pinned-posts/communities/${communityId}/${placement}/${postId}`);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data,
-        cachedAt,
-    };
-};
-
-const unpinPost = async ({ communityId, placement, postId, }) => {
-    const client = getActiveClient();
-    client.log('post/getPost', postId);
-    const { data } = await client.http.delete(`/api/v1/pinned-posts/communities/${communityId}/${placement}/${postId}`);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data,
-        cachedAt,
-    };
-};
-
 const postLinkedObject = (post) => {
     return Object.assign(Object.assign({}, post), { analytics: {
             markAsViewed: () => {
                 const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
                 analyticsEngineInstance.markPostAsViewed(post.postId);
             },
-        }, pin: (placement) => pinPost({ communityId: post.targetId, placement, postId: post.postId }), unpin: (placement) => unpinPost({ communityId: post.targetId, placement, postId: post.postId }), get latestComments() {
+        }, get latestComments() {
             if (!post.comments)
                 return [];
             return (post.comments
@@ -22382,13 +22428,7 @@ const getChannelIsMentioned = (channel, marker) => {
 };
 
 function convertRawUserToInternalUser(rawUser) {
-    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: rawUser.isGlobalBan });
-}
-function prepareUserPayload(response) {
-    return {
-        users: response.users.map(convertRawUserToInternalUser),
-        files: response.files,
-    };
+    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'];
@@ -23876,6 +23916,13 @@ 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 = (data) => {
@@ -23903,7 +23950,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();
@@ -25165,7 +25212,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());
@@ -25717,76 +25764,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
  */
@@ -26023,6 +26000,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
 */
@@ -26051,7 +26041,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 */
@@ -26084,170 +26075,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'
- * const { data: users, prevPage, nextPage, total } = await UserRepository.queryBlockedUsers({ page: Amity.PageRaw, limit: number })
+ * import { onUserUpdated } from '@amityco/ts-sdk'
+ * 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 payload = prepareUserPayload(data);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(payload, { cachedAt });
-        const cacheKey = ['blockedUsers', 'query', params];
-        pushToCache(cacheKey, { users: payload.users.map(getResolver('user')), paging: data.paging });
-    }
-    const { next, previous, total } = data.paging;
-    const nextPage = toPageRaw(next);
-    const prevPage = toPageRaw(previous);
-    return { data: payload.users, prevPage, nextPage, total, cachedAt };
-};
+const onUserUpdated = (callback) => createUserEventSubscriber('user.updated', callback);
+
 /**
  * ```js
- * import { queryBlockedUsers } from '@amityco/ts-sdk'
- * const { data: users } = queryBlockedUsers.locally({ page: 'page_token' })
+ * import { onUserFlagged } from '@amityco/ts-sdk'
+ * 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 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 onUserFlagged = (callback) => createUserEventSubscriber('user.flagged', callback);
 
-/* eslint-disable no-use-before-define */
-/* begin_public_function
-  id: user.get_blocked_users
-*/
 /**
  * ```js
- * import { UserRepository } from '@amityco/ts-sdk'
- * const unblockedUser = await UserRepository.blockUser('userId')
+ * import { onUserUnflagged } from '@amityco/ts-sdk'
+ * const dispose = onUserUnflagged(user => {
+ *   // ...
+ * })
  * ```
  *
- * Blocks a {@link Amity.InternalUser}
+ * Fired when a flag has been removed from 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 onUserUnflagged = (callback) => createUserEventSubscriber('user.unflagged', callback);
+
+/**
+ * ```js
+ * import { onUserFlagCleared } from '@amityco/ts-sdk'
+ * 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);
+
+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'
+ * 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);
     };
@@ -26257,7 +26475,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
@@ -26285,7 +26503,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,
@@ -26317,7 +26541,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 */
@@ -26346,7 +26571,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;
 };
 
@@ -26374,7 +26600,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 */
@@ -26403,7 +26630,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;
 };
 
@@ -26431,29 +26659,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]);
         }
     };
@@ -26672,12 +26906,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'
@@ -26750,7 +26999,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());
@@ -26786,92 +27035,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'
- * 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'
- * 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
@@ -26897,69 +27244,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());
@@ -26967,35 +27259,173 @@ const getFollowers = (params, callback, config) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { queryFollowings } from '@amityco/ts-sdk'
- * 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'
- * 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
@@ -27025,65 +27455,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());
@@ -27171,6 +27546,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,
@@ -27361,74 +27741,6 @@ const isUserFlaggedByMe = async (userId) => {
 };
 /* end_public_function */
 
-/**
- * ```js
- * import { onUserUpdated } from '@amityco/ts-sdk'
- * 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'
- * 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'
- * 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'
- * 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'
@@ -27539,7 +27851,7 @@ const getUser$1 = (userId, callback) => {
     return liveObject(userId, reactor, 'userId', getUser$2, [
         onUserFetched,
         onUserUpdated,
-        onUserDeleted,
+        onUserDeleted$2,
         onUserFlagged,
         onUserUnflagged,
         onUserFlagCleared,
@@ -27547,51 +27859,6 @@ const getUser$1 = (userId, callback) => {
 };
 /* 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 UserPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
         const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, displayName } = queryParams, params = __rest(queryParams, ["limit", "displayName"]);
@@ -27603,13 +27870,6 @@ class UserPaginationController extends PaginationController {
     }
 }
 
-class QueryStreamController {
-    constructor(query, cacheKey) {
-        this.query = query;
-        this.cacheKey = cacheKey;
-    }
-}
-
 class UserQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -27656,122 +27916,6 @@ class UserQueryStreamController extends QueryStreamController {
     }
 }
 
-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;
-    }
-}
-
-var EnumUserActions;
-(function (EnumUserActions) {
-    EnumUserActions["OnUserDeleted"] = "onUserDeleted";
-    EnumUserActions["OnUserUpdated"] = "onUserUpdated";
-    EnumUserActions["OnUserFlagged"] = "onUserFlagged";
-    EnumUserActions["OnUserUnflagged"] = "onUserUnflagged";
-    EnumUserActions["OnUserFlagCleared"] = "onUserFlagCleared";
-})(EnumUserActions || (EnumUserActions = {}));
-
-function isNonNullable(value) {
-    return value != null;
-}
-
 class UserLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         const queryStreamId = hash(query);
@@ -27801,7 +27945,7 @@ class UserLiveCollectionController extends LiveCollectionController {
     }
     startSubscription() {
         return this.queryStreamController.subscribeRTE([
-            { fn: onUserDeleted, action: EnumUserActions.OnUserDeleted },
+            { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
             { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
             { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
             { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
@@ -27833,11 +27977,11 @@ class UserLiveCollectionController extends LiveCollectionController {
         if (!this.query.displayName) {
             const sortFn = (() => {
                 switch (this.query.sortBy) {
-                    case Amity.UserSortByEnum.FirstCreated:
+                    case 'firstCreated':
                         return sortByFirstCreated;
-                    case Amity.UserSortByEnum.LastCreated:
+                    case 'lastCreated':
                         return sortByLastCreated;
-                    case Amity.UserSortByEnum.DisplayName:
+                    case 'displayName':
                         return sortByDisplayName;
                     default:
                         return sortByLastCreated;
@@ -27968,7 +28112,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`);
@@ -28063,7 +28207,7 @@ class SearchUserLiveCollectionController extends LiveCollectionController {
     }
     startSubscription() {
         return this.queryStreamController.subscribeRTE([
-            { fn: onUserDeleted, action: EnumUserActions.OnUserDeleted },
+            { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
             { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
             { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
             { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
@@ -28304,7 +28448,7 @@ var index$j = /*#__PURE__*/Object.freeze({
   unflagUser: unflagUser,
   isUserFlaggedByMe: isUserFlaggedByMe,
   onUserUpdated: onUserUpdated,
-  onUserDeleted: onUserDeleted,
+  onUserDeleted: onUserDeleted$2,
   onUserFlagged: onUserFlagged,
   onUserUnflagged: onUserUnflagged,
   onUserFlagCleared: onUserFlagCleared,
@@ -29211,6 +29355,7 @@ const prepareCommentFromFlaggedEvent = (payload) => {
  * @async
  * */
 const addReaction = async (referenceType, referenceId, reactionName) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('reaction/createReaction', {
         referenceId,
@@ -29229,8 +29374,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;
 };
@@ -29295,6 +29453,7 @@ addReaction.optimistically = (referenceType, referenceId, reactionName) => {
  * @async
  * */
 const removeReaction = async (referenceType, referenceId, reactionName) => {
+    var _a, _b;
     const client = getActiveClient();
     client.log('reaction/removeReaction', {
         referenceId,
@@ -29315,8 +29474,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;
 };
@@ -29361,6 +29533,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) => {
@@ -29369,8 +29601,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', {
@@ -29397,7 +29629,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]);
             }
@@ -29414,6 +29646,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);
 };
 
 /**
@@ -29620,6 +29878,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',
@@ -29641,6 +29902,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);
 };
 
 /**
@@ -30200,51 +30513,6 @@ var index$h = /*#__PURE__*/Object.freeze({
   getReactions: getReactions
 });
 
-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 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) => {
-    const { posts } = 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);
-    return Object.assign(Object.assign({}, postPayload), { posts, communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
-};
-
 function prepareCommentPayload(commentPayload) {
     const { comments } = commentPayload;
     return Object.assign(Object.assign({}, commentPayload), { comments: comments.map(comment => {
@@ -33836,10 +34104,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;
     }
@@ -33905,6 +34175,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) {
@@ -33943,6 +34240,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 }) {
@@ -33989,8 +34287,8 @@ 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 (typeof this.query.includeDeleted === 'boolean') {
-            channelMembers = channelMembers.filter(member => { var _a; return ((_a = member.user) === null || _a === void 0 ? void 0 : _a.isDeleted) === this.query.includeDeleted; });
+        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';
@@ -34808,7 +35106,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') {
@@ -34856,6 +35154,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);
 };
 
 /**
@@ -34977,6 +35312,40 @@ const onCommunityUserRoleAdded = (callback) => createCommunityMemberEventSubscri
  */
 const onCommunityUserRoleRemoved = (callback) => createCommunityMemberEventSubscriber('community.roleRemoved', callback);
 
+/**
+ * ```js
+ * import { onLocalCommunityUserAdded } from '@amityco/ts-sdk'
+ * 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'
+ * 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'
@@ -35129,6 +35498,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
@@ -35153,7 +35525,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);
@@ -35184,7 +35556,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);
@@ -35199,10 +35571,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;
     }
@@ -35271,6 +35645,96 @@ class CommunityMembersQueryStreamController extends QueryStreamController {
     }
 }
 
+/**
+ * ```js
+ * import { onLocalCommunityRoleRemoved } from '@amityco/ts-sdk'
+ * 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'
+ * 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);
@@ -35309,7 +35773,24 @@ 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 }) {
@@ -35342,8 +35823,8 @@ class CommunityMembersLiveCollectionController extends LiveCollectionController
         if (this.query.search) {
             communityMembers = filterBySearchTerm(communityMembers, this.query.search);
         }
-        if (typeof this.query.includeDeleted === 'boolean') {
-            communityMembers = communityMembers.filter(({ user }) => (user === null || user === void 0 ? void 0 : user.isDeleted) === this.query.includeDeleted);
+        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':
@@ -35435,10 +35916,12 @@ const getMembers = (params, callback, config) => {
  */
 class SearchCommunityMembersPaginationController 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;
     }
@@ -35545,11 +36028,19 @@ class SearchCommunityMembersLiveCollectionController extends LiveCollectionContr
             { 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 }) {
@@ -35582,8 +36073,8 @@ class SearchCommunityMembersLiveCollectionController extends LiveCollectionContr
         if (this.query.search) {
             communityMembers = filterBySearchTerm(communityMembers, this.query.search);
         }
-        if (typeof this.query.includeDeleted === 'boolean') {
-            communityMembers = communityMembers.filter(({ user }) => (user === null || user === void 0 ? void 0 : user.isDeleted) === this.query.includeDeleted);
+        if (this.query.includeDeleted === false) {
+            communityMembers = communityMembers.filter(({ user }) => (user === null || user === void 0 ? void 0 : user.isDeleted) !== true);
         }
         return communityMembers;
     }
@@ -35646,6 +36137,8 @@ var index$b = /*#__PURE__*/Object.freeze({
   onCommunityUserUnbanned: onCommunityUserUnbanned,
   onCommunityUserRoleAdded: onCommunityUserRoleAdded,
   onCommunityUserRoleRemoved: onCommunityUserRoleRemoved,
+  onLocalCommunityUserAdded: onLocalCommunityUserAdded,
+  onLocalCommunityUserRemoved: onLocalCommunityUserRemoved,
   onCommunityJoined: onCommunityJoined,
   onCommunityLeft: onCommunityLeft
 });
@@ -35909,11 +36402,11 @@ class CommunityLiveCollectionController extends LiveCollectionController {
         if (!this.query.displayName) {
             const sortFn = (() => {
                 switch (this.query.sortBy) {
-                    case "firstCreated" /* Amity.CommunitySortByEnum.FirstCreated */:
+                    case 'firstCreated':
                         return sortByFirstCreated;
-                    case "lastCreated" /* Amity.CommunitySortByEnum.LastCreated */:
+                    case 'lastCreated':
                         return sortByLastCreated;
-                    case "displayName" /* Amity.CommunitySortByEnum.DisplayName */:
+                    case 'displayName':
                         return sortByDisplayName;
                     default:
                         return sortByLastCreated;
@@ -36302,9 +36795,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)));
@@ -36334,9 +36828,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)));
@@ -37023,7 +37518,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)),
@@ -37123,7 +37618,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: [],
@@ -37134,14 +37637,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);
 };
 
@@ -37529,6 +38024,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);
@@ -37540,18 +38036,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([
@@ -37710,6 +38209,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.
@@ -37734,18 +38234,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],
@@ -38011,6 +38521,81 @@ const observeComment = (commentId, callback, policy = 'cache_then_server') => {
     };
 };
 
+/**
+ * ```js
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
+ * 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'
+ * 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'
+ * 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
 */
@@ -38035,26 +38620,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 */
@@ -38138,6 +38712,25 @@ class CommentQueryStreamController extends QueryStreamController {
     }
 }
 
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * 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) {
         const queryStreamId = hash(query);
@@ -38167,6 +38760,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 },
@@ -38174,6 +38769,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 }) {
@@ -38305,6 +38902,98 @@ var index$6 = /*#__PURE__*/Object.freeze({
   getComments: getComments
 });
 
+/**
+ * ```js
+ * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
+ * 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'
+ * 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'
+ * 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'
+ * 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
 */
@@ -38335,6 +39024,8 @@ const getPost$1 = (postId, callback) => {
     return liveObject(postId, responder, 'postId', getPost$2, [
         onPostApproved,
         onPostDeclined,
+        onLocalPostReactionAdded,
+        onLocalPostReactionRemoved,
         (callback) => {
             return onPostDeleted((post) => {
                 var _a;
@@ -38369,6 +39060,8 @@ const getPost$1 = (postId, callback) => {
         },
         onPostUnflagged,
         onPostUpdated,
+        onPostUpdatedLocal,
+        onLocalPostDeleted,
         convertEventPayload((callback) => {
             return onCommentCreated(async (comment) => {
                 if (comment.referenceId === postId) {
@@ -38562,6 +39255,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 },
@@ -38569,6 +39263,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) => {