@amityco/ts-sdk 7.7.1-1cf499d.0 → 7.7.1-68d81647.0

package/dist/index.cjs.js

@@ -658,7 +658,8 @@ const PAYLOAD2MODEL = {
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
-    if ('updatedAt' in nextData && 'updatedAt' in nextData) {
+    // Check if the new value is outdated.
+    if ('updatedAt' in nextData && 'updatedAt' in prevData) {
         return new Date(nextData.updatedAt) < new Date(prevData.updatedAt);
     }
     return false;
@@ -11855,15 +11856,18 @@ function isAmityClipPost(post) {
 }
 
 const postLinkedObject = (post) => {
-    return Object.assign(Object.assign({}, post), { childrenPosts: post.children
+    return shallowClone(post, {
+        childrenPosts: post.children
             .map(childPost => { var _a; return (_a = pullFromCache(['post', 'get', childPost])) === null || _a === void 0 ? void 0 : _a.data; })
             .filter(isNonNullable)
-            .map(postLinkedObject), analytics: {
+            .map(postLinkedObject),
+        analytics: {
             markAsViewed: () => {
                 const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
                 analyticsEngineInstance.markPostAsViewed(post.postId);
             },
-        }, get latestComments() {
+        },
+        get latestComments() {
             if (!post.comments)
                 return [];
             return (post.comments
@@ -11937,7 +11941,8 @@ const postLinkedObject = (post) => {
             return isAmityClipPost(post)
                 ? (_b = pullFromCache(['file', 'get', (_a = post === null || post === void 0 ? void 0 : post.data) === null || _a === void 0 ? void 0 : _a.fileId])) === null || _b === void 0 ? void 0 : _b.data
                 : undefined;
-        } });
+        },
+    });
 };
 
 const getCachedMarker = (message) => {
@@ -14932,7 +14937,7 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         ]);
         if (!model || ((_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)))
             return true;
-        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }) });
+        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }), updatedAt: new Date().toISOString() });
         if (referenceType === 'comment') {
             fireEvent('local.comment.addReaction', {
                 comment: updatedModel,
@@ -15055,7 +15060,7 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
         ]);
         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) }) });
