@amityco/ts-sdk 7.3.1-e2dead4.0 → 7.4.1-0e170b02.0

package/dist/index.cjs.js

@@ -23,6 +23,12 @@ var uuid__default = /*#__PURE__*/_interopDefaultLegacy(uuid$1);
 var hash__default = /*#__PURE__*/_interopDefaultLegacy(hash);
 var Hls__default = /*#__PURE__*/_interopDefaultLegacy(Hls);
 
+exports.MembershipAcceptanceTypeEnum = void 0;
+(function (MembershipAcceptanceTypeEnum) {
+    MembershipAcceptanceTypeEnum["AUTOMATIC"] = "automatic";
+    MembershipAcceptanceTypeEnum["INVITATION"] = "invitation";
+})(exports.MembershipAcceptanceTypeEnum || (exports.MembershipAcceptanceTypeEnum = {}));
+
 const FileType = Object.freeze({
     FILE: 'file',
     IMAGE: 'image',
@@ -112,10 +118,41 @@ const PostContentType = Object.freeze({
     POLL: 'poll',
 });
 
+exports.InvitationTypeEnum = void 0;
+(function (InvitationTypeEnum) {
+    InvitationTypeEnum["CommunityMemberInvite"] = "communityMemberInvite";
+    InvitationTypeEnum["LivestreamInvite"] = "livestreamInvite";
+})(exports.InvitationTypeEnum || (exports.InvitationTypeEnum = {}));
+exports.InvitationStatusEnum = void 0;
+(function (InvitationStatusEnum) {
+    InvitationStatusEnum["Pending"] = "pending";
+    InvitationStatusEnum["Approved"] = "approved";
+    InvitationStatusEnum["Rejected"] = "rejected";
+    InvitationStatusEnum["Cancelled"] = "cancelled";
+})(exports.InvitationStatusEnum || (exports.InvitationStatusEnum = {}));
+exports.InvitationSortByEnum = void 0;
+(function (InvitationSortByEnum) {
+    InvitationSortByEnum["FirstCreated"] = "firstCreated";
+    InvitationSortByEnum["LastCreated"] = "lastCreated";
+})(exports.InvitationSortByEnum || (exports.InvitationSortByEnum = {}));
+
+exports.JoinRequestStatusEnum = void 0;
+(function (JoinRequestStatusEnum) {
+    JoinRequestStatusEnum["Pending"] = "pending";
+    JoinRequestStatusEnum["Approved"] = "approved";
+    JoinRequestStatusEnum["Rejected"] = "rejected";
+    JoinRequestStatusEnum["Cancelled"] = "cancelled";
+})(exports.JoinRequestStatusEnum || (exports.JoinRequestStatusEnum = {}));
+exports.JoinResultStatusEnum = void 0;
+(function (JoinResultStatusEnum) {
+    JoinResultStatusEnum["Success"] = "success";
+    JoinResultStatusEnum["Pending"] = "pending";
+})(exports.JoinResultStatusEnum || (exports.JoinResultStatusEnum = {}));
+
 function getVersion() {
     try {
-        // the string ''v7.3.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.3.0-cjs';
+        // the string ''v7.4.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.4.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -558,6 +595,8 @@ const idResolvers = {
     pinTarget: ({ targetId }) => targetId,
     notificationTrayItem: ({ _id }) => _id,
     notificationTraySeen: ({ userId }) => userId,
+    invitation: ({ _id }) => _id,
+    joinRequest: ({ joinRequestId }) => joinRequestId,
 };
 /**
  * Retrieve the id resolver matching a domain name
@@ -610,6 +649,7 @@ const PAYLOAD2MODEL = {
     pinTargets: 'pinTarget',
     pins: 'pin',
     notificationTrayItems: 'notificationTrayItem',
+    invitations: 'invitation',
 };
 /** hidden */
 const isOutdated = (prevData, nextData) => {
@@ -4877,122 +4917,1219 @@ const getChannelMessagePreview = (channelId) => {
     return ((_b = (_a = pullFromCache(['messagePreviewChannel', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : null);
 };
 
-const ANALYTIC_CACHE_KEY = ['analytic', 'normal-priority'];
-const HIGH_PRIORITY_ANALYTIC_CACHE_KEY = ['analytic', 'high-priority'];
+const userLinkedObject = (user) => {
+    return Object.assign(Object.assign({}, user), { get avatar() {
+            var _a;
+            if (!user.avatarFileId)
+                return undefined;
+            const avatar = (_a = pullFromCache([
+                'file',
+                'get',
+                `${user.avatarFileId}`,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            return avatar;
+        } });
+};
 
-const syncEvent = async (events) => {
-    const client = getActiveClient();
-    const params = {
-        activities: events,
+const getChannelMessagePreviewWithUser = (channel) => {
+    var _a;
+    const messagePreview = channel.messagePreviewId
+        ? getChannelMessagePreview(channel.channelId)
+        : null;
+    const internalUser = (_a = pullFromCache([
+        'user',
+        'get',
+        messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.creatorId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    const messagePreviewWithUser = messagePreview
+        ? Object.assign(Object.assign({}, messagePreview), { user: internalUser ? userLinkedObject(internalUser) : undefined }) : null;
+    return Object.assign(Object.assign({}, channel), { messagePreview: messagePreviewWithUser });
+};
+
+const updateChannelMessagePreviewCache = (rawPayload) => {
+    var _a, _b;
+    const withMessageFeedInfo = (messagePreview) => {
+        var _a;
+        const messageFeedInfo = (_a = rawPayload.messageFeedsInfo) === null || _a === void 0 ? void 0 : _a.find(messageFeed => {
+            return messageFeed.messageFeedId === messagePreview.messageFeedId;
+        });
+        const { channelPublicId: channelId, messageFeedId: subChannelId, data, dataType, isDeleted, segment, creatorPublicId: creatorId, createdAt, updatedAt, } = messagePreview;
+        return {
+            channelId,
+            subChannelId,
+            data,
+            dataType,
+            isDeleted,
+            segment,
+            creatorId,
+            createdAt,
+            updatedAt,
+            subChannelName: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.name,
+            messagePreviewId: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.messagePreviewId,
+            subChannelUpdatedAt: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.updatedAt,
+        };
     };
-    await client.http.post('/api/v1/analytics/activities', params);
+    const newData = {
+        messagePreviewChannel: (_b = (_a = rawPayload.messagePreviews) === null || _a === void 0 ? void 0 : _a.map(messagePreview => withMessageFeedInfo(messagePreview))) !== null && _b !== void 0 ? _b : [],
+    };
+    ingestInCache(newData);
 };
 
-class AnalyticsEventSyncer {
-    constructor() {
-        this._timer = undefined;
-        this._high_priority_timer = undefined;
-    }
-    start() {
-        this.syncCapturedEvent();
-        this._timer = setInterval(() => {
-            this.syncCapturedEvent();
-        }, 1 * MINUTE);
-        this._high_priority_timer = setInterval(() => {
-            this.syncHighPriorityCapturedEvent();
-        }, 10 * SECOND$1);
-    }
-    stop() {
-        if (this._timer) {
-            clearInterval(this._timer);
-            this._timer = undefined;
-        }
-        if (this._high_priority_timer) {
-            clearInterval(this._high_priority_timer);
-            this._high_priority_timer = undefined;
-        }
-    }
-    async syncCapturedEvent() {
-        try {
-            // Must query only objects that have same userId with current logged-in user.
-            // Query captured event with maximum of 1000
-            // Order by latest first
-            // e.g., If there are 2000 events we will query 1000-2000 first
-            const cache = pullFromCache(ANALYTIC_CACHE_KEY);
-            if (!(cache === null || cache === void 0 ? void 0 : cache.data))
-                return;
-            if (cache.data.event.length === 0)
-                return;
-            const capturedEvents = cache.data.event;
-            await syncEvent(capturedEvents);
-            dropFromCache(ANALYTIC_CACHE_KEY);
-        }
-        catch (error) {
-            // stop and destroy all events
-            this.stop();
-            dropFromCache(ANALYTIC_CACHE_KEY);
-        }
-    }
-    async syncHighPriorityCapturedEvent() {
-        try {
-            // Must query only objects that have same userId with current logged-in user.
-            // Query captured event with maximum of 1000
-            // Order by latest first
-            // e.g., If there are 2000 events we will query 1000-2000 first
-            const cache = pullFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
-            if (!(cache === null || cache === void 0 ? void 0 : cache.data))
-                return;
-            if (cache.data.event.length === 0)
-                return;
-            const capturedEvents = cache.data.event;
-            await syncEvent(capturedEvents);
-            dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
-        }
-        catch (error) {
-            // stop and destroy all events
-            this.stop();
-            dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
-        }
-    }
+const getSubChannelMessagePreview = (subChannelId) => {
+    var _a, _b;
+    return ((_b = (_a = pullFromCache(['messagePreviewSubChannel', 'get', subChannelId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : null);
+};
+
+const getSubChannelMessagePreviewWithUser = (subChannel) => {
+    var _a;
+    const messagePreview = subChannel.messagePreviewId
+        ? getSubChannelMessagePreview(subChannel.subChannelId)
+        : null;
+    const messagePreviewWithUser = messagePreview
+        ? Object.assign(Object.assign({}, messagePreview), { user: (_a = pullFromCache(['user', 'get', messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.creatorId])) === null || _a === void 0 ? void 0 : _a.data }) : null;
+    return Object.assign(Object.assign({}, subChannel), { messagePreview: messagePreviewWithUser });
+};
+
+const updateSubChannelMessagePreviewCache = (rawPayload) => {
+    var _a, _b;
+    const withMessageFeedInfo = (messagePreview) => {
+        var _a;
+        const messageFeedInfo = (_a = rawPayload.messageFeeds) === null || _a === void 0 ? void 0 : _a.find(messageFeed => {
+            return messageFeed.messageFeedId === messagePreview.messageFeedId;
+        });
+        const { channelPublicId: channelId, messageFeedId: subChannelId, messageId: messagePreviewId, creatorPublicId: creatorId, data, dataType, isDeleted, segment, createdAt, updatedAt, } = messagePreview;
+        return {
+            messagePreviewId,
+            channelId,
+            subChannelId,
+            data,
+            dataType,
+            isDeleted,
+            segment,
+            creatorId,
+            createdAt,
+            updatedAt,
+            subChannelName: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.name,
+            subChannelUpdatedAt: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.updatedAt,
+        };
+    };
+    const newData = {
+        messagePreviewSubChannel: (_b = (_a = rawPayload.messages) === null || _a === void 0 ? void 0 : _a.map(messagePreview => withMessageFeedInfo(messagePreview))) !== null && _b !== void 0 ? _b : [],
+    };
+    ingestInCache(newData);
+};
+
+/**
+ * ```js
+ * import { shallowClone } from '~/utils/shallowClone'
+ * const newObj = shallowClone(obj)
+ * ```
+ *
+ * Clone an object with same prototype and properties
+ *
+ * @param obj the object to clone
+ * @returns new object with same prototype and properties
+ *
+ * @category utility
+ * @private
+ */
+function shallowClone(source, target) {
+    return Object.create(Object.getPrototypeOf(source), Object.assign(Object.assign({}, Object.getOwnPropertyDescriptors(source)), Object.getOwnPropertyDescriptors(target)));
 }
 
-class AnalyticsEventCapturer {
-    constructor() {
-        this._expireTime = 5 * MINUTE;
-        this._poolLimit = 1000;
-        this._recentViewed = {};
-        this._recentHighPriorityViewed = {};
-        // Story
-        this._throttleStoryTimer = undefined;
-        this._bufferNewSeenStoryReferenceIds = [];
-    }
-    isAbleToEnqueue({ uniqueId, expireTime, isHighPriority = false, }) {
-        const now = new Date();
-        // Get the recent view date (if any)
-        const recentViewedDate = isHighPriority
-            ? this._recentHighPriorityViewed[uniqueId]
-            : this._recentViewed[uniqueId];
-        // If this is the first view, always allow it
-        if (!recentViewedDate) {
-            return true;
-        }
-        const timeDiff = now.getTime() - recentViewedDate.getTime();
-        if (timeDiff < expireTime) {
-            // just recently view this post, ignore the event.
-            return false;
-        }
-        return true;
+function updateSubChannelCache(subChannelId, subChannel, params) {
+    pushToCache(['subChannel', 'get', subChannelId], 
+    // eslint-disable-next-line prefer-object-spread
+    shallowClone(subChannel, params));
+}
+
+/**
+ * ```js
+ * import { isInTombstone } from '@amityco/ts-sdk'
+ * const user = isInTombstone(["message", "messageId"])
+ * ```
+ *
+ * Checks if the {@link Amity.TombstoneCacheOptions} exists
+ * in cache and it's not expired means it's in tombstone
+ * and we throw an Error
+ *
+ * @param model the model to check
+ * @param modelId the object id to check
+ * @returns the matching cache entry, or undefined.
+ *
+ * @category Cache API
+ */
+const isInTombstone = (model, modelId) => {
+    const { log, cache } = getActiveClient();
+    const key = [model, CACHE_KEY_TOMBSTONE, modelId];
+    if (!cache)
+        return;
+    log('cache/api/isInTombstone', key);
+    const isInTombstone = pullFromCache(key);
+    const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
+    if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
+        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
     }
-    markAs({ uniqueId, contentId, contentType, activityType, metadata, }) {
-        if (!this.isAbleToEnqueue({ uniqueId, expireTime: this._expireTime }))
-            return;
-        const now = new Date();
-        const currentData = { event: [] };
-        const cache = pullFromCache(ANALYTIC_CACHE_KEY);
-        if (cache === null || cache === void 0 ? void 0 : cache.data) {
-            currentData.event = cache.data.event;
-        }
-        // If the pool is full (Max 1000 items), remove the oldest data
+};
+
+/**
+ * ```js
+ * import { getMessageMarkers } from '@amityco/ts-sdk'
+ * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a list of {@link Amity.MessageMarker} by messageIds
+ *
+ * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
+ * @returns A list of {@link Amity.MessageMarker} by messageIds
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const getMessageMarkers = async (messageIds) => {
+    const client = getActiveClient();
+    client.log('channel/getMessageMarkers', messageIds);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/messages`, {
+        params: {
+            messageIds,
+        },
+    });
+    const { contentMarkers, feedMarkers, userMarkers } = queryPayload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });
+    fireEvent('local.feedMarker.fetched', { feedMarkers });
+    fireEvent('local.messageMarker.fetched', { contentMarkers });
+    fireEvent('local.userMarker.fetched', { userMarkers });
+    return { data: contentMarkers, cachedAt };
+};
+
+const reCalculateChannelUnreadInfo = (channelId) => {
+    var _a;
+    const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
+    const cacheChannelUnreadInfo = (_a = pullFromCache(cacheKeyChannelUnread)) === null || _a === void 0 ? void 0 : _a.data;
+    const cacheKeySubChannelUnread = ['subChannelUnreadInfo', 'get'];
+    const cachedSubChannelUnreadInfo = queryCache(cacheKeySubChannelUnread);
+    let channelUnreads = 0;
+    let isMentioned = false;
+    if (cachedSubChannelUnreadInfo && (cachedSubChannelUnreadInfo === null || cachedSubChannelUnreadInfo === void 0 ? void 0 : cachedSubChannelUnreadInfo.length) > 0) {
+        const subChannelUnreadsInfo = cachedSubChannelUnreadInfo === null || cachedSubChannelUnreadInfo === void 0 ? void 0 : cachedSubChannelUnreadInfo.filter(({ data }) => {
+            return data.channelId === channelId && !data.isDeleted;
+        });
+        channelUnreads = subChannelUnreadsInfo
+            .map(({ data }) => data.unreadCount)
+            .reduce((acc, cur) => acc + cur, 0);
+        isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
+    }
+    const channelUnreadInfo = Object.assign(Object.assign({}, (cacheChannelUnreadInfo !== null && cacheChannelUnreadInfo !== void 0 ? cacheChannelUnreadInfo : {
+        channelId,
+        createdAt: new Date().toISOString(),
+    })), { updatedAt: new Date().toISOString(), unreadCount: channelUnreads, isMentioned });
+    pushToCache(cacheKeyChannelUnread, channelUnreadInfo);
+    return channelUnreadInfo;
+};
+
+const persistUnreadCountInfo = (payload) => {
+    const { feedMarkers, userFeedMarkers } = payload;
+    // calculate sub channel unread info and channel unread info
+    if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
+        const channelIds = [];
+        const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
+        userFeedMarkers.forEach(userFeedMarker => {
+            const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
+            if (!feedMarker)
+                return;
+            if (feedMarker.feedId === userFeedMarker.feedId) {
+                const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
+                const subChannelUnreadInfo = {
+                    subChannelId: feedMarker.feedId,
+                    channelId: feedMarker.entityId,
+                    readToSegment: userFeedMarker.readToSegment,
+                    lastSegment: feedMarker.lastSegment,
+                    lastMentionSegment: userFeedMarker.lastMentionSegment,
+                    unreadCount: Math.max(0, unreadCount),
+                    isMentioned: userFeedMarker.isMentioned,
+                    isDeleted: feedMarker.isDeleted,
+                    createdAt: userFeedMarker.createdAt,
+                    updatedAt: userFeedMarker.updatedAt,
+                };
+                // update sub channel unread info in cache
+                ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
+                if (!channelIds.includes(feedMarker.entityId)) {
+                    channelIds.push(feedMarker.entityId);
+                }
+            }
+        });
+        // re-calculate channel unread info in cache
+        channelIds.forEach(channelId => {
+            reCalculateChannelUnreadInfo(channelId);
+        });
+    }
+};
+
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannelMarkers', messageFeedIds, page);
+    const { data: queryPayload } = await client.http.get(`/api/v1/markers/message-feeds`, {
+        params: {
+            messageFeedIds,
+            options: {
+                token: toToken(page, 'skiplimit'),
+            },
+        },
+    });
+    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
+    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, userMarkers, feedMarkers: feedMarkersPayload, } = payload;
+    // if consistent mode is enabled, persist the unread count info to the cache
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        persistUnreadCountInfo({
+            feedMarkers: feedMarkersPayload,
+            userFeedMarkers: userFeedMarkersPayload,
+        });
+    }
+    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
+    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ userEntityMarkers, userFeedMarkers, userMarkers }, { cachedAt });
+    fireEvent('local.channelMarker.fetched', { userEntityMarkers });
+    fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
+    fireEvent('local.userMarker.fetched', { userMarkers });
+    const nextPage = toPage(paging.next);
+    const prevPage = toPage(paging.previous);
+    return { data: userFeedMarkers, cachedAt, prevPage, nextPage };
+};
+
+const getUserMarker = async () => {
+    const client = getActiveClient();
+    client.log('channel/getUserMarker');
+    const { data: payload } = await client.http.get(`/api/v1/markers/userMarker`);
+    const { userMarkers } = payload;
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache({ userMarkers }, { cachedAt });
+    fireEvent('local.userMarker.fetched', { userMarkers });
+    const latestUserMarker = userMarkers.reduce((maxUserMarker, userMarker) => {
+        if (maxUserMarker == null ||
+            new Date(maxUserMarker.lastSyncAt).getTime() < new Date(userMarker.lastSyncAt).getTime()) {
+            return userMarker;
+        }
+        return maxUserMarker;
+    }, undefined);
+    return { data: latestUserMarker, cachedAt };
+};
+
+/** @hidden */
+/*
+ * @param message payload from http request without myReactions
+ * add myReactions to http response if the event was a reaction event
+ */
+const prepareMessagePayloadForCache = (payload, reactors, event) => {
+    const client = getActiveClient();
+    const cached = pullFromCache(['message', 'get', payload.messageId]);
+    // '[]' in cases where the new reaction is the first one
+    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
+    // add myReactions to the payload
+    Object.assign(payload, { myReactions });
+    // check if there are any updates to the reactions
+    const latestReaction = reactors[0];
+    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
+    if (!isLatestReactionMine) {
+        return;
+    }
+    // new reaction added
+    if (event === 'message.reactionAdded' && !myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: [...myReactions, latestReaction.reactionName],
+        });
+    }
+    // existing reaction removed
+    if (event === 'message.reactionRemoved' && myReactions.includes(latestReaction.reactionName)) {
+        Object.assign(payload, {
+            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+        });
+    }
+};
+
+/*
+ * This is a simple utility that infers the value of isDeleted based on the
+ * value of includeDeleted
+ *
+ * There are two important things to note here:
+ *  1. `includeDeleted` is purely client side query param and not recognized by
+ *  the server
+ *  2. The only values we wish to expose with regards to `isDeleted` (the server
+ *  param for queries) is false | undefined and want to disallow users to query
+ *  for deleted entities
+ *
+ *  Although this is a very simple utility, it's only purpose is to keep things
+ *  DRY
+ */
+const inferIsDeleted = (includeDeleted) => includeDeleted === true ? undefined : false;
+
+function getSubChannelIsMentioned(channelId, subChannelId, marker) {
+    var _a, _b;
+    // Look for `unreadCount` in the marker param first
+    if (marker) {
+        return marker.hasMentioned;
+    }
+    const client = getActiveClient();
+    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        const cachedUnreadCount = (_a = pullFromCache([
+            'subChannelUnreadInfo',
+            'get',
+            subChannelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (cachedUnreadCount) {
+            return cachedUnreadCount.isMentioned;
+        }
+        return false;
+    }
+    const key = {
+        entityId: channelId,
+        feedId: subChannelId,
+        userId: getActiveUser()._id,
+    };
+    // If the marker param is not set, look in the cache
+    const cachedMarker = (_b = pullFromCache([
+        'subChannelMarker',
+        'get',
+        getResolver('subChannelMarker')(key),
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+    if (cachedMarker) {
+        return cachedMarker.hasMentioned;
+    }
+    // and if not found in cache use default value `false`
+    return false;
+}
+
+function getSubChannelUnreadCount(channelId, subChannelId, marker) {
+    var _a, _b;
+    // Look for `unreadCount` in the marker param first
+    if (marker) {
+        return marker.unreadCount;
+    }
+    const client = getActiveClient();
+    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        const cachedUnreadCount = (_a = pullFromCache([
+            'subChannelUnreadInfo',
+            'get',
+            subChannelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (cachedUnreadCount) {
+            return cachedUnreadCount.isDeleted ? 0 : cachedUnreadCount.unreadCount;
+        }
+        return 0;
+    }
+    const key = {
+        entityId: channelId,
+        feedId: subChannelId,
+        userId: getActiveUser()._id,
+    };
+    // If the marker param is not set, look in the cache
+    const cachedMarker = (_b = pullFromCache([
+        'subChannelMarker',
+        'get',
+        getResolver('subChannelMarker')(key),
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+    if (cachedMarker) {
+        return cachedMarker.unreadCount;
+    }
+    // and if not found in cache use default value `0`
+    return 0;
+}
+
+const MARKER_INCLUDED_SUB_CHANNEL_TYPE$1 = ['broadcast', 'conversation', 'community'];
+const isUnreadCountSupport$2 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE$1.includes(channelType);
+function convertFromRaw$2(_a) {
+    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
+    return Object.assign(Object.assign({ get unreadCount() {
+            return getSubChannelUnreadCount(channelId, messageFeedId);
+        },
+        get hasMentioned() {
+            return getSubChannelIsMentioned(channelId, messageFeedId);
+        },
+        get isMentioned() {
+            return getSubChannelIsMentioned(channelId, messageFeedId);
+        } }, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId, isUnreadCountSupport: isUnreadCountSupport$2({ channelType }) });
+}
+
+const mergePayloadWithLocal = (payload) => {
+    var _a, _b, _c;
+    const localMessage = (_b = (_a = queryCache(['message', 'get'])) === null || _a === void 0 ? void 0 : _a.find(({ data }) => data.messageId === payload.messageId)) === null || _b === void 0 ? void 0 : _b.data;
+    if (localMessage) {
+        return Object.assign(Object.assign(Object.assign({}, localMessage), payload), { 
+            // NOTE: referenceId is missing in the some payload event. If we have local message data with referenceId, use it instead.
+            referenceId: (_c = localMessage.referenceId) !== null && _c !== void 0 ? _c : payload.referenceId });
+    }
+    return payload;
+};
+function convertFromRaw$1(message, reactors, event) {
+    var _a;
+    const mergeMessage = mergePayloadWithLocal(message);
+    const { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment, messageId, creatorId } = mergeMessage, rest = __rest(mergeMessage, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment", "messageId", "creatorId"]);
+    let cache;
+    if (referenceId) {
+        cache = pullFromCache(['message', 'get', referenceId]);
+    }
+    if (!cache) {
+        cache = pullFromCache(['message', 'get', messageId]);
+    }
+    const out = Object.assign(Object.assign({}, rest), { messageId, channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, creatorPrivateId: message.creatorId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, 
+        /*
+         * Previously, myReactions were added only if it was part of the payload.
+         * So empty myReactions were not present. So I've edited the payload to add
+         * a default for those cases.
+         *
+         * Check git blame for previous iteration
+         */
+        myReactions: myReactions || ((_a = cache === null || cache === void 0 ? void 0 : cache.data.myReactions) !== null && _a !== void 0 ? _a : []), reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : messageId, referenceId, syncState: "synced" /* Amity.SyncState.Synced */ });
+    if (mentionedUsers) {
+        out.mentionees = mentionedUsers.map(mention => {
+            if (mention.type === 'channel') {
+                return mention;
+            }
+            return { type: 'user', userIds: mention.userPublicIds };
+        });
+    }
+    if (reactors && reactors.length && event) {
+        // mqtt event
+        prepareMessagePayloadForCache(out, reactors, event);
+    }
+    return out;
+}
+const preUpdateMessageCache = (rawPayload) => {
+    ingestInCache({
+        messages: rawPayload.messages.map(message => convertFromRaw$1(message, rawPayload.reactions)),
+    });
+};
+const DEBOUNCE_TIME = 2000;
+const currentDebounceMap = {};
+const prepareMessagePayload = async (payload, event) => {
+    const markerIds = payload.messages.map(({ messageId }) => messageId);
+    if (markerIds.length > 0) {
+        // since the get markers method requires a channel cache to function with the reducer.
+        preUpdateMessageCache(payload);
+        const markerIdsKey = markerIds.join('');
+        if (currentDebounceMap[markerIdsKey]) {
+            clearTimeout(currentDebounceMap[markerIdsKey]);
+        }
+        currentDebounceMap[markerIdsKey] = setTimeout(() => {
+            try {
+                getMessageMarkers(markerIds);
+            }
+            catch (_error) {
+                // do nothing
+            }
+        }, DEBOUNCE_TIME);
+    }
+    const { messageFeeds } = payload, restPayload = __rest(payload, ["messageFeeds"]);
+    // upsert messageFeeds to subchannel cache because messageFeeds from event payload not include messagePreviewId
+    if (messageFeeds && messageFeeds.length > 0) {
+        messageFeeds === null || messageFeeds === void 0 ? void 0 : messageFeeds.forEach(messageFeed => {
+            var _a, _b;
+            const subChannelCache = (_b = (_a = pullFromCache(['subChannel', 'get', messageFeed.messageFeedId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {};
+            // exclude getter properties from existing subChannel cache, update only other properties to existing subChannel cache
+            const _c = convertFromRaw$2(messageFeed), restSubChannel = __rest(_c, ["unreadCount", "isMentioned"]);
+            updateSubChannelCache(messageFeed.messageFeedId, subChannelCache, restSubChannel);
+        });
+    }
+    return Object.assign(Object.assign({}, restPayload), { messages: payload.messages.map(m => convertFromRaw$1(m, payload.reactions, event)) });
+};
+function convertParams(_a) {
+    var { subChannelId, mentionees, dataType, data } = _a, rest = __rest(_a, ["subChannelId", "mentionees", "dataType", "data"]);
+    if (dataType === MessageContentType.IMAGE || dataType === MessageContentType.FILE) {
+        return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data: Object.assign({ caption: '' }, data) }, rest);
+    }
+    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data }, rest);
+}
+function convertQueryParams$1(_a) {
+    var { sortBy, subChannelId, includingTags, excludingTags, includeDeleted, aroundMessageId, limit, type } = _a, rest = __rest(_a, ["sortBy", "subChannelId", "includingTags", "excludingTags", "includeDeleted", "aroundMessageId", "limit", "type"]);
+    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, isDeleted: inferIsDeleted(includeDeleted), options: {
+            sortBy,
+            limit: limit || COLLECTION_DEFAULT_PAGINATION_LIMIT,
+            around: aroundMessageId,
+        } });
+    if (includingTags) {
+        out.includeTags = includingTags;
+    }
+    if (type) {
+        out.dataType = type;
+    }
+    if (excludingTags) {
+        out.excludeTags = excludingTags;
+    }
+    return out;
+}
+
+function convertRawUserToInternalUser(rawUser) {
+    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
+}
+
+const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+/**
+ * Filter sub channel by type. Only conversation, community and broadcast type are included.
+ */
+const isUnreadCountSupport$1 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
+const preUpdateSubChannelCache = (rawPayload) => {
+    ingestInCache({
+        messageFeeds: rawPayload.messageFeeds.map(messageFeed => convertFromRaw$2(messageFeed)),
+    });
+};
+const prepareSubChannelPayload = async (rawPayload) => {
+    const markerIds = rawPayload.messageFeeds
+        .filter(isUnreadCountSupport$1)
+        .map(({ messageFeedId }) => messageFeedId);
+    if (markerIds.length > 0) {
+        // since the get markers method requires a channel cache to function with the reducer.
+        preUpdateSubChannelCache(rawPayload);
+        try {
+            await getSubChannelMarkers(markerIds);
+        }
+        catch (e) {
+            // empty block (from the spec, allow marker fetch to fail without having to do anything)
+        }
+    }
+    updateSubChannelMessagePreviewCache(rawPayload);
+    // attach marker to sub channel
+    const messageFeeds = rawPayload.messageFeeds.map(convertFromRaw$2);
+    const messages = rawPayload.messages.map(m => convertFromRaw$1(m));
+    const user = rawPayload.users.map(convertRawUserToInternalUser);
+    return Object.assign(Object.assign({}, rawPayload), { messageFeeds,
+        messages, users: user });
+};
+function convertQueryParams(_a) {
+    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
+    const out = Object.assign({}, rest);
+    if (excludeDefaultSubChannel !== undefined) {
+        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+    }
+    return out;
+}
+
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = await getSubChannel('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ * @async
+ */
+const getSubChannel$1 = async (subChannelId) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannel', subChannelId);
+    isInTombstone('subChannel', subChannelId);
+    try {
+        const response = await client.http.get(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`);
+        const data = await prepareSubChannelPayload(response.data);
+        const cachedAt = client.cache && Date.now();
+        if (client.cache)
+            ingestInCache(data, { cachedAt });
+        fireEvent('local.message-feed.fetched', data);
+        return {
+            data: data.messageFeeds[0],
+            cachedAt,
+        };
+    }
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            pushToTombstone('subChannel', subChannelId);
+        }
+        throw error;
+    }
+};
+/**
+ * ```js
+ * import { getSubChannel } from '@amityco/ts-sdk'
+ * const subChannel = getSubChannel.locally('foobar')
+ * ```
+ *
+ * Fetches a {@link Amity.SubChannel} object from cache
+ *
+ * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
+ * @returns the associated {@link Amity.SubChannel} object
+ *
+ * @category Channel API
+ */
+getSubChannel$1.locally = (subChannelId) => {
+    const client = getActiveClient();
+    client.log('channel/getSubChannel.locally', subChannelId);
+    if (!client.cache)
+        return;
+    const cached = pullFromCache(['subChannel', 'get', subChannelId]);
+    if (!cached)
+        return;
+    return {
+        data: cached.data,
+        cachedAt: cached.cachedAt,
+    };
+};
+
+const convertDateStringToTimestamp = (dateString) => {
+    return new Date(dateString).getTime();
+};
+
+const getMessagePreviewSetting$1 = async () => {
+    const client = getActiveClient();
+    return client.getMessagePreviewSetting(false);
+};
+const getSubChannelCache = async (subChannelId) => {
+    var _a;
+    let subChannelCache = (_a = pullFromCache(['subChannel', 'get', subChannelId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!subChannelCache) {
+        subChannelCache = (await getSubChannel$1(subChannelId)).data;
+    }
+    return subChannelCache;
+};
+const isLastestMessageOnSubchannel = (message) => {
+    var _a;
+    const cache = (_a = pullFromCache([
+        'messagePreviewSubChannel',
+        'get',
+        message.subChannelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    // The message payload from optimistic created event has no segment, so we check createdAt instead.
+    return (!cache ||
+        cache.segment <= message.channelSegment ||
+        convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
+};
+const isLastestMessageOnChannel = (message) => {
+    var _a;
+    const cache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        message.channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    return (!cache ||
+        convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
+};
+const handleMessageCreatedOnSubChannel = async (message) => {
+    const messagePreviewSetting = await getMessagePreviewSetting$1();
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    // 1. get subChannel from cache, if not exist fetch from server
+    const subChannelCache = await getSubChannelCache(subChannelId);
+    // 2. if messagePreviewSetting is NO_MESSAGE_PREVEIW, update only lastActiviy in subChannel cache
+    if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */) {
+        // 2.1 if the message is the latest message, update lastActivity to be createdAt in subChannel cache
+        if (convertDateStringToTimestamp(subChannelCache.lastActivity) <
+            convertDateStringToTimestamp(createdAt))
+            updateSubChannelCache(message.subChannelId, subChannelCache, {
+                lastActivity: createdAt,
+            });
+        return;
+    }
+    // 3. if messagePreviewSetting is `NOT` NO_MESSAGE_PREVEIW, update messagePreviewSubChannel and subChannel cache
+    // 3.1 check if the message is the latest message, if not ignore the message.
+    if (!isLastestMessageOnSubchannel(message))
+        return;
+    // 3.2 if the message is the latest message, update messagePreviewSubChannel and subChannel cache
+    pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
+        channelId,
+        creatorId,
+        messagePreviewId,
+        createdAt,
+        updatedAt,
+        subChannelId,
+        data,
+        dataType,
+        segment,
+        isDeleted,
+        subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
+        subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
+    });
+    updateSubChannelCache(message.subChannelId, subChannelCache, {
+        lastActivity: createdAt,
+        messagePreviewId,
+    });
+};
+const handleMessageUpdatedOnSubChannel = async (message) => {
+    var _a;
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    const messagePreviewSubChannelCache = (_a = pullFromCache([
+        'messagePreviewSubChannel',
+        'get',
+        message.subChannelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    // if messagePreviewSubChannel is not exist, ignore the message.
+    if (messagePreviewSubChannelCache &&
+        messagePreviewSubChannelCache.messagePreviewId === message.messageId) {
+        const subChannelCache = await getSubChannelCache(subChannelId);
+        pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
+            channelId,
+            creatorId,
+            messagePreviewId,
+            createdAt,
+            updatedAt,
+            subChannelId,
+            data,
+            dataType,
+            segment,
+            isDeleted,
+            subChannelUpdatedAt: subChannelCache.updatedAt,
+            subChannelName: messagePreviewSubChannelCache.subChannelName,
+        });
+    }
+};
+const handleMessageCreated = async (message) => {
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    if (isLastestMessageOnChannel(message)) {
+        const subChannelCache = await getSubChannelCache(subChannelId);
+        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
+            channelId,
+            creatorId,
+            messagePreviewId,
+            createdAt,
+            updatedAt,
+            subChannelId,
+            data,
+            dataType,
+            segment,
+            isDeleted,
+            subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
+            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
+        });
+    }
+};
+const handleMessageUpdated = async (message) => {
+    /**
+     * Channel Case
+     */
+    var _a;
+    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
+    const messagePreviewChannelCache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        message.channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (messagePreviewChannelCache &&
+        messagePreviewChannelCache.messagePreviewId === message.messageId) {
+        const subChannelCache = await getSubChannelCache(subChannelId);
+        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
+            channelId,
+            creatorId,
+            messagePreviewId,
+            createdAt,
+            updatedAt,
+            subChannelId,
+            data,
+            dataType,
+            segment,
+            isDeleted,
+            subChannelUpdatedAt: subChannelCache.updatedAt,
+            subChannelName: messagePreviewChannelCache.subChannelName,
+        });
+    }
+};
+const handleSubChannelUpdated = async (subChannel) => {
+    var _a, _b, _c, _d;
+    const { channelId, subChannelId } = subChannel;
+    /** Channel Case */
+    const messagePreviewChannelCache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.subChannelId) === subChannelId) {
+        const subChannelCache = (_b = pullFromCache([
+            'subChannel',
+            'get',
+            subChannelId,
+        ])) === null || _b === void 0 ? void 0 : _b.data;
+        pushToCache(['messagePreviewChannel', 'get', channelId], Object.assign(Object.assign({}, messagePreviewChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
+    }
+    /** SubChannel Case */
+    const messagePreviewSubChannelCache = (_c = pullFromCache([
+        'messagePreviewSubChannel',
+        'get',
+        subChannelId,
+    ])) === null || _c === void 0 ? void 0 : _c.data;
+    if (messagePreviewSubChannelCache &&
+        new Date(messagePreviewSubChannelCache.updatedAt).valueOf() >
+            new Date(subChannel.updatedAt).valueOf()) {
+        const subChannelCache = (_d = pullFromCache([
+            'subChannel',
+            'get',
+            subChannelId,
+        ])) === null || _d === void 0 ? void 0 : _d.data;
+        pushToCache(['messagePreviewSubChannel', 'get', subChannelId], Object.assign(Object.assign({}, messagePreviewSubChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
+    }
+};
+
+const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
+const isUnreadCountSupport = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
+function convertFromRaw(channel, options = { isMessagePreviewUpdated: true }) {
+    var _a;
+    let { messagePreviewId } = channel;
+    const messagePreviewChannelCache = (_a = pullFromCache([
+        'messagePreviewChannel',
+        'get',
+        channel.channelId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.messagePreviewId) && !options.isMessagePreviewUpdated) {
+        messagePreviewId = messagePreviewChannelCache.messagePreviewId;
+    }
+    return Object.assign(Object.assign({}, channel), { defaultSubChannelId: channel.channelInternalId, isUnreadCountSupport: isUnreadCountSupport(channel), messagePreviewId });
+}
+const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated: true }) => {
+    ingestInCache({
+        channels: rawPayload.channels.map(channel => convertFromRaw(channel, { isMessagePreviewUpdated: options.isMessagePreviewUpdated })),
+    });
+};
+const updateChannelUnread = ({ currentUserId, channels, channelUsers, }) => {
+    for (let i = 0; i < channels.length; i += 1) {
+        const cacheKey = ['channelUnread', 'get', channels[i].channelId];
+        const channelUser = channelUsers.find(channelUser => channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId);
+        let unreadCount = 0;
+        let readToSegment = null;
+        let lastMentionedSegment = null;
+        let isMentioned = false;
+        if (channelUser) {
+            readToSegment = channelUser.readToSegment;
+            lastMentionedSegment = channelUser.lastMentionedSegment;
+            unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
+            isMentioned = lastMentionedSegment > readToSegment;
+        }
+        const cacheChannelUnread = {
+            channelId: channels[i].channelId,
+            lastSegment: channels[i].messageCount,
+            readToSegment,
+            lastMentionedSegment,
+            unreadCount,
+            isMentioned,
+            isDeleted: channels[i].isDeleted || false,
+        };
+        pushToCache(cacheKey, cacheChannelUnread);
+    }
+};
+const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpdated: true }) => {
+    const client = getActiveClient();
+    const networkPreviewSetting = await client.getMessagePreviewSetting(false);
+    if (options.isMessagePreviewUpdated &&
+        networkPreviewSetting !== "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */ &&
+        rawPayload.messagePreviews &&
+        rawPayload.messagePreviews.length > 0) {
+        updateChannelMessagePreviewCache(rawPayload);
+    }
+    if (client.useLegacyUnreadCount) {
+        updateChannelUnread({
+            channels: rawPayload.channels,
+            channelUsers: rawPayload.channelUsers,
+            currentUserId: client.userId,
+        });
+    }
+    else {
+        const markerIds = rawPayload.channels
+            // filter channel by type. Only conversation, community and broadcast type are included.
+            .filter(isUnreadCountSupport)
+            .map(({ channelInternalId }) => channelInternalId);
+        if (markerIds.length > 0) {
+            // since the get markers method requires a channel cache to function with the reducer.
+            preUpdateChannelCache(rawPayload, {
+                isMessagePreviewUpdated: options.isMessagePreviewUpdated,
+            });
+            try {
+                await getChannelMarkers(markerIds);
+            }
+            catch (e) {
+                // empty block (from the spec, allow marker fetch to fail without having to do anything)
+            }
+        }
+    }
+    // convert raw channel to internal channel
+    const channels = rawPayload.channels.map(payload => convertFromRaw(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }));
+    // convert raw channel user to membership (add user object)
+    const channelUsers = rawPayload.channelUsers.map(channelUser => {
+        return convertRawMembershipToMembership(channelUser);
+    });
+    const users = rawPayload.users.map(convertRawUserToInternalUser);
+    const restRawPayload = __rest(rawPayload, ["messageFeedsInfo", "messagePreviews"]);
+    return Object.assign(Object.assign({}, restRawPayload), { users,
+        channels,
+        channelUsers });
+};
+
+/**
+ * ```js
+ * import { getSubChannelMarkers } from '@amityco/ts-sdk'
+ * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * ```
+ *
+ * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ *
+ * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
+ * @param page
+ * @returns A page of {@link Amity.SubChannelMarker} objects
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+const getUserMessageFeedMakers = async (channelIds) => {
+    const client = getActiveClient();
+    client.log('channel/getUserMessageFeedMakers', channelIds);
+    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
+        params: {
+            channelIds,
+        },
+    });
+    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
+    return data;
+};
+
+const prepareUnreadCountInfo = async (rawPayload) => {
+    const client = getActiveClient();
+    // if consistent mode is enabled, persist the unread count info to the cache
+    // Marker service API uses channelInternalId as channelId
+    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelInternalId }) => channelInternalId));
+    const { feedMarkers, userFeedMarkers } = queryPayload;
+    persistUnreadCountInfo({
+        feedMarkers,
+        userFeedMarkers,
+    });
+    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
+};
+
+const getCachedMarker$2 = (entityId) => {
+    var _a;
+    const key = {
+        entityId,
+        userId: getActiveUser()._id,
+    };
+    return (_a = pullFromCache([
+        'channelMarker',
+        'get',
+        getResolver('channelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+};
+const getUnreadInfoCached$1 = (channelId) => {
+    var _a;
+    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+};
+/**
+ * The function use to get value of hasMentioned or isMentioned field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ *
+ * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
+ * If not, the function will return the value from the channelMarker cache.
+ * If not found in the both cache, use `false` as defaul value.
+ */
+const getChannelIsMentioned = (channel, marker) => {
+    var _a, _b, _c, _d;
+    const client = getActiveClient();
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        return (_b = (_a = getUnreadInfoCached$1(channel.channelPublicId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
+    }
+    return (marker === null || marker === void 0 ? void 0 : marker.hasMentioned) !== undefined
+        ? marker === null || marker === void 0 ? void 0 : marker.hasMentioned
+        : (_d = (_c = getCachedMarker$2(channel.channelPublicId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
+};
+
+const getCachedMarker$1 = (entityId) => {
+    var _a;
+    const key = {
+        entityId,
+        userId: getActiveUser()._id,
+    };
+    return (_a = pullFromCache([
+        'channelMarker',
+        'get',
+        getResolver('channelMarker')(key),
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+};
+const getUnreadInfoCached = (channelId) => {
+    var _a;
+    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+};
+/**
+ * The function use to get value of unreadCount field.
+ * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ *
+ * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
+ * If not, the function will return the value from the channelMarker cache.
+ * If not found in the both cache, use `0` as defaul value.
+ */
+const getSubChannelsUnreadCount = (channel, marker) => {
+    var _a, _b, _c, _d, _e;
+    const client = getActiveClient();
+    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+        // Marker service API uses channelInternalId as channelId
+        return (_b = (_a = getUnreadInfoCached(channel.channelInternalId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
+    }
+    if (marker === null || marker === void 0 ? void 0 : marker.isDeleted) {
+        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
+        // leave the channel because currently backend can't handle this, so every time a user is banned
+        // from a channel or the channel is deleted the channel's unread count will reset to zero
+        return 0;
+    }
+    return (_e = (_c = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _c !== void 0 ? _c : (_d = getCachedMarker$1(channel.channelInternalId)) === null || _d === void 0 ? void 0 : _d.unreadCount) !== null && _e !== void 0 ? _e : 0;
+};
+
+const getLegacyChannelUnread = (channelId) => {
+    var _a;
+    return (_a = pullFromCache(['channelUnread', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
+};
+
+const constructChannelDynamicValue = (channel) => {
+    const client = getActiveClient();
+    const rest = __rest(channel, ["messageCount"]);
+    return shallowClone(rest, {
+        get unreadCount() {
+            var _a, _b;
+            return (_b = (_a = getLegacyChannelUnread(rest.channelId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
+        },
+        get subChannelsUnreadCount() {
+            return getSubChannelsUnreadCount(rest);
+        },
+        get isMentioned() {
+            var _a, _b;
+            if (client.useLegacyUnreadCount)
+                return (_b = (_a = getLegacyChannelUnread(rest.channelId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
+            return getChannelIsMentioned(rest);
+        },
+    });
+};
+
+const ANALYTIC_CACHE_KEY = ['analytic', 'normal-priority'];
+const HIGH_PRIORITY_ANALYTIC_CACHE_KEY = ['analytic', 'high-priority'];
+
+const syncEvent = async (events) => {
+    const client = getActiveClient();
+    const params = {
+        activities: events,
+    };
+    await client.http.post('/api/v1/analytics/activities', params);
+};
+
+class AnalyticsEventSyncer {
+    constructor() {
+        this._timer = undefined;
+        this._high_priority_timer = undefined;
+    }
+    start() {
+        this.syncCapturedEvent();
+        this._timer = setInterval(() => {
+            this.syncCapturedEvent();
+        }, 1 * MINUTE);
+        this._high_priority_timer = setInterval(() => {
+            this.syncHighPriorityCapturedEvent();
+        }, 10 * SECOND$1);
+    }
+    stop() {
+        if (this._timer) {
+            clearInterval(this._timer);
+            this._timer = undefined;
+        }
+        if (this._high_priority_timer) {
+            clearInterval(this._high_priority_timer);
+            this._high_priority_timer = undefined;
+        }
+    }
+    async syncCapturedEvent() {
+        try {
+            // Must query only objects that have same userId with current logged-in user.
+            // Query captured event with maximum of 1000
+            // Order by latest first
+            // e.g., If there are 2000 events we will query 1000-2000 first
+            const cache = pullFromCache(ANALYTIC_CACHE_KEY);
+            if (!(cache === null || cache === void 0 ? void 0 : cache.data))
+                return;
+            if (cache.data.event.length === 0)
+                return;
+            const capturedEvents = cache.data.event;
+            await syncEvent(capturedEvents);
+            dropFromCache(ANALYTIC_CACHE_KEY);
+        }
+        catch (error) {
+            // stop and destroy all events
+            this.stop();
+            dropFromCache(ANALYTIC_CACHE_KEY);
+        }
+    }
+    async syncHighPriorityCapturedEvent() {
+        try {
+            // Must query only objects that have same userId with current logged-in user.
+            // Query captured event with maximum of 1000
+            // Order by latest first
+            // e.g., If there are 2000 events we will query 1000-2000 first
+            const cache = pullFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+            if (!(cache === null || cache === void 0 ? void 0 : cache.data))
+                return;
+            if (cache.data.event.length === 0)
+                return;
+            const capturedEvents = cache.data.event;
+            await syncEvent(capturedEvents);
+            dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+        }
+        catch (error) {
+            // stop and destroy all events
+            this.stop();
+            dropFromCache(HIGH_PRIORITY_ANALYTIC_CACHE_KEY);
+        }
+    }
+}
+
+class AnalyticsEventCapturer {
+    constructor() {
+        this._expireTime = 5 * MINUTE;
+        this._poolLimit = 1000;
+        this._recentViewed = {};
+        this._recentHighPriorityViewed = {};
+        // Story
+        this._throttleStoryTimer = undefined;
+        this._bufferNewSeenStoryReferenceIds = [];
+    }
+    isAbleToEnqueue({ uniqueId, expireTime, isHighPriority = false, }) {
+        const now = new Date();
+        // Get the recent view date (if any)
+        const recentViewedDate = isHighPriority
+            ? this._recentHighPriorityViewed[uniqueId]
+            : this._recentViewed[uniqueId];
+        // If this is the first view, always allow it
+        if (!recentViewedDate) {
+            return true;
+        }
+        const timeDiff = now.getTime() - recentViewedDate.getTime();
+        if (timeDiff < expireTime) {
+            // just recently view this post, ignore the event.
+            return false;
+        }
+        return true;
+    }
+    markAs({ uniqueId, contentId, contentType, activityType, metadata, }) {
+        if (!this.isAbleToEnqueue({ uniqueId, expireTime: this._expireTime }))
+            return;
+        const now = new Date();
+        const currentData = { event: [] };
+        const cache = pullFromCache(ANALYTIC_CACHE_KEY);
+        if (cache === null || cache === void 0 ? void 0 : cache.data) {
+            currentData.event = cache.data.event;
+        }
+        // If the pool is full (Max 1000 items), remove the oldest data
         if (currentData.event.length >= this._poolLimit) {
             // Remove oldest data
             currentData.event.shift();
@@ -5176,20 +6313,6 @@ var AnalyticsEngine$1 = {
     },
 };
 
-const userLinkedObject = (user) => {
-    return Object.assign(Object.assign({}, user), { get avatar() {
-            var _a;
-            if (!user.avatarFileId)
-                return undefined;
-            const avatar = (_a = pullFromCache([
-                'file',
-                'get',
-                `${user.avatarFileId}`,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
-            return avatar;
-        } });
-};
-
 class StoryComputedValue {
     constructor(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt) {
         this._syncingStoriesCount = 0;
@@ -5621,7 +6744,7 @@ const postLinkedObject = (post) => {
         } });
 };
 
-const getCachedMarker$2 = (message) => {
+const getCachedMarker = (message) => {
     var _a, _b;
     const key = {
         creatorId: 'creatorPrivateId' in message ? message.creatorPrivateId : message.creatorId,
@@ -5639,7 +6762,7 @@ const getMessageReadCount = (message, marker) => {
     // Look in the marker param first
     return (_a = marker !== null && marker !== void 0 ? marker : 
     // If the marker param is not set, look in the cache
-    getCachedMarker$2(message)) !== null && _a !== void 0 ? _a : { readCount: 0, deliveredCount: 0 };
+    getCachedMarker(message)) !== null && _a !== void 0 ? _a : { readCount: 0, deliveredCount: 0 };
 }; // and if not found in cache use default value `0`
 
 /**
@@ -5882,31 +7005,6 @@ const markAsReadBySegment = async ({ subChannelId, readToSegment, }) => {
     }
 };
 
-const reCalculateChannelUnreadInfo = (channelId) => {
-    var _a;
-    const cacheKeyChannelUnread = ['channelUnreadInfo', 'get', channelId];
-    const cacheChannelUnreadInfo = (_a = pullFromCache(cacheKeyChannelUnread)) === null || _a === void 0 ? void 0 : _a.data;
-    const cacheKeySubChannelUnread = ['subChannelUnreadInfo', 'get'];
-    const cachedSubChannelUnreadInfo = queryCache(cacheKeySubChannelUnread);
-    let channelUnreads = 0;
-    let isMentioned = false;
-    if (cachedSubChannelUnreadInfo && (cachedSubChannelUnreadInfo === null || cachedSubChannelUnreadInfo === void 0 ? void 0 : cachedSubChannelUnreadInfo.length) > 0) {
-        const subChannelUnreadsInfo = cachedSubChannelUnreadInfo === null || cachedSubChannelUnreadInfo === void 0 ? void 0 : cachedSubChannelUnreadInfo.filter(({ data }) => {
-            return data.channelId === channelId && !data.isDeleted;
-        });
-        channelUnreads = subChannelUnreadsInfo
-            .map(({ data }) => data.unreadCount)
-            .reduce((acc, cur) => acc + cur, 0);
-        isMentioned = subChannelUnreadsInfo.some(({ data }) => data.isMentioned);
-    }
-    const channelUnreadInfo = Object.assign(Object.assign({}, (cacheChannelUnreadInfo !== null && cacheChannelUnreadInfo !== void 0 ? cacheChannelUnreadInfo : {
-        channelId,
-        createdAt: new Date().toISOString(),
-    })), { updatedAt: new Date().toISOString(), unreadCount: channelUnreads, isMentioned });
-    pushToCache(cacheKeyChannelUnread, channelUnreadInfo);
-    return channelUnreadInfo;
-};
-
 class LegacyMessageReadReceiptSyncEngine {
     constructor() {
         this.isActive = true;
@@ -6192,24 +7290,6 @@ const markAsRead = async (channelId) => {
     return true;
 };
 
-/**
- * ```js
- * import { shallowClone } from '~/utils/shallowClone'
- * const newObj = shallowClone(obj)
- * ```
- *
- * Clone an object with same prototype and properties
- *
- * @param obj the object to clone
- * @returns new object with same prototype and properties
- *
- * @category utility
- * @private
- */
-function shallowClone(source, target) {
-    return Object.create(Object.getPrototypeOf(source), Object.assign(Object.assign({}, Object.getOwnPropertyDescriptors(source)), Object.getOwnPropertyDescriptors(target)));
-}
-
 const channelLinkedObject = (channel) => {
     return shallowClone(channel, {
         markAsRead: () => markAsRead(channel.channelInternalId),
@@ -6285,1063 +7365,1283 @@ const notificationTrayLinkedObject = (noti) => {
     return Object.assign(Object.assign({}, noti), { isSeen: noti.lastSeenAt > noti.lastOccurredAt, isRecent: new Date(noti.lastOccurredAt).getTime() >= Date.now() - WEEK, users: noti.actors
             .map(({ publicId }) => pullFromCache(['user', 'get', publicId]))
             .filter(isNonNullable)
-            .map(({ data }) => data)
-            .map(user => userLinkedObject(user)) });
-};
-
-const LinkedObject = {
-    ad: adLinkedObject,
-    comment: commentLinkedObject,
-    post: postLinkedObject,
-    user: userLinkedObject,
-    category: categoryLinkedObject,
-    stream: streamLinkedObject,
-    story: storyLinkedObject,
-    storyTarget: storyTargetLinkedObject,
-    message: messageLinkedObject,
-    reactor: reactorLinkedObject,
-    channel: channelLinkedObject,
-    pinnedPost: pinnedPostLinkedObject,
-    notificationTray: notificationTrayLinkedObject,
-};
-
-const getChannelMessagePreviewWithUser = (channel) => {
-    var _a;
-    const messagePreview = channel.messagePreviewId
-        ? getChannelMessagePreview(channel.channelId)
-        : null;
-    const internalUser = (_a = pullFromCache([
-        'user',
-        'get',
-        messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.creatorId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    const messagePreviewWithUser = messagePreview
-        ? Object.assign(Object.assign({}, messagePreview), { user: internalUser ? LinkedObject.user(internalUser) : undefined }) : null;
-    return Object.assign(Object.assign({}, channel), { messagePreview: messagePreviewWithUser });
-};
-
-const updateChannelMessagePreviewCache = (rawPayload) => {
-    var _a, _b;
-    const withMessageFeedInfo = (messagePreview) => {
-        var _a;
-        const messageFeedInfo = (_a = rawPayload.messageFeedsInfo) === null || _a === void 0 ? void 0 : _a.find(messageFeed => {
-            return messageFeed.messageFeedId === messagePreview.messageFeedId;
-        });
-        const { channelPublicId: channelId, messageFeedId: subChannelId, data, dataType, isDeleted, segment, creatorPublicId: creatorId, createdAt, updatedAt, } = messagePreview;
-        return {
-            channelId,
-            subChannelId,
-            data,
-            dataType,
-            isDeleted,
-            segment,
-            creatorId,
-            createdAt,
-            updatedAt,
-            subChannelName: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.name,
-            messagePreviewId: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.messagePreviewId,
-            subChannelUpdatedAt: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.updatedAt,
-        };
-    };
-    const newData = {
-        messagePreviewChannel: (_b = (_a = rawPayload.messagePreviews) === null || _a === void 0 ? void 0 : _a.map(messagePreview => withMessageFeedInfo(messagePreview))) !== null && _b !== void 0 ? _b : [],
-    };
-    ingestInCache(newData);
-};
-
-const getSubChannelMessagePreview = (subChannelId) => {
-    var _a, _b;
-    return ((_b = (_a = pullFromCache(['messagePreviewSubChannel', 'get', subChannelId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : null);
-};
-
-const getSubChannelMessagePreviewWithUser = (subChannel) => {
-    var _a;
-    const messagePreview = subChannel.messagePreviewId
-        ? getSubChannelMessagePreview(subChannel.subChannelId)
-        : null;
-    const messagePreviewWithUser = messagePreview
-        ? Object.assign(Object.assign({}, messagePreview), { user: (_a = pullFromCache(['user', 'get', messagePreview === null || messagePreview === void 0 ? void 0 : messagePreview.creatorId])) === null || _a === void 0 ? void 0 : _a.data }) : null;
-    return Object.assign(Object.assign({}, subChannel), { messagePreview: messagePreviewWithUser });
-};
-
-const updateSubChannelMessagePreviewCache = (rawPayload) => {
-    var _a, _b;
-    const withMessageFeedInfo = (messagePreview) => {
-        var _a;
-        const messageFeedInfo = (_a = rawPayload.messageFeeds) === null || _a === void 0 ? void 0 : _a.find(messageFeed => {
-            return messageFeed.messageFeedId === messagePreview.messageFeedId;
-        });
-        const { channelPublicId: channelId, messageFeedId: subChannelId, messageId: messagePreviewId, creatorPublicId: creatorId, data, dataType, isDeleted, segment, createdAt, updatedAt, } = messagePreview;
-        return {
-            messagePreviewId,
-            channelId,
-            subChannelId,
-            data,
-            dataType,
-            isDeleted,
-            segment,
-            creatorId,
-            createdAt,
-            updatedAt,
-            subChannelName: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.name,
-            subChannelUpdatedAt: messageFeedInfo === null || messageFeedInfo === void 0 ? void 0 : messageFeedInfo.updatedAt,
-        };
-    };
-    const newData = {
-        messagePreviewSubChannel: (_b = (_a = rawPayload.messages) === null || _a === void 0 ? void 0 : _a.map(messagePreview => withMessageFeedInfo(messagePreview))) !== null && _b !== void 0 ? _b : [],
-    };
-    ingestInCache(newData);
+            .map(({ data }) => data)
+            .map(user => userLinkedObject(user)) });
 };
 
-function updateSubChannelCache(subChannelId, subChannel, params) {
-    pushToCache(['subChannel', 'get', subChannelId], 
-    // eslint-disable-next-line prefer-object-spread
-    shallowClone(subChannel, params));
-}
-
-/**
- * ```js
- * import { isInTombstone } from '@amityco/ts-sdk'
- * const user = isInTombstone(["message", "messageId"])
- * ```
- *
- * Checks if the {@link Amity.TombstoneCacheOptions} exists
- * in cache and it's not expired means it's in tombstone
- * and we throw an Error
- *
- * @param model the model to check
- * @param modelId the object id to check
- * @returns the matching cache entry, or undefined.
+/*
+ * verifies membership status
+ */
+function isMember(membership) {
+    return membership !== 'none';
+}
+/*
+ * checks if currently logged in user is part of the community
+ */
+function isCurrentUserPartOfCommunity(c, m) {
+    const { userId } = getActiveUser();
+    return c.communityId === m.communityId && m.userId === userId;
+}
+/*
+ * For mqtt events server will not send user specific data as it's broadcasted
+ * to multiple users and it also does not include communityUser
  *
- * @category Cache API
+ * Client SDK needs to check for the existing isJoined field in cache data before calculating.
+ * Althought this can be calculated, it's not scalable.
  */
-const isInTombstone = (model, modelId) => {
-    const { log, cache } = getActiveClient();
-    const key = [model, CACHE_KEY_TOMBSTONE, modelId];
-    if (!cache)
-        return;
-    log('cache/api/isInTombstone', key);
-    const isInTombstone = pullFromCache(key);
-    const { lifeSpan } = queryOptions('cache_then_server', CACHE_LIFESPAN_TOMBSTONE);
-    if (isInTombstone && isFresh(isInTombstone.data, lifeSpan)) {
-        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
-    }
+function updateMembershipStatus(communities, communityUsers) {
+    return communities.map(c => {
+        const cachedCommunity = pullFromCache([
+            'community',
+            'get',
+            c.communityId,
+        ]);
+        if ((cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data) && (cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data.hasOwnProperty('isJoined'))) {
+            return Object.assign(Object.assign({}, cachedCommunity.data), c);
+        }
+        const isJoined = communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
+        return Object.assign(Object.assign({}, c), { isJoined });
+    });
+}
+
+const getMatchPostSetting = (value) => {
+    var _a;
+    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
+};
+function addPostSetting({ communities }) {
+    return communities.map((_a) => {
+        var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
+        return (Object.assign({ postSetting: getMatchPostSetting({
+                needApprovalOnPostCreation,
+                onlyAdminCanPost,
+            }) }, restCommunityPayload));
+    });
+}
+const prepareCommunityPayload = (rawPayload) => {
+    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+    // Convert users to internal format
+    const internalUsers = rawPayload.users.map(convertRawUserToInternalUser);
+    // map users with community
+    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
+        const user = internalUsers.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareCommunityJoinRequestPayload = (rawPayload) => {
+    const mappedJoinRequests = rawPayload.joinRequests.map(joinRequest => {
+        return Object.assign(Object.assign({}, joinRequest), { joinRequestId: joinRequest._id });
+    });
+    const users = rawPayload.users.map(convertRawUserToInternalUser);
+    return Object.assign(Object.assign({}, rawPayload), { joinRequests: mappedJoinRequests, users });
+};
+const prepareCommunityMembershipPayload = (rawPayload) => {
+    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+    // map users with community
+    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
+        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareCommunityRequest = (params) => {
+    const { postSetting = undefined, storySetting } = params, restParam = __rest(params, ["postSetting", "storySetting"]);
+    return Object.assign(Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)), { 
+        // Convert story setting to the actual value. (Allow by default)
+        allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
+};
+const prepareSemanticSearchCommunityPayload = (_a) => {
+    var communityPayload = __rest(_a, ["searchResult"]);
+    const processedCommunityPayload = prepareCommunityPayload(communityPayload);
+    return Object.assign({}, processedCommunityPayload);
 };
 
+/* begin_public_function
+  id: joinRequest.approve
+*/
 /**
  * ```js
- * import { getMessageMarkers } from '@amityco/ts-sdk'
- * const messageMarkers = await getMessageMarkers(['sch1', 'sch2'])
+ * import { joinRequest } from '@amityco/ts-sdk'
+ * const isAccepted = await joinRequest.approve()
  * ```
  *
- * Fetches a list of {@link Amity.MessageMarker} by messageIds
+ * Accepts a {@link Amity.JoinRequest} object
  *
- * @param messageIds the feed IDs of the {@link Amity.RawMessage} marker to fetch
- * @returns A list of {@link Amity.MessageMarker} by messageIds
+ * @param joinRequest the {@link Amity.JoinRequest} to accept
+ * @returns A success boolean if the {@link Amity.JoinRequest} was accepted
  *
- * @category Channel API
+ * @category Join Request API
  * @async
- * @private
  */
-const getMessageMarkers = async (messageIds) => {
+const approveJoinRequest = async (joinRequest) => {
+    var _a;
     const client = getActiveClient();
-    client.log('channel/getMessageMarkers', messageIds);
-    const { data: queryPayload } = await client.http.get(`/api/v1/markers/messages`, {
+    client.log('joinRequest/approveJoinRequest', joinRequest.joinRequestId);
+    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/approve`, {
         params: {
-            messageIds,
+            userId: joinRequest.userId,
         },
     });
-    const { contentMarkers, feedMarkers, userMarkers } = queryPayload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache({ contentMarkers, feedMarkers, userMarkers }, { cachedAt });
-    fireEvent('local.feedMarker.fetched', { feedMarkers });
-    fireEvent('local.messageMarker.fetched', { contentMarkers });
-    fireEvent('local.userMarker.fetched', { userMarkers });
-    return { data: contentMarkers, cachedAt };
-};
-
-const persistUnreadCountInfo = (payload) => {
-    const { feedMarkers, userFeedMarkers } = payload;
-    // calculate sub channel unread info and channel unread info
-    if (feedMarkers.length > 0 && userFeedMarkers.length > 0) {
-        const channelIds = [];
-        const feedMarkerMap = new Map(feedMarkers.map(fm => [fm.feedId, fm]));
-        userFeedMarkers.forEach(userFeedMarker => {
-            const feedMarker = feedMarkerMap.get(userFeedMarker.feedId);
-            if (!feedMarker)
-                return;
-            if (feedMarker.feedId === userFeedMarker.feedId) {
-                const unreadCount = feedMarker.lastSegment - userFeedMarker.readToSegment;
-                const subChannelUnreadInfo = {
-                    subChannelId: feedMarker.feedId,
-                    channelId: feedMarker.entityId,
-                    readToSegment: userFeedMarker.readToSegment,
-                    lastSegment: feedMarker.lastSegment,
-                    lastMentionSegment: userFeedMarker.lastMentionSegment,
-                    unreadCount: Math.max(0, unreadCount),
-                    isMentioned: userFeedMarker.isMentioned,
-                    isDeleted: feedMarker.isDeleted,
-                    createdAt: userFeedMarker.createdAt,
-                    updatedAt: userFeedMarker.updatedAt,
-                };
-                // update sub channel unread info in cache
-                ingestInCache({ subChannelUnreadInfo: [subChannelUnreadInfo] });
-                if (!channelIds.includes(feedMarker.entityId)) {
-                    channelIds.push(feedMarker.entityId);
-                }
-            }
-        });
-        // re-calculate channel unread info in cache
-        channelIds.forEach(channelId => {
-            reCalculateChannelUnreadInfo(channelId);
+    // TODO : Check cache id
+    const joinRequestCache = (_a = pullFromCache([
+        'joinRequest',
+        'get',
+        joinRequest.joinRequestId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (joinRequestCache) {
+        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+            status: "approved" /* JoinRequestStatusEnum.Approved */,
         });
+        fireEvent('local.joinRequest.updated', [joinRequestCache]);
     }
-};
+    return data.success;
+};
+/* end_public_function */
 
+/* begin_public_function
+  id: joinRequest.cancel
+*/
 /**
  * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * import { joinRequest } from '@amityco/ts-sdk'
+ * const isCanceled = await joinRequest.cancel()
  * ```
  *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ * Cancels a {@link Amity.JoinRequest} object
  *
- * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.SubChannelMarker} objects
+ * @param joinRequest the {@link Amity.JoinRequest} to cancel
+ * @returns A success boolean if the {@link Amity.JoinRequest} was canceled
  *
- * @category Channel API
+ * @category Join Request API
  * @async
- * @private
  */
-const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
+const cancelJoinRequest = async (joinRequest) => {
+    var _a;
     const client = getActiveClient();
-    client.log('channel/getSubChannelMarkers', messageFeedIds, page);
-    const { data: queryPayload } = await client.http.get(`/api/v1/markers/message-feeds`, {
+    client.log('joinRequest/cancelJoinRequest', joinRequest.joinRequestId);
+    const { data } = await client.http.delete(`/api/v4/communities/${joinRequest.targetId}/join`, {
         params: {
-            messageFeedIds,
-            options: {
-                token: toToken(page, 'skiplimit'),
-            },
+            userId: joinRequest.userId,
         },
     });
-    const { paging } = queryPayload, payload = __rest(queryPayload, ["paging"]);
-    const { userEntityMarkers: userEntityMarkersPayload, userFeedMarkers: userFeedMarkersPayload, userMarkers, feedMarkers: feedMarkersPayload, } = payload;
-    // if consistent mode is enabled, persist the unread count info to the cache
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        persistUnreadCountInfo({
-            feedMarkers: feedMarkersPayload,
-            userFeedMarkers: userFeedMarkersPayload,
-        });
-    }
-    const userEntityMarkers = convertChannelMarkerResponse(userEntityMarkersPayload);
-    const userFeedMarkers = convertSubChannelMarkerResponse(userFeedMarkersPayload);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache({ userEntityMarkers, userFeedMarkers, userMarkers }, { cachedAt });
-    fireEvent('local.channelMarker.fetched', { userEntityMarkers });
-    fireEvent('local.subChannelMarker.fetched', { userFeedMarkers });
-    fireEvent('local.userMarker.fetched', { userMarkers });
-    const nextPage = toPage(paging.next);
-    const prevPage = toPage(paging.previous);
-    return { data: userFeedMarkers, cachedAt, prevPage, nextPage };
-};
-
-const getUserMarker = async () => {
-    const client = getActiveClient();
-    client.log('channel/getUserMarker');
-    const { data: payload } = await client.http.get(`/api/v1/markers/userMarker`);
-    const { userMarkers } = payload;
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache({ userMarkers }, { cachedAt });
-    fireEvent('local.userMarker.fetched', { userMarkers });
-    const latestUserMarker = userMarkers.reduce((maxUserMarker, userMarker) => {
-        if (maxUserMarker == null ||
-            new Date(maxUserMarker.lastSyncAt).getTime() < new Date(userMarker.lastSyncAt).getTime()) {
-            return userMarker;
-        }
-        return maxUserMarker;
-    }, undefined);
-    return { data: latestUserMarker, cachedAt };
-};
-
-/** @hidden */
-/*
- * @param message payload from http request without myReactions
- * add myReactions to http response if the event was a reaction event
- */
-const prepareMessagePayloadForCache = (payload, reactors, event) => {
-    const client = getActiveClient();
-    const cached = pullFromCache(['message', 'get', payload.messageId]);
-    // '[]' in cases where the new reaction is the first one
-    const myReactions = (cached === null || cached === void 0 ? void 0 : cached.data.myReactions) || [];
-    // add myReactions to the payload
-    Object.assign(payload, { myReactions });
-    // check if there are any updates to the reactions
-    const latestReaction = reactors[0];
-    const isLatestReactionMine = latestReaction && latestReaction.userId === client.userId;
-    if (!isLatestReactionMine) {
-        return;
-    }
-    // new reaction added
-    if (event === 'message.reactionAdded' && !myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: [...myReactions, latestReaction.reactionName],
-        });
+    const joinRequestCache = (_a = pullFromCache([
+        'joinRequest',
+        'get',
+        joinRequest.joinRequestId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (joinRequestCache) {
+        dropFromCache(['joinRequest', 'get', joinRequest.joinRequestId]);
+        fireEvent('local.joinRequest.deleted', [joinRequestCache]);
     }
-    // existing reaction removed
-    if (event === 'message.reactionRemoved' && myReactions.includes(latestReaction.reactionName)) {
-        Object.assign(payload, {
-            myReactions: myReactions.filter(x => x !== latestReaction.reactionName),
+    return data.success;
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: joinRequest.reject
+*/
+/**
+ * ```js
+ * import { joinRequest } from '@amityco/ts-sdk'
+ * const isRejected = await joinRequest.reject()
+ * ```
+ *
+ * Rejects a {@link Amity.JoinRequest} object
+ *
+ * @param joinRequest the {@link Amity.JoinRequest} to reject
+ * @returns A success boolean if the {@link Amity.JoinRequest} was rejected
+ *
+ * @category Join Request API
+ * @async
+ */
+const rejectJoinRequest = async (joinRequest) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('joinRequest/rejectJoinRequest', joinRequest.joinRequestId);
+    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/reject`);
+    const joinRequestCache = (_a = pullFromCache([
+        'joinRequest',
+        'get',
+        joinRequest.joinRequestId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (joinRequestCache) {
+        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+            status: "rejected" /* JoinRequestStatusEnum.Rejected */,
         });
+        fireEvent('local.joinRequest.updated', [joinRequestCache]);
     }
+    return data.success;
+};
+/* end_public_function */
+
+const joinRequestLinkedObject = (joinRequest) => {
+    return Object.assign(Object.assign({}, joinRequest), { get user() {
+            const cacheData = pullFromCache(['user', 'get', joinRequest.userId]);
+            if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
+                return userLinkedObject(cacheData.data);
+            return undefined;
+        }, cancel: async () => {
+            await cancelJoinRequest(joinRequest);
+        }, approve: async () => {
+            await approveJoinRequest(joinRequest);
+        }, reject: async () => {
+            await rejectJoinRequest(joinRequest);
+        } });
 };
 
-/*
- * This is a simple utility that infers the value of isDeleted based on the
- * value of includeDeleted
+/* begin_public_function
+  id: community.getMyJoinRequest
+*/
+/**
+ * ```js
+ * import { community } from '@amityco/ts-sdk'
+ * const isJoined = await community.getMyJoinRequest('foobar')
+ * ```
  *
- * There are two important things to note here:
- *  1. `includeDeleted` is purely client side query param and not recognized by
- *  the server
- *  2. The only values we wish to expose with regards to `isDeleted` (the server
- *  param for queries) is false | undefined and want to disallow users to query
- *  for deleted entities
+ * Joins a {@link Amity.Community} object
  *
- *  Although this is a very simple utility, it's only purpose is to keep things
- *  DRY
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A success boolean if the {@link Amity.Community} was joined
+ *
+ * @category Community API
+ * @async
  */
-const inferIsDeleted = (includeDeleted) => includeDeleted === true ? undefined : false;
+const getMyJoinRequest = async (communityId) => {
+    const client = getActiveClient();
+    client.log('community/myJoinRequest', communityId);
+    const { data: payload } = await client.http.get(`/api/v4/communities/${communityId}/join/me`);
+    const data = prepareCommunityJoinRequestPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    return {
+        data: data.joinRequests[0] ? joinRequestLinkedObject(data.joinRequests[0]) : undefined,
+        cachedAt,
+    };
+};
+/* end_public_function */
 
-function getSubChannelIsMentioned(channelId, subChannelId, marker) {
-    var _a, _b;
-    // Look for `unreadCount` in the marker param first
-    if (marker) {
-        return marker.hasMentioned;
-    }
+/* begin_public_function
+  id: community.join
+*/
+/**
+ * ```js
+ * import { community } from '@amityco/ts-sdk'
+ * const isJoined = await community.join('foobar')
+ * ```
+ *
+ * Joins a {@link Amity.Community} object
+ *
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A status join result
+ *
+ * @category Community API
+ * @async
+ */
+const joinRequest = async (communityId) => {
     const client = getActiveClient();
-    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        const cachedUnreadCount = (_a = pullFromCache([
-            'subChannelUnreadInfo',
-            'get',
-            subChannelId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (cachedUnreadCount) {
-            return cachedUnreadCount.isMentioned;
-        }
-        return false;
+    client.log('community/joinRequest', communityId);
+    const { data: payload } = await client.http.post(`/api/v4/communities/${communityId}/join`);
+    const data = prepareCommunityJoinRequestPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('local.community.join', data.joinRequests);
+    const status = data.joinRequests.length === 0 ? "success" /* JoinResultStatusEnum.Success */ : "pending" /* JoinResultStatusEnum.Pending */;
+    return status === "success" /* JoinResultStatusEnum.Success */
+        ? { status }
+        : { status, request: joinRequestLinkedObject(data.joinRequests[0]) };
+};
+/* end_public_function */
+
+class PaginationController {
+    constructor(queryParams) {
+        const { http } = getActiveClient();
+        this.queryParams = queryParams;
+        this.http = http;
     }
-    const key = {
-        entityId: channelId,
-        feedId: subChannelId,
-        userId: getActiveUser()._id,
-    };
-    // If the marker param is not set, look in the cache
-    const cachedMarker = (_b = pullFromCache([
-        'subChannelMarker',
-        'get',
-        getResolver('subChannelMarker')(key),
-    ])) === null || _b === void 0 ? void 0 : _b.data;
-    if (cachedMarker) {
-        return cachedMarker.hasMentioned;
+    loadFirstPage() {
+        return this.onFetch("first" /* Amity.LiveCollectionPageDirection.FIRST */);
     }
-    // and if not found in cache use default value `false`
-    return false;
-}
-
-function getSubChannelUnreadCount(channelId, subChannelId, marker) {
-    var _a, _b;
-    // Look for `unreadCount` in the marker param first
-    if (marker) {
-        return marker.unreadCount;
+    loadNextPage() {
+        return this.onFetch("next" /* Amity.LiveCollectionPageDirection.NEXT */);
     }
-    const client = getActiveClient();
-    // If consistent mode is enabled, look in the SubChannelUnreadCountInfo cache
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        const cachedUnreadCount = (_a = pullFromCache([
-            'subChannelUnreadInfo',
-            'get',
-            subChannelId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (cachedUnreadCount) {
-            return cachedUnreadCount.isDeleted ? 0 : cachedUnreadCount.unreadCount;
+    loadPreviousPage() {
+        return this.onFetch("prev" /* Amity.LiveCollectionPageDirection.PREV */);
+    }
+    async onFetch(direction = "first" /* Amity.LiveCollectionPageDirection.FIRST */) {
+        var _a, _b, _c, _d;
+        if (direction === 'prev' && !this.previousToken)
+            return;
+        if (direction === 'next' && !this.nextToken)
+            return;
+        let token;
+        if (direction === 'prev')
+            token = this.previousToken;
+        if (direction === 'next')
+            token = this.nextToken;
+        const queryResponse = await this.getRequest(this.queryParams, token);
+        if (direction === 'first') {
+            this.nextToken = (_a = queryResponse.paging) === null || _a === void 0 ? void 0 : _a.next;
+            this.previousToken = (_b = queryResponse.paging) === null || _b === void 0 ? void 0 : _b.previous;
         }
-        return 0;
+        if (direction === 'prev')
+            this.previousToken = (_c = queryResponse.paging) === null || _c === void 0 ? void 0 : _c.previous;
+        if (direction === 'next')
+            this.nextToken = (_d = queryResponse.paging) === null || _d === void 0 ? void 0 : _d.next;
+        return queryResponse;
     }
-    const key = {
-        entityId: channelId,
-        feedId: subChannelId,
-        userId: getActiveUser()._id,
-    };
-    // If the marker param is not set, look in the cache
-    const cachedMarker = (_b = pullFromCache([
-        'subChannelMarker',
-        'get',
-        getResolver('subChannelMarker')(key),
-    ])) === null || _b === void 0 ? void 0 : _b.data;
-    if (cachedMarker) {
-        return cachedMarker.unreadCount;
+    getNextToken() {
+        return this.nextToken;
+    }
+    getPrevToken() {
+        return this.previousToken;
     }
-    // and if not found in cache use default value `0`
-    return 0;
 }
 
-const MARKER_INCLUDED_SUB_CHANNEL_TYPE$1 = ['broadcast', 'conversation', 'community'];
-const isUnreadCountSupport$2 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE$1.includes(channelType);
-function convertFromRaw$2(_a) {
-    var { channelId, channelPublicId, channelType, childCount, creatorId, creatorPublicId, lastMessageId, lastMessageTimestamp, messageFeedId, name } = _a, rest = __rest(_a, ["channelId", "channelPublicId", "channelType", "childCount", "creatorId", "creatorPublicId", "lastMessageId", "lastMessageTimestamp", "messageFeedId", "name"]);
-    return Object.assign(Object.assign({ get unreadCount() {
-            return getSubChannelUnreadCount(channelId, messageFeedId);
-        },
-        get hasMentioned() {
-            return getSubChannelIsMentioned(channelId, messageFeedId);
-        },
-        get isMentioned() {
-            return getSubChannelIsMentioned(channelId, messageFeedId);
-        } }, rest), { channelId: channelPublicId, creatorId: creatorPublicId, displayName: name, lastActivity: lastMessageTimestamp, latestMessageId: lastMessageId, messageCount: childCount, subChannelId: messageFeedId, isUnreadCountSupport: isUnreadCountSupport$2({ channelType }) });
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+class JoinRequestsPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, communityId } = queryParams, params = __rest(queryParams, ["limit", "communityId"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v4/communities/${communityId}/join`, {
+            params: Object.assign(Object.assign({}, params), { options }),
+        });
+        return queryResponse;
+    }
 }
 
-const mergePayloadWithLocal = (payload) => {
-    var _a, _b, _c;
-    const localMessage = (_b = (_a = queryCache(['message', 'get'])) === null || _a === void 0 ? void 0 : _a.find(({ data }) => data.messageId === payload.messageId)) === null || _b === void 0 ? void 0 : _b.data;
-    if (localMessage) {
-        return Object.assign(Object.assign(Object.assign({}, localMessage), payload), { 
-            // NOTE: referenceId is missing in the some payload event. If we have local message data with referenceId, use it instead.
-            referenceId: (_c = localMessage.referenceId) !== null && _c !== void 0 ? _c : payload.referenceId });
+class QueryStreamController {
+    constructor(query, cacheKey) {
+        this.query = query;
+        this.cacheKey = cacheKey;
     }
-    return payload;
-};
-function convertFromRaw$1(message, reactors, event) {
-    var _a;
-    const mergeMessage = mergePayloadWithLocal(message);
-    const { channelPublicId, childCount, creatorPublicId, mentionedUsers, messageFeedId, myReactions, reactionCount, reactions, referenceId, segment, messageId, creatorId } = mergeMessage, rest = __rest(mergeMessage, ["channelPublicId", "childCount", "creatorPublicId", "mentionedUsers", "messageFeedId", "myReactions", "reactionCount", "reactions", "referenceId", "segment", "messageId", "creatorId"]);
-    let cache;
-    if (referenceId) {
-        cache = pullFromCache(['message', 'get', referenceId]);
+}
+
+var EnumJoinRequestAction;
+(function (EnumJoinRequestAction) {
+    EnumJoinRequestAction["OnLocalJoinRequestCreated"] = "OnLocalJoinRequestCreated";
+    EnumJoinRequestAction["OnLocalJoinRequestUpdated"] = "OnLocalJoinRequestUpdated";
+    EnumJoinRequestAction["OnLocalJoinRequestDeleted"] = "OnLocalJoinRequestDeleted";
+})(EnumJoinRequestAction || (EnumJoinRequestAction = {}));
+
+class JoinRequestsQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
     }
-    if (!cache) {
-        cache = pullFromCache(['message', 'get', messageId]);
+    async saveToMainDB(response) {
+        const processedPayload = await this.preparePayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
     }
-    const out = Object.assign(Object.assign({}, rest), { messageId, channelId: channelPublicId, channelSegment: segment, childrenNumber: childCount, creatorId: creatorPublicId, creatorPrivateId: message.creatorId, reactions: reactions !== null && reactions !== void 0 ? reactions : {}, 
-        /*
-         * Previously, myReactions were added only if it was part of the payload.
-         * So empty myReactions were not present. So I've edited the payload to add
-         * a default for those cases.
-         *
-         * Check git blame for previous iteration
-         */
-        myReactions: myReactions || ((_a = cache === null || cache === void 0 ? void 0 : cache.data.myReactions) !== null && _a !== void 0 ? _a : []), reactionsCount: reactionCount, subChannelId: messageFeedId, uniqueId: cache ? cache.data.uniqueId : messageId, referenceId, syncState: "synced" /* Amity.SyncState.Synced */ });
-    if (mentionedUsers) {
-        out.mentionees = mentionedUsers.map(mention => {
-            if (mention.type === 'channel') {
-                return mention;
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const joinRequests = (_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([
+                        ...joinRequests,
+                        ...response.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
+                    ]),
+                ] }));
+        }
+    }
+    reactor(action) {
+        return (joinRequest) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumJoinRequestAction.OnLocalJoinRequestUpdated) {
+                const isExist = collection.data.find(id => id === joinRequest[0].joinRequestId);
+                if (!isExist)
+                    return;
             }
-            return { type: 'user', userIds: mention.userPublicIds };
-        });
+            if (action === EnumJoinRequestAction.OnLocalJoinRequestCreated) {
+                collection.data = [
+                    ...new Set([
+                        ...joinRequest.map(joinRequest => joinRequest.joinRequestId),
+                        ...collection.data,
+                    ]),
+                ];
+            }
+            if (action === EnumJoinRequestAction.OnLocalJoinRequestDeleted) {
+                collection.data = collection.data.filter(id => id !== joinRequest[0].joinRequestId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
     }
-    if (reactors && reactors.length && event) {
-        // mqtt event
-        prepareMessagePayloadForCache(out, reactors, event);
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
     }
-    return out;
+}
+
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
 }
-const preUpdateMessageCache = (rawPayload) => {
-    ingestInCache({
-        messages: rawPayload.messages.map(message => convertFromRaw$1(message, rawPayload.reactions)),
+/**
+ *  convert all object getter property to static value
+ */
+const convertGetterPropsToStatic = (obj) => {
+    if (!isObject(obj)) {
+        return obj;
+    }
+    const entries = Object.entries(obj).map(([key, value]) => {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        if (typeof (descriptor === null || descriptor === void 0 ? void 0 : descriptor.get) === 'function') {
+            return [key, descriptor.get.call(obj)];
+        }
+        return [key, value];
     });
+    return Object.fromEntries(entries);
 };
-const DEBOUNCE_TIME = 2000;
-const currentDebounceMap = {};
-const prepareMessagePayload = async (payload, event) => {
-    const markerIds = payload.messages.map(({ messageId }) => messageId);
-    if (markerIds.length > 0) {
-        // since the get markers method requires a channel cache to function with the reducer.
-        preUpdateMessageCache(payload);
-        const markerIdsKey = markerIds.join('');
-        if (currentDebounceMap[markerIdsKey]) {
-            clearTimeout(currentDebounceMap[markerIdsKey]);
+const removeFunctionProperties = (obj) => {
+    if (!isObject(obj)) {
+        return obj;
+    }
+    const entries = Object.entries(obj).map(([key, value]) => {
+        if (typeof value === 'function') {
+            return [key, undefined];
         }
-        currentDebounceMap[markerIdsKey] = setTimeout(() => {
-            try {
-                getMessageMarkers(markerIds);
-            }
-            catch (_error) {
-                // do nothing
-            }
-        }, DEBOUNCE_TIME);
+        return [key, value];
+    });
+    return Object.fromEntries(entries);
+};
+
+class PaginationNoPageController {
+    constructor(queryParams) {
+        const { http } = getActiveClient();
+        this.queryParams = queryParams;
+        this.http = http;
     }
-    const { messageFeeds } = payload, restPayload = __rest(payload, ["messageFeeds"]);
-    // upsert messageFeeds to subchannel cache because messageFeeds from event payload not include messagePreviewId
-    if (messageFeeds && messageFeeds.length > 0) {
-        messageFeeds === null || messageFeeds === void 0 ? void 0 : messageFeeds.forEach(messageFeed => {
-            var _a, _b;
-            const subChannelCache = (_b = (_a = pullFromCache(['subChannel', 'get', messageFeed.messageFeedId])) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {};
-            // exclude getter properties from existing subChannel cache, update only other properties to existing subChannel cache
-            const _c = convertFromRaw$2(messageFeed), restSubChannel = __rest(_c, ["unreadCount", "isMentioned"]);
-            updateSubChannelCache(messageFeed.messageFeedId, subChannelCache, restSubChannel);
-        });
+    async onFetch() {
+        const queryResponse = await this.getRequest(this.queryParams);
+        return queryResponse;
     }
-    return Object.assign(Object.assign({}, restPayload), { messages: payload.messages.map(m => convertFromRaw$1(m, payload.reactions, event)) });
-};
-function convertParams(_a) {
-    var { subChannelId, mentionees, dataType, data } = _a, rest = __rest(_a, ["subChannelId", "mentionees", "dataType", "data"]);
-    if (dataType === MessageContentType.IMAGE || dataType === MessageContentType.FILE) {
-        return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data: Object.assign({ caption: '' }, data) }, rest);
+}
+
+class LiveCollectionController {
+    constructor(paginationController, queryStreamId, cacheKey, callback) {
+        this.paginationController = paginationController;
+        this.queryStreamId = queryStreamId;
+        this.cacheKey = cacheKey;
+        this.callback = callback;
     }
-    return Object.assign({ messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data }, rest);
-}
-function convertQueryParams$1(_a) {
-    var { sortBy, subChannelId, includingTags, excludingTags, includeDeleted, aroundMessageId, limit, type } = _a, rest = __rest(_a, ["sortBy", "subChannelId", "includingTags", "excludingTags", "includeDeleted", "aroundMessageId", "limit", "type"]);
-    const out = Object.assign(Object.assign({}, rest), { messageFeedId: subChannelId, isDeleted: inferIsDeleted(includeDeleted), options: {
-            sortBy,
-            limit: limit || COLLECTION_DEFAULT_PAGINATION_LIMIT,
-            around: aroundMessageId,
-        } });
-    if (includingTags) {
-        out.includeTags = includingTags;
+    async refresh() {
+        try {
+            let result;
+            if (this.paginationController instanceof PaginationNoPageController) {
+                result = await this.paginationController.onFetch();
+            }
+            else {
+                result = await this.paginationController.loadFirstPage();
+            }
+            if (!result)
+                return;
+            await this.persistModel(result);
+            this.persistQueryStream({
+                response: result,
+                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
+                refresh: true,
+            });
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
+        }
+        catch (e) {
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
+        }
     }
-    if (type) {
-        out.dataType = type;
+    loadPage({ initial = false, direction = "next" /* Amity.LiveCollectionPageDirection.NEXT */, }) {
+        this.setup();
+        this.notifyChange({ origin: "local" /* Amity.LiveDataOrigin.LOCAL */, loading: true });
+        if (initial) {
+            this.refresh();
+        }
+        else if (direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */) {
+            this.loadPrevPage();
+        }
+        else if (direction === "next" /* Amity.LiveCollectionPageDirection.NEXT */) {
+            this.loadNextPage();
+        }
     }
-    if (excludingTags) {
-        out.excludeTags = excludingTags;
+    async loadNextPage() {
+        try {
+            if (this.paginationController instanceof PaginationNoPageController)
+                return;
+            const result = await this.paginationController.loadNextPage();
+            if (!result)
+                return;
+            await this.persistModel(result);
+            this.persistQueryStream({
+                response: result,
+                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
+            });
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
+        }
+        catch (e) {
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
+        }
     }
-    return out;
-}
-
-const MARKER_INCLUDED_SUB_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
-/**
- * Filter sub channel by type. Only conversation, community and broadcast type are included.
- */
-const isUnreadCountSupport$1 = ({ channelType }) => MARKER_INCLUDED_SUB_CHANNEL_TYPE.includes(channelType);
-const preUpdateSubChannelCache = (rawPayload) => {
-    ingestInCache({
-        messageFeeds: rawPayload.messageFeeds.map(messageFeed => convertFromRaw$2(messageFeed)),
-    });
-};
-const prepareSubChannelPayload = async (rawPayload) => {
-    const markerIds = rawPayload.messageFeeds
-        .filter(isUnreadCountSupport$1)
-        .map(({ messageFeedId }) => messageFeedId);
-    if (markerIds.length > 0) {
-        // since the get markers method requires a channel cache to function with the reducer.
-        preUpdateSubChannelCache(rawPayload);
+    async loadPrevPage() {
         try {
-            await getSubChannelMarkers(markerIds);
+            if (this.paginationController instanceof PaginationNoPageController)
+                return;
+            const result = await this.paginationController.loadPreviousPage();
+            if (!result)
+                return;
+            await this.persistModel(result);
+            this.persistQueryStream({
+                response: result,
+                direction: "prev" /* Amity.LiveCollectionPageDirection.PREV */,
+            });
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
         }
         catch (e) {
-            // empty block (from the spec, allow marker fetch to fail without having to do anything)
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
         }
     }
-    updateSubChannelMessagePreviewCache(rawPayload);
-    // attach marker to sub channel
-    const messageFeeds = rawPayload.messageFeeds.map(convertFromRaw$2);
-    const messages = rawPayload.messages.map(m => convertFromRaw$1(m));
-    return Object.assign(Object.assign({}, rawPayload), { messageFeeds,
-        messages });
-};
-function convertQueryParams(_a) {
-    var { excludeDefaultSubChannel } = _a, rest = __rest(_a, ["excludeDefaultSubChannel"]);
-    const out = Object.assign({}, rest);
-    if (excludeDefaultSubChannel !== undefined) {
-        out.excludeDefaultMessageFeed = excludeDefaultSubChannel;
+    shouldNotify(data) {
+        const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
+        if (isEqual(this.snapshot, newData))
+            return false;
+        this.snapshot = newData;
+        return true;
+    }
+    getCacheKey() {
+        return this.cacheKey;
     }
-    return out;
 }
 
 /**
  * ```js
- * import { getSubChannel } from '@amityco/ts-sdk'
- * const subChannel = await getSubChannel('foobar')
+ * import { onJoinRequestCreated } from '@amityco/ts-sdk'
+ * const dispose = onJoinRequestCreated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category JoinRequest Events
+ */
+const onJoinRequestCreated = (callback) => {
+    const client = getActiveClient();
+    const disposers = [
+        createEventSubscriber(client, 'onJoinRequestCreated', 'local.joinRequest.created', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+/**
+ * ```js
+ * import { onJoinRequestUpdated } from '@amityco/ts-sdk'
+ * const dispose = onJoinRequestUpdated(data => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a {@link Amity.SubChannel} object
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
  *
- * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
- * @returns the associated {@link Amity.SubChannel} object
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Channel API
- * @async
+ * @category JoinRequest Events
  */
-const getSubChannel$1 = async (subChannelId) => {
+const onJoinRequestUpdated = (callback) => {
     const client = getActiveClient();
-    client.log('channel/getSubChannel', subChannelId);
-    isInTombstone('subChannel', subChannelId);
-    try {
-        const response = await client.http.get(`/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`);
-        const data = await prepareSubChannelPayload(response.data);
-        const cachedAt = client.cache && Date.now();
-        if (client.cache)
-            ingestInCache(data, { cachedAt });
-        fireEvent('local.message-feed.fetched', data);
-        return {
-            data: data.messageFeeds[0],
-            cachedAt,
-        };
-    }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('subChannel', subChannelId);
-        }
-        throw error;
-    }
-};
+    const disposers = [
+        createEventSubscriber(client, 'onJoinRequestUpdated', 'local.joinRequest.updated', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
 /**
  * ```js
- * import { getSubChannel } from '@amityco/ts-sdk'
- * const subChannel = getSubChannel.locally('foobar')
+ * import { onJoinRequestDeleted } from '@amityco/ts-sdk'
+ * const dispose = onJoinRequestDeleted(data => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a {@link Amity.SubChannel} object from cache
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
  *
- * @param subChannelId the ID of the {@link Amity.SubChannel} to fetch
- * @returns the associated {@link Amity.SubChannel} object
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Channel API
+ * @category JoinRequest Events
  */
-getSubChannel$1.locally = (subChannelId) => {
+const onJoinRequestDeleted = (callback) => {
     const client = getActiveClient();
-    client.log('channel/getSubChannel.locally', subChannelId);
-    if (!client.cache)
-        return;
-    const cached = pullFromCache(['subChannel', 'get', subChannelId]);
-    if (!cached)
-        return;
-    return {
-        data: cached.data,
-        cachedAt: cached.cachedAt,
+    const disposers = [
+        createEventSubscriber(client, 'onJoinRequestDeleted', 'local.joinRequest.deleted', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
     };
 };
 
-const convertDateStringToTimestamp = (dateString) => {
-    return new Date(dateString).getTime();
-};
-
-const getMessagePreviewSetting$1 = async () => {
-    const client = getActiveClient();
-    return client.getMessagePreviewSetting(false);
-};
-const getSubChannelCache = async (subChannelId) => {
-    var _a;
-    let subChannelCache = (_a = pullFromCache(['subChannel', 'get', subChannelId])) === null || _a === void 0 ? void 0 : _a.data;
-    if (!subChannelCache) {
-        subChannelCache = (await getSubChannel$1(subChannelId)).data;
+class JoinRequestsLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['joinRequest', 'collection', queryStreamId];
+        const paginationController = new JoinRequestsPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new JoinRequestsQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommunityJoinRequestPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
     }
-    return subChannelCache;
-};
-const isLastestMessageOnSubchannel = (message) => {
-    var _a;
-    const cache = (_a = pullFromCache([
-        'messagePreviewSubChannel',
-        'get',
-        message.subChannelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    // The message payload from optimistic created event has no segment, so we check createdAt instead.
-    return (!cache ||
-        cache.segment <= message.channelSegment ||
-        convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
-};
-const isLastestMessageOnChannel = (message) => {
-    var _a;
-    const cache = (_a = pullFromCache([
-        'messagePreviewChannel',
-        'get',
-        message.channelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    return (!cache ||
-        convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
-};
-const handleMessageCreatedOnSubChannel = async (message) => {
-    const messagePreviewSetting = await getMessagePreviewSetting$1();
-    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
-    // 1. get subChannel from cache, if not exist fetch from server
-    const subChannelCache = await getSubChannelCache(subChannelId);
-    // 2. if messagePreviewSetting is NO_MESSAGE_PREVEIW, update only lastActiviy in subChannel cache
-    if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */) {
-        // 2.1 if the message is the latest message, update lastActivity to be createdAt in subChannel cache
-        if (convertDateStringToTimestamp(subChannelCache.lastActivity) <
-            convertDateStringToTimestamp(createdAt))
-            updateSubChannelCache(message.subChannelId, subChannelCache, {
-                lastActivity: createdAt,
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: this.query,
             });
-        return;
+        }
     }
-    // 3. if messagePreviewSetting is `NOT` NO_MESSAGE_PREVEIW, update messagePreviewSubChannel and subChannel cache
-    // 3.1 check if the message is the latest message, if not ignore the message.
-    if (!isLastestMessageOnSubchannel(message))
-        return;
-    // 3.2 if the message is the latest message, update messagePreviewSubChannel and subChannel cache
-    pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
-        channelId,
-        creatorId,
-        messagePreviewId,
-        createdAt,
-        updatedAt,
-        subChannelId,
-        data,
-        dataType,
-        segment,
-        isDeleted,
-        subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
-        subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
-    });
-    updateSubChannelCache(message.subChannelId, subChannelCache, {
-        lastActivity: createdAt,
-        messagePreviewId,
-    });
-};
-const handleMessageUpdatedOnSubChannel = async (message) => {
-    var _a;
-    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
-    const messagePreviewSubChannelCache = (_a = pullFromCache([
-        'messagePreviewSubChannel',
-        'get',
-        message.subChannelId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    // if messagePreviewSubChannel is not exist, ignore the message.
-    if (messagePreviewSubChannelCache &&
-        messagePreviewSubChannelCache.messagePreviewId === message.messageId) {
-        const subChannelCache = await getSubChannelCache(subChannelId);
-        pushToCache(['messagePreviewSubChannel', 'get', message.subChannelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
-            data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: subChannelCache.updatedAt,
-            subChannelName: messagePreviewSubChannelCache.subChannelName,
-        });
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
     }
-};
-const handleMessageCreated = async (message) => {
-    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
-    if (isLastestMessageOnChannel(message)) {
-        const subChannelCache = await getSubChannelCache(subChannelId);
-        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
+    persistQueryStream({ response, direction, refresh, }) {
+        const joinRequestResponse = response;
+        this.queryStreamController.appendToQueryStream(joinRequestResponse, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onJoinRequestCreated, action: EnumJoinRequestAction.OnLocalJoinRequestCreated },
+            { fn: onJoinRequestUpdated, action: EnumJoinRequestAction.OnLocalJoinRequestUpdated },
+            { fn: onJoinRequestDeleted, action: EnumJoinRequestAction.OnLocalJoinRequestDeleted },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter(collection.data
+            .map(id => pullFromCache(['joinRequest', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)
+            .map(joinRequestLinkedObject));
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
             data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt,
-            subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
         });
     }
+    applyFilter(data) {
+        let joinRequest = data;
+        if (this.query.status) {
+            joinRequest = joinRequest.filter(joinRequest => joinRequest.status === this.query.status);
+        }
+        const sortFn = (() => {
+            switch (this.query.sortBy) {
+                case 'firstCreated':
+                    return sortByFirstCreated;
+                case 'lastCreated':
+                    return sortByLastCreated;
+                default:
+                    return sortByLastCreated;
+            }
+        })();
+        joinRequest = joinRequest.sort(sortFn);
+        return joinRequest;
+    }
+}
+
+/**
+ * Get Join Requests
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the join request are updated
+ * @returns joinRequests
+ *
+ * @category joinRequest Live Collection
+ *
+ */
+const getJoinRequests = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getJoinRequests: (tmpid: ${timestamp}) > listen`);
+    const joinRequestLiveCollection = new JoinRequestsLiveCollectionController(params, callback);
+    const disposers = joinRequestLiveCollection.startSubscription();
+    const cacheKey = joinRequestLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getJoinRequests (tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+const convertRawInvitationToInternalInvitation = (rawInvitation) => {
+    return Object.assign(Object.assign({}, rawInvitation), { createdById: rawInvitation.createdBy });
+};
+
+const prepareInvitationPayload = (rawPayload) => {
+    return Object.assign(Object.assign({}, rawPayload), { invitations: rawPayload.invitations.map(convertRawInvitationToInternalInvitation), users: rawPayload.users.map(convertRawUserToInternalUser) });
+};
+
+/* begin_public_function
+  id: invitation.createInvitations
+*/
+/**
+ * ```js
+ * import { createInvitations } from '@amityco/ts-sdk'
+ * const created = await createInvitations({
+ *  type: string,
+ *  targetType: string,
+ *  targetId: string,
+ *  userIds: string[]
+ * }))
+ * ```
+ *
+ * Creates an {@link Amity.Invitation}
+ *
+ * @param bundle The data necessary to create a new {@link Amity.Invitation}
+ * @returns The newly created {@link Amity.Invitation}
+ *
+ * @category Invitation API
+ * @async
+ */
+const createInvitations = async (bundle) => {
+    const client = getActiveClient();
+    client.log('invitation/createInvitations', bundle);
+    const { data: payload } = await client.http.post('/api/v1/invitations', bundle);
+    const data = prepareInvitationPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    fireEvent('local.invitation.created', data.invitations);
+    return {
+        data: data.invitations,
+        cachedAt,
+    };
 };
-const handleMessageUpdated = async (message) => {
-    /**
-     * Channel Case
-     */
+/* end_public_function */
+
+/* begin_public_function
+  id: invitation.accept
+*/
+/**
+ * ```js
+ * import { acceptInvitation } from '@amityco/ts-sdk'
+ * const isAccepted = await acceptInvitation(invitationId)
+ * ```
+ *
+ * Accepts a {@link Amity.Invitation} object
+ *
+ * @param invitationId the {@link Amity.Invitation} to accept
+ * @returns A success boolean if the {@link Amity.Invitation} was accepted
+ *
+ * @category Invitation API
+ * @async
+ */
+const acceptInvitation = async (invitationId) => {
     var _a;
-    const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
-    const messagePreviewChannelCache = (_a = pullFromCache([
-        'messagePreviewChannel',
+    const client = getActiveClient();
+    client.log('invitation/acceptInvitation', invitationId);
+    const { data } = await client.http.post(`/api/v1/invitations/${invitationId}/accept`);
+    const invitation = (_a = pullFromCache([
+        'invitation',
         'get',
-        message.channelId,
+        invitationId,
     ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (messagePreviewChannelCache &&
-        messagePreviewChannelCache.messagePreviewId === message.messageId) {
-        const subChannelCache = await getSubChannelCache(subChannelId);
-        pushToCache(['messagePreviewChannel', 'get', message.channelId], {
-            channelId,
-            creatorId,
-            messagePreviewId,
-            createdAt,
-            updatedAt,
-            subChannelId,
-            data,
-            dataType,
-            segment,
-            isDeleted,
-            subChannelUpdatedAt: subChannelCache.updatedAt,
-            subChannelName: messagePreviewChannelCache.subChannelName,
-        });
+    if (invitation) {
+        upsertInCache(['invitation', 'get', invitationId], { status: "approved" /* InvitationStatusEnum.Approved */ });
+        fireEvent('local.invitation.updated', [invitation]);
     }
+    return data.success;
 };
-const handleSubChannelUpdated = async (subChannel) => {
-    var _a, _b, _c, _d;
-    const { channelId, subChannelId } = subChannel;
-    /** Channel Case */
-    const messagePreviewChannelCache = (_a = pullFromCache([
-        'messagePreviewChannel',
+/* end_public_function */
+
+/* begin_public_function
+  id: invitation.reject
+*/
+/**
+ * ```js
+ * import { rejectInvitation } from '@amityco/ts-sdk'
+ * const isRejected = await rejectInvitation(invitationId)
+ * ```
+ *
+ * Rejects a {@link Amity.Invitation} object
+ *
+ * @param invitationId the {@link Amity.Invitation} to reject
+ * @returns A success boolean if the {@link Amity.Invitation} was rejected
+ *
+ * @category Invitation API
+ * @async
+ */
+const rejectInvitation = async (invitationId) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('invitation/rejectInvitation', invitationId);
+    const { data } = await client.http.post(`/api/v1/invitations/${invitationId}/reject`);
+    const invitation = (_a = pullFromCache([
+        'invitation',
         'get',
-        channelId,
+        invitationId,
     ])) === null || _a === void 0 ? void 0 : _a.data;
-    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.subChannelId) === subChannelId) {
-        const subChannelCache = (_b = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _b === void 0 ? void 0 : _b.data;
-        pushToCache(['messagePreviewChannel', 'get', channelId], Object.assign(Object.assign({}, messagePreviewChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
-    }
-    /** SubChannel Case */
-    const messagePreviewSubChannelCache = (_c = pullFromCache([
-        'messagePreviewSubChannel',
-        'get',
-        subChannelId,
-    ])) === null || _c === void 0 ? void 0 : _c.data;
-    if (messagePreviewSubChannelCache &&
-        new Date(messagePreviewSubChannelCache.updatedAt).valueOf() >
-            new Date(subChannel.updatedAt).valueOf()) {
-        const subChannelCache = (_d = pullFromCache([
-            'subChannel',
-            'get',
-            subChannelId,
-        ])) === null || _d === void 0 ? void 0 : _d.data;
-        pushToCache(['messagePreviewSubChannel', 'get', subChannelId], Object.assign(Object.assign({}, messagePreviewSubChannelCache), { subChannelName: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.displayName, subChannelUpdatedAt: subChannelCache === null || subChannelCache === void 0 ? void 0 : subChannelCache.updatedAt }));
+    if (invitation) {
+        upsertInCache(['invitation', 'get', invitationId], { status: "rejected" /* InvitationStatusEnum.Rejected */ });
+        fireEvent('local.invitation.updated', [invitation]);
     }
-};
-
-function convertRawUserToInternalUser(rawUser) {
-    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
-}
+    return data.success;
+};
+/* end_public_function */
 
-const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
-const isUnreadCountSupport = ({ type }) => MARKER_INCLUDED_CHANNEL_TYPE.includes(type);
-function convertFromRaw(channel, options = { isMessagePreviewUpdated: true }) {
+/* begin_public_function
+  id: invitation.cancel
+*/
+/**
+ * ```js
+ * import { cancelInvitation } from '@amityco/ts-sdk'
+ * const isCanceled = await cancelInvitation(invitationId)
+ * ```
+ *
+ * Cancels a {@link Amity.Invitation} object
+ *
+ * @param invitationId the {@link Amity.Invitation} to cancel
+ * @returns A success boolean if the {@link Amity.Invitation} was canceled
+ *
+ * @category Invitation API
+ * @async
+ */
+const cancelInvitation = async (invitationId) => {
     var _a;
-    let { messagePreviewId } = channel;
-    const messagePreviewChannelCache = (_a = pullFromCache([
-        'messagePreviewChannel',
+    const client = getActiveClient();
+    client.log('invitation/cancelInvitation', invitationId);
+    const { data } = await client.http.delete(`/api/v1/invitations/${invitationId}`);
+    const invitation = (_a = pullFromCache([
+        'invitation',
         'get',
-        channel.channelId,
+        invitationId,
     ])) === null || _a === void 0 ? void 0 : _a.data;
-    if ((messagePreviewChannelCache === null || messagePreviewChannelCache === void 0 ? void 0 : messagePreviewChannelCache.messagePreviewId) && !options.isMessagePreviewUpdated) {
-        messagePreviewId = messagePreviewChannelCache.messagePreviewId;
-    }
-    return Object.assign(Object.assign({}, channel), { defaultSubChannelId: channel.channelInternalId, isUnreadCountSupport: isUnreadCountSupport(channel), messagePreviewId });
-}
-const preUpdateChannelCache = (rawPayload, options = { isMessagePreviewUpdated: true }) => {
-    ingestInCache({
-        channels: rawPayload.channels.map(channel => convertFromRaw(channel, { isMessagePreviewUpdated: options.isMessagePreviewUpdated })),
-    });
-};
-const updateChannelUnread = ({ currentUserId, channels, channelUsers, }) => {
-    for (let i = 0; i < channels.length; i += 1) {
-        const cacheKey = ['channelUnread', 'get', channels[i].channelId];
-        const channelUser = channelUsers.find(channelUser => channelUser.channelId === channels[i].channelId && channelUser.userId === currentUserId);
-        let unreadCount = 0;
-        let readToSegment = null;
-        let lastMentionedSegment = null;
-        let isMentioned = false;
-        if (channelUser) {
-            readToSegment = channelUser.readToSegment;
-            lastMentionedSegment = channelUser.lastMentionedSegment;
-            unreadCount = Math.max(channels[i].messageCount - readToSegment, 0);
-            isMentioned = lastMentionedSegment > readToSegment;
-        }
-        const cacheChannelUnread = {
-            channelId: channels[i].channelId,
-            lastSegment: channels[i].messageCount,
-            readToSegment,
-            lastMentionedSegment,
-            unreadCount,
-            isMentioned,
-            isDeleted: channels[i].isDeleted || false,
-        };
-        pushToCache(cacheKey, cacheChannelUnread);
+    if (invitation) {
+        dropFromCache(['invitation', 'get', invitationId]);
+        fireEvent('local.invitation.deleted', [invitation]);
     }
+    return data.success;
 };
-const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpdated: true }) => {
+/* end_public_function */
+
+const prepareMyInvitationsPayload = (rawPayload) => {
+    return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), invitations: rawPayload.invitations.map(convertRawInvitationToInternalInvitation) });
+};
+
+const invitationLinkedObject = (invitation) => {
+    return Object.assign(Object.assign({}, invitation), { get user() {
+            const cacheData = pullFromCache(['user', 'get', invitation.invitedUserPublicId]);
+            if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
+                return userLinkedObject(cacheData.data);
+            return undefined;
+        },
+        get createdBy() {
+            const cacheData = pullFromCache(['user', 'get', invitation.inviterUserPublicId]);
+            if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
+                return userLinkedObject(cacheData.data);
+            return undefined;
+        },
+        get target() {
+            if (invitation.targetType === 'community') {
+                const cacheData = pullFromCache([
+                    'community',
+                    'get',
+                    invitation.targetId,
+                ]);
+                if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
+                    return cacheData.data;
+                return undefined;
+            }
+            return undefined;
+        }, accept: async () => {
+            await acceptInvitation(invitation._id);
+        }, reject: async () => {
+            await rejectInvitation(invitation._id);
+        }, cancel: async () => {
+            await cancelInvitation(invitation._id);
+        } });
+};
+
+/* begin_public_function
+  id: invitation.get
+*/
+/**
+ * ```js
+ * import { getInvitation } from '@amityco/ts-sdk'
+ * const { invitation } = await getInvitation(targetType, targetId)
+ * ```
+ *
+ * Get a {@link Amity.Invitation} object
+ *
+ * @param targetType The type of the target of the {@link Amity.Invitation}
+ * @param targetId The ID of the target of the {@link Amity.Invitation}
+ * @returns A {@link Amity.Invitation} object
+ *
+ * @category Invitation API
+ * @async
+ */
+const getInvitation = async (targetType, targetId) => {
     const client = getActiveClient();
-    const networkPreviewSetting = await client.getMessagePreviewSetting(false);
-    if (options.isMessagePreviewUpdated &&
-        networkPreviewSetting !== "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */ &&
-        rawPayload.messagePreviews &&
-        rawPayload.messagePreviews.length > 0) {
-        updateChannelMessagePreviewCache(rawPayload);
+    client.log('invitation/getInvitation', targetType, targetId);
+    const { data: payload } = await client.http.get(`/api/v1/invitations/me`, { params: { targetType, targetId } });
+    const data = prepareMyInvitationsPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    return {
+        data: data.invitations[0] ? invitationLinkedObject(data.invitations[0]) : undefined,
+        cachedAt,
+    };
+};
+/* end_public_function */
+
+var InvitationActionsEnum;
+(function (InvitationActionsEnum) {
+    InvitationActionsEnum["OnLocalInvitationCreated"] = "onLocalInvitationCreated";
+    InvitationActionsEnum["OnLocalInvitationUpdated"] = "onLocalInvitationUpdated";
+    InvitationActionsEnum["OnLocalInvitationDeleted"] = "onLocalInvitationDeleted";
+})(InvitationActionsEnum || (InvitationActionsEnum = {}));
+
+class InvitationsPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data } = await this.http.get('/api/v1/invitations', { params: Object.assign(Object.assign({}, params), { options }) });
+        return data;
     }
-    if (client.useLegacyUnreadCount) {
-        updateChannelUnread({
-            channels: rawPayload.channels,
-            channelUsers: rawPayload.channelUsers,
-            currentUserId: client.userId,
-        });
+}
+
+class InvitationsQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange, preparePayload) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+        this.preparePayload = preparePayload;
     }
-    else {
-        const markerIds = rawPayload.channels
-            // filter channel by type. Only conversation, community and broadcast type are included.
-            .filter(isUnreadCountSupport)
-            .map(({ channelInternalId }) => channelInternalId);
-        if (markerIds.length > 0) {
-            // since the get markers method requires a channel cache to function with the reducer.
-            preUpdateChannelCache(rawPayload, {
-                isMessagePreviewUpdated: options.isMessagePreviewUpdated,
+    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.invitations.map(getResolver('invitation')),
             });
-            try {
-                await getChannelMarkers(markerIds);
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const invitations = (_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([...invitations, ...response.invitations.map(getResolver('invitation'))]),
+                ] }));
+        }
+    }
+    reactor(action) {
+        return (invitations) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === InvitationActionsEnum.OnLocalInvitationUpdated) {
+                const isExist = collection.data.find(id => id === invitations[0].invitationId);
+                if (!isExist)
+                    return;
             }
-            catch (e) {
-                // empty block (from the spec, allow marker fetch to fail without having to do anything)
+            if (action === InvitationActionsEnum.OnLocalInvitationCreated) {
+                collection.data = [
+                    ...new Set([
+                        ...invitations.map(invitation => invitation.invitationId),
+                        ...collection.data,
+                    ]),
+                ];
             }
-        }
+            if (action === InvitationActionsEnum.OnLocalInvitationDeleted) {
+                collection.data = collection.data.filter(id => id !== invitations[0].invitationId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
     }
-    // convert raw channel to internal channel
-    const channels = rawPayload.channels.map(payload => convertFromRaw(payload, { isMessagePreviewUpdated: options.isMessagePreviewUpdated }));
-    // convert raw channel user to membership (add user object)
-    const channelUsers = rawPayload.channelUsers.map(channelUser => {
-        return convertRawMembershipToMembership(channelUser);
-    });
-    const users = rawPayload.users.map(convertRawUserToInternalUser);
-    const restRawPayload = __rest(rawPayload, ["messageFeedsInfo", "messagePreviews"]);
-    return Object.assign(Object.assign({}, restRawPayload), { users,
-        channels,
-        channelUsers });
-};
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
 
 /**
  * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * import { onLocalInvitationCreated } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationCreated(data => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ * Fired when an {@link Amity.InvitationPayload} has been created
  *
- * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.SubChannelMarker} objects
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Channel API
- * @async
- * @private
+ * @category Invitation Events
  */
-const getUserMessageFeedMakers = async (channelIds) => {
-    const client = getActiveClient();
-    client.log('channel/getUserMessageFeedMakers', channelIds);
-    const { data } = await client.http.get(`/api/v1/markers/user-message-feed`, {
-        params: {
-            channelIds,
-        },
-    });
-    fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
-    return data;
-};
-
-const prepareUnreadCountInfo = async (rawPayload) => {
+const onLocalInvitationCreated = (callback) => {
     const client = getActiveClient();
-    // if consistent mode is enabled, persist the unread count info to the cache
-    // Marker service API uses channelInternalId as channelId
-    const queryPayload = await getUserMessageFeedMakers(rawPayload.channels.map(({ channelInternalId }) => channelInternalId));
-    const { feedMarkers, userFeedMarkers } = queryPayload;
-    persistUnreadCountInfo({
-        feedMarkers,
-        userFeedMarkers,
-    });
-    client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationCreated', 'local.invitation.created', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
-const getCachedMarker$1 = (entityId) => {
-    var _a;
-    const key = {
-        entityId,
-        userId: getActiveUser()._id,
-    };
-    return (_a = pullFromCache([
-        'channelMarker',
-        'get',
-        getResolver('channelMarker')(key),
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-};
-const getUnreadInfoCached$1 = (channelId) => {
-    var _a;
-    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
-};
 /**
- * The function use to get value of hasMentioned or isMentioned field.
- * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ * ```js
+ * import { onLocalInvitationUpdated } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationUpdated(data => {
+ *   // ...
+ * })
+ * ```
  *
- * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
- * If not, the function will return the value from the channelMarker cache.
- * If not found in the both cache, use `false` as defaul value.
+ * Fired when an {@link Amity.InvitationPayload} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Invitation Events
  */
-const getChannelIsMentioned = (channel, marker) => {
-    var _a, _b, _c, _d;
+const onLocalInvitationUpdated = (callback) => {
     const client = getActiveClient();
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        return (_b = (_a = getUnreadInfoCached$1(channel.channelPublicId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
-    }
-    return (marker === null || marker === void 0 ? void 0 : marker.hasMentioned) !== undefined
-        ? marker === null || marker === void 0 ? void 0 : marker.hasMentioned
-        : (_d = (_c = getCachedMarker$1(channel.channelPublicId)) === null || _c === void 0 ? void 0 : _c.hasMentioned) !== null && _d !== void 0 ? _d : false;
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationUpdated', 'local.invitation.updated', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
-const getCachedMarker = (entityId) => {
-    var _a;
-    const key = {
-        entityId,
-        userId: getActiveUser()._id,
-    };
-    return (_a = pullFromCache([
-        'channelMarker',
-        'get',
-        getResolver('channelMarker')(key),
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-};
-const getUnreadInfoCached = (channelId) => {
-    var _a;
-    return (_a = pullFromCache(['channelUnreadInfo', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
-};
 /**
- * The function use to get value of unreadCount field.
- * function will get the value from marker params first, if there is no hasMentioned field, will look in to the cache.
+ * ```js
+ * import { onLocalInvitationDeleted } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationDeleted(data => {
+ *   // ...
+ * })
+ * ```
  *
- * If consistent mode is enabled, the function will return the value from the channelUnreadCountInfo cache.
- * If not, the function will return the value from the channelMarker cache.
- * If not found in the both cache, use `0` as defaul value.
+ * Fired when an {@link Amity.InvitationPayload} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Invitation Events
  */
-const getSubChannelsUnreadCount = (channel, marker) => {
-    var _a, _b, _c, _d, _e;
+const onLocalInvitationDeleted = (callback) => {
     const client = getActiveClient();
-    if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-        // Marker service API uses channelInternalId as channelId
-        return (_b = (_a = getUnreadInfoCached(channel.channelInternalId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
-    }
-    if (marker === null || marker === void 0 ? void 0 : marker.isDeleted) {
-        // NOTE: This is a temporary solution to handle the channel marker when the user is forced to
-        // leave the channel because currently backend can't handle this, so every time a user is banned
-        // from a channel or the channel is deleted the channel's unread count will reset to zero
-        return 0;
-    }
-    return (_e = (_c = marker === null || marker === void 0 ? void 0 : marker.unreadCount) !== null && _c !== void 0 ? _c : (_d = getCachedMarker(channel.channelInternalId)) === null || _d === void 0 ? void 0 : _d.unreadCount) !== null && _e !== void 0 ? _e : 0;
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationDeleted', 'local.invitation.deleted', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
-const getLegacyChannelUnread = (channelId) => {
-    var _a;
-    return (_a = pullFromCache(['channelUnread', 'get', channelId])) === null || _a === void 0 ? void 0 : _a.data;
-};
+class InvitationsLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['invitation', 'collection', queryStreamId];
+        const paginationController = new InvitationsPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new InvitationsQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareInvitationPayload);
+        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: this.query,
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: onLocalInvitationCreated,
+                action: InvitationActionsEnum.OnLocalInvitationCreated,
+            },
+            {
+                fn: onLocalInvitationUpdated,
+                action: InvitationActionsEnum.OnLocalInvitationUpdated,
+            },
+            {
+                fn: onLocalInvitationDeleted,
+                action: InvitationActionsEnum.OnLocalInvitationDeleted,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter((_b = collection.data
+            .map(id => pullFromCache(['invitation', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => invitationLinkedObject(data))) !== null && _b !== void 0 ? _b : []);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let invitations = data;
+        if (this.query.targetId) {
+            invitations = invitations.filter(invitation => invitation.targetId === this.query.targetId);
+        }
+        if (this.query.statuses) {
+            invitations = invitations.filter(invitation => { var _a; return (_a = this.query.statuses) === null || _a === void 0 ? void 0 : _a.includes(invitation.status); });
+        }
+        if (this.query.targetType) {
+            invitations = invitations.filter(invitation => invitation.targetType === this.query.targetType);
+        }
+        if (this.query.type) {
+            invitations = invitations.filter(invitation => invitation.type === this.query.type);
+        }
+        const sortFn = (() => {
+            switch (this.query.sortBy) {
+                case 'firstCreated':
+                    return sortByFirstCreated;
+                case 'lastCreated':
+                    return sortByLastCreated;
+                default:
+                    return sortByLastCreated;
+            }
+        })();
+        invitations = invitations.sort(sortFn);
+        return invitations;
+    }
+}
 
-const constructChannelDynamicValue = (channel) => {
-    const client = getActiveClient();
-    const rest = __rest(channel, ["messageCount"]);
-    return shallowClone(rest, {
-        get unreadCount() {
-            var _a, _b;
-            return (_b = (_a = getLegacyChannelUnread(rest.channelId)) === null || _a === void 0 ? void 0 : _a.unreadCount) !== null && _b !== void 0 ? _b : 0;
-        },
-        get subChannelsUnreadCount() {
-            return getSubChannelsUnreadCount(rest);
-        },
-        get isMentioned() {
-            var _a, _b;
-            if (client.useLegacyUnreadCount)
-                return (_b = (_a = getLegacyChannelUnread(rest.channelId)) === null || _a === void 0 ? void 0 : _a.isMentioned) !== null && _b !== void 0 ? _b : false;
-            return getChannelIsMentioned(rest);
-        },
+/**
+ * Get invitations
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the invitations are updated
+ * @returns invitations
+ *
+ * @category Invitation Live Collection
+ *
+ */
+const getInvitations = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getInvitations: (tmpid: ${timestamp}) > listen`);
+    const invitationsLiveCollection = new InvitationsLiveCollectionController(params, callback);
+    const disposers = invitationsLiveCollection.startSubscription();
+    const cacheKey = invitationsLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
     });
+    return () => {
+        log(`getInvitations (tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+const communityLinkedObject = (community) => {
+    return Object.assign(Object.assign({}, community), { createInvitations: async (userIds) => {
+            await createInvitations({
+                type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */,
+                targetType: 'community',
+                targetId: community.communityId,
+                userIds,
+            });
+        }, getMemberInvitations: (params, callback) => {
+            return getInvitations(Object.assign(Object.assign({}, params), { targetId: community.communityId, targetType: 'community', type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */ }), callback);
+        }, getInvitation: async () => {
+            const { data } = await getInvitation('community', community.communityId);
+            return data;
+        }, join: async () => {
+            return joinRequest(community.communityId);
+        }, getJoinRequests: (params, callback) => {
+            return getJoinRequests(Object.assign(Object.assign({}, params), { communityId: community.communityId }), callback);
+        }, getMyJoinRequest: async () => {
+            const { data } = await getMyJoinRequest(community.communityId);
+            return data;
+        } });
+};
+
+const LinkedObject = {
+    ad: adLinkedObject,
+    comment: commentLinkedObject,
+    post: postLinkedObject,
+    user: userLinkedObject,
+    category: categoryLinkedObject,
+    stream: streamLinkedObject,
+    story: storyLinkedObject,
+    storyTarget: storyTargetLinkedObject,
+    message: messageLinkedObject,
+    reactor: reactorLinkedObject,
+    channel: channelLinkedObject,
+    pinnedPost: pinnedPostLinkedObject,
+    notificationTray: notificationTrayLinkedObject,
+    community: communityLinkedObject,
+    invitation: invitationLinkedObject,
+    joinRequest: joinRequestLinkedObject,
 };
 
 const constructChannelObject = (channel) => {
@@ -10063,38 +11363,6 @@ const onMessageMarked = (callback) => {
     return createEventSubscriber(client, 'messageMarker/onMessageMarked', 'marker.marked-message', filter);
 };
 
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-/**
- *  convert all object getter property to static value
- */
-const convertGetterPropsToStatic = (obj) => {
-    if (!isObject(obj)) {
-        return obj;
-    }
-    const entries = Object.entries(obj).map(([key, value]) => {
-        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
-        if (typeof (descriptor === null || descriptor === void 0 ? void 0 : descriptor.get) === 'function') {
-            return [key, descriptor.get.call(obj)];
-        }
-        return [key, value];
-    });
-    return Object.fromEntries(entries);
-};
-const removeFunctionProperties = (obj) => {
-    if (!isObject(obj)) {
-        return obj;
-    }
-    const entries = Object.entries(obj).map(([key, value]) => {
-        if (typeof value === 'function') {
-            return [key, undefined];
-        }
-        return [key, value];
-    });
-    return Object.fromEntries(entries);
-};
-
 /**
  *
  * ```js
@@ -10204,7 +11472,7 @@ const getUserUnread = (callback) => {
     };
 };
 
-var index$m = /*#__PURE__*/Object.freeze({
+var index$n = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getActiveClient: getActiveClient,
   getActiveUser: getActiveUser,
@@ -10708,51 +11976,6 @@ const onLocalFollowRequestAccepted = (callback) => createLocalFollowEventSubscri
 
 const onLocalFollowRequestDeclined = (callback) => createLocalFollowEventSubscriber('local.follow.requestDeclined', callback);
 
-class PaginationController {
-    constructor(queryParams) {
-        const { http } = getActiveClient();
-        this.queryParams = queryParams;
-        this.http = http;
-    }
-    loadFirstPage() {
-        return this.onFetch("first" /* Amity.LiveCollectionPageDirection.FIRST */);
-    }
-    loadNextPage() {
-        return this.onFetch("next" /* Amity.LiveCollectionPageDirection.NEXT */);
-    }
-    loadPreviousPage() {
-        return this.onFetch("prev" /* Amity.LiveCollectionPageDirection.PREV */);
-    }
-    async onFetch(direction = "first" /* Amity.LiveCollectionPageDirection.FIRST */) {
-        var _a, _b, _c, _d;
-        if (direction === 'prev' && !this.previousToken)
-            return;
-        if (direction === 'next' && !this.nextToken)
-            return;
-        let token;
-        if (direction === 'prev')
-            token = this.previousToken;
-        if (direction === 'next')
-            token = this.nextToken;
-        const queryResponse = await this.getRequest(this.queryParams, token);
-        if (direction === 'first') {
-            this.nextToken = (_a = queryResponse.paging) === null || _a === void 0 ? void 0 : _a.next;
-            this.previousToken = (_b = queryResponse.paging) === null || _b === void 0 ? void 0 : _b.previous;
-        }
-        if (direction === 'prev')
-            this.previousToken = (_c = queryResponse.paging) === null || _c === void 0 ? void 0 : _c.previous;
-        if (direction === 'next')
-            this.nextToken = (_d = queryResponse.paging) === null || _d === void 0 ? void 0 : _d.next;
-        return queryResponse;
-    }
-    getNextToken() {
-        return this.nextToken;
-    }
-    getPrevToken() {
-        return this.previousToken;
-    }
-}
-
 class FollowerPaginationController extends PaginationController {
     async getRequest(queryParams, token) {
         const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, userId } = queryParams, params = __rest(queryParams, ["limit", "userId"]);
@@ -10766,13 +11989,6 @@ class FollowerPaginationController extends PaginationController {
     }
 }
 
-class QueryStreamController {
-    constructor(query, cacheKey) {
-        this.query = query;
-        this.cacheKey = cacheKey;
-    }
-}
-
 var EnumFollowActions;
 (function (EnumFollowActions) {
     EnumFollowActions["OnRequested"] = "onRequested";
@@ -10840,109 +12056,6 @@ class FollowerQueryStreamController extends QueryStreamController {
     }
 }
 
-class PaginationNoPageController {
-    constructor(queryParams) {
-        const { http } = getActiveClient();
-        this.queryParams = queryParams;
-        this.http = http;
-    }
-    async onFetch() {
-        const queryResponse = await this.getRequest(this.queryParams);
-        return queryResponse;
-    }
-}
-
-class LiveCollectionController {
-    constructor(paginationController, queryStreamId, cacheKey, callback) {
-        this.paginationController = paginationController;
-        this.queryStreamId = queryStreamId;
-        this.cacheKey = cacheKey;
-        this.callback = callback;
-    }
-    async refresh() {
-        try {
-            let result;
-            if (this.paginationController instanceof PaginationNoPageController) {
-                result = await this.paginationController.onFetch();
-            }
-            else {
-                result = await this.paginationController.loadFirstPage();
-            }
-            if (!result)
-                return;
-            await this.persistModel(result);
-            this.persistQueryStream({
-                response: result,
-                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
-                refresh: true,
-            });
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
-        }
-        catch (e) {
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
-        }
-    }
-    loadPage({ initial = false, direction = "next" /* Amity.LiveCollectionPageDirection.NEXT */, }) {
-        this.setup();
-        this.notifyChange({ origin: "local" /* Amity.LiveDataOrigin.LOCAL */, loading: true });
-        if (initial) {
-            this.refresh();
-        }
-        else if (direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */) {
-            this.loadPrevPage();
-        }
-        else if (direction === "next" /* Amity.LiveCollectionPageDirection.NEXT */) {
-            this.loadNextPage();
-        }
-    }
-    async loadNextPage() {
-        try {
-            if (this.paginationController instanceof PaginationNoPageController)
-                return;
-            const result = await this.paginationController.loadNextPage();
-            if (!result)
-                return;
-            await this.persistModel(result);
-            this.persistQueryStream({
-                response: result,
-                direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */,
-            });
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
-        }
-        catch (e) {
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
-        }
-    }
-    async loadPrevPage() {
-        try {
-            if (this.paginationController instanceof PaginationNoPageController)
-                return;
-            const result = await this.paginationController.loadPreviousPage();
-            if (!result)
-                return;
-            await this.persistModel(result);
-            this.persistQueryStream({
-                response: result,
-                direction: "prev" /* Amity.LiveCollectionPageDirection.PREV */,
-            });
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
-        }
-        catch (e) {
-            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
-        }
-    }
-    shouldNotify(data) {
-        const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
-        if (isEqual(this.snapshot, newData))
-            return false;
-        this.snapshot = newData;
-        return true;
-    }
-    getCacheKey() {
-        return this.cacheKey;
-    }
-}
-
 const onFollowerUserDeleted = ({ userId }) => (callback) => {
     const client = getActiveClient();
     const filter = (data) => {
@@ -11411,7 +12524,7 @@ const getMyFollowInfo = (callback) => {
 };
 /* end_public_function */
 
-var index$l = /*#__PURE__*/Object.freeze({
+var index$m = /*#__PURE__*/Object.freeze({
   __proto__: null,
   blockUser: blockUser,
   unBlockUser: unBlockUser,
@@ -12426,9 +13539,9 @@ var AmityUserSearchMatchType;
     AmityUserSearchMatchType["PARTIAL"] = "partial";
 })(AmityUserSearchMatchType || (AmityUserSearchMatchType = {}));
 
-var index$k = /*#__PURE__*/Object.freeze({
+var index$l = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  Relationship: index$l,
+  Relationship: index$m,
   getUserByIds: getUserByIds,
   updateUser: updateUser,
   flagUser: flagUser,
@@ -12736,7 +13849,7 @@ const updateAltText = async (fileId, altText) => {
 };
 /* end_public_function */
 
-var index$j = /*#__PURE__*/Object.freeze({
+var index$k = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getFile: getFile,
   uploadFile: uploadFile,
@@ -13075,46 +14188,15 @@ getComment$2.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: LinkedObject.comment(cached.data),
-        cachedAt: cached.cachedAt,
-    };
-};
-
-/*
- * verifies membership status
- */
-function isMember(membership) {
-    return membership !== 'none';
-}
-/*
- * checks if currently logged in user is part of the community
- */
-function isCurrentUserPartOfCommunity(c, m) {
-    const { userId } = getActiveUser();
-    return c.communityId === m.communityId && m.userId === userId;
-}
-/*
- * For mqtt events server will not send user specific data as it's broadcasted
- * to multiple users and it also does not include communityUser
- *
- * Client SDK needs to check for the existing isJoined field in cache data before calculating.
- * Althought this can be calculated, it's not scalable.
- */
-function updateMembershipStatus(communities, communityUsers) {
-    return communities.map(c => {
-        const cachedCommunity = pullFromCache(['community', 'get', c.communityId]);
-        if ((cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data) && (cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data.hasOwnProperty('isJoined'))) {
-            return Object.assign(Object.assign({}, cachedCommunity.data), c);
-        }
-        const isJoined = communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
-        return Object.assign(Object.assign({}, c), { isJoined });
-    });
-}
+        return;
+    const cached = pullFromCache(['comment', 'get', commentId]);
+    if (!cached)
+        return;
+    return {
+        data: LinkedObject.comment(cached.data),
+        cachedAt: cached.cachedAt,
+    };
+};
 
 const getMyReactionsInCache = (payload, eventPrefix) => {
     var _a, _b;
@@ -13430,53 +14512,6 @@ removeReaction.optimistically = (referenceType, referenceId, reactionName) => {
     return !((_d = reaction === null || reaction === void 0 ? void 0 : reaction.myReactions) === null || _d === void 0 ? void 0 : _d.includes(reactionName));
 };
 
-const getMatchPostSetting = (value) => {
-    var _a;
-    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
-        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
-        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
-};
-function addPostSetting({ communities }) {
-    return communities.map((_a) => {
-        var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
-        return (Object.assign({ postSetting: getMatchPostSetting({
-                needApprovalOnPostCreation,
-                onlyAdminCanPost,
-            }) }, restCommunityPayload));
-    });
-}
-const prepareCommunityPayload = (rawPayload) => {
-    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
-    // map users with community
-    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
-        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
-    });
-    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
-    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
-};
-const prepareCommunityMembershipPayload = (rawPayload) => {
-    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
-    // map users with community
-    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
-        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
-    });
-    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
-    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
-};
-const prepareCommunityRequest = (params) => {
-    const { postSetting = undefined, storySetting } = params, restParam = __rest(params, ["postSetting", "storySetting"]);
-    return Object.assign(Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)), { 
-        // Convert story setting to the actual value. (Allow by default)
-        allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
-};
-const prepareSemanticSearchCommunityPayload = (_a) => {
-    var communityPayload = __rest(_a, ["searchResult"]);
-    const processedCommunityPayload = prepareCommunityPayload(communityPayload);
-    return Object.assign({}, processedCommunityPayload);
-};
-
 const preparePostPayload = (payload) => {
     const { posts: postsData } = payload, postPayload = __rest(payload, ["posts"]);
     // Unpack community payload by mapping payload field to postSetting value.
@@ -14604,7 +15639,7 @@ const getReactions = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$i = /*#__PURE__*/Object.freeze({
+var index$j = /*#__PURE__*/Object.freeze({
   __proto__: null,
   addReaction: addReaction,
   removeReaction: removeReaction,
@@ -15934,10 +16969,11 @@ getDeliveredUsers.locally = (query) => {
 const flagMessage = async (messageId, reason) => {
     const client = getActiveClient();
     client.log('message/flag', messageId);
-    const isPredefinedReason = Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
+    const isPredefinedReason = reason &&
+        Object.entries(exports.ContentFlagReasonEnum).some(([key, value]) => key !== exports.ContentFlagReasonEnum.Others && value === reason);
     const body = {
         reason: isPredefinedReason ? reason : exports.ContentFlagReasonEnum.Others,
-        detail: isPredefinedReason ? '' : reason,
+        detail: !isPredefinedReason ? reason : '',
     };
     const { data: payload } = await client.http.post(`/api/v5/messages/${encodeURIComponent(messageId)}/flags`, body);
     if (client.cache) {
@@ -16426,7 +17462,7 @@ const getMessages = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$h = /*#__PURE__*/Object.freeze({
+var index$i = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createMessage: createMessage,
   updateMessage: updateMessage,
@@ -16952,7 +17988,7 @@ const stopMessageReceiptSync = (subChannelId) => {
 };
 /* end_public_function */
 
-var index$g = /*#__PURE__*/Object.freeze({
+var index$h = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getSubChannelByIds: getSubChannels$1,
   createSubChannel: createSubChannel,
@@ -18266,7 +19302,7 @@ const searchMembers$1 = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$f = /*#__PURE__*/Object.freeze({
+var index$g = /*#__PURE__*/Object.freeze({
   __proto__: null,
   addMembers: addMembers$1,
   removeMembers: removeMembers$1,
@@ -18469,7 +19505,7 @@ const unmuteMembers = async (channelId, userIds) => {
 };
 /* end_public_function */
 
-var index$e = /*#__PURE__*/Object.freeze({
+var index$f = /*#__PURE__*/Object.freeze({
   __proto__: null,
   addRole: addRole,
   removeRole: removeRole,
@@ -18479,10 +19515,10 @@ var index$e = /*#__PURE__*/Object.freeze({
   unmuteMembers: unmuteMembers
 });
 
-var index$d = /*#__PURE__*/Object.freeze({
+var index$e = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  Membership: index$f,
-  Moderation: index$e,
+  Membership: index$g,
+  Moderation: index$f,
   getChannelByIds: getChannelByIds$1,
   createChannel: createChannel,
   updateChannel: updateChannel,
@@ -18536,12 +19572,15 @@ const saveCommunityUsers = (communities, communityUsers) => {
  * @category Community API
  * @async
  */
-const getCommunities$1 = async (communityIds) => {
+const getCommunities$1 = async (communityIds, includeDiscoverablePrivateCommunity) => {
     const client = getActiveClient();
     client.log('community/getCommunities', communityIds);
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const { data: payload } = await client.http.get(`/api/v3/communities/list`, {
-        params: { communityIds },
+        params: {
+            communityIds,
+            includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity !== null && includeDiscoverablePrivateCommunity !== void 0 ? includeDiscoverablePrivateCommunity : true,
+        },
     });
     const data = prepareCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
@@ -18550,7 +19589,7 @@ const getCommunities$1 = async (communityIds) => {
         saveCommunityUsers(data.communities, data.communityUsers);
     }
     return {
-        data: data.communities,
+        data: data.communities.map(community => LinkedObject.community(community)),
         cachedAt,
     };
 };
@@ -18592,7 +19631,7 @@ getCommunities$1.locally = (communityIds) => {
 /**
  * ```js
  * import { createCommunity } from '@amityco/ts-sdk'
- * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar' })
+ * const created = await createCommunity({ communityId: 'foobar', displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
  * ```
  *
  * Creates an {@link Amity.Community}
@@ -18616,7 +19655,7 @@ const createCommunity = async (bundle) => {
     }
     const { communities } = data;
     return {
-        data: communities[0],
+        data: LinkedObject.community(communities[0]),
         cachedAt,
     };
 };
@@ -18628,7 +19667,7 @@ const createCommunity = async (bundle) => {
 /**
  * ```js
  * import { updateCommunity } from '@amityco/ts-sdk'
- * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
  * ```
  *
  * Updates an {@link Amity.Community}
@@ -18653,7 +19692,7 @@ const updateCommunity = async (communityId, patch) => {
     }
     const { communities } = data;
     return {
-        data: communities.find(community => community.communityId === communityId),
+        data: LinkedObject.community(communities.find(community => community.communityId === communityId)),
         cachedAt,
     };
 };
@@ -18673,11 +19712,16 @@ const updateCommunity = async (communityId, patch) => {
  * @category Community API
  * @async
  */
-const getCommunity$1 = async (communityId) => {
+const getCommunity$1 = async (communityId, type, includeDiscoverablePrivateCommunity) => {
     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}`);
+    const { data: payload } = await client.http.get(`/api/v3/communities/${communityId}`, {
+        params: {
+            type: 'communityJoinRequest',
+            includeDiscoverablePrivateCommunity: includeDiscoverablePrivateCommunity !== null && includeDiscoverablePrivateCommunity !== void 0 ? includeDiscoverablePrivateCommunity : true,
+        },
+    });
     const data = prepareCommunityPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache) {
@@ -18686,7 +19730,7 @@ const getCommunity$1 = async (communityId) => {
     }
     const { communities } = data;
     return {
-        data: communities.find(community => community.communityId === communityId),
+        data: LinkedObject.community(communities.find(community => community.communityId === communityId)),
         cachedAt,
     };
 };
@@ -18712,7 +19756,7 @@ getCommunity$1.locally = (communityId) => {
     if (!cached)
         return;
     return {
-        data: cached.data,
+        data: LinkedObject.community(cached.data),
         cachedAt: cached.cachedAt,
     };
 };
@@ -18752,6 +19796,9 @@ const deleteCommunity = async (communityId) => {
 };
 /* end_public_function */
 
+/**
+ * @deprecated This function will to be deprecated and use the new community.join().
+ */
 /* begin_public_function
   id: community.join
 */
@@ -18892,10 +19939,11 @@ const onCommunityDeleted = (callback) => createCommunityEventSubscriber('communi
  */
 class CommunitiesPaginationController$1 extends PaginationController {
     async getRequest(queryParams, token) {
+        var _a;
         const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
         const options = token ? { token } : { limit };
         const { data: queryResponse } = await this.http.get(`/api/v3/communities`, {
-            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(params.includeDeleted), keyword: params.displayName, filter: params.membership, options }),
+            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(params.includeDeleted), keyword: params.displayName, filter: params.membership, includeDiscoverablePrivateCommunity: (_a = params.includeDiscoverablePrivateCommunity) !== null && _a !== void 0 ? _a : true, options }),
         });
         return queryResponse;
     }
@@ -19862,7 +20910,7 @@ const searchMembers = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$c = /*#__PURE__*/Object.freeze({
+var index$d = /*#__PURE__*/Object.freeze({
   __proto__: null,
   addMembers: addMembers,
   removeMembers: removeMembers,
@@ -20342,7 +21390,7 @@ class TrendingCommunityLiveCollectionController extends LiveCollectionController
         const data = (_b = collection.data
             .map(id => pullFromCache(['community', 'get', id]))
             .filter(isNonNullable)
-            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : [];
+            .map(({ data }) => communityLinkedObject(data))) !== null && _b !== void 0 ? _b : [];
         if (!this.shouldNotify(data) && origin === 'event')
             return;
         this.callback({
@@ -20504,7 +21552,7 @@ class RecommendedCommunityLiveCollectionController extends LiveCollectionControl
         const data = (_b = collection.data
             .map(id => pullFromCache(['community', 'get', id]))
             .filter(isNonNullable)
-            .map(({ data }) => data)) !== null && _b !== void 0 ? _b : [];
+            .map(({ data }) => communityLinkedObject(data))) !== null && _b !== void 0 ? _b : [];
         if (!this.shouldNotify(data) && origin === 'event')
             return;
         this.callback({
@@ -20887,7 +21935,7 @@ const unbanMembers = async (communityId, userIds) => {
 };
 /* end_public_function */
 
-var index$b = /*#__PURE__*/Object.freeze({
+var index$c = /*#__PURE__*/Object.freeze({
   __proto__: null,
   addRoles: addRoles,
   removeRoles: removeRoles,
@@ -20895,10 +21943,10 @@ var index$b = /*#__PURE__*/Object.freeze({
   unbanMembers: unbanMembers
 });
 
-var index$a = /*#__PURE__*/Object.freeze({
+var index$b = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  Moderation: index$b,
-  Membership: index$c,
+  Moderation: index$c,
+  Membership: index$d,
   getCommunityByIds: getCommunities$1,
   createCommunity: createCommunity,
   updateCommunity: updateCommunity,
@@ -21131,7 +22179,7 @@ const getCategories = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$9 = /*#__PURE__*/Object.freeze({
+var index$a = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getCategory: getCategory,
   getCategories: getCategories
@@ -21299,7 +22347,7 @@ getCustomRankingGlobalFeed.locally = (query) => {
         : undefined;
 };
 
-var index$8 = /*#__PURE__*/Object.freeze({
+var index$9 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   queryGlobalFeed: queryGlobalFeed,
   getCustomRankingGlobalFeed: getCustomRankingGlobalFeed
@@ -21672,19 +22720,26 @@ const declinePost = async (postId) => {
 /**
  * ```js
  * import { PostRepository } from '@amityco/ts-sdk'
- * const flagged = await PostRepository.flagPost(postId)
+ * 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) => {
+const flagPost = async (postId, reason) => {
     const client = getActiveClient();
     client.log('post/flagPost', postId);
-    const { data: payload } = await client.http.post(`/api/v3/posts/${encodeURIComponent(postId)}/flag`);
+    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'));
     }
@@ -22147,19 +23202,26 @@ const hardDeleteComment = async (commentId) => {
 /**
  * ```js
  * import { CommentRepository } from '@amityco/ts-sdk'
- * const flagged = await CommentRepository.flagComment('commentId')
+ * 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) => {
+const flagComment = async (commentId, reason) => {
     const client = getActiveClient();
     client.log('comment/flagComment', commentId);
-    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/flag`);
+    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);
     }
@@ -22614,7 +23676,7 @@ const getComments = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$7 = /*#__PURE__*/Object.freeze({
+var index$8 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getCommentByIds: getCommentByIds,
   createComment: createComment,
@@ -23140,7 +24202,8 @@ class PinnedPostQueryStreamController extends QueryStreamController {
         const client = getActiveClient();
         const cachedAt = client.cache && Date.now();
         if (client.cache) {
-            ingestInCache(response, { cachedAt });
+            const processedPayload = Object.assign(Object.assign({}, response), { users: response.users ? response.users.map(convertRawUserToInternalUser) : [] });
+            ingestInCache(processedPayload, { cachedAt });
         }
     }
     appendToQueryStream(response, direction, refresh = false) {
@@ -23269,7 +24332,8 @@ class GlobalPinnedPostQueryStreamController extends QueryStreamController {
         const client = getActiveClient();
         const cachedAt = client.cache && Date.now();
         if (client.cache) {
-            ingestInCache(response, { cachedAt });
+            const processedPayload = Object.assign(Object.assign({}, response), { users: response.users.map(convertRawUserToInternalUser) });
+            ingestInCache(processedPayload, { cachedAt });
         }
     }
     appendToQueryStream(response, direction, refresh = false) {
@@ -23621,7 +24685,7 @@ const semanticSearchPosts = (params, callback, config) => {
     };
 };
 
-var index$6 = /*#__PURE__*/Object.freeze({
+var index$7 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getPostByIds: getPostByIds,
   createPost: createPost,
@@ -24155,7 +25219,7 @@ const getStreams = (params, callback, config) => {
     };
 };
 
-var index$5 = /*#__PURE__*/Object.freeze({
+var index$6 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createStream: createStream,
   updateStream: updateStream,
@@ -24442,7 +25506,7 @@ const getPoll = (pollId, callback) => {
 };
 /* end_public_function */
 
-var index$4 = /*#__PURE__*/Object.freeze({
+var index$5 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createPoll: createPoll,
   closePoll: closePoll,
@@ -24813,7 +25877,7 @@ const getPlayer = async (parameters) => {
     return video;
 };
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$4 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getPlayer: getPlayer
 });
@@ -25986,7 +27050,7 @@ const getGlobalStoryTargets = (params, callback, config) => {
     };
 };
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createImageStory: createImageStory,
   createVideoStory: createVideoStory,
@@ -26023,7 +27087,7 @@ const getNetworkAds = async () => {
     };
 };
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getNetworkAds: getNetworkAds
 });
@@ -26414,7 +27478,7 @@ const markTraySeen = async (lastSeenAt) => {
 };
 /* end_public_function */
 
-var index = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   getNotificationTraySeen: getNotificationTraySeen,
   getNotificationTrayItems: getNotificationTrayItems,
@@ -26423,31 +27487,232 @@ var index = /*#__PURE__*/Object.freeze({
   onNotificationTraySeenUpdated: onNotificationTraySeenUpdated
 });
 
+class MyInvitationsPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data } = await this.http.get('/api/v1/invitations/me', { params: Object.assign(Object.assign({}, params), { options }) });
+        await getCommunities$1(data.invitations.map(invitation => invitation.targetId));
+        return data;
+    }
+}
+
+class MyInvitationsQueryStreamController 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.invitations.map(getResolver('invitation')),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const invitations = (_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([...invitations, ...response.invitations.map(getResolver('invitation'))]),
+                ] }));
+        }
+    }
+    reactor(action) {
+        return (invitations) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === InvitationActionsEnum.OnLocalInvitationUpdated) {
+                const isExist = collection.data.find(id => id === invitations[0].invitationId);
+                if (!isExist)
+                    return;
+            }
+            if (action === InvitationActionsEnum.OnLocalInvitationCreated) {
+                const client = getActiveClient();
+                const myInvitations = invitations.filter(invitation => invitation.invitedUserId === client.userId);
+                collection.data = [
+                    ...new Set([
+                        ...myInvitations.map(invitation => invitation.invitationId),
+                        ...collection.data,
+                    ]),
+                ];
+            }
+            if (action === InvitationActionsEnum.OnLocalInvitationDeleted) {
+                collection.data = collection.data.filter(id => id !== invitations[0].invitationId);
+            }
+            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 MyInvitationsLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['invitation', 'collection', queryStreamId];
+        const paginationController = new MyInvitationsPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new MyInvitationsQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareMyInvitationsPayload);
+        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: this.query,
+            });
+        }
+    }
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: onLocalInvitationCreated,
+                action: InvitationActionsEnum.OnLocalInvitationCreated,
+            },
+            {
+                fn: onLocalInvitationUpdated,
+                action: InvitationActionsEnum.OnLocalInvitationUpdated,
+            },
+            {
+                fn: onLocalInvitationDeleted,
+                action: InvitationActionsEnum.OnLocalInvitationDeleted,
+            },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter((_b = collection.data
+            .map(id => pullFromCache(['invitation', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => invitationLinkedObject(data))) !== null && _b !== void 0 ? _b : []);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let invitations = data;
+        if (this.query.targetId) {
+            invitations = invitations.filter(invitation => invitation.targetId === this.query.targetId);
+        }
+        if (this.query.statuses) {
+            invitations = invitations.filter(invitation => { var _a; return (_a = this.query.statuses) === null || _a === void 0 ? void 0 : _a.includes(invitation.status); });
+        }
+        if (this.query.targetType) {
+            invitations = invitations.filter(invitation => invitation.targetType === this.query.targetType);
+        }
+        if (this.query.type) {
+            invitations = invitations.filter(invitation => invitation.type === this.query.type);
+        }
+        const sortFn = (() => {
+            switch (this.query.sortBy) {
+                case 'firstCreated':
+                    return sortByFirstCreated;
+                case 'lastCreated':
+                    return sortByLastCreated;
+                default:
+                    return sortByLastCreated;
+            }
+        })();
+        invitations = invitations.sort(sortFn);
+        return invitations;
+    }
+}
+
+/**
+ * Get my community invitations
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the invitations are fetched
+ * @returns invitations
+ *
+ * @category My Community Invitations Live Collection
+ *
+ */
+const getMyCommunityInvitations = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
+    }
+    const timestamp = Date.now();
+    log(`getMyCommunityInvitations: (tmpid: ${timestamp}) > listen`);
+    const invitationsLiveCollection = new MyInvitationsLiveCollectionController(Object.assign(Object.assign({}, params), { targetType: 'community', statuses: ["pending" /* InvitationStatusEnum.Pending */] }), callback);
+    const disposers = invitationsLiveCollection.startSubscription();
+    const cacheKey = invitationsLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getInvitations (tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  onLocalInvitationCreated: onLocalInvitationCreated,
+  onLocalInvitationUpdated: onLocalInvitationUpdated,
+  onLocalInvitationDeleted: onLocalInvitationDeleted,
+  getMyCommunityInvitations: getMyCommunityInvitations
+});
+
 exports.API_REGIONS = API_REGIONS;
-exports.AdRepository = index$1;
-exports.CategoryRepository = index$9;
-exports.ChannelRepository = index$d;
-exports.Client = index$m;
-exports.CommentRepository = index$7;
+exports.AdRepository = index$2;
+exports.CategoryRepository = index$a;
+exports.ChannelRepository = index$e;
+exports.Client = index$n;
+exports.CommentRepository = index$8;
 exports.CommunityPostSettingMaps = CommunityPostSettingMaps;
 exports.CommunityPostSettings = CommunityPostSettings;
-exports.CommunityRepository = index$a;
+exports.CommunityRepository = index$b;
 exports.ContentFeedType = ContentFeedType;
 exports.DefaultCommunityPostSetting = DefaultCommunityPostSetting;
-exports.FeedRepository = index$8;
-exports.FileRepository = index$j;
+exports.FeedRepository = index$9;
+exports.FileRepository = index$k;
 exports.FileType = FileType;
-exports.LiveStreamPlayer = index$3;
+exports.InvitationRepository = index;
+exports.LiveStreamPlayer = index$4;
 exports.MessageContentType = MessageContentType;
-exports.MessageRepository = index$h;
-exports.PollRepository = index$4;
+exports.MessageRepository = index$i;
+exports.PollRepository = index$5;
 exports.PostContentType = PostContentType;
-exports.PostRepository = index$6;
-exports.ReactionRepository = index$i;
-exports.StoryRepository = index$2;
-exports.StreamRepository = index$5;
-exports.SubChannelRepository = index$g;
-exports.UserRepository = index$k;
+exports.PostRepository = index$7;
+exports.ReactionRepository = index$j;
+exports.StoryRepository = index$3;
+exports.StreamRepository = index$6;
+exports.SubChannelRepository = index$h;
+exports.UserRepository = index$l;
 exports.VERSION = VERSION;
 exports.VideoResolution = VideoResolution;
 exports.VideoSize = VideoSize;
@@ -26500,7 +27765,7 @@ exports.isPaged = isPaged;
 exports.isReportedByMe = isReportedByMe;
 exports.isSkip = isSkip;
 exports.mergeInCache = mergeInCache;
-exports.notificationTray = index;
+exports.notificationTray = index$1;
 exports.onChannelMarkerFetched = onChannelMarkerFetched;
 exports.onFeedMarkerFetched = onFeedMarkerFetched;
 exports.onFeedMarkerUpdated = onFeedMarkerUpdated;