@amityco/ts-sdk 7.7.1-3f344102.0 → 7.7.1-47be9e51.0

package/dist/index.cjs.js

@@ -6362,17 +6362,19 @@ const dispose$7 = (cb) => {
 const onChannelSetMuted = (callback) => {
     if (callbacks$7.length === 0) {
         const client = getActiveClient();
-        const filter = async (payload) => {
+        const filter = async (payloads) => {
             var _a;
-            upsertInCache(['channel', 'get', payload.channelId], {
-                // If muteTimeout > now => user is muted
-                // Otherwise => user is unmuted
-                isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+            payloads.forEach(payload => {
+                upsertInCache(['channel', 'get', payload.channelId], {
+                    // If muteTimeout > now => user is muted
+                    // Otherwise => user is unmuted
+                    isMuted: Date.parse(payload.muteTimeout) > Date.now(),
+                });
             });
             const channel = (_a = pullFromCache([
                 'channel',
                 'get',
-                payload.channelId,
+                payloads[0].channelId,
             ])) === null || _a === void 0 ? void 0 : _a.data;
             if (channel) {
                 callbacks$7.forEach(cb => cb(channel));
@@ -23179,1101 +23181,706 @@ getCustomRankingGlobalFeed.locally = (query) => {
         : undefined;
 };
 
-var index$a = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    queryGlobalFeed: queryGlobalFeed,
-    getCustomRankingGlobalFeed: getCustomRankingGlobalFeed
-});
+class UserFeedPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { userId, feedSources, dataTypes, includeDeleted, matchingOnlyParentPost, limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["userId", "feedSources", "dataTypes", "includeDeleted", "matchingOnlyParentPost", "limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v4/user-feeds/${userId}`, {
+            params: Object.assign(Object.assign({}, params), { options, dataTypes: (dataTypes === null || dataTypes === void 0 ? void 0 : dataTypes.length) ? dataTypes : undefined, includePostedFeed: feedSources, isDeleted: inferIsDeleted(includeDeleted), matchingOnlyParentPost: matchingOnlyParentPost !== null && matchingOnlyParentPost !== void 0 ? matchingOnlyParentPost : !(dataTypes === null || dataTypes === void 0 ? void 0 : dataTypes.length) }),
+        });
+        return queryResponse;
+    }
+}
+
+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 UserFeedQueryStreamController 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, _b;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            // if the collection is parent post collection and
+            // post is not included in the collection or post is child post
+            if ((!this.query.dataTypes || this.query.dataTypes.length === 0) &&
+                !collection.data.includes(post.parentPostId ? post.parentPostId : post.postId))
+                return;
+            if (action === EnumPostActions.OnPostDeleted) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (post.parentPostId && post.isDeleted) {
+                const parentPost = (_b = pullFromCache([
+                    'post',
+                    'get',
+                    post.parentPostId,
+                ])) === null || _b === void 0 ? void 0 : _b.data;
+                if (!parentPost)
+                    return;
+                parentPost.children = parentPost.children.filter(childId => childId !== post.postId);
+                pushToCache(['post', 'get', parentPost.postId], parentPost);
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                if (this.query.dataTypes &&
+                    this.query.dataTypes.length > 0 &&
+                    !this.query.dataTypes.includes(post.dataType)) {
+                    return;
+                }
+                collection.data = [...new Set([post.postId, ...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)));
+    }
+}
 
 /* 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;
+    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.post(posts[0]),
+        data: LinkedObject.comment(comments[0]),
         cachedAt,
     };
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.edit, post.edit.custom_post
+  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 (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);
+    if (permanent) {
+        scheduleTask(() => pushToTombstone('comment', commentId));
+    }
+    else {
+        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
+    }
+    return deleted;
 };
+/* end_public_function */
 
 /* begin_public_function
-  id: post.soft_delete
+  id: comment.soft_delete
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const success = await PostRepository.softDeletePost('foobar')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.softDeleteComment('foobar')
  * ```
  *
- * Soft deletes a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to soft 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
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const softDeletePost = async (postId) => {
+const softDeleteComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/softDeletePost', postId);
-    const softDeleted = await deletePost(postId, false);
-    return LinkedObject.post(softDeleted);
+    client.log('comment/softDeleteComment', commentId);
+    const softDeleted = deleteComment(commentId);
+    return softDeleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.hard_delete
+  id: comment.hard_delete
 */
 /**
  * ```js
- * import { hardDeletePost } from '@amityco/ts-sdk'
- * const success = await hardDeletePost('foobar')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.hardDeleteComment('foobar')
  * ```
  *
- * Hard deletes a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to be hard 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
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const hardDeletePost = async (postId) => {
+const hardDeleteComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/hardDeletePost', postId);
-    const hardDeleted = await deletePost(postId, true);
-    return LinkedObject.post(hardDeleted);
+    client.log('comment/hardDeleteComment', commentId);
+    const hardDeleted = deleteComment(commentId, true);
+    return hardDeleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.approve
+  id: comment.flag
 */
 /**
  * ```js
- * import { approvePost } from '@amityco/ts-sdk'
- *
- * const { data: post } = await approvePost('postId')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const flagged = await CommentRepository.flagComment(commentId, reason)
  * ```
  *
- * Approves a {@link Amity.Post}
- *
- * @param postId The {@link Amity.Post} ID to be approved
- * @return A {@link Amity.Post} that was approved
+ * @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 approvePost = async (postId) => {
+ * */
+const flagComment = async (commentId, reason) => {
     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: post.decline
-*/
-/**
- * ```js
- * import { declinePost } from '@amityco/ts-sdk'
- *
- * const {data: post} = await declinePost('postId')
- * ```
- *
- * Declines a {@link Amity.Post}
- *
- * @param postId The {@link Amity.Post} ID to be declined
- * @return A {@link Amity.Post} that was declined
- *
- * @category Post API
- * @async
- */
-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);
-    }
-    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 */
-
-/* begin_public_function
-  id: post.flag
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const flagged = await PostRepository.flagPost(postId, reason)
- * ```
- *
- * @param postId of the post to flag
- * @param reason the reason to flag the post
- * @returns a boolean
- *
- * @category Post API
- * @async
- * */
-const flagPost = async (postId, 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 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: comment.get_by_ids
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.Comment} objects
- *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
- *
- * @category Comment API
- * @async
- */
-const getCommentByIds = async (commentIds) => {
+const getComment$1 = async (commentId) => {
     const client = getActiveClient();
-    client.log('comment/getCommentByIds', commentIds);
-    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
+    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/list`, {
-            params: { commentIds: encodedCommentIds },
-        });
+        const response = await client.http.get(`/api/v3/comments/${encodeURIComponent(commentId)}`);
         data = response.data;
     }
     catch (error) {
-        commentIds.forEach(commentId => {
-            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                pushToTombstone('comment', 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 });
+    const { comments } = data;
     return {
-        data: data.comments.map(comment => LinkedObject.comment(comment)),
+        data: comments.find(comment => comment.commentId === commentId),
         cachedAt,
     };
 };
-/* end_public_function */
-/**
- * ```js
- * import { getCommentByIds } from '@amityco/ts-sdk'
- * const comments = getCommentByIds.locally(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.Comment} objects from cache
- *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
- *
- * @category Comment API
- */
-getCommentByIds.locally = (commentIds) => {
-    var _a;
+getComment$1.locally = (commentId) => {
     const client = getActiveClient();
-    client.log('comment/getCommentByIds.locally', commentIds);
+    client.log('comment/getComment.locally', commentId);
     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)
+    const cached = pullFromCache(['comment', 'get', commentId]);
+    if (!cached)
         return;
     return {
-        data: comments.map(comment => LinkedObject.comment(comment)),
-        cachedAt: oldest.cachedAt,
+        data: cached.data,
+        cachedAt: cached.cachedAt,
     };
 };
 
-/* begin_public_function
-  id: comment.create
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const newComment = await CommentRepository.createComment(bundle)
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleteLocal(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Creates an {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been deleted
  *
- * @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 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: [],
-            });
-        }
-    }
-    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 */
+const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
 
-/* begin_public_function
-  id: comment.update_comment
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const updated = await CommentRepository.updateComment(commentId, {
- *   data: { text: 'hello world' }
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionAdded(comment => {
+ *   // ...
  * })
  * ```
  *
- * Updates an {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
- * @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 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 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,
-    };
-};
-/* 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 onLocalCommentReactionAdded = (callback) => {
     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);
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
+        }
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
         }
-        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,
     };
+    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
 };
 
-/* begin_public_function
-  id: comment.soft_delete, comment.hard_delete
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.deleteComment('foobar')
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @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 deleteComment = async (commentId, permanent = false) => {
-    var _a;
+const onLocalCommentReactionRemoved = (callback) => {
     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: [],
-        });
-    }
-    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;
-            }
-            else
-                removeCount = 1;
-            post.commentsCount -= removeCount;
-            fireEvent('local.post.updated', {
-                posts: [post],
-                categories: [],
-                comments: [],
-                communities: [],
-                communityUsers: [],
-                feeds: [],
-                files: [],
-                postChildren: [],
-                users: [],
-                videoStreamings: [],
-            });
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
         }
-    }
-    fireEvent('local.comment.deleted', {
-        comments: [deleted],
-        commentChildren: [],
-        files: [],
-        users: [],
-        communityUsers: [],
-    });
-    if (permanent) {
-        scheduleTask(() => pushToTombstone('comment', commentId));
-    }
-    else {
-        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
-    }
-    return deleted;
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
+        }
+    };
+    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
 };
-/* end_public_function */
 
 /* begin_public_function
-  id: comment.soft_delete
+  id: comment.get
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.softDeleteComment('foobar')
- * ```
+ * import { CommentRepository } from '@amityco/ts-sdk';
  *
- * 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
- *
- * @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')
- * ```
- *
- * 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
- *
- * @category Comment API
- * @async
- */
-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);
-    }
-    fireEvent('comment.flagged', payload);
-    return !!payload;
-};
-/* 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 */
-
-/* begin_public_function
-  id: comment.check_flag_by_me
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const isReported = await CommentRepository.isCommentFlaggedByMe('commentId')
- * ```
- *
- * @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 Comment 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 client = getActiveClient();
-    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 { comments } = data;
-    return {
-        data: comments.find(comment => comment.commentId === commentId),
-        cachedAt,
-    };
-};
-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,
-    };
-};
-
-/**
- * ```js
- * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleteLocal(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
-
-/**
- * ```js
- * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionAdded(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been reacted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onLocalCommentReactionAdded = (callback) => {
-    const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
-        }
-        else {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
-        }
-    };
-    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
-};
-
-/**
- * ```js
- * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionRemoved(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been reacted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onLocalCommentReactionRemoved = (callback) => {
-    const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
-        }
-        else {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
-        }
-    };
-    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
-};
-
-/* begin_public_function
-  id: comment.get
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk';
- *
- * let comment;
+ * let comment;
  *
  * const unsub = CommentRepository.getComment(commentId, response => {
  *   comment = response.data;
@@ -24548,7 +24155,7 @@ const getComments = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$9 = /*#__PURE__*/Object.freeze({
+var index$a = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getCommentByIds: getCommentByIds,
     createComment: createComment,
@@ -24570,97 +24177,783 @@ var index$9 = /*#__PURE__*/Object.freeze({
     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)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    const result = posts.find(post => post.postId === postId);
+    return {
+        data: result,
+        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 { onPostUpdatedLocal } from '@amityco/ts-sdk'
+ * const dispose = onPostUpdatedLocal(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+
+/**
+ * ```js
+ * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ post }) => {
+        if (!client.cache) {
+            callback(post);
+        }
+        else {
+            upsertInCache(['post', 'get', post.postId], post);
+            callback(post);
+        }
+    };
+    return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ post }) => {
+        if (!client.cache) {
+            callback(post);
+        }
+        else {
+            upsertInCache(['post', 'get', post.postId], post);
+            callback(post);
+        }
+    };
+    return createEventSubscriber(client, 'local.post.removeReaction', 'local.post.removeReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalPostDeleted } from '@amityco/ts-sdk'
+ * const dispose = onLocalPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
+
+class UserFeedLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['userFeed', 'collection', queryStreamId];
+        const paginationController = new UserFeedPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new UserFeedQueryStreamController(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([
+            { 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$1(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$1(comment.referenceId);
+                        callback(comment);
+                    });
+                }, 'referenceId', 'post'),
+                action: EnumPostActions.OnPostUpdated,
+            },
+        ]);
+    }
+    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(['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,
+        });
+    }
+    applyFilter(data) {
+        var _a;
+        let posts = data;
+        if (!this.query.includeDeleted) {
+            posts = filterByPropEquality(posts, 'isDeleted', false);
+        }
+        if ((_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.length) {
+            posts = filterByPostDataTypes(posts, this.query.dataTypes);
+        }
+        switch (this.query.sortBy) {
+            case 'firstCreated':
+                posts = posts.sort(sortByFirstCreated);
+                break;
+            case 'lastCreated':
+            default:
+                posts = posts.sort(sortByLastCreated);
+                break;
+        }
+        return posts;
+    }
+}
+
+/* begin_public_function
+  id: feed.query.user_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsubscribe = FeedRepository.getUserFeed({
+ *   userId: string,
+ *   feedSources: ['user', 'community'],
+ * }, response => response => processResponse(response))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given user and feedSources
+ *
+ * @param params.userId the ID of the user
+ * @param params.feedSources the sources of the feed
+ * @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 Posts Live Collection
+ */
+const getUserFeed = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getUserFeed(tmpid: ${timestamp}) > listen`);
+    const userFeedLiveCollection = new UserFeedLiveCollectionController(params, callback);
+    const disposers = userFeedLiveCollection.startSubscription();
+    const cacheKey = userFeedLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getUserFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+var index$9 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    queryGlobalFeed: queryGlobalFeed,
+    getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
+    getUserFeed: getUserFeed
+});
+
+/* begin_public_function
+  id: post.get_by_ids
+*/
+/**
+ * ```js
+ * import { getPostByIds } from '@amityco/ts-sdk'
+ * const { data: posts } = await getPostByIds(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Post} objects
+ *
+ * @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 getPostByIds = async (postIds) => {
+    const client = getActiveClient();
+    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/posts/list`, {
+            params: { postIds: encodedPostIds },
+        });
+        payload = response.data;
+    }
+    catch (error) {
+        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 });
+    return {
+        data: data.posts.map(LinkedObject.post),
+        cachedAt,
+    };
+};
+/* 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('post/getPostByIds.locally', postIds);
+    if (!client.cache)
+        return;
+    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: 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 { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   data: { text: 'hello world' }
+ * }))
+ * ```
+ *
+ * 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 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 { PostRepository } from '@amityco/ts-sdk'
+ * const updated = await PostRepository.editPost(postId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Post}
+ *
+ * @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 Post API
+ * @async
+ */
+const editPost = async (postId, 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');
+    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,
+    };
+};
+/* end_public_function */
+
+/**
+ * ```js
+ * import { deletePost } from '@amityco/ts-sdk'
+ * const success = await deletePost('foobar')
+ * ```
+ *
+ * Deletes a {@link Amity.Post}
+ *
+ * @param postId The {@link Amity.Post} ID to delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
+ *
+ * @private
+ * @async
+ */
+const deletePost = async (postId, permanent = false) => {
+    var _a;
+    const client = getActiveClient();
+    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: 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);
+};
+/* end_public_function */
+
+/* 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: post.decline
+*/
 /**
  * ```js
- * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
- * const dispose = onPostUpdatedLocal(post => {
- *   // ...
- * })
+ * import { declinePost } from '@amityco/ts-sdk'
+ *
+ * const {data: post} = await declinePost('postId')
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been updated
+ * Declines 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 declined
+ * @return A {@link Amity.Post} that was declined
  *
- * @category Post Events
+ * @category Post API
+ * @async
  */
-const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+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);
+    }
+    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 */
 
+/* begin_public_function
+  id: post.flag
+*/
 /**
  * ```js
- * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onPostReactionAdded(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const flagged = await PostRepository.flagPost(postId, reason)
  * ```
  *
- * 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 flag
+ * @param reason the reason to flag the post
+ * @returns a boolean
  *
- * @category Post Events
- */
-const onLocalPostReactionAdded = (callback) => {
+ * @category Post API
+ * @async
+ * */
+const flagPost = async (postId, reason) => {
     const client = getActiveClient();
-    const filter = ({ post }) => {
-        if (!client.cache) {
-            callback(post);
-        }
-        else {
-            upsertInCache(['post', 'get', post.postId], post);
-            callback(post);
-        }
+    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 : '',
     };
-    return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+    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 { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onPostReactionRemoved(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const unflagged = await PostRepository.unflagPost(postId)
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been reacted
+ * @param postId of the post to unflag
+ * @returns the unflag post result
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @category Post API
+ * @async
+ * */
+const unflagPost = async (postId) => {
+    const client = getActiveClient();
+    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 { PostRepository } from '@amityco/ts-sdk'
+ * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
+ * ```
  *
- * @category Post Events
- */
-const onLocalPostReactionRemoved = (callback) => {
+ * @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 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
@@ -24684,7 +24977,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 }));
@@ -24773,19 +25066,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);
@@ -24851,47 +25131,6 @@ 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,
-    };
-};
-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,
-    };
-};
-
 class PostLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
         const queryStreamId = hash__default["default"](query);
@@ -24941,7 +25180,7 @@ class PostLiveCollectionController extends LiveCollectionController {
                         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);
+                        await getPost$1(comment.referenceId);
                         callback(comment);
                     });
                 }, 'referenceId', 'post'),
@@ -24954,7 +25193,7 @@ class PostLiveCollectionController extends LiveCollectionController {
                         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);
+                        await getPost$1(comment.referenceId);
                         callback(comment);
                     });
                 }, 'referenceId', 'post'),
@@ -25580,7 +25819,7 @@ var index$8 = /*#__PURE__*/Object.freeze({
     onPostUnflagged: onPostUnflagged,
     onPostReactionAdded: onPostReactionAdded,
     onPostReactionRemoved: onPostReactionRemoved,
-    getPost: getPost$1,
+    getPost: getPost,
     getPosts: getPosts,
     getPinnedPosts: getPinnedPosts,
     getGlobalPinnedPosts: getGlobalPinnedPosts,
@@ -28786,13 +29025,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;