+        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) }), updatedAt: new Date().toISOString() });
         if (referenceType === 'comment') {
             fireEvent('local.comment.removeReaction', {
                 comment: updatedModel,
@@ -15169,6 +15174,26 @@ const prepareSemanticSearchPostPayload = (_a) => {
     return Object.assign(Object.assign({}, processedPostPayload), { polls });
 };
 
+const processDeleteChildPost = (payload) => {
+    var _a;
+    const post = payload.posts[0];
+    if (!post.parentId)
+        return;
+    const parentPost = (_a = pullFromCache(['post', 'get', post.parentPostId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!parentPost)
+        return;
+    pushToCache(['post', 'get', parentPost.postId], Object.assign(Object.assign({}, parentPost), { children: parentPost.children.filter(childId => childId !== post.postId) }));
+};
+const processCreateChildPost = (payload) => {
+    var _a;
+    const post = payload.posts[0];
+    if (!post.parentId)
+        return;
+    const parentPost = (_a = pullFromCache(['post', 'get', post.parentPostId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!parentPost)
+        return;
+    pushToCache(['post', 'get', parentPost.postId], Object.assign(Object.assign({}, parentPost), { children: [...new Set([post.postId, ...parentPost.children])] }));
+};
 const createPostEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
@@ -15193,6 +15218,7 @@ const createPostEventSubscriber = (event, callback) => {
             }
             if (event === 'post.deleted') {
                 const { postId, postedUserId } = payload.posts[0];
+                processDeleteChildPost(payload);
                 try {
                     isInTombstone('post', postId);
                 }
@@ -15219,6 +15245,8 @@ const createPostEventSubscriber = (event, callback) => {
                 }
                 queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
             }
+            if (event === 'post.created')
+                processCreateChildPost(payload);
             callback(post.data);
         }
     };
@@ -15245,6 +15273,8 @@ const createLocalPostEventSubscriber = (event, callback) => {
                 });
             }
             const post = pullFromCache(['post', 'get', payload.posts[0].postId]);
+            if (event === 'local.post.deleted')
+                processDeleteChildPost(payload);
             callback(post.data);
         }
     };
@@ -23023,6 +23053,9 @@ var index$b = /*#__PURE__*/Object.freeze({
   id: feed.query.global_feed
 */
 /**
+ *
+ * @deprecated This function will to be deprecated. Please use getGlobalFeed instead.
+ *
  * ```js
  * import { queryGlobalFeed } from '@amityco/ts-sdk'
  * const posts = await queryGlobalFeed()
@@ -23105,1564 +23138,1914 @@ queryGlobalFeed.locally = (query) => {
         : undefined;
 };
 
-/* begin_public_function
-  id: feed.query.custom_ranking_feed
-*/
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-const getCustomRankingGlobalFeed = async (query) => {
-    const client = getActiveClient();
-    client.log('feed/getCustomRankingGlobalFeed', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { queryToken, limit } = _a, params = __rest(_a, ["queryToken", "limit"]);
-    const options = (() => {
-        if (queryToken)
-            return { token: queryToken };
-        return undefined;
-    })();
-    const { data: queryPayload } = await client.http.get(`/api/v5/me/global-feeds`, {
-        params: Object.assign(Object.assign({}, params), { limit: !queryToken ? limit : undefined, options }),
-    });
-    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const { posts } = data;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(data);
-        const cacheKey = ['customGlobalFeed', 'query', Object.assign(Object.assign({}, params), { options })];
-        pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
+class CustomRankingGlobalFeedPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v5/me/global-feeds`, {
+            params: Object.assign(Object.assign({}, params), { options }),
+        });
+        return queryResponse;
     }
-    return { data: posts.map(LinkedObject.post), cachedAt, paging };
-};
-/* end_public_function */
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed.locally()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects from cache
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-getCustomRankingGlobalFeed.locally = (query) => {
-    var _a, _b;
-    const client = getActiveClient();
-    client.log('post/getCustomRankingGlobalFeed.locally', query);
-    if (!client.cache)
-        return;
-    const params = __rest(query !== null && query !== void 0 ? query : {}, []);
-    const queryKey = ['customGlobalFeed', 'query', Object.assign({}, params)];
-    const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
-    if (!(data === null || data === void 0 ? void 0 : data.posts.length))
-        return;
-    const posts = data.posts
-        .map(postId => pullFromCache(['post', 'get', postId]))
-        .filter(Boolean)
-        .map(({ data }) => data);
-    const { paging } = data;
-    return posts.length === ((_b = data === null || data === void 0 ? void 0 : data.posts) === null || _b === void 0 ? void 0 : _b.length)
-        ? { data: posts.map(LinkedObject.post), cachedAt, paging }
-        : undefined;
-};
+}
 
-var index$a = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    queryGlobalFeed: queryGlobalFeed,
-    getCustomRankingGlobalFeed: getCustomRankingGlobalFeed
-});
+var EnumPostActions;
+(function (EnumPostActions) {
+    EnumPostActions["OnPostCreated"] = "onPostCreated";
+    EnumPostActions["OnPostUpdated"] = "onPostUpdated";
+    EnumPostActions["OnPostDeleted"] = "onPostDeleted";
+    EnumPostActions["OnPostFlagged"] = "onPostFlagged";
+    EnumPostActions["OnPostUnflagged"] = "onPostUnflagged";
+    EnumPostActions["OnPostReactionAdded"] = "onPostReactionAdded";
+    EnumPostActions["OnPostReactionRemoved"] = "onPostReactionRemoved";
+    EnumPostActions["OnPostApproved"] = "onPostApproved";
+    EnumPostActions["OnPostDeclined"] = "onPostDeclined";
+})(EnumPostActions || (EnumPostActions = {}));
+
+class CustomRankingGlobalFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && !collection.data.includes(post.parentPostId))
+                return;
+            // Delete Action
+            if (action === EnumPostActions.OnPostDeleted) {
+                // Parent Post - Remove from collection
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                // If the query has dataTypes array with value, check if post.dataType is include in the array
+                if (this.query.dataTypes && this.query.dataTypes.length > 0) {
+                    if (!this.query.dataTypes.includes(post.dataType))
+                        return;
+                }
+                collection.data = [...new Set([post.postId, ...collection.data])];
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
 
 /* begin_public_function
-  id: post.get_by_ids
+  id: comment.get_by_ids
 */
 /**
  * ```js
- * import { getPostByIds } from '@amityco/ts-sdk'
- * const { data: posts } = await getPostByIds(['foo', 'bar'])
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
  * ```
  *
- * Fetches a collection of {@link Amity.Post} objects
+ * Fetches a collection of {@link Amity.Comment} objects
  *
- * @param postIds the IDs of the {@link Amity.Post} to fetch
- * @returns the associated collection of {@link Amity.Post} objects
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const getPostByIds = async (postIds) => {
+const getCommentByIds = async (commentIds) => {
     const client = getActiveClient();
-    client.log('post/getPostByIds', postIds);
-    const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
-    let payload;
+    client.log('comment/getCommentByIds', commentIds);
+    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
+    let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/posts/list`, {
-            params: { postIds: encodedPostIds },
+        const response = await client.http.get(`/api/v3/comments/list`, {
+            params: { commentIds: encodedCommentIds },
         });
-        payload = response.data;
+        data = response.data;
     }
     catch (error) {
-        postIds.forEach(postId => {
+        commentIds.forEach(commentId => {
             if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                pushToTombstone('post', postId);
+                pushToTombstone('comment', commentId);
             }
         });
         throw error;
     }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
     return {
-        data: data.posts.map(LinkedObject.post),
+        data: data.comments.map(comment => LinkedObject.comment(comment)),
         cachedAt,
     };
 };
 /* end_public_function */
 /**
  * ```js
- * import { getPostByIds } from '@amityco/ts-sdk'
- * const { data: posts } = getPostByIds.locally(['foo', 'bar'])
+ * import { getCommentByIds } from '@amityco/ts-sdk'
+ * const comments = getCommentByIds.locally(['foo', 'bar'])
  * ```
  *
- * Fetches a collection of {@link Amity.Post} objects from cache
+ * Fetches a collection of {@link Amity.Comment} objects from cache
  *
- * @param postIds the IDs of the {@link Amity.Post} to fetch
- * @returns the associated collection of {@link Amity.Post} objects
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
  *
- * @category Post API
+ * @category Comment API
  */
-getPostByIds.locally = (postIds) => {
+getCommentByIds.locally = (commentIds) => {
     var _a;
     const client = getActiveClient();
-    client.log('post/getPostByIds.locally', postIds);
+    client.log('comment/getCommentByIds.locally', commentIds);
     if (!client.cache)
         return;
-    const cached = postIds
-        .map(postId => pullFromCache(['post', 'get', postId]))
+    const cached = commentIds
+        .map(commentId => pullFromCache(['comment', 'get', commentId]))
         .filter(Boolean);
-    const posts = cached.map(({ data }) => data);
+    const comments = cached.map(({ data }) => data);
     const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
-    if ((cached === null || cached === void 0 ? void 0 : cached.length) < postIds.length)
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) < commentIds.length)
         return;
     return {
-        data: posts.map(LinkedObject.post),
+        data: comments.map(comment => LinkedObject.comment(comment)),
         cachedAt: oldest.cachedAt,
     };
 };
 
 /* begin_public_function
-  id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
+  id: comment.create
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const created = await PostRepository.createPost({
- *   targetType: 'user',
- *   targetId: 'foobar',
- *   data: { text: 'hello world' }
- * }))
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const newComment = await CommentRepository.createComment(bundle)
  * ```
  *
- * Creates an {@link Amity.Post}
+ * Creates an {@link Amity.Comment}
  *
- * @param bundle The data necessary to create a new {@link Amity.Post}
- * @returns The newly created {@link Amity.Post}
+ * @param bundle The data necessary to create a new {@link Amity.Comment}
+ * @returns The newly created {@link Amity.Comment}
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const createPost = async (bundle) => {
+const createComment = async (bundle) => {
+    var _a;
     const client = getActiveClient();
-    client.log('post/createPost', bundle);
-    if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
-        // eslint-disable-next-line no-param-reassign
-        delete bundle.dataType;
-    }
-    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
-    fireEvent('post.created', payload);
-    const data = preparePostPayload(payload);
+    client.log('comment/createComment', bundle);
+    const { data } = await client.http.post('/api/v3/comments', bundle);
+    const { comments } = data;
+    // BE always returns an array of comments If it got record 0 from BE it might have a problem on creation logic
+    if (comments.length === 0)
+        throw new Error('Comment not created');
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    const { posts } = data;
-    return {
-        data: LinkedObject.post(posts[0]),
-        cachedAt,
-    };
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: post.edit, post.edit.custom_post
+    if (['post', 'content'].includes(bundle.referenceType)) {
+        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,
+                videoStreamings: [],
+            });
+        }
+    }
+    else if (bundle.referenceType === 'story') {
+        const storyIndex = pullFromCache([
+            "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
+            bundle.referenceId,
+        ]);
+        if (storyIndex === null || storyIndex === void 0 ? void 0 : storyIndex.data) {
+            const cacheStory = pullFromCache([
+                "story" /* STORY_KEY_CACHE.STORY */,
+                'get',
+                storyIndex.data,
+            ]);
+            if (cacheStory === null || cacheStory === void 0 ? void 0 : cacheStory.data) {
+                fireEvent('story.updated', {
+                    stories: [
+                        Object.assign(Object.assign({}, cacheStory.data), { commentsCount: cacheStory.data.commentsCount + 1, comments: [...new Set([...cacheStory.data.comments, comments[0].commentId])] }),
+                    ],
+                    categories: [],
+                    comments,
+                    communities: [],
+                    communityUsers: data.communityUsers,
+                    files: data.files,
+                    users: data.users,
+                });
+            }
+        }
+    }
+    fireEvent('local.comment.created', data);
+    return {
+        data: LinkedObject.comment(comments[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: comment.update_comment
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const updated = await PostRepository.editPost(postId, {
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const updated = await CommentRepository.updateComment(commentId, {
  *   data: { text: 'hello world' }
  * })
  * ```
  *
- * Updates an {@link Amity.Post}
+ * Updates an {@link Amity.Comment}
  *
- * @param postId The ID of the {@link Amity.Post} to edit
+ * @param commentId The ID of the {@link Amity.Comment} to edit
  * @param patch The patch data to apply
- * @returns the updated {@link Amity.Post} object
+ * @returns the updated {@link Amity.Comment} object
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const editPost = async (postId, patch) => {
+const updateComment = async (commentId, patch) => {
     const client = getActiveClient();
-    client.log('user/editPost', patch);
-    const { data: payload } = await client.http.put(`/api/v4/posts/${encodeURIComponent(postId)}`, patch);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
+    client.log('user/updateComment', patch);
+    const { data } = await client.http.put(`/api/v3/comments/${encodeURIComponent(commentId)}`, patch);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    fireEvent('local.post.updated', data);
-    const { posts } = data;
+    fireEvent('comment.updated', data);
+    const { comments } = data;
     return {
-        data: LinkedObject.post(posts.find(post => post.postId === postId)),
+        data: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)),
         cachedAt,
     };
 };
 /* end_public_function */
 
+// Due to we have optimistic logic, we will use referenceId as a id in SDK instead of storyId
+const applyMissingField = (rawData, isCreated = false) => {
+    const { storyId, referenceId } = rawData;
+    if (!isCreated) {
+        if (referenceId)
+            return Object.assign(Object.assign({}, rawData), { syncState: "synced" /* Amity.SyncState.Synced */ });
+    }
+    return Object.assign(Object.assign({}, rawData), { syncState: "synced" /* Amity.SyncState.Synced */, referenceId: storyId });
+};
+const convertRawStoryToInternal = (data, isCreated = false) => {
+    const { stories } = data;
+    const storiesData = stories.map(story => applyMissingField(story, isCreated));
+    return Object.assign(Object.assign({}, data), { stories: storiesData });
+};
+
+const getStoryByStoryId$1 = async (storyId) => {
+    const client = getActiveClient();
+    client.log('story/getStoryByStoryId', storyId);
+    // Get story referenceId from cache
+    const cacheReferenceId = pullFromCache([
+        "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
+        storyId,
+    ]);
+    if (cacheReferenceId === null || cacheReferenceId === void 0 ? void 0 : cacheReferenceId.data) {
+        const { data: referenceId } = cacheReferenceId;
+        isInTombstone('story', referenceId);
+    }
+    let data;
+    try {
+        const response = await client.http.get(`/api/v4/stories/${storyId}`);
+        data = convertRawStoryToInternal(response.data);
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('story', storyId);
+        }
+        throw error;
+    }
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+        ingestInCache(data, { cachedAt });
+    }
+    return {
+        data: data.stories[0],
+        cachedAt,
+    };
+};
+getStoryByStoryId$1.locally = (storyId) => {
+    const client = getActiveClient();
+    client.log('story/getStorybyStoryId', storyId);
+    // Get story referenceId from cache
+    const cacheReferenceId = pullFromCache([
+        "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
+        storyId,
+    ]);
+    if (cacheReferenceId === null || cacheReferenceId === void 0 ? void 0 : cacheReferenceId.data) {
+        const { data: referenceId } = cacheReferenceId;
+        isInTombstone('story', referenceId);
+    }
+    const cachedAt = client.cache && Date.now();
+    const storyCache = pullFromCache(['story', 'get', storyId]);
+    if (!storyCache)
+        return;
+    return {
+        data: storyCache.data,
+        cachedAt,
+    };
+};
+
+/* begin_public_function
+  id: comment.soft_delete, comment.hard_delete
+*/
 /**
  * ```js
- * import { deletePost } from '@amityco/ts-sdk'
- * const success = await deletePost('foobar')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.deleteComment('foobar')
  * ```
  *
- * Deletes a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to delete
- * @return A success boolean if the {@link Amity.Post} was deleted
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @private
+ * @category Comment API
  * @async
  */
-const deletePost = async (postId, permanent = false) => {
+const deleteComment = async (commentId, permanent = false) => {
     var _a;
     const client = getActiveClient();
-    const post = await getPost$2(postId);
-    await client.http.delete(`/api/v4/posts/${encodeURIComponent(postId)}`, {
+    const comment = await getComment$2(commentId);
+    // API-FIX: This endpoint has not been implemented yet.
+    await client.http.delete(`/api/v4/comments/${encodeURIComponent(commentId)}`, {
         params: {
-            postId,
+            commentId,
             permanent,
         },
     });
-    // there is currently a limitation which doesn't allow us to fire event to tell that community
-    // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
-    // and so we cannot refetch the community or advertise on events. hopefully this should be solved
-    // later when realtime events covers that for us.
-    if (post.data.targetType === 'community') {
-        const community = await getCommunity$1(post.data.targetId);
-        const communityUsersCache = (_a = queryCache(['communityUsers', 'get'])) !== null && _a !== void 0 ? _a : [];
-        const communityUsers = communityUsersCache
-            .filter(({ key }) => {
-            // cache key is ['communityUsers', 'get', `${communityId}#`${userId}`}]
-            if (key[0] !== 'communityUsers')
-                return false;
-            if (key[1] !== 'get')
-                return false;
-            if (typeof key[2] === 'string')
-                return key[2].includes(community.data.communityId);
-            return false;
-        })
-            .map(({ data }) => data);
-        fireEvent('community.updated', {
-            communities: [community.data],
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, comment.data), { isDeleted: true });
+    if (permanent) {
+        scheduleTask(() => pushToTombstone('comment', commentId));
+    }
+    else {
+        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
+    }
+    if (comment.data.referenceType === 'story') {
+        const story = await getStoryByStoryId$1(comment.data.referenceId);
+        fireEvent('local.story.updated', {
+            stories: [story.data],
             categories: [],
-            communityUsers,
-            feeds: [],
+            comments: [],
+            communities: [],
+            communityUsers: [],
             files: [],
             users: [],
         });
     }
-    // to support hard deletion
-    const deleted = Object.assign(Object.assign({}, post.data), { isDeleted: true });
-    if (permanent) {
-        setTimeout(() => {
-            pushToTombstone('post', postId);
-        }, 0);
-    }
     else {
-        upsertInCache(['post', 'get', postId], { isDeleted: true });
+        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: [],
+                videoStreamings: [],
+            });
+        }
     }
