@amityco/ts-sdk 7.6.1-bba8c29.0 → 7.6.1-ce05a481.0

package/dist/index.cjs.js

@@ -35,6 +35,7 @@ const FileType = Object.freeze({
     FILE: 'file',
     IMAGE: 'image',
     VIDEO: 'video',
+    CLIP: 'clip',
 });
 const VideoResolution = Object.freeze({
     '1080P': '1080p',
@@ -118,6 +119,7 @@ const PostContentType = Object.freeze({
     VIDEO: 'video',
     LIVESTREAM: 'liveStream',
     POLL: 'poll',
+    CLIP: 'clip',
 });
 
 exports.InvitationTypeEnum = void 0;
@@ -656,7 +658,8 @@ const PAYLOAD2MODEL = {
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
-    if ('updatedAt' in nextData && 'updatedAt' in nextData) {
+    // Check if the new value is outdated.
+    if ('updatedAt' in nextData && 'updatedAt' in prevData) {
         return new Date(nextData.updatedAt) < new Date(prevData.updatedAt);
     }
     return false;
@@ -6693,15 +6696,23 @@ function isAmityVideoPost(post) {
         'videoFileId' in post.data &&
         'thumbnailFileId' in post.data &&
         post.dataType === 'video');
+}
+function isAmityClipPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'fileId' in post.data &&
+        post.dataType === 'clip');
 }
 
 const postLinkedObject = (post) => {
-    return Object.assign(Object.assign({}, post), { analytics: {
+    return shallowClone(post, {
+        analytics: {
             markAsViewed: () => {
                 const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
                 analyticsEngineInstance.markPostAsViewed(post.postId);
             },
-        }, get latestComments() {
+        },
+        get latestComments() {
             if (!post.comments)
                 return [];
             return (post.comments
@@ -6747,7 +6758,14 @@ const postLinkedObject = (post) => {
             return isAmityFilePost(post)
                 ? (_b = pullFromCache(['file', 'get', (_a = post === null || post === void 0 ? void 0 : post.data) === null || _a === void 0 ? void 0 : _a.fileId])) === null || _b === void 0 ? void 0 : _b.data
                 : undefined;
-        } });
+        },
+        getClipInfo() {
+            var _a, _b;
+            return isAmityClipPost(post)
+                ? (_b = pullFromCache(['file', 'get', (_a = post === null || post === void 0 ? void 0 : post.data) === null || _a === void 0 ? void 0 : _a.fileId])) === null || _b === void 0 ? void 0 : _b.data
+                : undefined;
+        },
+    });
 };
 
 const getCachedMarker = (message) => {
@@ -13915,6 +13933,57 @@ const updateAltText = async (fileId, altText) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: file.upload.clip
+*/
+/**
+ * ```js
+ * import { FileRepository } from '@amityco/ts-sdk'
+ * const created = await FileRepository.uploadClip(formData)
+ * ```
+ *
+ * Creates an {@link Amity.File}
+ *
+ * @param formData The data necessary to create a new {@link Amity.File}
+ * @param onProgress The callback to track the upload progress
+ * @returns The newly created {@link Amity.File}
+ *
+ * @category File API
+ * @async
+ */
+const uploadClip = async (formData, feedType, onProgress) => {
+    const client = getActiveClient();
+    client.log('file/uploadClip', formData);
+    const file = formData.get('files');
+    if (!file)
+        throw new Error('The formData object must have a `files` key.');
+    const accessType = GlobalFileAccessType$1.getInstance().getFileAccessType();
+    formData.append('accessType', accessType);
+    formData.append('preferredFilename', file.name);
+    if (feedType) {
+        formData.append('feedType', feedType);
+    }
+    const headers = 'getHeaders' in formData
+        ? formData.getHeaders()
+        : { 'content-type': 'multipart/form-data' };
+    const { data } = await client.upload.post('/api/v4/clips', formData, {
+        headers,
+        onUploadProgress({ loaded, total = 100 }) {
+            onProgress && onProgress(Math.round((loaded * 100) / total));
+        },
+    });
+    // API-FIX: payload should be serialized properly
+    // const { files } = data
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ files: data }, { cachedAt });
+    return {
+        data,
+        cachedAt,
+    };
+};
+/* end_public_function */
+
 var index$k = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getFile: getFile,
@@ -13923,7 +13992,8 @@ var index$k = /*#__PURE__*/Object.freeze({
   fileUrlWithSize: fileUrlWithSize,
   uploadVideo: uploadVideo,
   uploadImage: uploadImage,
-  updateAltText: updateAltText
+  updateAltText: updateAltText,
+  uploadClip: uploadClip
 });
 
 /**
@@ -14377,7 +14447,7 @@ const addReaction = async (referenceType, referenceId, reactionName) => {
         ]);
         if (!model || ((_a = model.data.myReactions) === null || _a === void 0 ? void 0 : _a.includes(reactionName)))
             return true;
-        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }) });
+        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: model.data.reactionsCount + 1, myReactions: [...((_b = model.data.myReactions) !== null && _b !== void 0 ? _b : []), reactionName], reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: ((_c = model.data.reactions[reactionName]) !== null && _c !== void 0 ? _c : 0) + 1 }), updatedAt: new Date().toISOString() });
         if (referenceType === 'comment') {
             fireEvent('local.comment.addReaction', {
                 comment: updatedModel,
@@ -14500,7 +14570,7 @@ const removeReaction = async (referenceType, referenceId, reactionName) => {
         ]);
         if (!model)
             return true;
-        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: Math.max(0, model.data.reactionsCount - 1), myReactions: ((_a = model.data.myReactions) !== null && _a !== void 0 ? _a : []).filter(item => item !== reactionName), reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: Math.max(0, ((_b = model.data.reactions[reactionName]) !== null && _b !== void 0 ? _b : 0) - 1) }) });
+        const updatedModel = Object.assign(Object.assign({}, model.data), { reactionsCount: Math.max(0, model.data.reactionsCount - 1), myReactions: ((_a = model.data.myReactions) !== null && _a !== void 0 ? _a : []).filter(item => item !== reactionName), reactions: Object.assign(Object.assign({}, model.data.reactions), { [reactionName]: Math.max(0, ((_b = model.data.reactions[reactionName]) !== null && _b !== void 0 ? _b : 0) - 1) }), updatedAt: new Date().toISOString() });
         if (referenceType === 'comment') {
             fireEvent('local.comment.removeReaction', {
                 comment: updatedModel,
@@ -14602,6 +14672,26 @@ const prepareSemanticSearchPostPayload = (_a) => {
     return Object.assign(Object.assign({}, processedPostPayload), { polls });
 };
 
+const processDeleteChildPost = (payload) => {
+    var _a;
+    const post = payload.posts[0];
+    if (!post.parentId)
+        return;
+    const parentPost = (_a = pullFromCache(['post', 'get', post.parentPostId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!parentPost)
+        return;
+    pushToCache(['post', 'get', parentPost.postId], Object.assign(Object.assign({}, parentPost), { children: parentPost.children.filter(childId => childId !== post.postId) }));
+};
+const processCreateChildPost = (payload) => {
+    var _a;
+    const post = payload.posts[0];
+    if (!post.parentId)
+        return;
+    const parentPost = (_a = pullFromCache(['post', 'get', post.parentPostId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!parentPost)
+        return;
+    pushToCache(['post', 'get', parentPost.postId], Object.assign(Object.assign({}, parentPost), { children: [...new Set([post.postId, ...parentPost.children])] }));
+};
 const createPostEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
@@ -14626,6 +14716,7 @@ const createPostEventSubscriber = (event, callback) => {
             }
             if (event === 'post.deleted') {
                 const { postId, postedUserId } = payload.posts[0];
+                processDeleteChildPost(payload);
                 try {
                     isInTombstone('post', postId);
                 }
@@ -14652,6 +14743,8 @@ const createPostEventSubscriber = (event, callback) => {
                 }
                 queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
             }
+            if (event === 'post.created')
+                processCreateChildPost(payload);
             callback(post.data);
         }
     };
@@ -14678,6 +14771,8 @@ const createLocalPostEventSubscriber = (event, callback) => {
                 });
             }
             const post = pullFromCache(['post', 'get', payload.posts[0].postId]);
+            if (event === 'local.post.deleted')
+                processDeleteChildPost(payload);
             callback(post.data);
         }
     };
@@ -19791,16 +19886,11 @@ const updateCommunity = async (communityId, patch) => {
  * @category Community API
  * @async
  */
-const getCommunity$1 = async (communityId, type, includeDiscoverablePrivateCommunity) => {
+const getCommunity$1 = async (communityId) => {
     const client = getActiveClient();
     client.log('community/getCommunity', communityId);
     // API-FIX: endpoint should not be /list, parameters should be querystring.
-    const { data: payload } = await client.http.get(`/api/v3/communities/${communityId}`, {
-        params: {
-            type: 'communityJoinRequest',
-            includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity !== null && includeDiscoverablePrivateCommunity !== void 0 ? includeDiscoverablePrivateCommunity : true,
-        },
-    });
+    const { data: payload } = await client.http.get(`/api/v3/communities/${communityId}`);
     const data = prepareCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -22504,1249 +22594,720 @@ var index$a = /*#__PURE__*/Object.freeze({
   getCategories: getCategories
 });
 
+class CustomRankingGlobalFeedPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v5/me/global-feeds`, {
+            params: Object.assign(Object.assign({}, params), { options }),
+        });
+        return queryResponse;
+    }
+}
+
+var EnumPostActions;
+(function (EnumPostActions) {
+    EnumPostActions["OnPostCreated"] = "onPostCreated";
+    EnumPostActions["OnPostUpdated"] = "onPostUpdated";
+    EnumPostActions["OnPostDeleted"] = "onPostDeleted";
+    EnumPostActions["OnPostFlagged"] = "onPostFlagged";
+    EnumPostActions["OnPostUnflagged"] = "onPostUnflagged";
+    EnumPostActions["OnPostReactionAdded"] = "onPostReactionAdded";
+    EnumPostActions["OnPostReactionRemoved"] = "onPostReactionRemoved";
+    EnumPostActions["OnPostApproved"] = "onPostApproved";
+    EnumPostActions["OnPostDeclined"] = "onPostDeclined";
+})(EnumPostActions || (EnumPostActions = {}));
+
+class CustomRankingGlobalFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && !collection.data.includes(post.parentPostId))
+                return;
+            // Delete Action
+            if (action === EnumPostActions.OnPostDeleted) {
+                // Parent Post - Remove from collection
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                // If the query has dataTypes array with value, check if post.dataType is include in the array
+                if (this.query.dataTypes && this.query.dataTypes.length > 0) {
+                    if (!this.query.dataTypes.includes(post.dataType))
+                        return;
+                }
+                collection.data = [...new Set([post.postId, ...collection.data])];
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
 /* begin_public_function
-  id: feed.query.global_feed
+  id: comment.get_by_ids
 */
 /**
  * ```js
- * import { queryGlobalFeed } from '@amityco/ts-sdk'
- * const posts = await queryGlobalFeed()
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
  * ```
  *
- * Queries a paginable list of {@link Amity.Post} objects
+ * Fetches a collection of {@link Amity.Comment} objects
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
  *
- * @category Feed API
+ * @category Comment API
  * @async
- * */
-const queryGlobalFeed = async (query) => {
+ */
+const getCommentByIds = async (commentIds) => {
     const client = getActiveClient();
-    client.log('feed/queryGlobalFeed', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { queryToken } = _a, params = __rest(_a, ["queryToken"]);
-    const options = (() => {
-        if (queryToken)
-            return { token: queryToken };
-        return undefined;
-    })();
-    const { data: queryPayload } = await client.http.get(`/api/v4/me/global-feeds`, {
-        params: Object.assign(Object.assign({}, params), { options }),
-    });
-    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const { posts } = data;
-    const { communities: processedCommunity } = prepareCommunityPayload(data);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(Object.assign(Object.assign({}, data), { communitis: processedCommunity }));
-        const cacheKey = ['globalFeed', 'query', Object.assign(Object.assign({}, params), { options })];
-        pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
+    client.log('comment/getCommentByIds', commentIds);
+    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
+    let data;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/comments/list`, {
+            params: { commentIds: encodedCommentIds },
+        });
+        data = response.data;
+    }
+    catch (error) {
+        commentIds.forEach(commentId => {
+            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+                pushToTombstone('comment', commentId);
+            }
+        });
+        throw error;
     }
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
     return {
-        data: posts.map(LinkedObject.post),
+        data: data.comments.map(comment => LinkedObject.comment(comment)),
         cachedAt,
-        paging,
     };
 };
 /* end_public_function */
 /**
  * ```js
- * import { queryGlobalFeed } from '@amityco/ts-sdk'
- * const posts = await queryGlobalFeed.locally()
+ * import { getCommentByIds } from '@amityco/ts-sdk'
+ * const comments = getCommentByIds.locally(['foo', 'bar'])
  * ```
  *
- * Queries a paginable list of {@link Amity.Post} objects from cache
+ * Fetches a collection of {@link Amity.Comment} objects from cache
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
+ * @param commentIds the IDs of the {@link Amity.Comment} to fetch
+ * @returns the associated collection of {@link Amity.Comment} objects
  *
- * @category Feed API
- * @async
- * */
-queryGlobalFeed.locally = (query) => {
-    var _a, _b;
+ * @category Comment API
+ */
+getCommentByIds.locally = (commentIds) => {
+    var _a;
     const client = getActiveClient();
-    client.log('post/queryGlobalFeed.locally', query);
+    client.log('comment/getCommentByIds.locally', commentIds);
     if (!client.cache)
         return;
-    const params = __rest(query !== null && query !== void 0 ? query : {}, []);
-    const queryKey = ['globalFeed', 'query', Object.assign({}, params)];
-    const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
-    if (!(data === null || data === void 0 ? void 0 : data.posts.length))
+    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;
-    const posts = data.posts
-        .map(postId => pullFromCache(['post', 'get', postId]))
-        .filter(Boolean)
-        .map(({ data }) => data)
-        .map(LinkedObject.post);
-    const { paging } = data;
-    return posts.length === ((_b = data === null || data === void 0 ? void 0 : data.posts) === null || _b === void 0 ? void 0 : _b.length)
-        ? {
-            data: posts,
-            cachedAt,
-            paging,
-        }
-        : undefined;
+    return {
+        data: comments.map(comment => LinkedObject.comment(comment)),
+        cachedAt: oldest.cachedAt,
+    };
 };
 
 /* begin_public_function
-  id: feed.query.custom_ranking_feed
+  id: comment.create
 */
 /**
  * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed()
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const newComment = await CommentRepository.createComment(bundle)
  * ```
  *
- * Queries a paginable list of {@link Amity.Post} objects
+ * Creates an {@link Amity.Comment}
  *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
+ * @param bundle The data necessary to create a new {@link Amity.Comment}
+ * @returns The newly created {@link Amity.Comment}
  *
- * @category Feed API
+ * @category Comment API
  * @async
- * */
-const getCustomRankingGlobalFeed = async (query) => {
+ */
+const createComment = async (bundle) => {
+    var _a;
     const client = getActiveClient();
-    client.log('feed/getCustomRankingGlobalFeed', query);
-    const _a = query !== null && query !== void 0 ? query : {}, { queryToken, limit } = _a, params = __rest(_a, ["queryToken", "limit"]);
-    const options = (() => {
-        if (queryToken)
-            return { token: queryToken };
-        return undefined;
-    })();
-    const { data: queryPayload } = await client.http.get(`/api/v5/me/global-feeds`, {
-        params: Object.assign(Object.assign({}, params), { limit: !queryToken ? limit : undefined, options }),
-    });
-    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const { posts } = data;
+    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);
-        const cacheKey = ['customGlobalFeed', 'query', Object.assign(Object.assign({}, params), { options })];
-        pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });
-    }
-    return { data: posts.map(LinkedObject.post), cachedAt, paging };
-};
-/* end_public_function */
-/**
- * ```js
- * import { FeedRepository } from '@amityco/ts-sdk'
- * const posts = await FeedRepository.getCustomRankingGlobalFeed.locally()
- * ```
- *
- * Queries a paginable list of {@link Amity.Post} objects from cache
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.Post} objects
- *
- * @category Feed API
- * @async
- * */
-getCustomRankingGlobalFeed.locally = (query) => {
-    var _a, _b;
-    const client = getActiveClient();
-    client.log('post/getCustomRankingGlobalFeed.locally', query);
-    if (!client.cache)
-        return;
-    const params = __rest(query !== null && query !== void 0 ? query : {}, []);
-    const queryKey = ['customGlobalFeed', 'query', Object.assign({}, params)];
-    const { data, cachedAt } = (_a = pullFromCache(queryKey)) !== null && _a !== void 0 ? _a : {};
-    if (!(data === null || data === void 0 ? void 0 : data.posts.length))
-        return;
-    const posts = data.posts
-        .map(postId => pullFromCache(['post', 'get', postId]))
-        .filter(Boolean)
-        .map(({ data }) => data);
-    const { paging } = data;
-    return posts.length === ((_b = data === null || data === void 0 ? void 0 : data.posts) === null || _b === void 0 ? void 0 : _b.length)
-        ? { data: posts.map(LinkedObject.post), cachedAt, paging }
-        : undefined;
-};
-
-var index$9 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  queryGlobalFeed: queryGlobalFeed,
-  getCustomRankingGlobalFeed: getCustomRankingGlobalFeed
-});
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    if (['post', 'content'].includes(bundle.referenceType)) {
+        const post = (_a = pullFromCache(['post', 'get', bundle.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+        if (post) {
+            post.commentsCount += 1;
+            fireEvent('local.post.updated', {
+                posts: [post],
+                categories: [],
+                comments: [],
+                communities: [],
+                communityUsers: data.communityUsers,
+                feeds: [],
+                files: data.files,
+                postChildren: [],
+                users: data.users,
+                videoStreamings: [],
+            });
+        }
+    }
+    else if (bundle.referenceType === 'story') {
+        const storyIndex = pullFromCache([
+            "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
+            bundle.referenceId,
+        ]);
+        if (storyIndex === null || storyIndex === void 0 ? void 0 : storyIndex.data) {
+            const cacheStory = pullFromCache([
+                "story" /* STORY_KEY_CACHE.STORY */,
+                'get',
+                storyIndex.data,
+            ]);
+            if (cacheStory === null || cacheStory === void 0 ? void 0 : cacheStory.data) {
+                fireEvent('story.updated', {
+                    stories: [
+                        Object.assign(Object.assign({}, cacheStory.data), { commentsCount: cacheStory.data.commentsCount + 1, comments: [...new Set([...cacheStory.data.comments, comments[0].commentId])] }),
+                    ],
+                    categories: [],
+                    comments,
+                    communities: [],
+                    communityUsers: data.communityUsers,
+                    files: data.files,
+                    users: data.users,
+                });
+            }
+        }
+    }
+    fireEvent('local.comment.created', data);
+    return {
+        data: LinkedObject.comment(comments[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
 
 /* begin_public_function
-  id: post.get_by_ids
+  id: comment.update_comment
 */
 /**
  * ```js
- * import { getPostByIds } from '@amityco/ts-sdk'
- * const { data: posts } = await getPostByIds(['foo', 'bar'])
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const updated = await CommentRepository.updateComment(commentId, {
+ *   data: { text: 'hello world' }
+ * })
  * ```
  *
- * Fetches a collection of {@link Amity.Post} objects
+ * Updates an {@link Amity.Comment}
  *
- * @param postIds the IDs of the {@link Amity.Post} to fetch
- * @returns the associated collection of {@link Amity.Post} objects
+ * @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 Post API
+ * @category Comment API
  * @async
  */
-const getPostByIds = async (postIds) => {
+const updateComment = async (commentId, patch) => {
     const client = getActiveClient();
-    client.log('post/getPostByIds', postIds);
-    const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
-    let payload;
+    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 {
-        // 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;
+        const response = await client.http.get(`/api/v4/stories/${storyId}`);
+        data = convertRawStoryToInternal(response.data);
     }
     catch (error) {
-        postIds.forEach(postId => {
-            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                pushToTombstone('post', postId);
-            }
-        });
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('story', storyId);
+        }
         throw error;
     }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
     const cachedAt = client.cache && Date.now();
-    if (client.cache)
+    if (client.cache) {
         ingestInCache(data, { cachedAt });
+    }
     return {
-        data: data.posts.map(LinkedObject.post),
+        data: data.stories[0],
         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;
+getStoryByStoryId$1.locally = (storyId) => {
     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)
+    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: posts.map(LinkedObject.post),
-        cachedAt: oldest.cachedAt,
+        data: storyCache.data,
+        cachedAt,
     };
 };
 
 /* begin_public_function
-  id: post.create.text_post, post.create.image_post, post.create.file_post, post.create.video_post, post.create.poll_post, post.create.livestream_post, post.create.custom_post
+  id: comment.soft_delete, comment.hard_delete
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const created = await PostRepository.createPost({
- *   targetType: 'user',
- *   targetId: 'foobar',
- *   data: { text: 'hello world' }
- * }))
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.deleteComment('foobar')
  * ```
  *
- * Creates an {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param bundle The data necessary to create a new {@link Amity.Post}
- * @returns The newly created {@link Amity.Post}
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const createPost = async (bundle) => {
+const deleteComment = async (commentId, permanent = false) => {
+    var _a;
     const client = getActiveClient();
-    client.log('post/createPost', bundle);
-    if (!bundle.dataType || ['text', 'image', 'file', 'video'].includes(bundle.dataType)) {
-        // eslint-disable-next-line no-param-reassign
-        delete bundle.dataType;
+    const 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 (permanent) {
+        scheduleTask(() => pushToTombstone('comment', commentId));
     }
-    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
-    fireEvent('post.created', payload);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { posts } = data;
-    return {
-        data: LinkedObject.post(posts[0]),
-        cachedAt,
-    };
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: post.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],
+    else {
+        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
+    }
+    if (comment.data.referenceType === 'story') {
+        const story = await getStoryByStoryId$1(comment.data.referenceId);
+        fireEvent('local.story.updated', {
+            stories: [story.data],
             categories: [],
-            communityUsers,
-            feeds: [],
+            comments: [],
+            communities: [],
+            communityUsers: [],
             files: [],
             users: [],
         });
     }
-    // to support hard deletion
-    const deleted = Object.assign(Object.assign({}, post.data), { isDeleted: true });
-    if (permanent) {
-        setTimeout(() => {
-            pushToTombstone('post', postId);
-        }, 0);
-    }
     else {
-        upsertInCache(['post', 'get', postId], { isDeleted: true });
+        const post = (_a = pullFromCache(['post', 'get', comment.data.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+        if (post) {
+            let removeCount;
+            if (!deleted.parentId) {
+                // NOTE: delete the parent comment will remove all children comments
+                removeCount = deleted.childrenNumber + 1;
+            }
+            else
+                removeCount = 1;
+            post.commentsCount -= removeCount;
+            fireEvent('local.post.updated', {
+                posts: [post],
+                categories: [],
+                comments: [],
+                communities: [],
+                communityUsers: [],
+                feeds: [],
+                files: [],
+                postChildren: [],
+                users: [],
+                videoStreamings: [],
+            });
+        }
     }
-    fireEvent('local.post.deleted', {
-        posts: [deleted],
-        categories: [],
-        comments: [],
-        communities: [],
-        communityUsers: [],
-        feeds: [],
+    fireEvent('local.comment.deleted', {
+        comments: [deleted],
+        commentChildren: [],
         files: [],
-        postChildren: [],
         users: [],
-        videoStreamings: [],
+        communityUsers: [],
     });
-    return LinkedObject.post(deleted);
-};
+    return deleted;
+};
+/* end_public_function */
 
 /* begin_public_function
-  id: post.soft_delete
+  id: comment.soft_delete
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const success = await PostRepository.softDeletePost('foobar')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.softDeleteComment('foobar')
  * ```
  *
- * Soft deletes a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to soft delete
- * @return A success boolean if the {@link Amity.Post} was deleted
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const softDeletePost = async (postId) => {
+const softDeleteComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/softDeletePost', postId);
-    const softDeleted = await deletePost(postId, false);
-    return LinkedObject.post(softDeleted);
+    client.log('comment/softDeleteComment', commentId);
+    const softDeleted = deleteComment(commentId);
+    return softDeleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.hard_delete
+  id: comment.hard_delete
 */
 /**
  * ```js
- * import { hardDeletePost } from '@amityco/ts-sdk'
- * const success = await hardDeletePost('foobar')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const success = await CommentRepository.hardDeleteComment('foobar')
  * ```
  *
- * Hard deletes a {@link Amity.Post}
+ * Deletes a {@link Amity.Comment}
  *
- * @param postId The {@link Amity.Post} ID to be hard delete
- * @return A success boolean if the {@link Amity.Post} was deleted
+ * @param commentId The {@link Amity.Comment} ID to delete
+ * @return A success boolean if the {@link Amity.Comment} was deleted
  *
- * @category Post API
+ * @category Comment API
  * @async
  */
-const hardDeletePost = async (postId) => {
+const hardDeleteComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/hardDeletePost', postId);
-    const hardDeleted = await deletePost(postId, true);
-    return LinkedObject.post(hardDeleted);
+    client.log('comment/hardDeleteComment', commentId);
+    const hardDeleted = deleteComment(commentId, true);
+    return hardDeleted;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.approve
+  id: comment.flag
 */
 /**
  * ```js
- * import { approvePost } from '@amityco/ts-sdk'
- *
- * const { data: post } = await approvePost('postId')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const flagged = await CommentRepository.flagComment(commentId, reason)
  * ```
  *
- * Approves a {@link Amity.Post}
- *
- * @param postId The {@link Amity.Post} ID to be approved
- * @return A {@link Amity.Post} that was approved
+ * @param commentId The ID of the comment to flag
+ * @param reason the reason to flag the comment
+ * @returns the created report result
  *
- * @category Post API
+ * @category Comment API
  * @async
- */
-const approvePost = async (postId) => {
+ * */
+const flagComment = async (commentId, reason) => {
     const client = getActiveClient();
-    client.log('post/approvePost', postId);
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/approve`);
-    fireEvent('post.approved', payload);
-    // fire virtual event for community update
-    if (payload.posts[0].targetType === 'community') {
-        fireEvent('community.updated', payload);
-    }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data: LinkedObject.post(data.posts.find(post => post.postId === postId)),
-        cachedAt,
+    client.log('comment/flagComment', commentId);
+    const isPredefinedReason = reason &&
+        Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
+    const body = {
+        reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
+        detail: reason && !isPredefinedReason ? reason : '',
     };
+    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/flag`, body);
+    if (client.cache) {
+        ingestInCache(payload);
+    }
+    fireEvent('comment.flagged', payload);
+    return !!payload;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.decline
+  id: comment.unflag
 */
 /**
  * ```js
- * import { declinePost } from '@amityco/ts-sdk'
- *
- * const {data: post} = await declinePost('postId')
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const unflagged = await CommentRepository.unflagComment('commentId')
  * ```
  *
- * Declines a {@link Amity.Post}
- *
- * @param postId The {@link Amity.Post} ID to be declined
- * @return A {@link Amity.Post} that was declined
+ * @param commentId The ID of comment to unflag
+ * @returns the unflagged result
  *
- * @category Post API
+ * @category Comment API
  * @async
- */
-const declinePost = async (postId) => {
+ * */
+const unflagComment = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/declinePost', postId);
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/decline`);
-    // fire virtual event
-    if (payload.posts[0].targetType === 'community') {
-        fireEvent('community.updated', payload);
-    }
-    fireEvent('post.declined', payload);
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data: LinkedObject.post(payload.posts.find(post => post.postId === postId)),
-        cachedAt,
-    };
-};
-/* 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(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
-    const body = {
-        reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
-        detail: reason && !isPredefinedReason ? reason : '',
-    };
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`, body);
-    if (client.cache) {
-        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
-    }
-    fireEvent('post.flagged', payload);
-    return !!payload;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: post.unflag
-*/
-/**
- * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const unflagged = await PostRepository.unflagPost(postId)
- * ```
- *
- * @param postId of the post to unflag
- * @returns the unflag post result
- *
- * @category Post API
- * @async
- * */
-const unflagPost = async (postId) => {
-    const client = getActiveClient();
-    client.log('post/unflagPost', postId);
-    const { data: payload } = await client.http.delete(`/api/v3/posts/${encodeURIComponent(postId)}/unflag`);
+    client.log('comment/unflagComment', commentId);
+    const { data: payload } = await client.http.delete(`/api/v3/comments/${encodeURIComponent(commentId)}/unflag`);
     if (client.cache) {
-        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+        ingestInCache(payload);
     }
-    fireEvent('post.unflagged', payload);
+    fireEvent('comment.unflagged', payload);
     return !!payload;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: post.check_flag_by_me
+  id: comment.check_flag_by_me
 */
 /**
  * ```js
- * import { PostRepository } from '@amityco/ts-sdk'
- * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ * const isReported = await CommentRepository.isCommentFlaggedByMe('commentId')
  * ```
  *
- * @param postId of the post to check if flagged by current user
- * @returns `true` if the post is flagged by me, `false` if doesn't.
+ * @param commentId The ID of the comment to check if flagged by current user
+ * @returns `true` if the comment is flagged by me, `false` if doesn't.
  *
- * @category Post API
+ * @category Comment API
  * @async
  * */
-const isPostFlaggedByMe = async (postId) => {
+const isCommentFlaggedByMe = async (commentId) => {
     const client = getActiveClient();
-    client.log('post/isPostFlaggedByMe', postId);
-    const { data: { result }, } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
+    client.log('comment/isCommentFlaggedByMe', commentId);
+    const { data: { result }, } = await client.http.get(`/api/v3/comments/${commentId}/isflagbyme`);
     return result;
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: comment.get_by_ids
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const comments = await CommentRepository.getCommentByIds(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.Comment} objects
- *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
- *
- * @category Comment API
- * @async
- */
-const getCommentByIds = async (commentIds) => {
+const getComment$1 = async (commentId) => {
     const client = getActiveClient();
-    client.log('comment/getCommentByIds', commentIds);
-    const encodedCommentIds = commentIds.map(commentId => encodeURIComponent(commentId));
+    client.log('comment/getComment', commentId);
+    isInTombstone('comment', commentId);
     let data;
     try {
         // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/comments/list`, {
-            params: { commentIds: encodedCommentIds },
-        });
+        const response = await client.http.get(`/api/v3/comments/${encodeURIComponent(commentId)}`);
         data = response.data;
     }
     catch (error) {
-        commentIds.forEach(commentId => {
-            if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-                pushToTombstone('comment', commentId);
-            }
-        });
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('comment', commentId);
+        }
         throw error;
     }
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
+    const { comments } = data;
     return {
-        data: data.comments.map(comment => LinkedObject.comment(comment)),
+        data: comments.find(comment => comment.commentId === commentId),
         cachedAt,
     };
 };
-/* end_public_function */
-/**
- * ```js
- * import { getCommentByIds } from '@amityco/ts-sdk'
- * const comments = getCommentByIds.locally(['foo', 'bar'])
- * ```
- *
- * Fetches a collection of {@link Amity.Comment} objects from cache
- *
- * @param commentIds the IDs of the {@link Amity.Comment} to fetch
- * @returns the associated collection of {@link Amity.Comment} objects
- *
- * @category Comment API
- */
-getCommentByIds.locally = (commentIds) => {
-    var _a;
+getComment$1.locally = (commentId) => {
     const client = getActiveClient();
-    client.log('comment/getCommentByIds.locally', commentIds);
+    client.log('comment/getComment.locally', commentId);
     if (!client.cache)
         return;
-    const cached = commentIds
-        .map(commentId => pullFromCache(['comment', 'get', commentId]))
-        .filter(Boolean);
-    const comments = cached.map(({ data }) => data);
-    const oldest = (_a = cached.sort((a, b) => (a.cachedAt < b.cachedAt ? -1 : 1))) === null || _a === void 0 ? void 0 : _a[0];
-    if ((cached === null || cached === void 0 ? void 0 : cached.length) < commentIds.length)
+    const cached = pullFromCache(['comment', 'get', commentId]);
+    if (!cached)
         return;
     return {
-        data: comments.map(comment => LinkedObject.comment(comment)),
-        cachedAt: oldest.cachedAt,
+        data: cached.data,
+        cachedAt: cached.cachedAt,
     };
 };
 
-/* begin_public_function
-  id: comment.create
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const newComment = await CommentRepository.createComment(bundle)
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleteLocal(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Creates an {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been deleted
  *
- * @param bundle The data necessary to create a new {@link Amity.Comment}
- * @returns The newly created {@link Amity.Comment}
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment API
- * @async
+ * @category Comment Events
  */
-const createComment = async (bundle) => {
-    var _a;
-    const client = getActiveClient();
-    client.log('comment/createComment', bundle);
-    const { data } = await client.http.post('/api/v3/comments', bundle);
-    const { comments } = data;
-    // BE always returns an array of comments If it got record 0 from BE it might have a problem on creation logic
-    if (comments.length === 0)
-        throw new Error('Comment not created');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    if (['post', 'content'].includes(bundle.referenceType)) {
-        const post = (_a = pullFromCache(['post', 'get', bundle.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
-        if (post) {
-            post.commentsCount += 1;
-            fireEvent('local.post.updated', {
-                posts: [post],
-                categories: [],
-                comments: [],
-                communities: [],
-                communityUsers: data.communityUsers,
-                feeds: [],
-                files: data.files,
-                postChildren: [],
-                users: data.users,
-                videoStreamings: [],
-            });
-        }
-    }
-    else if (bundle.referenceType === 'story') {
-        const storyIndex = pullFromCache([
-            "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
-            bundle.referenceId,
-        ]);
-        if (storyIndex === null || storyIndex === void 0 ? void 0 : storyIndex.data) {
-            const cacheStory = pullFromCache([
-                "story" /* STORY_KEY_CACHE.STORY */,
-                'get',
-                storyIndex.data,
-            ]);
-            if (cacheStory === null || cacheStory === void 0 ? void 0 : cacheStory.data) {
-                fireEvent('story.updated', {
-                    stories: [
-                        Object.assign(Object.assign({}, cacheStory.data), { commentsCount: cacheStory.data.commentsCount + 1, comments: [...new Set([...cacheStory.data.comments, comments[0].commentId])] }),
-                    ],
-                    categories: [],
-                    comments,
-                    communities: [],
-                    communityUsers: data.communityUsers,
-                    files: data.files,
-                    users: data.users,
-                });
-            }
-        }
-    }
-    fireEvent('local.comment.created', data);
-    return {
-        data: LinkedObject.comment(comments[0]),
-        cachedAt,
-    };
-};
-/* end_public_function */
+const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
 
-/* begin_public_function
-  id: comment.update_comment
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const updated = await CommentRepository.updateComment(commentId, {
- *   data: { text: 'hello world' }
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionAdded(comment => {
+ *   // ...
  * })
  * ```
  *
- * Updates an {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
- * @param commentId The ID of the {@link Amity.Comment} to edit
- * @param patch The patch data to apply
- * @returns the updated {@link Amity.Comment} object
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment API
- * @async
+ * @category Comment Events
  */
-const updateComment = async (commentId, patch) => {
-    const client = getActiveClient();
-    client.log('user/updateComment', patch);
-    const { data } = await client.http.put(`/api/v3/comments/${encodeURIComponent(commentId)}`, patch);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    fireEvent('comment.updated', data);
-    const { comments } = data;
-    return {
-        data: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)),
-        cachedAt,
-    };
-};
-/* end_public_function */
-
-// Due to we have optimistic logic, we will use referenceId as a id in SDK instead of storyId
-const applyMissingField = (rawData, isCreated = false) => {
-    const { storyId, referenceId } = rawData;
-    if (!isCreated) {
-        if (referenceId)
-            return Object.assign(Object.assign({}, rawData), { syncState: "synced" /* Amity.SyncState.Synced */ });
-    }
-    return Object.assign(Object.assign({}, rawData), { syncState: "synced" /* Amity.SyncState.Synced */, referenceId: storyId });
-};
-const convertRawStoryToInternal = (data, isCreated = false) => {
-    const { stories } = data;
-    const storiesData = stories.map(story => applyMissingField(story, isCreated));
-    return Object.assign(Object.assign({}, data), { stories: storiesData });
-};
-
-const getStoryByStoryId$1 = async (storyId) => {
+const onLocalCommentReactionAdded = (callback) => {
     const client = getActiveClient();
-    client.log('story/getStoryByStoryId', storyId);
-    // Get story referenceId from cache
-    const cacheReferenceId = pullFromCache([
-        "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
-        storyId,
-    ]);
-    if (cacheReferenceId === null || cacheReferenceId === void 0 ? void 0 : cacheReferenceId.data) {
-        const { data: referenceId } = cacheReferenceId;
-        isInTombstone('story', referenceId);
-    }
-    let data;
-    try {
-        const response = await client.http.get(`/api/v4/stories/${storyId}`);
-        data = convertRawStoryToInternal(response.data);
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('story', storyId);
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
+        }
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
         }
-        throw error;
-    }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache) {
-        ingestInCache(data, { cachedAt });
-    }
-    return {
-        data: data.stories[0],
-        cachedAt,
-    };
-};
-getStoryByStoryId$1.locally = (storyId) => {
-    const client = getActiveClient();
-    client.log('story/getStorybyStoryId', storyId);
-    // Get story referenceId from cache
-    const cacheReferenceId = pullFromCache([
-        "story-reference" /* STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID */,
-        storyId,
-    ]);
-    if (cacheReferenceId === null || cacheReferenceId === void 0 ? void 0 : cacheReferenceId.data) {
-        const { data: referenceId } = cacheReferenceId;
-        isInTombstone('story', referenceId);
-    }
-    const cachedAt = client.cache && Date.now();
-    const storyCache = pullFromCache(['story', 'get', storyId]);
-    if (!storyCache)
-        return;
-    return {
-        data: storyCache.data,
-        cachedAt,
     };
+    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
 };
 
-/* begin_public_function
-  id: comment.soft_delete, comment.hard_delete
-*/
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.deleteComment('foobar')
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
+ *   // ...
+ * })
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Fired when a {@link Amity.InternalComment} has been reacted
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Comment API
- * @async
+ * @category Comment Events
  */
-const deleteComment = async (commentId, permanent = false) => {
-    var _a;
+const onLocalCommentReactionRemoved = (callback) => {
     const client = getActiveClient();
-    const comment = await getComment$2(commentId);
-    // API-FIX: This endpoint has not been implemented yet.
-    await client.http.delete(`/api/v4/comments/${encodeURIComponent(commentId)}`, {
-        params: {
-            commentId,
-            permanent,
-        },
-    });
-    // to support hard deletion
-    const deleted = Object.assign(Object.assign({}, comment.data), { isDeleted: true });
-    if (comment.data.referenceType === 'story') {
-        const story = await getStoryByStoryId$1(comment.data.referenceId);
-        fireEvent('local.story.updated', {
-            stories: [story.data],
-            categories: [],
-            comments: [],
-            communities: [],
-            communityUsers: [],
-            files: [],
-            users: [],
-        });
-    }
-    else {
-        const post = (_a = pullFromCache(['post', 'get', comment.data.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
-        if (post) {
-            let removeCount;
-            if (!deleted.parentId) {
-                // NOTE: delete the parent comment will remove all children comments
-                removeCount = deleted.childrenNumber + 1;
-            }
-            else
-                removeCount = 1;
-            post.commentsCount -= removeCount;
-            fireEvent('local.post.updated', {
-                posts: [post],
-                categories: [],
-                comments: [],
-                communities: [],
-                communityUsers: [],
-                feeds: [],
-                files: [],
-                postChildren: [],
-                users: [],
-                videoStreamings: [],
-            });
+    const filter = ({ comment }) => {
+        if (!client.cache) {
+            callback(comment);
         }
-    }
-    fireEvent('local.comment.deleted', {
-        comments: [deleted],
-        commentChildren: [],
-        files: [],
-        users: [],
-        communityUsers: [],
-    });
-    if (permanent) {
-        scheduleTask(() => pushToTombstone('comment', commentId));
-    }
-    else {
-        upsertInCache(['comment', 'get', commentId], { isDeleted: true });
-    }
-    return deleted;
-};
-/* end_public_function */
+        else {
+            upsertInCache(['comment', 'get', comment.commentId], comment);
+            callback(commentLinkedObject(comment));
+        }
+    };
+    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
+};
 
 /* begin_public_function
-  id: comment.soft_delete
+  id: comment.get
 */
 /**
  * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.softDeleteComment('foobar')
- * ```
- *
- * Deletes a {@link Amity.Comment}
+ * import { CommentRepository } from '@amityco/ts-sdk';
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * let comment;
  *
- * @category Comment API
- * @async
- */
-const softDeleteComment = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/softDeleteComment', commentId);
-    const softDeleted = deleteComment(commentId);
-    return softDeleted;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: comment.hard_delete
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const success = await CommentRepository.hardDeleteComment('foobar')
+ * const unsub = CommentRepository.getComment(commentId, response => {
+ *   comment = response.data;
+ * });
  * ```
  *
- * Deletes a {@link Amity.Comment}
+ * Observe all mutation on a given {@link Amity.Comment}
  *
- * @param commentId The {@link Amity.Comment} ID to delete
- * @return A success boolean if the {@link Amity.Comment} was deleted
+ * @param commentId the ID of the comment to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the comment
  *
- * @category Comment API
- * @async
+ * @category Comment Live Object
  */
-const hardDeleteComment = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/hardDeleteComment', commentId);
-    const hardDeleted = deleteComment(commentId, true);
-    return hardDeleted;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: comment.flag
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const flagged = await CommentRepository.flagComment(commentId, reason)
- * ```
- *
- * @param commentId The ID of the comment to flag
- * @param reason the reason to flag the comment
- * @returns the created report result
- *
- * @category Comment API
- * @async
- * */
-const flagComment = async (commentId, reason) => {
-    const client = getActiveClient();
-    client.log('comment/flagComment', commentId);
-    const isPredefinedReason = reason &&
-        Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
-    const body = {
-        reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
-        detail: reason && !isPredefinedReason ? reason : '',
-    };
-    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/flag`, body);
-    if (client.cache) {
-        ingestInCache(payload);
-    }
-    fireEvent('comment.flagged', payload);
-    return !!payload;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: comment.unflag
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const unflagged = await CommentRepository.unflagComment('commentId')
- * ```
- *
- * @param commentId The ID of comment to unflag
- * @returns the unflagged result
- *
- * @category Comment API
- * @async
- * */
-const unflagComment = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/unflagComment', commentId);
-    const { data: payload } = await client.http.delete(`/api/v3/comments/${encodeURIComponent(commentId)}/unflag`);
-    if (client.cache) {
-        ingestInCache(payload);
-    }
-    fireEvent('comment.unflagged', payload);
-    return !!payload;
-};
-/* end_public_function */
-
-/* begin_public_function
-  id: comment.check_flag_by_me
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk'
- * const isReported = await CommentRepository.isCommentFlaggedByMe('commentId')
- * ```
- *
- * @param commentId The ID of the comment to check if flagged by current user
- * @returns `true` if the comment is flagged by me, `false` if doesn't.
- *
- * @category Comment API
- * @async
- * */
-const isCommentFlaggedByMe = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/isCommentFlaggedByMe', commentId);
-    const { data: { result }, } = await client.http.get(`/api/v3/comments/${commentId}/isflagbyme`);
-    return result;
-};
-/* end_public_function */
-
-const getComment$1 = async (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/getComment', commentId);
-    isInTombstone('comment', commentId);
-    let data;
-    try {
-        // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/comments/${encodeURIComponent(commentId)}`);
-        data = response.data;
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('comment', commentId);
-        }
-        throw error;
-    }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { comments } = data;
-    return {
-        data: comments.find(comment => comment.commentId === commentId),
-        cachedAt,
-    };
-};
-getComment$1.locally = (commentId) => {
-    const client = getActiveClient();
-    client.log('comment/getComment.locally', commentId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['comment', 'get', commentId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
-};
-
-/**
- * ```js
- * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
- * const dispose = onCommentDeleteLocal(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been deleted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onCommentDeleteLocal = (callback) => createLocalCommentEventSubscriber('local.comment.deleted', callback);
-
-/**
- * ```js
- * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionAdded(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been reacted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onLocalCommentReactionAdded = (callback) => {
-    const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
-        }
-        else {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
-        }
-    };
-    return createEventSubscriber(client, 'local.comment.addReaction', 'local.comment.addReaction', filter);
-};
-
-/**
- * ```js
- * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onLocalCommentReactionRemoved(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been reacted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onLocalCommentReactionRemoved = (callback) => {
-    const client = getActiveClient();
-    const filter = ({ comment }) => {
-        if (!client.cache) {
-            callback(comment);
-        }
-        else {
-            upsertInCache(['comment', 'get', comment.commentId], comment);
-            callback(commentLinkedObject(comment));
-        }
-    };
-    return createEventSubscriber(client, 'local.comment.removeReaction', 'local.comment.removeReaction', filter);
-};
-
-/* begin_public_function
-  id: comment.get
-*/
-/**
- * ```js
- * import { CommentRepository } from '@amityco/ts-sdk';
- *
- * let comment;
- *
- * const unsub = CommentRepository.getComment(commentId, response => {
- *   comment = response.data;
- * });
- * ```
- *
- * Observe all mutation on a given {@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
- *
- * @category Comment Live Object
- */
-const getComment = (commentId, callback) => {
-    return liveObject(commentId, callback, 'commentId', getComment$1, [
-        onCommentDeleteLocal,
-        onCommentDeleted,
-        onCommentFlagged,
-        onCommentReactionAdded,
-        onCommentReactionRemoved,
-        onCommentUnflagged,
-        onCommentUpdated,
-        onLocalCommentReactionAdded,
-        onLocalCommentReactionRemoved,
-    ]);
+const getComment = (commentId, callback) => {
+    return liveObject(commentId, callback, 'commentId', getComment$1, [
+        onCommentDeleteLocal,
+        onCommentDeleted,
+        onCommentFlagged,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentUnflagged,
+        onCommentUpdated,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ]);
 };
 /* end_public_function */
 
@@ -23995,7 +23556,7 @@ const getComments = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$8 = /*#__PURE__*/Object.freeze({
+var index$9 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getCommentByIds: getCommentByIds,
   createComment: createComment,
@@ -24017,97 +23578,930 @@ var index$8 = /*#__PURE__*/Object.freeze({
   getComments: getComments
 });
 
-/**
- * ```js
- * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
- * const dispose = onPostUpdatedLocal(post => {
- *   // ...
- * })
+const getPost$1 = async (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost', postId);
+    isInTombstone('post', postId);
+    let payload;
+    try {
+        // API-FIX: endpoint should not be /list, parameters should be querystring.
+        const response = await client.http.get(`/api/v3/posts/${encodeURIComponent(postId)}`);
+        payload = response.data;
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('post', postId);
+        }
+        throw error;
+    }
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    const result = posts.find(post => post.postId === postId);
+    return {
+        data: result,
+        cachedAt,
+    };
+};
+getPost$1.locally = (postId) => {
+    const client = getActiveClient();
+    client.log('post/getPost.locally', postId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['post', 'get', postId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
+
+/**
+ * ```js
+ * import { onLocalPostDeleted } from '@amityco/ts-sdk'
+ * const dispose = onLocalPostDeleted(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
+
+/**
+ * ```js
+ * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionAdded(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostReactionAdded = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ post }) => {
+        if (!client.cache) {
+            callback(post);
+        }
+        else {
+            upsertInCache(['post', 'get', post.postId], post);
+            callback(post);
+        }
+    };
+    return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onPostReactionRemoved(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onLocalPostReactionRemoved = (callback) => {
+    const client = getActiveClient();
+    const filter = ({ post }) => {
+        if (!client.cache) {
+            callback(post);
+        }
+        else {
+            upsertInCache(['post', 'get', post.postId], post);
+            callback(post);
+        }
+    };
+    return createEventSubscriber(client, 'local.post.removeReaction', 'local.post.removeReaction', filter);
+};
+
+/**
+ * ```js
+ * import { onPostUpdatedLocal } from '@amityco/ts-sdk'
+ * const dispose = onPostUpdatedLocal(post => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalPost} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Post Events
+ */
+const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+
+const commentEventHanlder$1 = (callback, eventHandler, cacheKey) => {
+    return eventHandler(async (comment) => {
+        var _a;
+        const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!currentCollection || !currentCollection.data.includes(comment.referenceId))
+            return;
+        await getPost$1(comment.referenceId);
+        callback(comment);
+    });
+};
+const generateCommentSubscriptions$1 = (cacheKey) => {
+    const eventHandlers = [
+        onCommentCreated,
+        onCommentDeleted,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentCreatedLocal,
+        onCommentDeleteLocal,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ];
+    return eventHandlers.map(handler => ({
+        fn: convertEventPayload((callback) => commentEventHanlder$1(callback, handler, cacheKey), 'referenceId', 'post'),
+        action: EnumPostActions.OnPostUpdated,
+    }));
+};
+const getGlobalFeedSubscriptions = (cacheKey) => {
+    return [
+        { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
+        { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+        { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
+        { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
+        { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
+        { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
+        { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+        { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
+        { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+        { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+        { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+        { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+        { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
+        ...generateCommentSubscriptions$1(cacheKey),
+    ];
+};
+
+class CustomRankingGlobalFeedLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['customRankingGlobalFeed', 'collection', queryStreamId];
+        const paginationController = new CustomRankingGlobalFeedPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new CustomRankingGlobalFeedQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: post.query
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = PostRepository.getPosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, response => merge(posts, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param params.targetType the type of the target
+ * @param params.targetId 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 getCustomRankingGlobalFeed = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getCustomRankingGlobalFeed(tmpid: ${timestamp}) > listen`);
+    const liveCollection = new CustomRankingGlobalFeedLiveCollectionController(params, callback);
+    const disposers = liveCollection.startSubscription();
+    const cacheKey = liveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getCustomRankingGlobalFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+class GlobalFeedPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit, resolveParent } = queryParams, params = __rest(queryParams, ["limit", "resolveParent"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v4/me/global-feeds`, {
+            params: Object.assign(Object.assign({}, params), { resolveParent: resolveParent !== null && resolveParent !== void 0 ? resolveParent : true, options }),
+        });
+        return queryResponse;
+    }
+}
+
+class GlobalFeedQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.posts.map(getResolver('post')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const posts = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])] }));
+        }
+    }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (post.parentPostId && !collection.data.includes(post.parentPostId))
+                return;
+            // Delete Action
+            if (action === EnumPostActions.OnPostDeleted) {
+                // Parent Post - Remove from collection
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+                // If the query has dataTypes array with value, check if post.dataType is include in the array
+                if (this.query.dataTypes && this.query.dataTypes.length > 0) {
+                    if (!this.query.dataTypes.includes(post.dataType))
+                        return;
+                }
+                collection.data = [...new Set([post.postId, ...collection.data])];
+            }
+            if (action === EnumPostActions.OnPostDeclined) {
+                collection.data = collection.data.filter(postId => postId !== post.postId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+class GlobalFeedLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['globalFeed', 'collection', queryStreamId];
+        const paginationController = new GlobalFeedPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new GlobalFeedQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), preparePostPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(getGlobalFeedSubscriptions(this.cacheKey));
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = ((_b = collection.data
+            .map(id => pullFromCache(['post', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : []).map(LinkedObject.post);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: post.query
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = PostRepository.getPosts({
+ *   targetType: Amity.PostTargetType,
+ *   targetId: Amity.Post['targetId'],
+ * }, response => merge(posts, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ * @param params.targetType the type of the target
+ * @param params.targetId 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 getGlobalFeed = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getGlobalFeed(tmpid: ${timestamp}) > listen`);
+    const liveCollection = new GlobalFeedLiveCollectionController(params, callback);
+    const disposers = liveCollection.startSubscription();
+    const cacheKey = liveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getGlobalFeed(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+var index$8 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
+  getGlobalFeed: getGlobalFeed
+});
+
+/* 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 = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    return {
+        data: LinkedObject.post(posts[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: post.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);
+    }
+    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)
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been updated
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param postId of the post to flag
+ * @param reason the reason to flag the post
+ * @returns a boolean
  *
- * @category Post Events
- */
-const onPostUpdatedLocal = (callback) => createLocalPostEventSubscriber('local.post.updated', callback);
+ * @category Post API
+ * @async
+ * */
+const flagPost = async (postId, reason) => {
+    const client = getActiveClient();
+    client.log('post/flagPost', postId);
+    const isPredefinedReason = reason &&
+        Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
+    const body = {
+        reason: reason && isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
+        detail: reason && !isPredefinedReason ? reason : '',
+    };
+    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`, body);
+    if (client.cache) {
+        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+    }
+    fireEvent('post.flagged', payload);
+    return !!payload;
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: post.unflag
+*/
 /**
  * ```js
- * import { onLocalPostReactionAdded } from '@amityco/ts-sdk'
- * const dispose = onPostReactionAdded(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const unflagged = await PostRepository.unflagPost(postId)
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been reacted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param postId of the post to unflag
+ * @returns the unflag post result
  *
- * @category Post Events
- */
-const onLocalPostReactionAdded = (callback) => {
+ * @category Post API
+ * @async
+ * */
+const unflagPost = async (postId) => {
     const client = getActiveClient();
-    const filter = ({ post }) => {
-        if (!client.cache) {
-            callback(post);
-        }
-        else {
-            upsertInCache(['post', 'get', post.postId], post);
-            callback(post);
-        }
-    };
-    return createEventSubscriber(client, 'local.post.addReaction', 'local.post.addReaction', filter);
-};
+    client.log('post/unflagPost', postId);
+    const { data: payload } = await client.http.delete(`/api/v3/posts/${encodeURIComponent(postId)}/unflag`);
+    if (client.cache) {
+        ingestInCache(prepareMembershipPayload(payload, 'communityUsers'));
+    }
+    fireEvent('post.unflagged', payload);
+    return !!payload;
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: post.check_flag_by_me
+*/
 /**
  * ```js
- * import { onLocalPostReactionRemoved } from '@amityco/ts-sdk'
- * const dispose = onPostReactionRemoved(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const isReported = await PostRepository.isPostFlaggedByMe('post', postId)
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been reacted
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param postId of the post to check if flagged by current user
+ * @returns `true` if the post is flagged by me, `false` if doesn't.
  *
- * @category Post Events
- */
-const onLocalPostReactionRemoved = (callback) => {
+ * @category Post API
+ * @async
+ * */
+const isPostFlaggedByMe = async (postId) => {
     const client = getActiveClient();
-    const filter = ({ post }) => {
-        if (!client.cache) {
-            callback(post);
-        }
-        else {
-            upsertInCache(['post', 'get', post.postId], post);
-            callback(post);
-        }
-    };
-    return createEventSubscriber(client, 'local.post.removeReaction', 'local.post.removeReaction', filter);
-};
+    client.log('post/isPostFlaggedByMe', postId);
+    const { data: { result }, } = await client.http.get(`/api/v3/posts/${postId}/isflagbyme`);
+    return result;
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: post.create.clip_post
+*/
 /**
  * ```js
- * import { onLocalPostDeleted } from '@amityco/ts-sdk'
- * const dispose = onLocalPostDeleted(post => {
- *   // ...
- * })
+ * import { PostRepository } from '@amityco/ts-sdk'
+ * const created = await PostRepository.createClipPost({
+ *   targetType: 'user',
+ *   targetId: 'foobar',
+ *   dataType: 'clip',
+ *   data: { text: 'hello world' },
+ *   attachments: [{ type: 'clip', fileId: 'fileId123', displayMode: 'fill', isMuted: false }]
+ * }))
  * ```
  *
- * Fired when a {@link Amity.InternalPost} has been deleted
+ * Creates an {@link Amity.Post}
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @param bundle The data necessary to create a new {@link Amity.Post}
+ * @returns The newly created {@link Amity.Post}
  *
- * @category Post Events
+ * @category Post API
+ * @async
  */
-const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.post.deleted', callback);
+const createClipPost = async (bundle) => {
+    const client = getActiveClient();
+    client.log('post/createPost', bundle);
+    const { data: payload } = await client.http.post('/api/v4/posts', bundle);
+    fireEvent('post.created', payload);
+    const data = prepareMembershipPayload(payload, 'communityUsers');
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { posts } = data;
+    return {
+        data: LinkedObject.post(posts[0]),
+        cachedAt,
+    };
+};
+/* end_public_function */
 
 /* begin_public_function
   id: post.get
@@ -24131,7 +24525,7 @@ const onLocalPostDeleted = (callback) => createLocalPostEventSubscriber('local.p
  *
  * @category Post Live Object
  */
-const getPost$1 = (postId, callback) => {
+const getPost = (postId, callback) => {
     const responder = (snapshot) => {
         const { data } = snapshot;
         callback(Object.assign(Object.assign({}, snapshot), { data: data ? LinkedObject.post(snapshot.data) : data }));
@@ -24205,7 +24599,7 @@ class PostPaginationController extends PaginationController {
             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/v4/posts`, {
+        const { data: queryResponse } = await this.http.get(`/api/v5/posts`, {
             params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), 
                 /*
                  * when creating post like image, file, video BE will create 2 posts
@@ -24220,19 +24614,6 @@ class PostPaginationController extends PaginationController {
     }
 }
 
-var EnumPostActions;
-(function (EnumPostActions) {
-    EnumPostActions["OnPostCreated"] = "onPostCreated";
-    EnumPostActions["OnPostUpdated"] = "onPostUpdated";
-    EnumPostActions["OnPostDeleted"] = "onPostDeleted";
-    EnumPostActions["OnPostFlagged"] = "onPostFlagged";
-    EnumPostActions["OnPostUnflagged"] = "onPostUnflagged";
-    EnumPostActions["OnPostReactionAdded"] = "onPostReactionAdded";
-    EnumPostActions["OnPostReactionRemoved"] = "onPostReactionRemoved";
-    EnumPostActions["OnPostApproved"] = "onPostApproved";
-    EnumPostActions["OnPostDeclined"] = "onPostDeclined";
-})(EnumPostActions || (EnumPostActions = {}));
-
 class PostQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -24298,45 +24679,50 @@ class PostQueryStreamController extends QueryStreamController {
     }
 }
 
-const getPost = async (postId) => {
-    const client = getActiveClient();
-    client.log('post/getPost', postId);
-    isInTombstone('post', postId);
-    let payload;
-    try {
-        // API-FIX: endpoint should not be /list, parameters should be querystring.
-        const response = await client.http.get(`/api/v3/posts/${encodeURIComponent(postId)}`);
-        payload = response.data;
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('post', postId);
-        }
-        throw error;
-    }
-    const data = prepareMembershipPayload(payload, 'communityUsers');
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { posts } = data;
-    const result = posts.find(post => post.postId === postId);
-    return {
-        data: result,
-        cachedAt,
-    };
+const commentEventHanlder = (callback, eventHandler, cacheKey, resolveId) => {
+    return eventHandler(async (comment) => {
+        var _a;
+        const currentCollection = (_a = pullFromCache(cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!currentCollection ||
+            !currentCollection.data.includes(resolveId ? resolveId(comment.referenceId) : comment.referenceId))
+            return;
+        await getPost$1(comment.referenceId);
+        callback(comment);
+    });
 };
-getPost.locally = (postId) => {
-    const client = getActiveClient();
-    client.log('post/getPost.locally', postId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['post', 'get', postId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
-    };
+const generateCommentSubscriptions = ({ cacheKey, resolveId, }) => {
+    const eventHandlers = [
+        onCommentCreated,
+        onCommentDeleted,
+        onCommentReactionAdded,
+        onCommentReactionRemoved,
+        onCommentCreatedLocal,
+        onCommentDeleteLocal,
+        onLocalCommentReactionAdded,
+        onLocalCommentReactionRemoved,
+    ];
+    return eventHandlers.map(handler => ({
+        fn: convertEventPayload((callback) => commentEventHanlder(callback, handler, cacheKey, resolveId), 'referenceId', 'post'),
+        action: EnumPostActions.OnPostUpdated,
+    }));
+};
+const getPostSubscription = (cacheKey) => {
+    return [
+        { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
+        { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+        { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
+        { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
+        { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
+        { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
+        { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+        { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
+        { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+        { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+        { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+        { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+        { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
+        ...generateCommentSubscriptions({ cacheKey }),
+    ];
 };
 
 class PostLiveCollectionController extends LiveCollectionController {
@@ -24367,47 +24753,7 @@ class PostLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
-            { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
-            { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
-            { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
-            { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
-            { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
-            { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
-            { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
-            { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
-            { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
-            { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
-            { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
-            { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
-            {
-                fn: convertEventPayload((callback) => {
-                    return onCommentCreated(async (comment) => {
-                        var _a;
-                        const currentCollection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                            return;
-                        await getPost(comment.referenceId);
-                        callback(comment);
-                    });
-                }, 'referenceId', 'post'),
-                action: EnumPostActions.OnPostUpdated,
-            },
-            {
-                fn: convertEventPayload((callback) => {
-                    return onCommentDeleted(async (comment) => {
-                        var _a;
-                        const currentCollection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-                        if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                            return;
-                        await getPost(comment.referenceId);
-                        callback(comment);
-                    });
-                }, 'referenceId', 'post'),
-                action: EnumPostActions.OnPostUpdated,
-            },
-        ]);
+        return this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -24542,6 +24888,22 @@ class PinnedPostQueryStreamController extends QueryStreamController {
             });
         }
     }
+    reactor(action) {
+        return (post) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumPostActions.OnPostDeleted) {
+                collection.data = collection.data.filter(referenceId => referenceId !== `global#${post.postId}`);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
 }
 
 class PinnedPostLiveCollectionController extends LiveCollectionController {
@@ -24573,7 +24935,10 @@ class PinnedPostLiveCollectionController extends LiveCollectionController {
     }
     // eslint-disable-next-line class-methods-use-this
     startSubscription() {
-        return [];
+        return this.queryStreamController.subscribeRTE(generateCommentSubscriptions({
+            cacheKey: this.cacheKey,
+            resolveId: id => `${this.query.placement}#${id}`,
+        }));
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -24725,6 +25090,10 @@ class GlobalPinnedPostLiveCollectionController extends LiveCollectionController
                 fn: onPostDeleted,
                 action: EnumPostActions.OnPostDeleted,
             },
+            ...generateCommentSubscriptions({
+                cacheKey: this.cacheKey,
+                resolveId: id => `global#${id}`,
+            }),
         ]);
     }
     notifyChange({ origin, loading, error }) {
@@ -25017,6 +25386,7 @@ var index$7 = /*#__PURE__*/Object.freeze({
   flagPost: flagPost,
   unflagPost: unflagPost,
   isPostFlaggedByMe: isPostFlaggedByMe,
+  createClipPost: createClipPost,
   onPostCreated: onPostCreated,
   onPostUpdated: onPostUpdated,
   onPostDeleted: onPostDeleted,
@@ -25026,7 +25396,7 @@ var index$7 = /*#__PURE__*/Object.freeze({
   onPostUnflagged: onPostUnflagged,
   onPostReactionAdded: onPostReactionAdded,
   onPostReactionRemoved: onPostReactionRemoved,
-  getPost: getPost$1,
+  getPost: getPost,
   getPosts: getPosts,
   getPinnedPosts: getPinnedPosts,
   getGlobalPinnedPosts: getGlobalPinnedPosts,
@@ -28011,13 +28381,13 @@ exports.AdRepository = index$2;
 exports.CategoryRepository = index$a;
 exports.ChannelRepository = index$e;
 exports.Client = index$n;
-exports.CommentRepository = index$8;
+exports.CommentRepository = index$9;
 exports.CommunityPostSettingMaps = CommunityPostSettingMaps;
 exports.CommunityPostSettings = CommunityPostSettings;
 exports.CommunityRepository = index$b;
 exports.ContentFeedType = ContentFeedType;
 exports.DefaultCommunityPostSetting = DefaultCommunityPostSetting;
-exports.FeedRepository = index$9;
+exports.FeedRepository = index$8;
 exports.FileRepository = index$k;
 exports.FileType = FileType;
 exports.InvitationRepository = index;