@amityco/ts-sdk 7.7.1-00acca4a.0 → 7.7.1-0c84fd02.0

package/dist/index.esm.js

@@ -22453,19 +22453,17 @@ const dispose$7 = (cb) => {
 const onChannelSetMuted = (callback) => {
     if (callbacks$7.length === 0) {
         const client = getActiveClient();
-        const filter = async (payloads) => {
+        const filter = async (payload) => {
             var _a;
-            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(),
-                });
+            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',
-                payloads[0].channelId,
+                payload.channelId,
             ])) === null || _a === void 0 ? void 0 : _a.data;
             if (channel) {
                 callbacks$7.forEach(cb => cb(channel));
@@ -25874,6 +25872,26 @@ const fetchLinkPreview = async (url) => {
     return data;
 };
 
+/**
+ * ```js
+ * import Client from '@amityco/ts-sdk'
+ * const shareableLinkConfiguration = await Client.getShareableLinkConfiguration()
+ * const postLinkPattern = shareableLinkConfiguration.post
+ * ```
+ *
+ * Fetches a {@link Amity.ShareableLinkConfiguration} object
+ *
+ * @returns A Promise of {@link Amity.ShareableLinkConfiguration} object
+ *
+ * @category Client API
+ * @async
+ */
+const getShareableLinkConfiguration = async () => {
+    const client = getActiveClient();
+    const { data } = await client.http.get(`/api/v3/network-settings/shareable-deep-links`);
+    return data;
+};
+
 /**
  * ```js
  * import { onChannelMarkerFetched } from '@amityco/ts-sdk'
@@ -26243,6 +26261,7 @@ var index$o = /*#__PURE__*/Object.freeze({
     enableUnreadCount: enableUnreadCount,
     setUploadedFileAccessType: setUploadedFileAccessType,
     fetchLinkPreview: fetchLinkPreview,
+    getShareableLinkConfiguration: getShareableLinkConfiguration,
     onConnectionError: onConnectionError,
     onClientDisconnected: onClientDisconnected,
     onClientBanned: onClientBanned,
@@ -33828,23 +33847,20 @@ const onStreamViewerBanned = (callback) => {
     const client = getActiveClient();
     const filter = (payloads) => {
         var _a;
-        payloads.forEach(streamBanned => {
+        const { list } = payloads;
+        list.forEach(payload => {
             var _a;
-            mergeInCache(['stream', 'get', streamBanned.streamId], { watcherUrl: null });
+            mergeInCache(['stream', 'get', payload.streamId], { watcherUrl: null });
             // Update isDeleted = true in banned user's messages
             const messageCache = (_a = queryCache(['message', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(
             // Check if creator id and user id are internal or external id
-            ({ data }) => data.creatorId === streamBanned.userId);
+            ({ data }) => data.creatorId === payload.userId);
             // Update isDeleted for each relavant messages
             messageCache === null || messageCache === void 0 ? void 0 : messageCache.forEach(message => {
                 mergeInCache(message.key, { isDeleted: true });
             });
         });
-        const stream = (_a = pullFromCache([
-            'stream',
-            'get',
-            payloads[0].streamId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
+        const stream = (_a = pullFromCache(['stream', 'get', list[0].streamId])) === null || _a === void 0 ? void 0 : _a.data;
         if (!stream)
             return;
         callback(stream);
@@ -39272,1035 +39288,1010 @@ getCustomRankingGlobalFeed.locally = (query) => {
         : undefined;
 };
 
-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)));
-    }
-}
+var index$a = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    queryGlobalFeed: queryGlobalFeed,
+    getCustomRankingGlobalFeed: getCustomRankingGlobalFeed
+});
 
 /* begin_public_function
-  id: comment.get_by_ids
+  id: post.get_by_ids
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
+ * import { getPostByIds } from '@amityco/ts-sdk'
+ * const { data: posts } = await getPostByIds(['foo', 'bar'])
  * ```
  *
- * Fetches a collection of {@link Amity.Comment} objects
+ * Fetches a 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
+ * @param postIds the IDs of the {@link Amity.Post} to fetch
+ * @returns the associated collection of {@link Amity.Post} objects
  *
- * @category Comment API
+ * @category Post API
  * @async
  */
-const getCommentByIds = async (commentIds) => {
+const getPostByIds = async (postIds) => {
     const client = getActiveClient();
-    client.log('comment/getCommentByIds', commentIds);
-    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
-    let data;
+    client.log('post/getPostByIds', postIds);
+    const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
+    let payload;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/comments/list`, {
-            params: { commentIds: encodedCommentIds },
+        const response = await client.http.get(`/api/v3/posts/list`, {
+            params: { postIds: encodedPostIds },
         });
-        data = response.data;
+        payload = response.data;
     }
     catch (error) {
-        commentIds.forEach(commentId => {
+        postIds.forEach(postId => {
             if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                pushToTombstone('comment', commentId);
+                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.comments.map(comment => LinkedObject.comment(comment)),
+        data: data.posts.map(LinkedObject.post),
         cachedAt,
     };
 };
 /* end_public_function */
 /**
  * ```js
- * import { getCommentByIds } from '@amityco/ts-sdk'
- * const comments = getCommentByIds.locally(['foo', 'bar'])
+ * import { getPostByIds } from '@amityco/ts-sdk'
+ * const { data: posts } = getPostByIds.locally(['foo', 'bar'])
  * ```
  *
- * Fetches a collection of {@link Amity.Comment} objects from cache
+ * Fetches a collection of {@link Amity.Post} objects from cache
  *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated 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
  *
- * @category Comment API
+ * @category Post API
  */
-getCommentByIds.locally = (commentIds) => {
+getPostByIds.locally = (postIds) => {
     var _a;
     const client = getActiveClient();
-    client.log('comment/getCommentByIds.locally', commentIds);
+    client.log('post/getPostByIds.locally', postIds);
     if (!client.cache)
         return;
-    const cached = commentIds
-        .map(commentId => pullFromCache(['comment', 'get', commentId]))
+    const cached = postIds
+        .map(postId => pullFromCache(['post', 'get', postId]))
         .filter(Boolean);
-    const comments = cached.map(({ data }) => data);
+    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) < commentIds.length)
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) < postIds.length)
         return;
     return {
-        data: comments.map(comment => LinkedObject.comment(comment)),
+        data: posts.map(LinkedObject.post),
         cachedAt: oldest.cachedAt,
     };
 };
 
 /* begin_public_function
-  id: comment.create
+  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 { CommentRepository } from '@amityco/ts-sdk'
- * const newComment = await CommentRepository.createComment(bundle)
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   data: { text: 'hello world' }
+ * }))
  * ```
  *
- * Creates an {@link Amity.Comment}
+ * Creates an {@link Amity.Post}
  *
- * @param bundle The data necessary to create a new {@link Amity.Comment}
- * @returns The newly created {@link Amity.Comment}
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
  *
- * @category Comment API
+ * @category Post API
  * @async
  */
-const createComment = async (bundle) => {
-    var _a;
+const createPost = async (bundle) => {
     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');
+    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 });
-    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);
+    const { posts } = data;
     return {
-        data: LinkedObject.comment(comments[0]),
+        data: LinkedObject.post(posts[0]),
         cachedAt,
     };
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: comment.update_comment
+  id: post.edit, post.edit.custom_post
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const updated = await CommentRepository.updateComment(commentId, {
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const updated = await PostRepository.editPost(postId, {
  *   data: { text: 'hello world' }
  * })
  * ```
  *
- * Updates an {@link Amity.Comment}
+ * Updates an {@link Amity.Post}
  *
- * @param commentId The ID of the {@link Amity.Comment} to edit
+ * @param postId The ID of the {@link Amity.Post} to edit
  * @param patch The patch data to apply
- * @returns the updated {@link Amity.Comment} object
+ * @returns the updated {@link Amity.Post} object
  *
- * @category Comment API
+ * @category Post API
  * @async
  */
-const updateComment = async (commentId, patch) => {
+const editPost = async (postId, patch) => {
     const client = getActiveClient();
-    client.log('user/updateComment', patch);
-    const { data } = await client.http.put(`/api/v3/comments/${encodeURIComponent(commentId)}`, patch);
+    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('comment.updated', data);
-    const { comments } = data;
+    fireEvent('local.post.updated', data);
+    const { posts } = data;
     return {
-        data: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)),
+        data: LinkedObject.post(posts.find(post => post.postId === postId)),
         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 { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.deleteComment('foobar')
+ * import { deletePost } from '@amityco/ts-sdk'
+ * const success = await deletePost('foobar')
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Deletes a {@link Amity.Post}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param postId The {@link Amity.Post} ID to delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Comment API
+ * @private
  * @async
  */
-const deleteComment = async (commentId, permanent = false) => {
+const deletePost = async (postId, permanent = false) => {
     var _a;
     const client = getActiveClient();
-    const comment = await getComment$2(commentId);
-    // API-FIX: This endpoint has not been implemented yet.
-    await client.http.delete(`/api/v4/comments/${encodeURIComponent(commentId)}`, {
+    const post = await getPost$2(postId);
+    await client.http.delete(`/api/v4/posts/${encodeURIComponent(postId)}`, {
         params: {
-            commentId,
+            postId,
             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],
+    // 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: [],
-            comments: [],
-            communities: [],
-            communityUsers: [],
+            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 {
-        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: [],
-            });
-        }
+        upsertInCache(['post', 'get', postId], { isDeleted: true });
     }
-    fireEvent('local.comment.deleted', {
-        comments: [deleted],
-        commentChildren: [],
+    fireEvent('local.post.deleted', {
+        posts: [deleted],
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: [],
+        feeds: [],
         files: [],
+        postChildren: [],
         users: [],
-        communityUsers: [],
+        videoStreamings: [],
     });
-    if (permanent) {
-        scheduleTask(() => pushToTombstone('comment', commentId));
-    }
-    else {
-        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
-    }
-    return deleted;
+    return LinkedObject.post(deleted);
 };
-/* end_public_function */
 
 /* begin_public_function
-  id: comment.soft_delete
+  id: post.soft_delete
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.softDeleteComment('foobar')
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const success = await PostRepository.softDeletePost('foobar')
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Soft deletes a {@link Amity.Post}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param postId The {@link Amity.Post} ID to soft delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Comment API
+ * @category Post API
  * @async
  */
-const softDeleteComment = async (commentId) => {
+const softDeletePost = async (postId) => {
     const client = getActiveClient();
-    client.log('comment/softDeleteComment', commentId);
-    const softDeleted = deleteComment(commentId);
-    return softDeleted;
+    client.log('post/softDeletePost', postId);
+    const softDeleted = await deletePost(postId, false);
+    return LinkedObject.post(softDeleted);
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: comment.hard_delete
+  id: post.hard_delete
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.hardDeleteComment('foobar')
+ * import { hardDeletePost } from '@amityco/ts-sdk'
+ * const success = await hardDeletePost('foobar')
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Hard deletes a {@link Amity.Post}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param postId The {@link Amity.Post} ID to be hard delete
+ * @return A success boolean if the {@link Amity.Post} was deleted
  *
- * @category Comment API
+ * @category Post API
  * @async
  */
-const hardDeleteComment = async (commentId) => {
+const hardDeletePost = async (postId) => {
     const client = getActiveClient();
-    client.log('comment/hardDeleteComment', commentId);
-    const hardDeleted = deleteComment(commentId, true);
-    return hardDeleted;
+    client.log('post/hardDeletePost', postId);
+    const hardDeleted = await deletePost(postId, true);
+    return LinkedObject.post(hardDeleted);
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: comment.flag
+  id: post.approve
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const flagged = await CommentRepository.flagComment(commentId, reason)
+ * import { approvePost } from '@amityco/ts-sdk'
+ *
+ * const { data: post } = await approvePost('postId')
  * ```
  *
- * @param commentId The ID of the comment to flag
- * @param reason the reason to flag the comment
- * @returns the created report result
+ * Approves a {@link Amity.Post}
  *
- * @category Comment API
- * @async
- * */
-const flagComment = async (commentId, reason) => {
+ * @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('comment/flagComment', commentId);
+    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);
     const isPredefinedReason = reason &&
         Object.entries(ContentFlagReasonEnum).some(([key, value]) => key !== ContentFlagReasonEnum.Others && value === reason);
     const body = {
         reason: reason && isPredefinedReason ? reason : ContentFlagReasonEnum.Others,
         detail: reason && !isPredefinedReason ? reason : '',
     };
-    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/flag`, body);
+    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`, body);
     if (client.cache) {
-        ingestInCache(payload);
+        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
     }
-    fireEvent('comment.flagged', payload);
+    fireEvent('post.flagged', payload);
     return !!payload;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: comment.unflag
+  id: post.unflag
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const unflagged = await CommentRepository.unflagComment('commentId')
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const unflagged = await PostRepository.unflagPost(postId)
  * ```
  *
- * @param commentId The ID of comment to unflag
- * @returns the unflagged result
+ * @param postId of the post to unflag
+ * @returns the unflag post result
  *
- * @category Comment API
+ * @category Post API
  * @async
  * */
-const unflagComment = async (commentId) => {
+const unflagPost = async (postId) => {
     const client = getActiveClient();
-    client.log('comment/unflagComment', commentId);
-    const { data: payload } = await client.http.delete(`/api/v3/comments/${encodeURIComponent(commentId)}/unflag`);
+    client.log('post/unflagPost', postId);
+    const { data: payload } = await client.http.delete(`/api/v3/posts/${encodeURIComponent(postId)}/unflag`);
     if (client.cache) {
-        ingestInCache(payload);
+        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
     }
-    fireEvent('comment.unflagged', payload);
+    fireEvent('post.unflagged', payload);
     return !!payload;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: comment.check_flag_by_me
+  id: post.check_flag_by_me
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const isReported = await CommentRepository.isCommentFlaggedByMe('commentId')
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
  * ```
  *
- * @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.
+ * @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 Comment API
+ * @category Post API
  * @async
  * */
-const isCommentFlaggedByMe = async (commentId) => {
+const isPostFlaggedByMe = async (postId) => {
     const client = getActiveClient();
-    client.log('comment/isCommentFlaggedByMe', commentId);
-    const { data: { result }, } = await client.http.get(`/api/v3/comments/${commentId}/isflagbyme`);
+    client.log('post/isPostFlaggedByMe', postId);
+    const { data: { result }, } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
     return result;
 };
 /* end_public_function */
 
-const getComment$1 = async (commentId) => {
+/* 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('comment/getComment', commentId);
-    isInTombstone('comment', commentId);
+    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 client = getActiveClient();
+    client.log('comment/getCommentByIds', commentIds);
+    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/comments/${encodeURIComponent(commentId)}`);
+        const response = await client.http.get(`/api/v3/comments/list`, {
+            params: { commentIds: encodedCommentIds },
+        });
         data = response.data;
     }
     catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('comment', commentId);
-        }
+        commentIds.forEach(commentId => {
+            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+                pushToTombstone('comment', commentId);
+            }
+        });
         throw error;
     }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    const { comments } = data;
     return {
-        data: comments.find(comment => comment.commentId === commentId),
+        data: data.comments.map(comment => LinkedObject.comment(comment)),
         cachedAt,
     };
 };
-getComment$1.locally = (commentId) => {
+/* 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;
     const client = getActiveClient();
-    client.log('comment/getComment.locally', commentId);
+    client.log('comment/getCommentByIds.locally', commentIds);
     if (!client.cache)
         return;
-    const cached = pullFromCache(['comment', 'get', commentId]);
-    if (!cached)
+    const cached = commentIds
+        .map(commentId => pullFromCache(['comment', 'get', commentId]))
+        .filter(Boolean);
+    const comments = cached.map(({ data }) => data);
+    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
+    if ((cached === null || cached === void 0 ? void 0 : cached.length) < commentIds.length)
         return;
     return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
+        data: comments.map(comment => LinkedObject.comment(comment)),
+        cachedAt: oldest.cachedAt,
     };
 };
 
+/* begin_public_function
+  id: comment.create
+*/
 /**
  * ```js
- * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleteLocal(comment => {
- *   // ...
- * })
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const newComment = await CommentRepository.createComment(bundle)
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been deleted
+ * Creates an {@link Amity.Comment}
  *
- * @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.Comment}
+ * @returns The newly created {@link Amity.Comment}
  *
- * @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
+ * @category Comment API
+ * @async
  */
-const onLocalCommentReactionAdded = (callback) => {
+const createComment = async (bundle) => {
+    var _a;
     const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
+    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 {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
+    }
+    else if (bundle.referenceType === 'story') {
+        const storyIndex = pullFromCache([
+            "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
+            bundle.referenceId,
+        ]);
+        if (storyIndex === null || storyIndex === void 0 ? void 0 : storyIndex.data) {
+            const cacheStory = pullFromCache([
+                "story" /* STORY_KEY_CACHE.STORY */,
+                'get',
+                storyIndex.data,
+            ]);
+            if (cacheStory === null || cacheStory === void 0 ? void 0 : cacheStory.data) {
+                fireEvent('story.updated', {
+                    stories: [
+                        Object.assign(Object.assign({}, cacheStory.data), { commentsCount: cacheStory.data.commentsCount + 1, comments: [...new Set([...cacheStory.data.comments, comments[0].commentId])] }),
+                    ],
+                    categories: [],
+                    comments,
+                    communities: [],
+                    communityUsers: data.communityUsers,
+                    files: data.files,
+                    users: data.users,
+                });
+            }
         }
+    }
+    fireEvent('local.comment.created', data);
+    return {
+        data: LinkedObject.comment(comments[0]),
+        cachedAt,
     };
-    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
 };
+/* end_public_function */
 
+/* begin_public_function
+  id: comment.update_comment
+*/
 /**
  * ```js
- * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionRemoved(comment => {
- *   // ...
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const updated = await CommentRepository.updateComment(commentId, {
+ *   data: { text: 'hello world' }
  * })
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been reacted
+ * Updates an {@link Amity.Comment}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @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
  *
- * @category Comment Events
+ * @category Comment API
+ * @async
  */
-const onLocalCommentReactionRemoved = (callback) => {
+const updateComment = async (commentId, patch) => {
     const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
-        }
-        else {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
+    client.log('user/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 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,
     };
-    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
 };
 
 /* begin_public_function
-  id: comment.get
+  id: comment.soft_delete, comment.hard_delete
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk';
- *
- * let comment;
- *
- * const unsub = CommentRepository.getComment(commentId, response => {
- *   comment = response.data;
- * });
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.deleteComment('foobar')
  * ```
  *
- * Observe all mutation on a given {@link Amity.Comment}
+ * Deletes a {@link Amity.Comment}
  *
- * @param commentId the ID of the comment to observe
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Comment Live Object
+ * @category Comment API
+ * @async
  */
-const getComment = (commentId, callback) => {
-    return liveObject(commentId, callback, 'commentId', getComment$1, [
-        onCommentDeleteLocal,
-        onCommentDeleted,
-        onCommentFlagged,
-        onCommentReactionAdded,
-        onCommentReactionRemoved,
-        onCommentUnflagged,
-        onCommentUpdated,
-        onLocalCommentReactionAdded,
-        onLocalCommentReactionRemoved,
-    ]);
-};
-/* end_public_function */
-
-class CommentPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
-        const baseOptions = {
-            type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
-        };
-        const options = token ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { limit });
-        const { data: queryResponse } = await this.http.get(`/api/v3/comments`, {
-            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), options }),
-        });
-        return queryResponse;
-    }
-}
-
-var EnumCommentActions;
-(function (EnumCommentActions) {
-    EnumCommentActions["OnCommentCreated"] = "onCommentCreated";
-    EnumCommentActions["OnCommentUpdated"] = "onCommentUpdated";
-    EnumCommentActions["OnCommentDeleted"] = "onCommentDeleted";
-    EnumCommentActions["OnCommentFlagged"] = "onCommentFlagged";
-    EnumCommentActions["OnCommentUnflagged"] = "onCommentUnflagged";
-    EnumCommentActions["OnCommentReactionAdded"] = "onCommentReactionAdded";
-    EnumCommentActions["OnCommentReactionRemoved"] = "onCommentReactionRemoved";
-})(EnumCommentActions || (EnumCommentActions = {}));
-
-class CommentQueryStreamController extends QueryStreamController {
-    constructor(query, cacheKey, notifyChange, preparePayload) {
-        super(query, cacheKey);
-        this.notifyChange = notifyChange;
-        this.preparePayload = preparePayload;
-    }
-    async saveToMainDB(response) {
-        const processedPayload = await this.preparePayload(response);
-        const client = getActiveClient();
-        const cachedAt = client.cache && Date.now();
-        if (client.cache) {
-            ingestInCache(processedPayload, { cachedAt });
-        }
+const deleteComment = async (commentId, permanent = false) => {
+    var _a;
+    const client = getActiveClient();
+    const comment = await getComment$2(commentId);
+    // API-FIX: This endpoint has not been implemented yet.
+    await client.http.delete(`/api/v4/comments/${encodeURIComponent(commentId)}`, {
+        params: {
+            commentId,
+            permanent,
+        },
+    });
+    // to support hard deletion
+    const deleted = Object.assign(Object.assign({}, comment.data), { isDeleted: true });
+    if (comment.data.referenceType === 'story') {
+        const story = await getStoryByStoryId$1(comment.data.referenceId);
+        fireEvent('local.story.updated', {
+            stories: [story.data],
+            categories: [],
+            comments: [],
+            communities: [],
+            communityUsers: [],
+            files: [],
+            users: [],
+        });
     }
-    appendToQueryStream(response, direction, refresh = false) {
-        var _a, _b;
-        if (refresh) {
-            pushToCache(this.cacheKey, {
-                data: response.comments.map(getResolver('comment')),
+    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: [],
             });
         }
-        else {
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            const comments = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...comments, ...response.comments.map(getResolver('comment'))])] }));
-        }
     }
-    reactor(action) {
-        return (comment) => {
-            var _a;
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            if (this.query.referenceId !== comment.referenceId ||
-                this.query.referenceType !== comment.referenceType ||
-                !collection) {
-                return;
-            }
-            if (this.query.parentId && this.query.parentId !== comment.parentId) {
-                return;
-            }
-            if (!this.query.parentId && comment.parentId) {
-                return;
-            }
-            if (action === EnumCommentActions.OnCommentCreated) {
-                collection.data = [...new Set([comment.commentId, ...collection.data])];
-            }
-            pushToCache(this.cacheKey, collection);
-            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
-        };
+    fireEvent('local.comment.deleted', {
+        comments: [deleted],
+        commentChildren: [],
+        files: [],
+        users: [],
+        communityUsers: [],
+    });
+    if (permanent) {
+        scheduleTask(() => pushToTombstone('comment', commentId));
     }
-    subscribeRTE(createSubscriber) {
-        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    else {
+        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
     }
-}
+    return deleted;
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: comment.soft_delete
+*/
 /**
  * ```js
- * import { onCommentCreated } from '@amityco/ts-sdk'
- * const dispose = onCommentCreated(comment => {
- *   // ...
- * })
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.softDeleteComment('foobar')
  * ```
  *
- * Fired when a {@link Amity.InternalComment} has been created
+ * Deletes a {@link Amity.Comment}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Comment Events
+ * @category Comment API
+ * @async
  */
-const onCommentCreatedLocal = (callback) => {
-    return createLocalCommentEventSubscriber('local.comment.created', callback);
+const softDeleteComment = async (commentId) => {
+    const client = getActiveClient();
+    client.log('comment/softDeleteComment', commentId);
+    const softDeleted = deleteComment(commentId);
+    return softDeleted;
 };
-
-class CommentLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash(query);
-        const cacheKey = ['comments', 'collection', queryStreamId];
-        const paginationController = new CommentPaginationController(query);
-        super(paginationController, queryStreamId, cacheKey, callback);
-        this.query = query;
-        this.queryStreamController = new CommentQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommentPayload);
-        this.callback = callback.bind(this);
-        this.loadPage({ initial: true });
-    }
-    setup() {
-        var _a;
-        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection) {
-            pushToCache(this.cacheKey, {
-                data: [],
-                params: {},
-            });
-        }
-    }
-    async persistModel(queryPayload) {
-        await this.queryStreamController.saveToMainDB(queryPayload);
-    }
-    persistQueryStream({ response, direction, refresh, }) {
-        this.queryStreamController.appendToQueryStream(response, direction, refresh);
-    }
-    startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
-            { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
-            { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
-            { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
-            { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
-            { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
-            { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
-            { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
-            { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
-            { fn: onLocalCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
-            { fn: onLocalCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
-        ]);
-    }
-    notifyChange({ origin, loading, error }) {
-        var _a, _b;
-        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        const data = this.applyFilter((_b = collection.data
-            .map(id => pullFromCache(['comment', 'get', id]))
-            .filter(isNonNullable)
-            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.comment);
-        if (!this.shouldNotify(data) && origin === 'event')
-            return;
-        this.callback({
-            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
-            data,
-            hasNextPage: !!this.paginationController.getNextToken(),
-            loading,
-            error,
-        });
-    }
-    applyFilter(data) {
-        let comments = data;
-        if (!this.query.includeDeleted) {
-            comments = filterByPropEquality(comments, 'isDeleted', false);
-        }
-        if (this.query.parentId) {
-            comments = comments.filter(comment => comment.parentId === this.query.parentId);
-        }
-        if (typeof this.query.hasFlag === 'boolean') {
-            if (this.query.hasFlag) {
-                comments = comments.filter(comment => comment.hashFlag != null);
-            }
-            else {
-                comments = comments.filter(comment => comment.hashFlag == null);
-            }
-        }
-        if (this.query.dataTypes) {
-            if (this.query.dataTypes.matchType === 'exact') {
-                comments = comments.filter(comment => {
-                    var _a, _b;
-                    const sortedDataTypesQueryValue = ((_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.sort()) || [];
-                    const sortedDataTypesCommentValue = ((_b = comment.dataTypes) === null || _b === void 0 ? void 0 : _b.sort()) || [];
-                    if (sortedDataTypesCommentValue.length !== sortedDataTypesQueryValue.length) {
-                        return false;
-                    }
-                    return sortedDataTypesQueryValue.every((value, index) => value === sortedDataTypesCommentValue[index]);
-                });
-            }
-            if (this.query.dataTypes.matchType === 'any') {
-                comments = comments.filter(comment => { var _a; return (_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.some(value => { var _a; return (_a = comment.dataTypes) === null || _a === void 0 ? void 0 : _a.includes(value); }); });
-            }
-        }
-        switch (this.query.sortBy) {
-            case 'firstCreated':
-                comments = comments.sort(sortByFirstCreated);
-                break;
-            case 'lastCreated':
-            default:
-                comments = comments.sort(sortByLastCreated);
-                break;
-        }
-        return comments;
-    }
-}
+/* end_public_function */
 
 /* begin_public_function
-  id: comment.query
+  id: comment.hard_delete
 */
 /**
  * ```js
- * import { getComments } from '@amityco/ts-sdk'
- *
- * let comments = []
- * const unsub = getComments({
- *   referenceType: Amity.InternalComment['referenceType'];
- *   referenceId: Amity.InternalComment['referenceId'];
- * }, response => merge(comments, response.data))
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.hardDeleteComment('foobar')
  * ```
  *
- * Observe all mutations on a list of {@link Amity.InternalComment} for a given target object
+ * Deletes a {@link Amity.Comment}
  *
- * @param referenceType the type of the target
- * @param referenceId the ID of the target
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Comments Live Collection
+ * @category Comment API
+ * @async
  */
-const getComments = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log('For using Live Collection feature you need to enable Cache!');
-    }
-    const timestamp = Date.now();
-    log(`getComments(tmpid: ${timestamp}) > listen`);
-    const commentsLiveCollection = new CommentLiveCollectionController(params, callback);
-    const disposers = commentsLiveCollection.startSubscription();
-    const cacheKey = commentsLiveCollection.getCacheKey();
-    disposers.push(() => dropFromCache(cacheKey));
-    return () => {
-        log(`getComments(tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
+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(ContentFlagReasonEnum).some(([key, value]) => key !== ContentFlagReasonEnum.Others && value === reason);
+    const body = {
+        reason: reason && isPredefinedReason ? reason : 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 */
 
-var index$a = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getCommentByIds: getCommentByIds,
-    createComment: createComment,
-    updateComment: updateComment,
-    deleteComment: deleteComment,
-    softDeleteComment: softDeleteComment,
-    hardDeleteComment: hardDeleteComment,
-    flagComment: flagComment,
-    unflagComment: unflagComment,
-    isCommentFlaggedByMe: isCommentFlaggedByMe,
-    onCommentCreated: onCommentCreated,
-    onCommentUpdated: onCommentUpdated,
-    onCommentDeleted: onCommentDeleted,
-    onCommentFlagged: onCommentFlagged,
-    onCommentUnflagged: onCommentUnflagged,
-    onCommentReactionAdded: onCommentReactionAdded,
-    onCommentReactionRemoved: onCommentReactionRemoved,
-    getComment: getComment,
-    getComments: getComments
-});
+/* 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 getPost$1 = async (postId) => {
+const getComment$1 = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/getPost', postId);
-    isInTombstone('post', postId);
-    let payload;
+    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/posts/${encodeURIComponent(postId)}`);
-        payload = response.data;
+        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('post', postId);
+            pushToTombstone('comment', commentId);
         }
         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);
+    const { comments } = data;
     return {
-        data: result,
+        data: comments.find(comment => comment.commentId === commentId),
         cachedAt,
     };
 };
-getPost$1.locally = (postId) => {
+getComment$1.locally = (commentId) => {
     const client = getActiveClient();
-    client.log('post/getPost.locally', postId);
+    client.log('comment/getComment.locally', commentId);
     if (!client.cache)
         return;
-    const cached = pullFromCache(['post', 'get', postId]);
+    const cached = pullFromCache(['comment', 'get', commentId]);
     if (!cached)
         return;
     return {
@@ -40311,110 +40302,228 @@ getPost$1.locally = (postId) => {
 
 /**
  * ```js
- * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
- * const dispose = onPostUpdatedLocal(post => {
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleteLocal(comment => {
  *   // ...
  * })
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been updated
+ * 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 Post Events
+ * @category Comment Events
  */
-const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
 
 /**
  * ```js
- * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onPostReactionAdded(post => {
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionAdded(comment => {
  *   // ...
  * })
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been reacted
+ * 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 Post Events
+ * @category Comment Events
  */
-const onLocalPostReactionAdded = (callback) => {
+const onLocalCommentReactionAdded = (callback) => {
     const client = getActiveClient();
-    const filter = ({ post }) => {
+    const filter = ({ comment }) => {
         if (!client.cache) {
-            callback(post);
+            callback(comment);
         }
         else {
-            upsertInCache(['post', 'get', post.postId], post);
-            callback(post);
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
         }
     };
-    return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
 };
 
 /**
  * ```js
- * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onPostReactionRemoved(post => {
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
  *   // ...
  * })
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been reacted
+ * 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 Post Events
+ * @category Comment Events
  */
-const onLocalPostReactionRemoved = (callback) => {
+const onLocalCommentReactionRemoved = (callback) => {
     const client = getActiveClient();
-    const filter = ({ post }) => {
+    const filter = ({ comment }) => {
         if (!client.cache) {
-            callback(post);
+            callback(comment);
         }
         else {
-            upsertInCache(['post', 'get', post.postId], post);
-            callback(post);
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
         }
     };
-    return createEventSubscriber(client, 'local.post.removeReaction', 'local.post.removeReaction', filter);
+    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
 };
 
+/* begin_public_function
+  id: comment.get
+*/
 /**
  * ```js
- * import { onLocalPostDeleted } from '@amityco/ts-sdk'
- * const dispose = onLocalPostDeleted(post => {
- *   // ...
- * })
+ * import { CommentRepository } from '@amityco/ts-sdk';
+ *
+ * let comment;
+ *
+ * const unsub = CommentRepository.getComment(commentId, response => {
+ *   comment = response.data;
+ * });
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been deleted
+ * Observe all mutation on a given {@link Amity.Comment}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Post Events
+ * @category Comment Live Object
  */
-const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
+const getComment = (commentId, callback) => {
+    return liveObject(commentId, callback, 'commentId', getComment$1, [
+        onCommentDeleteLocal,
+        onCommentDeleted,
+        onCommentFlagged,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentUnflagged,
+        onCommentUpdated,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ]);
+};
+/* end_public_function */
 
-class UserFeedLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash(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 });
+class CommentPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted } = queryParams, params = __rest(queryParams, ["limit", "includeDeleted"]);
+        const baseOptions = {
+            type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
+        };
+        const options = token ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { limit });
+        const { data: queryResponse } = await this.http.get(`/api/v3/comments`, {
+            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), options }),
+        });
+        return queryResponse;
     }
-    setup() {
-        var _a;
-        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+}
+
+var EnumCommentActions;
+(function (EnumCommentActions) {
+    EnumCommentActions["OnCommentCreated"] = "onCommentCreated";
+    EnumCommentActions["OnCommentUpdated"] = "onCommentUpdated";
+    EnumCommentActions["OnCommentDeleted"] = "onCommentDeleted";
+    EnumCommentActions["OnCommentFlagged"] = "onCommentFlagged";
+    EnumCommentActions["OnCommentUnflagged"] = "onCommentUnflagged";
+    EnumCommentActions["OnCommentReactionAdded"] = "onCommentReactionAdded";
+    EnumCommentActions["OnCommentReactionRemoved"] = "onCommentReactionRemoved";
+})(EnumCommentActions || (EnumCommentActions = {}));
+
+class CommentQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.comments.map(getResolver('comment')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const comments = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...comments, ...response.comments.map(getResolver('comment'))])] }));
+        }
+    }
+    reactor(action) {
+        return (comment) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (this.query.referenceId !== comment.referenceId ||
+                this.query.referenceType !== comment.referenceType ||
+                !collection) {
+                return;
+            }
+            if (this.query.parentId && this.query.parentId !== comment.parentId) {
+                return;
+            }
+            if (!this.query.parentId && comment.parentId) {
+                return;
+            }
+            if (action === EnumCommentActions.OnCommentCreated) {
+                collection.data = [...new Set([comment.commentId, ...collection.data])];
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentCreatedLocal = (callback) => {
+    return createLocalCommentEventSubscriber('local.comment.created', callback);
+};
+
+class CommentLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['comments', 'collection', queryStreamId];
+        const paginationController = new CommentPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new CommentQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommentPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
         if (!collection) {
             pushToCache(this.cacheKey, {
                 data: [],
@@ -40430,45 +40539,17 @@ class UserFeedLiveCollectionController extends LiveCollectionController {
     }
     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,
-            },
+            { fn: onCommentCreatedLocal, action: EnumCommentActions.OnCommentCreated },
+            { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
+            { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
+            { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
+            { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+            { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
+            { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
+            { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+            { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+            { fn: onLocalCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+            { fn: onLocalCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -40477,9 +40558,9 @@ class UserFeedLiveCollectionController extends LiveCollectionController {
         if (!collection)
             return;
         const data = this.applyFilter((_b = collection.data
-            .map(id => pullFromCache(['post', 'get', id]))
+            .map(id => pullFromCache(['comment', 'get', id]))
             .filter(isNonNullable)
-            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.comment);
         if (!this.shouldNotify(data) && origin === 'event')
             return;
         this.callback({
@@ -40491,560 +40572,204 @@ class UserFeedLiveCollectionController extends LiveCollectionController {
         });
     }
     applyFilter(data) {
-        var _a;
-        let posts = data;
+        let comments = data;
         if (!this.query.includeDeleted) {
-            posts = filterByPropEquality(posts, 'isDeleted', false);
+            comments = filterByPropEquality(comments, 'isDeleted', false);
         }
-        if ((_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.length) {
-            posts = filterByPostDataTypes(posts, this.query.dataTypes);
+        if (this.query.parentId) {
+            comments = comments.filter(comment => comment.parentId === this.query.parentId);
+        }
+        if (typeof this.query.hasFlag === 'boolean') {
+            if (this.query.hasFlag) {
+                comments = comments.filter(comment => comment.hashFlag != null);
+            }
+            else {
+                comments = comments.filter(comment => comment.hashFlag == null);
+            }
+        }
+        if (this.query.dataTypes) {
+            if (this.query.dataTypes.matchType === 'exact') {
+                comments = comments.filter(comment => {
+                    var _a, _b;
+                    const sortedDataTypesQueryValue = ((_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.sort()) || [];
+                    const sortedDataTypesCommentValue = ((_b = comment.dataTypes) === null || _b === void 0 ? void 0 : _b.sort()) || [];
+                    if (sortedDataTypesCommentValue.length !== sortedDataTypesQueryValue.length) {
+                        return false;
+                    }
+                    return sortedDataTypesQueryValue.every((value, index) => value === sortedDataTypesCommentValue[index]);
+                });
+            }
+            if (this.query.dataTypes.matchType === 'any') {
+                comments = comments.filter(comment => { var _a; return (_a = this.query.dataTypes) === null || _a === void 0 ? void 0 : _a.values.some(value => { var _a; return (_a = comment.dataTypes) === null || _a === void 0 ? void 0 : _a.includes(value); }); });
+            }
         }
         switch (this.query.sortBy) {
             case 'firstCreated':
-                posts = posts.sort(sortByFirstCreated);
+                comments = comments.sort(sortByFirstCreated);
                 break;
             case 'lastCreated':
             default:
-                posts = posts.sort(sortByLastCreated);
+                comments = comments.sort(sortByLastCreated);
                 break;
         }
-        return posts;
+        return comments;
     }
 }
 
 /* begin_public_function
-  id: feed.query.user_feed
+  id: comment.query
 */
 /**
  * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
+ * import { getComments } from '@amityco/ts-sdk'
  *
- * let posts = []
- * const unsubscribe = FeedRepository.getUserFeed({
- *   userId: string,
- *   feedSources: ['user', 'community'],
- * }, response => response => processResponse(response))
+ * let comments = []
+ * const unsub = getComments({
+ *   referenceType: Amity.InternalComment['referenceType'];
+ *   referenceId: Amity.InternalComment['referenceId'];
+ * }, response => merge(comments, response.data))
  * ```
  *
- * Observe all mutations on a list of {@link Amity.Post} for a given user and feedSources
+ * Observe all mutations on a list of {@link Amity.InternalComment} for a given target object
  *
- * @param params.userId the ID of the user
- * @param params.feedSources the sources of the feed
+ * @param referenceType the type of the target
+ * @param referenceId the ID of the target
  * @param callback the function to call when new data are available
- * @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 { 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);
+ *
+ * @category Comments Live Collection
+ */
+const getComments = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log('For using Live Collection feature you need to enable Cache!');
     }
-    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,
+    const timestamp = Date.now();
+    log(`getComments(tmpid: ${timestamp}) > listen`);
+    const commentsLiveCollection = new CommentLiveCollectionController(params, callback);
+    const disposers = commentsLiveCollection.startSubscription();
+    const cacheKey = commentsLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getComments(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
     };
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: post.flag
-*/
+var index$9 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getCommentByIds: getCommentByIds,
+    createComment: createComment,
+    updateComment: updateComment,
+    deleteComment: deleteComment,
+    softDeleteComment: softDeleteComment,
+    hardDeleteComment: hardDeleteComment,
+    flagComment: flagComment,
+    unflagComment: unflagComment,
+    isCommentFlaggedByMe: isCommentFlaggedByMe,
+    onCommentCreated: onCommentCreated,
+    onCommentUpdated: onCommentUpdated,
+    onCommentDeleted: onCommentDeleted,
+    onCommentFlagged: onCommentFlagged,
+    onCommentUnflagged: onCommentUnflagged,
+    onCommentReactionAdded: onCommentReactionAdded,
+    onCommentReactionRemoved: onCommentReactionRemoved,
+    getComment: getComment,
+    getComments: getComments
+});
+
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const flagged = await PostRepository.flagPost(postId, reason)
+ * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
+ * const dispose = onPostUpdatedLocal(post => {
+ *   // ...
+ * })
  * ```
  *
- * @param postId of the post to flag
- * @param reason the reason to flag the post
- * @returns a boolean
+ * Fired when a {@link Amity.InternalPost} has been updated
  *
- * @category Post API
- * @async
- * */
-const flagPost = async (postId, reason) => {
-    const client = getActiveClient();
-    client.log('post/flagPost', postId);
-    const isPredefinedReason = reason &&
-        Object.entries(ContentFlagReasonEnum).some(([key, value]) => key !== ContentFlagReasonEnum.Others && value === reason);
-    const body = {
-        reason: reason && isPredefinedReason ? reason : ContentFlagReasonEnum.Others,
-        detail: reason && !isPredefinedReason ? reason : '',
-    };
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`, body);
-    if (client.cache) {
-        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
-    }
-    fireEvent('post.flagged', payload);
-    return !!payload;
-};
-/* end_public_function */
+ * @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);
 
-/* begin_public_function
-  id: post.unflag
-*/
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const unflagged = await PostRepository.unflagPost(postId)
+ * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
  * ```
  *
- * @param postId of the post to unflag
- * @returns the unflag post result
+ * Fired when a {@link Amity.InternalPost} has been reacted
  *
- * @category Post API
- * @async
- * */
-const unflagPost = async (postId) => {
+ * @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();
-    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;
+    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);
 };
-/* 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)
+ * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
  * ```
  *
- * @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.
+ * Fired when a {@link Amity.InternalPost} has been reacted
  *
- * @category Post API
- * @async
- * */
-const isPostFlaggedByMe = async (postId) => {
+ * @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();
-    client.log('post/isPostFlaggedByMe', postId);
-    const { data: { result }, } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
-    return result;
+    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);
 };
-/* 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 }]
- * }))
+ * import { onLocalPostDeleted } from '@amityco/ts-sdk'
+ * const dispose = onLocalPostDeleted(post => {
+ *   // ...
+ * })
  * ```
  *
- * Creates an {@link Amity.Post}
+ * Fired when a {@link Amity.InternalPost} has been deleted
  *
- * @param bundle The data necessary to create a new {@link Amity.Post}
- * @returns The newly created {@link Amity.Post}
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Post API
- * @async
+ * @category Post Events
  */
-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 */
+const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
 
 /* begin_public_function
   id: post.get
@@ -41068,7 +40793,7 @@ const createClipPost = async (bundle) => {
  *
  * @category Post Live Object
  */
-const getPost = (postId, callback) => {
+const getPost$1 = (postId, callback) => {
     const responder = (snapshot) => {
         const { data } = snapshot;
         callback(Object.assign(Object.assign({}, snapshot), { data: data ? LinkedObject.post(snapshot.data) : data }));
@@ -41157,6 +40882,19 @@ 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);
@@ -41222,6 +40960,47 @@ 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(query);
@@ -41271,7 +41050,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$1(comment.referenceId);
+                        await getPost(comment.referenceId);
                         callback(comment);
                     });
                 }, 'referenceId', 'post'),
@@ -41284,7 +41063,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$1(comment.referenceId);
+                        await getPost(comment.referenceId);
                         callback(comment);
                     });
                 }, 'referenceId', 'post'),
@@ -41910,7 +41689,7 @@ var index$8 = /*#__PURE__*/Object.freeze({
     onPostUnflagged: onPostUnflagged,
     onPostReactionAdded: onPostReactionAdded,
     onPostReactionRemoved: onPostReactionRemoved,
-    getPost: getPost,
+    getPost: getPost$1,
     getPosts: getPosts,
     getPinnedPosts: getPinnedPosts,
     getGlobalPinnedPosts: getGlobalPinnedPosts,
@@ -42279,12 +42058,9 @@ const onStreamViewerUnbanned = (callback) => {
     const filter = async (payloads) => {
         var _a;
         // Get new stream object to restore stream watcherUrl in cache
-        await Promise.all(payloads.map(({ streamId }) => getStream(streamId)));
-        const stream = (_a = pullFromCache([
-            'stream',
-            'get',
-            payloads[0].streamId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
+        const { list } = payloads;
+        await Promise.all(list.map(({ streamId }) => getStream(streamId)));
+        const stream = (_a = pullFromCache(['stream', 'get', list[0].streamId])) === null || _a === void 0 ? void 0 : _a.data;
         if (!stream)
             return;
         callback(stream);
@@ -45111,4 +44887,4 @@ var index = /*#__PURE__*/Object.freeze({
     getReactions: getReactions
 });
 
-export { API_REGIONS, index$3 as AdRepository, index$b as CategoryRepository, index$f as ChannelRepository, index$o as Client, index$a as CommentRepository, CommunityPostSettingMaps, CommunityPostSettings, index$c as CommunityRepository, ContentFeedType, ContentFlagReasonEnum, DefaultCommunityPostSetting, index$9 as FeedRepository, FileAccessTypeEnum, index$l as FileRepository, FileType, index$1 as InvitationRepository, InvitationSortByEnum, InvitationStatusEnum, InvitationTypeEnum, JoinRequestStatusEnum, JoinResultStatusEnum, index as LiveReactionRepository, index$5 as LiveStreamPlayer, MembershipAcceptanceTypeEnum, MessageContentType, index$j as MessageRepository, index$6 as PollRepository, PostContentType, index$8 as PostRepository, index$k as ReactionRepository, index$4 as StoryRepository, index$7 as StreamRepository, index$i as SubChannelRepository, SubscriptionLevels, index$m as UserRepository, VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, backupCache, createQuery, createReport, createUserToken, deleteReport, disableCache, dropFromCache, enableCache, filterByChannelMembership, filterByCommunityMembership, filterByFeedType, filterByPostDataTypes, filterByPropEquality, filterByPropInclusion, filterByPropIntersection, filterBySearchTerm, filterByStringComparePartially, getChannelTopic, getCommentTopic, getCommunityStoriesTopic, getCommunityTopic, getLiveReactionTopic, getLiveStreamTopic, getMarkedMessageTopic, getMarkerUserFeedTopic, getMessageTopic, getMyFollowersTopic, getMyFollowingsTopic, getNetworkTopic, getPostTopic, getRole, getSmartFeedChannelTopic, getSmartFeedMessageTopic, getSmartFeedSubChannelTopic, getStoryTopic, getSubChannelTopic, getUserTopic, isAfterBefore, isAfterBeforeRaw, isCachable, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkip, mergeInCache, index$2 as notificationTray, onChannelMarkerFetched, onFeedMarkerFetched, onFeedMarkerUpdated, onMessageMarked, onMessageMarkerFetched, onSubChannelMarkerFetched, onSubChannelMarkerUpdated, onUserMarkerFetched, onUserMarkerFetchedLegacy, pullFromCache, pushToCache, queryCache, queryOptions, queryRoles, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByFirstUpdated, sortByLastActivity, sortByLastCreated, sortByLastUpdated, sortByLocalSortingDate, sortByName, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, upsertInCache, wipeCache };
+export { API_REGIONS, index$3 as AdRepository, index$b as CategoryRepository, index$f as ChannelRepository, index$o as Client, index$9 as CommentRepository, CommunityPostSettingMaps, CommunityPostSettings, index$c as CommunityRepository, ContentFeedType, ContentFlagReasonEnum, DefaultCommunityPostSetting, index$a as FeedRepository, FileAccessTypeEnum, index$l as FileRepository, FileType, index$1 as InvitationRepository, InvitationSortByEnum, InvitationStatusEnum, InvitationTypeEnum, JoinRequestStatusEnum, JoinResultStatusEnum, index as LiveReactionRepository, index$5 as LiveStreamPlayer, MembershipAcceptanceTypeEnum, MessageContentType, index$j as MessageRepository, index$6 as PollRepository, PostContentType, index$8 as PostRepository, index$k as ReactionRepository, index$4 as StoryRepository, index$7 as StreamRepository, index$i as SubChannelRepository, SubscriptionLevels, index$m as UserRepository, VERSION, VideoResolution, VideoSize, VideoTranscodingStatus, backupCache, createQuery, createReport, createUserToken, deleteReport, disableCache, dropFromCache, enableCache, filterByChannelMembership, filterByCommunityMembership, filterByFeedType, filterByPostDataTypes, filterByPropEquality, filterByPropInclusion, filterByPropIntersection, filterBySearchTerm, filterByStringComparePartially, getChannelTopic, getCommentTopic, getCommunityStoriesTopic, getCommunityTopic, getLiveReactionTopic, getLiveStreamTopic, getMarkedMessageTopic, getMarkerUserFeedTopic, getMessageTopic, getMyFollowersTopic, getMyFollowingsTopic, getNetworkTopic, getPostTopic, getRole, getSmartFeedChannelTopic, getSmartFeedMessageTopic, getSmartFeedSubChannelTopic, getStoryTopic, getSubChannelTopic, getUserTopic, isAfterBefore, isAfterBeforeRaw, isCachable, isFetcher, isFresh, isLocal, isMutator, isOffline, isPaged, isReportedByMe, isSkip, mergeInCache, index$2 as notificationTray, onChannelMarkerFetched, onFeedMarkerFetched, onFeedMarkerUpdated, onMessageMarked, onMessageMarkerFetched, onSubChannelMarkerFetched, onSubChannelMarkerUpdated, onUserMarkerFetched, onUserMarkerFetchedLegacy, pullFromCache, pushToCache, queryCache, queryOptions, queryRoles, restoreCache, runQuery, sortByChannelSegment, sortByDisplayName, sortByFirstCreated, sortByFirstUpdated, sortByLastActivity, sortByLastCreated, sortByLastUpdated, sortByLocalSortingDate, sortByName, sortBySegmentNumber, subscribeTopic, toPage, toPageRaw, toToken, upsertInCache, wipeCache };