-    fireEvent('local.post.deleted', {
-        posts: [deleted],
-        categories: [],
-        comments: [],
-        communities: [],
-        communityUsers: [],
-        feeds: [],
+    fireEvent('local.comment.deleted', {
+        comments: [deleted],
+        commentChildren: [],
         files: [],
-        postChildren: [],
         users: [],
-        videoStreamings: [],
+        communityUsers: [],
     });
-    return LinkedObject.post(deleted);
-};
-
-/* begin_public_function
-  id: post.soft_delete
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const success = await PostRepository.softDeletePost('foobar')
- * ```
- *
- * Soft deletes a {@link Amity.Post}
- *
- * @param postId The {@link Amity.Post} ID to soft delete
- * @return A success boolean if the {@link Amity.Post} was deleted
- *
- * @category Post API
- * @async
- */
-const softDeletePost = async (postId) => {
-    const client = getActiveClient();
-    client.log('post/softDeletePost', postId);
-    const softDeleted = await deletePost(postId, false);
-    return LinkedObject.post(softDeleted);
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: post.hard_delete
-*/
-/**
- * ```js
- * import { hardDeletePost } from '@amityco/ts-sdk'
- * const success = await hardDeletePost('foobar')
- * ```
- *
- * Hard deletes a {@link Amity.Post}
- *
- * @param postId The {@link Amity.Post} ID to be hard delete
- * @return A success boolean if the {@link Amity.Post} was deleted
- *
- * @category Post API
- * @async
- */
-const hardDeletePost = async (postId) => {
-    const client = getActiveClient();
-    client.log('post/hardDeletePost', postId);
-    const hardDeleted = await deletePost(postId, true);
-    return LinkedObject.post(hardDeleted);
+    return deleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.approve
+  id: comment.soft_delete
 */
 /**
  * ```js
- * import { approvePost } from '@amityco/ts-sdk'
- *
- * const { data: post } = await approvePost('postId')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.softDeleteComment('foobar')
  * ```
  *
- * Approves a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to be approved
- * @return A {@link Amity.Post} that was approved
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const approvePost = async (postId) => {
+const softDeleteComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/approvePost', postId);
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/approve`);
-    fireEvent('post.approved', payload);
-    // fire virtual event for community update
-    if (payload.posts[0].targetType === 'community') {
-        fireEvent('community.updated', payload);
-    }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data: LinkedObject.post(data.posts.find(post => post.postId === postId)),
-        cachedAt,
-    };
+    client.log('comment/softDeleteComment', commentId);
+    const softDeleted = deleteComment(commentId);
+    return softDeleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.decline
+  id: comment.hard_delete
 */
 /**
  * ```js
- * import { declinePost } from '@amityco/ts-sdk'
- *
- * const {data: post} = await declinePost('postId')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.hardDeleteComment('foobar')
  * ```
  *
- * Declines a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to be declined
- * @return A {@link Amity.Post} that was declined
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const declinePost = async (postId) => {
+const hardDeleteComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/declinePost', postId);
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/decline`);
-    // fire virtual event
-    if (payload.posts[0].targetType === 'community') {
-        fireEvent('community.updated', payload);
-    }
-    fireEvent('post.declined', payload);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data: LinkedObject.post(payload.posts.find(post => post.postId === postId)),
-        cachedAt,
-    };
+    client.log('comment/hardDeleteComment', commentId);
+    const hardDeleted = deleteComment(commentId, true);
+    return hardDeleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.flag
+  id: comment.flag
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const flagged = await PostRepository.flagPost(postId, reason)
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const flagged = await CommentRepository.flagComment(commentId, reason)
  * ```
  *
- * @param postId of the post to flag
- * @param reason the reason to flag the post
- * @returns a boolean
+ * @param commentId The ID of the comment to flag
+ * @param reason the reason to flag the comment
+ * @returns the created report result
  *
- * @category Post API
+ * @category Comment API
  * @async
  * */
-const flagPost = async (postId, reason) => {
+const flagComment = async (commentId, reason) => {
     const client = getActiveClient();
-    client.log('post/flagPost', postId);
+    client.log('comment/flagComment', commentId);
     const isPredefinedReason = reason &&
         Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
     const body = {
         reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
         detail: reason && !isPredefinedReason ? reason : '',
     };
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`, body);
+    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/flag`, body);
     if (client.cache) {
-        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+        ingestInCache(payload);
     }
-    fireEvent('post.flagged', payload);
+    fireEvent('comment.flagged', payload);
     return !!payload;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.unflag
+  id: comment.unflag
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const unflagged = await PostRepository.unflagPost(postId)
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const unflagged = await CommentRepository.unflagComment('commentId')
  * ```
  *
- * @param postId of the post to unflag
- * @returns the unflag post result
+ * @param commentId The ID of comment to unflag
+ * @returns the unflagged result
  *
- * @category Post API
+ * @category Comment API
  * @async
  * */
-const unflagPost = async (postId) => {
+const unflagComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/unflagPost', postId);
-    const { data: payload } = await client.http.delete(`/api/v3/posts/${encodeURIComponent(postId)}/unflag`);
+    client.log('comment/unflagComment', commentId);
+    const { data: payload } = await client.http.delete(`/api/v3/comments/${encodeURIComponent(commentId)}/unflag`);
     if (client.cache) {
-        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+        ingestInCache(payload);
     }
-    fireEvent('post.unflagged', payload);
+    fireEvent('comment.unflagged', payload);
     return !!payload;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.check_flag_by_me
+  id: comment.check_flag_by_me
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const isReported = await CommentRepository.isCommentFlaggedByMe('commentId')
  * ```
  *
- * @param postId of the post to check if flagged by current user
- * @returns `true` if the post is flagged by me, `false` if doesn't.
+ * @param commentId The ID of the comment to check if flagged by current user
+ * @returns `true` if the comment is flagged by me, `false` if doesn't.
  *
- * @category Post API
+ * @category Comment API
  * @async
  * */
-const isPostFlaggedByMe = async (postId) => {
+const isCommentFlaggedByMe = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/isPostFlaggedByMe', postId);
-    const { data: { result }, } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
+    client.log('comment/isCommentFlaggedByMe', commentId);
+    const { data: { result }, } = await client.http.get(`/api/v3/comments/${commentId}/isflagbyme`);
     return result;
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: post.create.clip_post
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const created = await PostRepository.createClipPost({
- *   targetType: 'user',
- *   targetId: 'foobar',
- *   dataType: 'clip',
- *   data: { text: 'hello world' },
- *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
- * }))
- * ```
- *
- * Creates an {@link Amity.Post}
- *
- * @param bundle The data necessary to create a new {@link Amity.Post}
- * @returns The newly created {@link Amity.Post}
- *
- * @category Post API
- * @async
- */
-const createClipPost = async (bundle) => {
+const getComment$1 = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/createPost', bundle);
-    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
-    fireEvent('post.created', payload);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
+    client.log('comment/getComment', commentId);
+    isInTombstone('comment', commentId);
+    let data;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/comments/${encodeURIComponent(commentId)}`);
+        data = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('comment', commentId);
+        }
+        throw error;
+    }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    const { posts } = data;
+    const { comments } = data;
     return {
-        data: LinkedObject.post(posts[0]),
+        data: comments.find(comment => comment.commentId === commentId),
         cachedAt,
     };
 };
-/* end_public_function */
+getComment$1.locally = (commentId) => {
+    const client = getActiveClient();
+    client.log('comment/getComment.locally', commentId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['comment', 'get', commentId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
 
-/* begin_public_function
-  id: comment.get_by_ids
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleteLocal(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a collection of {@link Amity.Comment} objects
+ * Fired when a {@link Amity.InternalComment} has been deleted
  *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment API
- * @async
+ * @category Comment Events
  */
-const getCommentByIds = async (commentIds) => {
-    const client = getActiveClient();
-    client.log('comment/getCommentByIds', commentIds);
-    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
-    let data;
-    try {
-        // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/comments/list`, {
-            params: { commentIds: encodedCommentIds },
-        });
-        data = response.data;
-    }
-    catch (error) {
-        commentIds.forEach(commentId => {
-            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                pushToTombstone('comment', commentId);
-            }
-        });
-        throw error;
-    }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data: data.comments.map(comment => LinkedObject.comment(comment)),
-        cachedAt,
-    };
-};
-/* end_public_function */
+const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
+
 /**
  * ```js
- * import { getCommentByIds } from '@amityco/ts-sdk'
- * const comments = getCommentByIds.locally(['foo', 'bar'])
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionAdded(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a collection of {@link Amity.Comment} objects from cache
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment API
+ * @category Comment Events
  */
-getCommentByIds.locally = (commentIds) => {
-    var _a;
+const onLocalCommentReactionAdded = (callback) => {
     const client = getActiveClient();
-    client.log('comment/getCommentByIds.locally', commentIds);
-    if (!client.cache)
-        return;
-    const cached = commentIds
-        .map(commentId => pullFromCache(['comment', 'get', commentId]))
-        .filter(Boolean);
-    const comments = cached.map(({ data }) => data);
-    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
-    if ((cached === null || cached === void 0 ? void 0 : cached.length) < commentIds.length)
-        return;
-    return {
-        data: comments.map(comment => LinkedObject.comment(comment)),
-        cachedAt: oldest.cachedAt,
+    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);
 };
 
-/* begin_public_function
-  id: comment.create
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const newComment = await CommentRepository.createComment(bundle)
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Creates an {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
- * @param bundle The data necessary to create a new {@link Amity.Comment}
- * @returns The newly created {@link Amity.Comment}
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment API
- * @async
+ * @category Comment Events
  */
-const createComment = async (bundle) => {
-    var _a;
+const onLocalCommentReactionRemoved = (callback) => {
     const client = getActiveClient();
-    client.log('comment/createComment', bundle);
-    const { data } = await client.http.post('/api/v3/comments', bundle);
-    const { comments } = data;
-    // BE always returns an array of comments If it got record 0 from BE it might have a problem on creation logic
-    if (comments.length === 0)
-        throw new Error('Comment not created');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    if (['post', 'content'].includes(bundle.referenceType)) {
-        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,
-                videoStreamings: [],
-            });
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
         }
-    }
-    else if (bundle.referenceType === 'story') {
-        const storyIndex = pullFromCache([
-            "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
-            bundle.referenceId,
-        ]);
-        if (storyIndex === null || storyIndex === void 0 ? void 0 : storyIndex.data) {
-            const cacheStory = pullFromCache([
-                "story" /* STORY_KEY_CACHE.STORY */,
-                'get',
-                storyIndex.data,
-            ]);
-            if (cacheStory === null || cacheStory === void 0 ? void 0 : cacheStory.data) {
-                fireEvent('story.updated', {
-                    stories: [
-                        Object.assign(Object.assign({}, cacheStory.data), { commentsCount: cacheStory.data.commentsCount + 1, comments: [...new Set([...cacheStory.data.comments, comments[0].commentId])] }),
-                    ],
-                    categories: [],
-                    comments,
-                    communities: [],
-                    communityUsers: data.communityUsers,
-                    files: data.files,
-                    users: data.users,
-                });
-            }
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
         }
-    }
-    fireEvent('local.comment.created', data);
-    return {
-        data: LinkedObject.comment(comments[0]),
-        cachedAt,
     };
+    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
 };
-/* end_public_function */
 
 /* begin_public_function
-  id: comment.update_comment
+  id: comment.get
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const updated = await CommentRepository.updateComment(commentId, {
- *   data: { text: 'hello world' }
- * })
+ * import { CommentRepository } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsub = CommentRepository.getComment(commentId, response => {
+ *   comment = response.data;
+ * });
  * ```
  *
- * Updates an {@link Amity.Comment}
+ * Observe all mutation on a given {@link Amity.Comment}
  *
- * @param commentId The ID of the {@link Amity.Comment} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Comment} object
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Comment API
- * @async
+ * @category Comment Live Object
  */
-const updateComment = async (commentId, patch) => {
-    const client = getActiveClient();
-    client.log('user/updateComment', patch);
-    const { data } = await client.http.put(`/api/v3/comments/${encodeURIComponent(commentId)}`, patch);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    fireEvent('comment.updated', data);
-    const { comments } = data;
-    return {
-        data: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)),
-        cachedAt,
-    };
+const getComment = (commentId, callback) => {
+    return liveObject(commentId, callback, 'commentId', getComment$1, [
+        onCommentDeleteLocal,
+        onCommentDeleted,
+        onCommentFlagged,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentUnflagged,
+        onCommentUpdated,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ]);
 };
 /* end_public_function */
 
-// Due to we have optimistic logic, we will use referenceId as a id in SDK instead of storyId
-const applyMissingField = (rawData, isCreated = false) => {
-    const { storyId, referenceId } = rawData;
-    if (!isCreated) {
-        if (referenceId)
-            return Object.assign(Object.assign({}, rawData), { syncState: "synced" /* Amity.SyncState.Synced */ });
+class CommentPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
+        const baseOptions = {
+            type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
+        };
+        const options = token ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { limit });
+        const { data: queryResponse } = await this.http.get(`/api/v3/comments`, {
+            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), options }),
+        });
+        return queryResponse;
     }
-    return Object.assign(Object.assign({}, rawData), { syncState: "synced" /* Amity.SyncState.Synced */, referenceId: storyId });
-};
-const convertRawStoryToInternal = (data, isCreated = false) => {
-    const { stories } = data;
-    const storiesData = stories.map(story => applyMissingField(story, isCreated));
-    return Object.assign(Object.assign({}, data), { stories: storiesData });
-};
+}
 
-const getStoryByStoryId$1 = async (storyId) => {
-    const client = getActiveClient();
-    client.log('story/getStoryByStoryId', storyId);
-    // Get story referenceId from cache
-    const cacheReferenceId = pullFromCache([
-        "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
-        storyId,
-    ]);
-    if (cacheReferenceId === null || cacheReferenceId === void 0 ? void 0 : cacheReferenceId.data) {
-        const { data: referenceId } = cacheReferenceId;
-        isInTombstone('story', referenceId);
-    }
-    let data;
-    try {
-        const response = await client.http.get(`/api/v4/stories/${storyId}`);
-        data = convertRawStoryToInternal(response.data);
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('story', storyId);
-        }
-        throw error;
+var EnumCommentActions;
+(function (EnumCommentActions) {
+    EnumCommentActions["OnCommentCreated"] = "onCommentCreated";
+    EnumCommentActions["OnCommentUpdated"] = "onCommentUpdated";
+    EnumCommentActions["OnCommentDeleted"] = "onCommentDeleted";
+    EnumCommentActions["OnCommentFlagged"] = "onCommentFlagged";
+    EnumCommentActions["OnCommentUnflagged"] = "onCommentUnflagged";
+    EnumCommentActions["OnCommentReactionAdded"] = "onCommentReactionAdded";
+    EnumCommentActions["OnCommentReactionRemoved"] = "onCommentReactionRemoved";
+})(EnumCommentActions || (EnumCommentActions = {}));
+
+class CommentQueryStreamController 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.comments.map(getResolver('comment')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const comments = (_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([...comments, ...response.comments.map(getResolver('comment'))])] }));
+        }
+    }
+    reactor(action) {
+        return (comment) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (this.query.referenceId !== comment.referenceId ||
+                this.query.referenceType !== comment.referenceType ||
+                !collection) {
+                return;
+            }
+            if (this.query.parentId && this.query.parentId !== comment.parentId) {
+                return;
+            }
+            if (!this.query.parentId && comment.parentId) {
+                return;
+            }
+            if (action === EnumCommentActions.OnCommentCreated) {
+                collection.data = [...new Set([comment.commentId, ...collection.data])];
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+/**
+ * ```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__default["default"](query);
+        const cacheKey = ['comments', 'collection', queryStreamId];
+        const paginationController = new CommentPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new CommentQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommentPayload);
+        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: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
+            { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
+            { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
+            { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
+            { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+            { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
+            { 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 }) {
+        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(['comment', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.comment);
+        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 comments = data;
+        if (!this.query.includeDeleted) {
+            comments = filterByPropEquality(comments, 'isDeleted', false);
+        }
+        if (this.query.parentId) {
+            comments = comments.filter(comment => comment.parentId === this.query.parentId);
+        }
+        if (typeof this.query.hasFlag === 'boolean') {
+            if (this.query.hasFlag) {
+                comments = comments.filter(comment => comment.hashFlag != null);
+            }
+            else {
+                comments = comments.filter(comment => comment.hashFlag == null);
+            }
+        }
+        if (this.query.dataTypes) {
+            if (this.query.dataTypes.matchType === 'exact') {
+                comments = comments.filter(comment => {
+                    var _a, _b;
+                    const sortedDataTypesQueryValue = ((_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.sort()) || [];
+                    const sortedDataTypesCommentValue = ((_b = comment.dataTypes) === null || _b === void 0 ? void 0 : _b.sort()) || [];
+                    if (sortedDataTypesCommentValue.length !== sortedDataTypesQueryValue.length) {
+                        return false;
+                    }
+                    return sortedDataTypesQueryValue.every((value, index) => value === sortedDataTypesCommentValue[index]);
+                });
+            }
+            if (this.query.dataTypes.matchType === 'any') {
+                comments = comments.filter(comment => { var _a; return (_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.some(value => { var _a; return (_a = comment.dataTypes) === null || _a === void 0 ? void 0 : _a.includes(value); }); });
+            }
+        }
+        switch (this.query.sortBy) {
+            case 'firstCreated':
+                comments = comments.sort(sortByFirstCreated);
+                break;
+            case 'lastCreated':
+            default:
+                comments = comments.sort(sortByLastCreated);
+                break;
+        }
+        return comments;
+    }
+}
+
+/* begin_public_function
+  id: comment.query
+*/
+/**
+ * ```js
+ * import { getComments } from '@amityco/ts-sdk'
+ *
+ * let comments = []
+ * const unsub = getComments({
+ *   referenceType: Amity.InternalComment['referenceType'];
+ *   referenceId: Amity.InternalComment['referenceId'];
+ * }, response => merge(comments, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.InternalComment} for a given target object
+ *
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Comments Live Collection
+ */
+const getComments = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Collection feature you need to enable Cache!');
+    }
+    const timestamp = Date.now();
+    log(`getComments(tmpid: ${timestamp}) > listen`);
+    const commentsLiveCollection = new CommentLiveCollectionController(params, callback);
+    const disposers = commentsLiveCollection.startSubscription();
+    const cacheKey = commentsLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getComments(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+var index$a = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getCommentByIds: getCommentByIds,
+    createComment: createComment,
+    updateComment: updateComment,
+    deleteComment: deleteComment,
+    softDeleteComment: softDeleteComment,
+    hardDeleteComment: hardDeleteComment,
+    flagComment: flagComment,
+    unflagComment: unflagComment,
+    isCommentFlaggedByMe: isCommentFlaggedByMe,
+    onCommentCreated: onCommentCreated,
+    onCommentUpdated: onCommentUpdated,
+    onCommentDeleted: onCommentDeleted,
+    onCommentFlagged: onCommentFlagged,
+    onCommentUnflagged: onCommentUnflagged,
+    onCommentReactionAdded: onCommentReactionAdded,
+    onCommentReactionRemoved: onCommentReactionRemoved,
+    getComment: getComment,
+    getComments: getComments
+});
+
+const getPost$1 = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost', postId);
+    isInTombstone('post', postId);
+    let payload;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/posts/${encodeURIComponent(postId)}`);
+        payload = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('post', postId);
+        }
+        throw error;
+    }
+    const data = prepareMembershipPayload(payload, 'communityUsers');
     const cachedAt = client.cache && Date.now();
-    if (client.cache) {
+    if (client.cache)
         ingestInCache(data, { cachedAt });
-    }
+    const { posts } = data;
+    const result = posts.find(post => post.postId === postId);
     return {
-        data: data.stories[0],
+        data: result,
         cachedAt,
     };
 };
-getStoryByStoryId$1.locally = (storyId) => {
-    const client = getActiveClient();
-    client.log('story/getStorybyStoryId', storyId);
-    // Get story referenceId from cache
-    const cacheReferenceId = pullFromCache([
-        "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
-        storyId,
-    ]);
-    if (cacheReferenceId === null || cacheReferenceId === void 0 ? void 0 : cacheReferenceId.data) {
-        const { data: referenceId } = cacheReferenceId;
-        isInTombstone('story', referenceId);
-    }
-    const cachedAt = client.cache && Date.now();
-    const storyCache = pullFromCache(['story', 'get', storyId]);
-    if (!storyCache)
-        return;
-    return {
-        data: storyCache.data,
-        cachedAt,
-    };
+getPost$1.locally = (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost.locally', postId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['post', 'get', postId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
+
+/**
+ * ```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);
+
+/**
+ * ```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 { 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);
+
+const commentEventHandler$1 = (callback, eventHandler, cacheKey) => {
+    return eventHandler(async (comment) => {
+        var _a;
+        const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!currentCollection || !currentCollection.data.includes(comment.referenceId))
+            return;
+        await getPost$1(comment.referenceId);
+        callback(comment);
+    });
+};
+const generateCommentSubscriptions$1 = (cacheKey) => {
+    const eventHandlers = [
+        onCommentCreated,
+        onCommentDeleted,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentCreatedLocal,
+        onCommentDeleteLocal,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ];
+    return eventHandlers.map(handler => ({
+        fn: convertEventPayload((callback) => commentEventHandler$1(callback, handler, cacheKey), 'referenceId', 'post'),
+        action: EnumPostActions.OnPostUpdated,
+    }));
+};
+const getGlobalFeedSubscriptions = (cacheKey) => {
+    return [
+        { 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 },
+        { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+        { 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 },
+        ...generateCommentSubscriptions$1(cacheKey),
+    ];
 };
 
+class CustomRankingGlobalFeedLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['customRankingGlobalFeed', 'collection', queryStreamId];
+        const paginationController = new CustomRankingGlobalFeedPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new CustomRankingGlobalFeedQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
 /* begin_public_function
-  id: comment.soft_delete, comment.hard_delete
+  id: feed.query.custom_ranking_feed
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.deleteComment('foobar')
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = FeedRepository.getGlobalFeed({
+ *   dataTypes: ['video','image'],
+ *   resolveParent: true,
+ * }, response => processResponse(response))
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param params.dataTypes array of data types for the posts
+ * @param callback the function to call when new data are available
+ * @param config
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
  *
- * @category Comment API
- * @async
+ * @category Posts Live Collection
  */
-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.
-    await client.http.delete(`/api/v4/comments/${encodeURIComponent(commentId)}`, {
-        params: {
-            commentId,
-            permanent,
-        },
-    });
-    // to support hard deletion
-    const deleted = Object.assign(Object.assign({}, comment.data), { isDeleted: true });
-    if (comment.data.referenceType === 'story') {
-        const story = await getStoryByStoryId$1(comment.data.referenceId);
-        fireEvent('local.story.updated', {
-            stories: [story.data],
-            categories: [],
-            comments: [],
-            communities: [],
-            communityUsers: [],
-            files: [],
-            users: [],
+const getCustomRankingGlobalFeed = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getCustomRankingGlobalFeed(tmpid: ${timestamp}) > listen`);
+    const liveCollection = new CustomRankingGlobalFeedLiveCollectionController(params, callback);
+    const disposers = liveCollection.startSubscription();
+    const cacheKey = liveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getCustomRankingGlobalFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+class GlobalFeedPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit, resolveParent } = queryParams, params = __rest(queryParams, ["limit", "resolveParent"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v4/me/global-feeds`, {
+            params: Object.assign(Object.assign({}, params), { resolveParent: resolveParent !== null && resolveParent !== void 0 ? resolveParent : true, options }),
         });
+        return queryResponse;
     }
-    else {
-        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;
+}
+
+class GlobalFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && !collection.data.includes(post.parentPostId))
+                return;
+            // Delete Action
+            if (action === EnumPostActions.OnPostDeleted) {
+                // Parent Post - Remove from collection
+                collection.data = collection.data.filter(postId => postId !== post.postId);
             }
-            else
-                removeCount = 1;
-            post.commentsCount -= removeCount;
-            fireEvent('local.post.updated', {
-                posts: [post],
-                categories: [],
-                comments: [],
-                communities: [],
-                communityUsers: [],
-                feeds: [],
-                files: [],
-                postChildren: [],
-                users: [],
-                videoStreamings: [],
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                // If the query has dataTypes array with value, check if post.dataType is include in the array
+                if (this.query.dataTypes && this.query.dataTypes.length > 0) {
+                    if (!this.query.dataTypes.includes(post.dataType))
+                        return;
+                }
+                collection.data = [...new Set([post.postId, ...collection.data])];
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+class GlobalFeedLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['globalFeed', 'collection', queryStreamId];
+        const paginationController = new GlobalFeedPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new GlobalFeedQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
             });
         }
     }
-    fireEvent('local.comment.deleted', {
-        comments: [deleted],
-        commentChildren: [],
-        files: [],
-        users: [],
-        communityUsers: [],
-    });
-    if (permanent) {
-        scheduleTask(() => pushToTombstone('comment', commentId));
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
     }
-    else {
-        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
-    return deleted;
-};
-/* end_public_function */
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
 
 /* begin_public_function
-  id: comment.soft_delete
+  id: feed.query.global_feed
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.softDeleteComment('foobar')
- * ```
- *
- * Deletes a {@link Amity.Comment}
- *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * import { FeedRepository } from '@amityco/ts-sdk'
  *
- * @category Comment API
- * @async
- */
-const softDeleteComment = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/softDeleteComment', commentId);
-    const softDeleted = deleteComment(commentId);
-    return softDeleted;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: comment.hard_delete
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.hardDeleteComment('foobar')
+ * let posts = []
+ * const unsub = FeedRepository.getGlobalFeed({
+ *   dataTypes: ['video','image'],
+ *   resolveParent: true,
+ * }, response => processResponse(response))
  * ```
  *
- * Deletes a {@link Amity.Comment}
- *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * Observe all mutations on a list of {@link Amity.Post} for global feed
+ * @param params.dataTypes array of data types for the posts
+ * @param params.resolveParent
+ * @param callback the function to call when new data are available
+ * @param config
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
  *
- * @category Comment API
- * @async
+ * @category Posts Live Collection
  */
-const hardDeleteComment = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/hardDeleteComment', commentId);
-    const hardDeleted = deleteComment(commentId, true);
-    return hardDeleted;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: comment.flag
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const flagged = await CommentRepository.flagComment(commentId, reason)
- * ```
- *
- * @param commentId The ID of the comment to flag
- * @param reason the reason to flag the comment
- * @returns the created report result
- *
- * @category Comment API
- * @async
- * */
-const flagComment = async (commentId, reason) => {
-    const client = getActiveClient();
-    client.log('comment/flagComment', commentId);
-    const isPredefinedReason = reason &&
-        Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
-    const body = {
-        reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
-        detail: reason && !isPredefinedReason ? reason : '',
-    };
-    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/flag`, body);
-    if (client.cache) {
-        ingestInCache(payload);
+const getGlobalFeed = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
     }
-    fireEvent('comment.flagged', payload);
-    return !!payload;
+    const timestamp = Date.now();
+    log(`getGlobalFeed(tmpid: ${timestamp}) > listen`);
+    const liveCollection = new GlobalFeedLiveCollectionController(params, callback);
+    const disposers = liveCollection.startSubscription();
+    const cacheKey = liveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getGlobalFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: comment.unflag
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const unflagged = await CommentRepository.unflagComment('commentId')
- * ```
- *
- * @param commentId The ID of comment to unflag
- * @returns the unflagged result
- *
- * @category Comment API
- * @async
- * */
-const unflagComment = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/unflagComment', commentId);
-    const { data: payload } = await client.http.delete(`/api/v3/comments/${encodeURIComponent(commentId)}/unflag`);
-    if (client.cache) {
-        ingestInCache(payload);
-    }
-    fireEvent('comment.unflagged', payload);
-    return !!payload;
-};
-/* end_public_function */
+var index$9 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    queryGlobalFeed: queryGlobalFeed,
+    getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
+    getGlobalFeed: getGlobalFeed
+});
 
 /* begin_public_function
-  id: comment.check_flag_by_me
+  id: post.get_by_ids
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const isReported = await CommentRepository.isCommentFlaggedByMe('commentId')
+ * import { getPostByIds } from '@amityco/ts-sdk'
+ * const { data: posts } = await getPostByIds(['foo', 'bar'])
  * ```
  *
- * @param commentId The ID of the comment to check if flagged by current user
- * @returns `true` if the comment is flagged by me, `false` if doesn't.
+ * Fetches a collection of {@link Amity.Post} objects
  *
- * @category Comment API
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
  * @async
- * */
-const isCommentFlaggedByMe = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/isCommentFlaggedByMe', commentId);
-    const { data: { result }, } = await client.http.get(`/api/v3/comments/${commentId}/isflagbyme`);
-    return result;
-};
-/* end_public_function */
-
-const getComment$1 = async (commentId) => {
+ */
+const getPostByIds = async (postIds) => {
     const client = getActiveClient();
-    client.log('comment/getComment', commentId);
-    isInTombstone('comment', commentId);
-    let data;
+    client.log('post/getPostByIds', postIds);
+    const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
+    let payload;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/comments/${encodeURIComponent(commentId)}`);
-        data = response.data;
+        const response = await client.http.get(`/api/v3/posts/list`, {
+            params: { postIds: encodedPostIds },
+        });
+        payload = response.data;
     }
     catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('comment', commentId);
-        }
+        postIds.forEach(postId => {
+            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+                pushToTombstone('post', postId);
+            }
+        });
         throw error;
     }
+    const data = prepareMembershipPayload(payload, 'communityUsers');
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    const { comments } = data;
     return {
-        data: comments.find(comment => comment.commentId === commentId),
+        data: data.posts.map(LinkedObject.post),
         cachedAt,
     };
 };
-getComment$1.locally = (commentId) => {
+/* end_public_function */
+/**
+ * ```js
+ * import { getPostByIds } from '@amityco/ts-sdk'
+ * const { data: posts } = getPostByIds.locally(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects from cache
+ *
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
+ *
+ * @category Post API
+ */
+getPostByIds.locally = (postIds) => {
+    var _a;
     const client = getActiveClient();
-    client.log('comment/getComment.locally', commentId);
+    client.log('post/getPostByIds.locally', postIds);
     if (!client.cache)
         return;
-    const cached = pullFromCache(['comment', 'get', commentId]);
-    if (!cached)
+    const cached = postIds
+        .map(postId => pullFromCache(['post', 'get', postId]))
+        .filter(Boolean);
+    const posts = cached.map(({ data }) => data);
+    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) < postIds.length)
         return;
     return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
+        data: posts.map(LinkedObject.post),
+        cachedAt: oldest.cachedAt,
     };
 };
 
+/* begin_public_function
+  id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
+*/
 /**
  * ```js
- * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleteLocal(comment => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   data: { text: 'hello world' }
+ * }))
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been deleted
+ * Creates an {@link Amity.Post}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
  *
- * @category Comment Events
+ * @category Post API
+ * @async
  */
-const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
+const createPost = async (bundle) => {
+    const client = getActiveClient();
+    client.log('post/createPost', bundle);
+    if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
+        // eslint-disable-next-line no-param-reassign
+        delete bundle.dataType;
+    }
+    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
+    fireEvent('post.created', payload);
+    const data = preparePostPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    return {
+        data: LinkedObject.post(posts[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: post.edit, post.edit.custom_post
+*/
 /**
  * ```js
- * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionAdded(comment => {
- *   // ...
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const updated = await PostRepository.editPost(postId, {
+ *   data: { text: 'hello world' }
  * })
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been reacted
+ * Updates an {@link Amity.Post}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param postId The ID of the {@link Amity.Post} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Post} object
  *
- * @category Comment Events
+ * @category Post API
+ * @async
  */
-const onLocalCommentReactionAdded = (callback) => {
+const editPost = async (postId, patch) => {
     const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
-        }
-        else {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
-        }
+    client.log('user/editPost', patch);
+    const { data: payload } = await client.http.put(`/api/v4/posts/${encodeURIComponent(postId)}`, patch);
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('local.post.updated', data);
+    const { posts } = data;
+    return {
+        data: LinkedObject.post(posts.find(post => post.postId === postId)),
+        cachedAt,
     };
-    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
 };
+/* end_public_function */
 
 /**
  * ```js
- * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionRemoved(comment => {
- *   // ...
- * })
+ * import { deletePost } from '@amityco/ts-sdk'
+ * const success = await deletePost('foobar')
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been reacted
+ * Deletes a {@link Amity.Post}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param postId The {@link Amity.Post} ID to delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Comment Events
+ * @private
+ * @async
  */
-const onLocalCommentReactionRemoved = (callback) => {
+const deletePost = async (postId, permanent = false) => {
+    var _a;
     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);
+    const post = await getPost$2(postId);
+    await client.http.delete(`/api/v4/posts/${encodeURIComponent(postId)}`, {
+        params: {
+            postId,
+            permanent,
+        },
+    });
+    // there is currently a limitation which doesn't allow us to fire event to tell that community
+    // has been updated. reason is that, when the object is deleted, we don't have its `communityId`
+    // and so we cannot refetch the community or advertise on events. hopefully this should be solved
+    // later when realtime events covers that for us.
+    if (post.data.targetType === 'community') {
+        const community = await getCommunity$1(post.data.targetId);
+        const communityUsersCache = (_a = queryCache(['communityUsers', 'get'])) !== null && _a !== void 0 ? _a : [];
+        const communityUsers = communityUsersCache
+            .filter(({ key }) => {
+            // cache key is ['communityUsers', 'get', `${communityId}#`${userId}`}]
+            if (key[0] !== 'communityUsers')
+                return false;
+            if (key[1] !== 'get')
+                return false;
+            if (typeof key[2] === 'string')
+                return key[2].includes(community.data.communityId);
+            return false;
+        })
+            .map(({ data }) => data);
+        fireEvent('community.updated', {
+            communities: [community.data],
+            categories: [],
+            communityUsers,
+            feeds: [],
+            files: [],
+            users: [],
+        });
+    }
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, post.data), { isDeleted: true });
+    if (permanent) {
+        setTimeout(() => {
+            pushToTombstone('post', postId);
+        }, 0);
+    }
+    else {
+        upsertInCache(['post', 'get', postId], { isDeleted: true });
+    }
+    fireEvent('local.post.deleted', {
+        posts: [deleted],
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: [],
+        feeds: [],
+        files: [],
+        postChildren: [],
+        users: [],
+        videoStreamings: [],
+    });
+    return LinkedObject.post(deleted);
 };
 
 /* begin_public_function
-  id: comment.get
+  id: post.soft_delete
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk';
- *
- * let comment;
- *
- * const unsub = CommentRepository.getComment(commentId, response => {
- *   comment = response.data;
- * });
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const success = await PostRepository.softDeletePost('foobar')
  * ```
  *
- * Observe all mutation on a given {@link Amity.Comment}
+ * Soft deletes a {@link Amity.Post}
  *
- * @param commentId the ID of the comment to observe
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
+ * @param postId The {@link Amity.Post} ID to soft delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Comment Live Object
- */
-const getComment = (commentId, callback) => {
-    return liveObject(commentId, callback, 'commentId', getComment$1, [
-        onCommentDeleteLocal,
-        onCommentDeleted,
-        onCommentFlagged,
-        onCommentReactionAdded,
-        onCommentReactionRemoved,
-        onCommentUnflagged,
-        onCommentUpdated,
-        onLocalCommentReactionAdded,
-        onLocalCommentReactionRemoved,
-    ]);
-};
-/* end_public_function */
-
-class CommentPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
-        const baseOptions = {
-            type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
-        };
-        const options = token ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { limit });
-        const { data: queryResponse } = await this.http.get(`/api/v3/comments`, {
-            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), options }),
-        });
-        return queryResponse;
-    }
-}
-
-var EnumCommentActions;
-(function (EnumCommentActions) {
-    EnumCommentActions["OnCommentCreated"] = "onCommentCreated";
-    EnumCommentActions["OnCommentUpdated"] = "onCommentUpdated";
-    EnumCommentActions["OnCommentDeleted"] = "onCommentDeleted";
-    EnumCommentActions["OnCommentFlagged"] = "onCommentFlagged";
-    EnumCommentActions["OnCommentUnflagged"] = "onCommentUnflagged";
-    EnumCommentActions["OnCommentReactionAdded"] = "onCommentReactionAdded";
-    EnumCommentActions["OnCommentReactionRemoved"] = "onCommentReactionRemoved";
-})(EnumCommentActions || (EnumCommentActions = {}));
-
-class CommentQueryStreamController 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.comments.map(getResolver('comment')),
-            });
-        }
-        else {
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            const comments = (_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([...comments, ...response.comments.map(getResolver('comment'))])] }));
-        }
-    }
-    reactor(action) {
-        return (comment) => {
-            var _a;
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            if (this.query.referenceId !== comment.referenceId ||
-                this.query.referenceType !== comment.referenceType ||
-                !collection) {
-                return;
-            }
-            if (this.query.parentId && this.query.parentId !== comment.parentId) {
-                return;
-            }
-            if (!this.query.parentId && comment.parentId) {
-                return;
-            }
-            if (action === EnumCommentActions.OnCommentCreated) {
-                collection.data = [...new Set([comment.commentId, ...collection.data])];
-            }
-            pushToCache(this.cacheKey, collection);
-            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
-        };
-    }
-    subscribeRTE(createSubscriber) {
-        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
-    }
-}
+ * @category Post API
+ * @async
+ */
+const softDeletePost = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/softDeletePost', postId);
+    const softDeleted = await deletePost(postId, false);
+    return LinkedObject.post(softDeleted);
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: post.hard_delete
+*/
 /**
  * ```js
- * import { onCommentCreated } from '@amityco/ts-sdk'
- * const dispose = onCommentCreated(comment => {
- *   // ...
- * })
+ * import { hardDeletePost } from '@amityco/ts-sdk'
+ * const success = await hardDeletePost('foobar')
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been created
+ * Hard deletes a {@link Amity.Post}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param postId The {@link Amity.Post} ID to be hard delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Comment Events
+ * @category Post API
+ * @async
  */
-const onCommentCreatedLocal = (callback) => {
-    return createLocalCommentEventSubscriber('local.comment.created', callback);
+const hardDeletePost = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/hardDeletePost', postId);
+    const hardDeleted = await deletePost(postId, true);
+    return LinkedObject.post(hardDeleted);
 };
+/* end_public_function */
 
-class CommentLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash__default["default"](query);
-        const cacheKey = ['comments', 'collection', queryStreamId];
-        const paginationController = new CommentPaginationController(query);
-        super(paginationController, queryStreamId, cacheKey, callback);
-        this.query = query;
-        this.queryStreamController = new CommentQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommentPayload);
-        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: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
-            { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
-            { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
-            { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
-            { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
-            { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
-            { 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 }) {
-        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(['comment', 'get', id]))
-            .filter(isNonNullable)
-            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.comment);
-        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 comments = data;
-        if (!this.query.includeDeleted) {
-            comments = filterByPropEquality(comments, 'isDeleted', false);
-        }
-        if (this.query.parentId) {
-            comments = comments.filter(comment => comment.parentId === this.query.parentId);
-        }
-        if (typeof this.query.hasFlag === 'boolean') {
-            if (this.query.hasFlag) {
-                comments = comments.filter(comment => comment.hashFlag != null);
-            }
-            else {
-                comments = comments.filter(comment => comment.hashFlag == null);
-            }
-        }
-        if (this.query.dataTypes) {
-            if (this.query.dataTypes.matchType === 'exact') {
-                comments = comments.filter(comment => {
-                    var _a, _b;
-                    const sortedDataTypesQueryValue = ((_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.sort()) || [];
-                    const sortedDataTypesCommentValue = ((_b = comment.dataTypes) === null || _b === void 0 ? void 0 : _b.sort()) || [];
-                    if (sortedDataTypesCommentValue.length !== sortedDataTypesQueryValue.length) {
-                        return false;
-                    }
-                    return sortedDataTypesQueryValue.every((value, index) => value === sortedDataTypesCommentValue[index]);
-                });
-            }
-            if (this.query.dataTypes.matchType === 'any') {
-                comments = comments.filter(comment => { var _a; return (_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.some(value => { var _a; return (_a = comment.dataTypes) === null || _a === void 0 ? void 0 : _a.includes(value); }); });
-            }
-        }
-        switch (this.query.sortBy) {
-            case 'firstCreated':
-                comments = comments.sort(sortByFirstCreated);
-                break;
-            case 'lastCreated':
-            default:
-                comments = comments.sort(sortByLastCreated);
-                break;
-        }
-        return comments;
+/* begin_public_function
+  id: post.approve
+*/
+/**
+ * ```js
+ * import { approvePost } from '@amityco/ts-sdk'
+ *
+ * const { data: post } = await approvePost('postId')
+ * ```
+ *
+ * Approves a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to be approved
+ * @return A {@link Amity.Post} that was approved
+ *
+ * @category Post API
+ * @async
+ */
+const approvePost = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/approvePost', postId);
+    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/approve`);
+    fireEvent('post.approved', payload);
+    // fire virtual event for community update
+    if (payload.posts[0].targetType === 'community') {
+        fireEvent('community.updated', payload);
     }
-}
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    return {
+        data: LinkedObject.post(data.posts.find(post => post.postId === postId)),
+        cachedAt,
+    };
+};
+/* end_public_function */
 
 /* begin_public_function
-  id: comment.query
+  id: post.decline
 */
 /**
  * ```js
- * import { getComments } from '@amityco/ts-sdk'
+ * import { declinePost } from '@amityco/ts-sdk'
  *
- * let comments = []
- * const unsub = getComments({
- *   referenceType: Amity.InternalComment['referenceType'];
- *   referenceId: Amity.InternalComment['referenceId'];
- * }, response => merge(comments, response.data))
+ * const {data: post} = await declinePost('postId')
  * ```
  *
- * Observe all mutations on a list of {@link Amity.InternalComment} for a given target object
+ * Declines a {@link Amity.Post}
  *
- * @param referenceType the type of the target
- * @param referenceId the ID of the target
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ * @param postId The {@link Amity.Post} ID to be declined
+ * @return A {@link Amity.Post} that was declined
  *
- * @category Comments Live Collection
+ * @category Post API
+ * @async
  */
-const getComments = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log('For using Live Collection feature you need to enable Cache!');
+const declinePost = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/declinePost', postId);
+    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/decline`);
+    // fire virtual event
+    if (payload.posts[0].targetType === 'community') {
+        fireEvent('community.updated', payload);
     }
-    const timestamp = Date.now();
-    log(`getComments(tmpid: ${timestamp}) > listen`);
-    const commentsLiveCollection = new CommentLiveCollectionController(params, callback);
-    const disposers = commentsLiveCollection.startSubscription();
-    const cacheKey = commentsLiveCollection.getCacheKey();
-    disposers.push(() => dropFromCache(cacheKey));
-    return () => {
-        log(`getComments(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
+    fireEvent('post.declined', payload);
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    return {
+        data: LinkedObject.post(payload.posts.find(post => post.postId === postId)),
+        cachedAt,
     };
 };
 /* end_public_function */
 
-var index$9 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getCommentByIds: getCommentByIds,
-    createComment: createComment,
-    updateComment: updateComment,
-    deleteComment: deleteComment,
-    softDeleteComment: softDeleteComment,
-    hardDeleteComment: hardDeleteComment,
-    flagComment: flagComment,
-    unflagComment: unflagComment,
-    isCommentFlaggedByMe: isCommentFlaggedByMe,
-    onCommentCreated: onCommentCreated,
-    onCommentUpdated: onCommentUpdated,
-    onCommentDeleted: onCommentDeleted,
-    onCommentFlagged: onCommentFlagged,
-    onCommentUnflagged: onCommentUnflagged,
-    onCommentReactionAdded: onCommentReactionAdded,
-    onCommentReactionRemoved: onCommentReactionRemoved,
-    getComment: getComment,
-    getComments: getComments
-});
-
+/* begin_public_function
+  id: post.flag
+*/
 /**
  * ```js
- * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
- * const dispose = onPostUpdatedLocal(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const flagged = await PostRepository.flagPost(postId, reason)
  * ```
  *
- * 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
+ * @param postId of the post to flag
+ * @param reason the reason to flag the post
+ * @returns a boolean
  *
- * @category Post Events
- */
-const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+ * @category Post API
+ * @async
+ * */
+const flagPost = async (postId, reason) => {
+    const client = getActiveClient();
+    client.log('post/flagPost', postId);
+    const isPredefinedReason = reason &&
+        Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
+    const body = {
+        reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
+        detail: reason && !isPredefinedReason ? reason : '',
+    };
+    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`, body);
+    if (client.cache) {
+        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+    }
+    fireEvent('post.flagged', payload);
+    return !!payload;
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: post.unflag
+*/
 /**
  * ```js
- * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onPostReactionAdded(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const unflagged = await PostRepository.unflagPost(postId)
  * ```
  *
- * 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
+ * @param postId of the post to unflag
+ * @returns the unflag post result
  *
- * @category Post Events
- */
-const onLocalPostReactionAdded = (callback) => {
+ * @category Post API
+ * @async
+ * */
+const unflagPost = async (postId) => {
     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);
+    client.log('post/unflagPost', postId);
+    const { data: payload } = await client.http.delete(`/api/v3/posts/${encodeURIComponent(postId)}/unflag`);
+    if (client.cache) {
+        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+    }
+    fireEvent('post.unflagged', payload);
+    return !!payload;
 };
+/* end_public_function */
 
+/* begin_public_function
+  id: post.check_flag_by_me
+*/
 /**
  * ```js
- * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onPostReactionRemoved(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
  * ```
  *
- * 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
+ * @param postId of the post to check if flagged by current user
+ * @returns `true` if the post is flagged by me, `false` if doesn't.
  *
- * @category Post Events
- */
-const onLocalPostReactionRemoved = (callback) => {
+ * @category Post API
+ * @async
+ * */
+const isPostFlaggedByMe = async (postId) => {
     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);
+    client.log('post/isPostFlaggedByMe', postId);
+    const { data: { result }, } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
+    return result;
 };
+/* end_public_function */
 
+/* begin_public_function
+  id: post.create.clip_post
+*/
 /**
  * ```js
- * import { onLocalPostDeleted } from '@amityco/ts-sdk'
- * const dispose = onLocalPostDeleted(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createClipPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   dataType: 'clip',
+ *   data: { text: 'hello world' },
+ *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
+ * }))
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been deleted
+ * Creates an {@link Amity.Post}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
  *
- * @category Post Events
+ * @category Post API
+ * @async
  */
-const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
+const createClipPost = async (bundle) => {
+    const client = getActiveClient();
+    client.log('post/createPost', bundle);
+    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
+    fireEvent('post.created', payload);
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    return {
+        data: LinkedObject.post(posts[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
 
 /* begin_public_function
   id: post.get
@@ -24686,7 +25069,7 @@ const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.p
  *
  * @category Post Live Object
  */
-const getPost$1 = (postId, callback) => {
+const getPost = (postId, callback) => {
     const responder = (snapshot) => {
         const { data } = snapshot;
         callback(Object.assign(Object.assign({}, snapshot), { data: data ? LinkedObject.post(snapshot.data) : data }));
@@ -24775,19 +25158,6 @@ class PostPaginationController extends PaginationController {
     }
 }
 
-var EnumPostActions;
-(function (EnumPostActions) {
-    EnumPostActions["OnPostCreated"] = "onPostCreated";
-    EnumPostActions["OnPostUpdated"] = "onPostUpdated";
-    EnumPostActions["OnPostDeleted"] = "onPostDeleted";
-    EnumPostActions["OnPostFlagged"] = "onPostFlagged";
-    EnumPostActions["OnPostUnflagged"] = "onPostUnflagged";
-    EnumPostActions["OnPostReactionAdded"] = "onPostReactionAdded";
-    EnumPostActions["OnPostReactionRemoved"] = "onPostReactionRemoved";
-    EnumPostActions["OnPostApproved"] = "onPostApproved";
-    EnumPostActions["OnPostDeclined"] = "onPostDeclined";
-})(EnumPostActions || (EnumPostActions = {}));
-
 class PostQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -24853,45 +25223,50 @@ class PostQueryStreamController extends QueryStreamController {
     }
 }
 
-const getPost = async (postId) => {
-    const client = getActiveClient();
-    client.log('post/getPost', postId);
-    isInTombstone('post', postId);
-    let payload;
-    try {
-        // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/posts/${encodeURIComponent(postId)}`);
-        payload = response.data;
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('post', postId);
-        }
-        throw error;
-    }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { posts } = data;
-    const result = posts.find(post => post.postId === postId);
-    return {
-        data: result,
-        cachedAt,
-    };
+const commentEventHandler = (callback, eventHandler, cacheKey, resolveId) => {
+    return eventHandler(async (comment) => {
+        var _a;
+        const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!currentCollection ||
+            !currentCollection.data.includes(resolveId ? resolveId(comment.referenceId) : comment.referenceId))
+            return;
+        await getPost$1(comment.referenceId);
+        callback(comment);
+    });
 };
-getPost.locally = (postId) => {
-    const client = getActiveClient();
-    client.log('post/getPost.locally', postId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['post', 'get', postId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
+const generateCommentSubscriptions = ({ cacheKey, resolveId, }) => {
+    const eventHandlers = [
+        onCommentCreated,
+        onCommentDeleted,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentCreatedLocal,
+        onCommentDeleteLocal,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ];
+    return eventHandlers.map(handler => ({
+        fn: convertEventPayload((callback) => commentEventHandler(callback, handler, cacheKey, resolveId), 'referenceId', 'post'),
+        action: EnumPostActions.OnPostUpdated,
+    }));
+};
+const getPostSubscription = (cacheKey) => {
+    return [
+        { 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 },
+        { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+        { 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 },
+        ...generateCommentSubscriptions({ cacheKey }),
+    ];
 };
 
 class PostLiveCollectionController extends LiveCollectionController {
@@ -24922,47 +25297,7 @@ class PostLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        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 },
-            { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
-            { 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) => {
-                        var _a;
-                        const currentCollection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                            return;
-                        await getPost(comment.referenceId);
-                        callback(comment);
-                    });
-                }, 'referenceId', 'post'),
-                action: EnumPostActions.OnPostUpdated,
-            },
-            {
-                fn: convertEventPayload((callback) => {
-                    return onCommentDeleted(async (comment) => {
-                        var _a;
-                        const currentCollection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                            return;
-                        await getPost(comment.referenceId);
-                        callback(comment);
-                    });
-                }, 'referenceId', 'post'),
-                action: EnumPostActions.OnPostUpdated,
-            },
-        ]);
+        return this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -25097,6 +25432,22 @@ class PinnedPostQueryStreamController extends QueryStreamController {
             });
         }
     }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumPostActions.OnPostDeleted) {
+                collection.data = collection.data.filter(referenceId => referenceId !== `global#${post.postId}`);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
 }
 
 class PinnedPostLiveCollectionController extends LiveCollectionController {
@@ -25128,7 +25479,10 @@ class PinnedPostLiveCollectionController extends LiveCollectionController {
     }
     // eslint-disable-next-line class-methods-use-this
     startSubscription() {
-        return [];
+        return this.queryStreamController.subscribeRTE(generateCommentSubscriptions({
+            cacheKey: this.cacheKey,
+            resolveId: id => `${this.query.placement}#${id}`,
+        }));
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -25280,6 +25634,10 @@ class GlobalPinnedPostLiveCollectionController extends LiveCollectionController
                 fn: onPostDeleted,
                 action: EnumPostActions.OnPostDeleted,
             },
+            ...generateCommentSubscriptions({
+                cacheKey: this.cacheKey,
+                resolveId: id => `global#${id}`,
+            }),
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -25582,7 +25940,7 @@ var index$8 = /*#__PURE__*/Object.freeze({
     onPostUnflagged: onPostUnflagged,
     onPostReactionAdded: onPostReactionAdded,
     onPostReactionRemoved: onPostReactionRemoved,
-    getPost: getPost$1,
+    getPost: getPost,
     getPosts: getPosts,
     getPinnedPosts: getPinnedPosts,
     getGlobalPinnedPosts: getGlobalPinnedPosts,
@@ -28788,13 +29146,13 @@ exports.AdRepository = index$3;
 exports.CategoryRepository = index$b;
 exports.ChannelRepository = index$f;
 exports.Client = index$o;
-exports.CommentRepository = index$9;
+exports.CommentRepository = index$a;
 exports.CommunityPostSettingMaps = CommunityPostSettingMaps;
 exports.CommunityPostSettings = CommunityPostSettings;
 exports.CommunityRepository = index$c;
 exports.ContentFeedType = ContentFeedType;
 exports.DefaultCommunityPostSetting = DefaultCommunityPostSetting;
-exports.FeedRepository = index$a;
+exports.FeedRepository = index$9;
 exports.FileRepository = index$l;
 exports.FileType = FileType;
 exports.InvitationRepository = index$1;