@amityco/ts-sdk 7.4.1-d23fab2f.0 → 7.4.1-e8631ca7.0

package/dist/index.cjs.js

@@ -129,7 +129,12 @@ exports.InvitationStatusEnum = void 0;
     InvitationStatusEnum["Approved"] = "approved";
     InvitationStatusEnum["Rejected"] = "rejected";
     InvitationStatusEnum["Cancelled"] = "cancelled";
-})(exports.InvitationStatusEnum || (exports.InvitationStatusEnum = {}));
+})(exports.InvitationStatusEnum || (exports.InvitationStatusEnum = {}));
+exports.InvitationSortByEnum = void 0;
+(function (InvitationSortByEnum) {
+    InvitationSortByEnum["FirstCreated"] = "firstCreated";
+    InvitationSortByEnum["LastCreated"] = "lastCreated";
+})(exports.InvitationSortByEnum || (exports.InvitationSortByEnum = {}));
 
 function getVersion() {
     try {
@@ -4898,6 +4903,1102 @@ 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 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 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,
+        };
+    };
+    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);
+};
+
+/**
+ * ```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)));
+}
+
+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 */);
+    }
+};
+
+/**
+ * ```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;
+}
+
+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));
+    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;
+    }
+    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 }));
+    }
+};
+
+function convertRawUserToInternalUser(rawUser) {
+    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
+}
+
+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'];
 
@@ -5197,20 +6298,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;
@@ -5642,7 +6729,7 @@ const postLinkedObject = (post) => {
         } });
 };
 
-const getCachedMarker$2 = (message) => {
+const getCachedMarker = (message) => {
     var _a, _b;
     const key = {
         creatorId: 'creatorPrivateId' in message ? message.creatorPrivateId : message.creatorId,
@@ -5660,7 +6747,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`
 
 /**
@@ -5903,31 +6990,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;
@@ -6213,24 +7275,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),
@@ -6310,6 +7354,14 @@ const notificationTrayLinkedObject = (noti) => {
             .map(user => userLinkedObject(user)) });
 };
 
+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
 */
@@ -6335,11 +7387,12 @@ const notificationTrayLinkedObject = (noti) => {
 const createInvitations = async (bundle) => {
     const client = getActiveClient();
     client.log('invitation/createInvitations', bundle);
-    const { data } = await client.http.post('/api/v1/invitations', 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);
+    fireEvent('local.invitation.created', data.invitations);
     return {
         data: data.invitations,
         cachedAt,
@@ -6367,1167 +7420,652 @@ const createInvitations = async (bundle) => {
 const acceptInvitation = async (invitationId) => {
     var _a;
     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',
-        invitationId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (invitation) {
-        upsertInCache(['invitation', 'get', invitationId], { status: "approved" /* InvitationStatusEnum.Approved */ });
-        fireEvent('local.invitation.updated', { invitations: [invitation] });
-    }
-    return data.success;
-};
-/* 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`);
+    client.log('invitation/acceptInvitation', invitationId);
+    const { data } = await client.http.post(`/api/v1/invitations/${invitationId}/accept`);
     const invitation = (_a = pullFromCache([
         'invitation',
         'get',
         invitationId,
     ])) === null || _a === void 0 ? void 0 : _a.data;
     if (invitation) {
-        upsertInCache(['invitation', 'get', invitationId], { status: "rejected" /* InvitationStatusEnum.Rejected */ });
-        fireEvent('local.invitation.updated', { invitations: [invitation] });
+        upsertInCache(['invitation', 'get', invitationId], { status: "approved" /* InvitationStatusEnum.Approved */ });
+        fireEvent('local.invitation.updated', [invitation]);
     }
     return data.success;
 };
 /* end_public_function */
 
 /* begin_public_function
-  id: invitation.cancel
+  id: invitation.reject
 */
 /**
  * ```js
- * import { cancelInvitation } from '@amityco/ts-sdk'
- * const isCanceled = await cancelInvitation(invitationId)
+ * import { rejectInvitation } from '@amityco/ts-sdk'
+ * const isRejected = await rejectInvitation(invitationId)
  * ```
  *
- * Cancels a {@link Amity.Invitation} object
+ * Rejects a {@link Amity.Invitation} object
  *
- * @param invitationId the {@link Amity.Invitation} to cancel
- * @returns A success boolean if the {@link Amity.Invitation} was canceled
+ * @param invitationId the {@link Amity.Invitation} to reject
+ * @returns A success boolean if the {@link Amity.Invitation} was rejected
  *
  * @category Invitation API
  * @async
  */
-const cancelInvitation = async (invitationId) => {
+const rejectInvitation = async (invitationId) => {
     var _a;
     const client = getActiveClient();
-    client.log('invitation/cancelInvitation', invitationId);
-    const { data } = await client.http.delete(`/api/v1/invitations/${invitationId}`);
+    client.log('invitation/rejectInvitation', invitationId);
+    const { data } = await client.http.post(`/api/v1/invitations/${invitationId}/reject`);
     const invitation = (_a = pullFromCache([
         'invitation',
         'get',
         invitationId,
     ])) === null || _a === void 0 ? void 0 : _a.data;
     if (invitation) {
-        dropFromCache(['invitation', 'get', invitationId]);
-        fireEvent('local.invitation.deleted', { invitations: [invitation] });
+        upsertInCache(['invitation', 'get', invitationId], { status: "rejected" /* InvitationStatusEnum.Rejected */ });
+        fireEvent('local.invitation.updated', [invitation]);
     }
     return data.success;
 };
 /* end_public_function */
 
-const communityLinkedObject = (community) => {
-    return Object.assign(Object.assign({}, community), { createInvitations: async (userIds) => {
-            await createInvitations({
-                type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */,
-                targetType: 'community',
-                targetId: community.communityId,
-                userIds,
-            });
-        } });
-};
-
-const invitationLinkedObject = (invitation) => {
-    return Object.assign(Object.assign({}, invitation), { accept: async () => {
-            await acceptInvitation(invitation._id);
-        }, reject: async () => {
-            await rejectInvitation(invitation._id);
-        }, cancel: async () => {
-            await cancelInvitation(invitation._id);
-        } });
-};
-
-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,
-};
-
-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);
-};
-
-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 */);
-    }
-};
-
-/**
- * ```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 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);
-        });
-    }
-};
-
+/* begin_public_function
+  id: invitation.cancel
+*/
 /**
  * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
+ * import { cancelInvitation } from '@amityco/ts-sdk'
+ * const isCanceled = await cancelInvitation(invitationId)
  * ```
  *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ * Cancels a {@link Amity.Invitation} 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 invitationId the {@link Amity.Invitation} to cancel
+ * @returns A success boolean if the {@link Amity.Invitation} was canceled
  *
- * @category Channel API
+ * @category Invitation API
  * @async
- * @private
  */
-const getSubChannelMarkers = async (messageFeedIds, page = { limit: 100 }) => {
+const cancelInvitation = async (invitationId) => {
+    var _a;
     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,
-        });
+    client.log('invitation/cancelInvitation', invitationId);
+    const { data } = await client.http.delete(`/api/v1/invitations/${invitationId}`);
+    const invitation = (_a = pullFromCache([
+        'invitation',
+        'get',
+        invitationId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (invitation) {
+        dropFromCache(['invitation', 'get', invitationId]);
+        fireEvent('local.invitation.deleted', [invitation]);
     }
-    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 };
-};
+    return data.success;
+};
+/* end_public_function */
 
-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 };
+const prepareMyInvitationsPayload = (rawPayload) => {
+    return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), invitations: rawPayload.invitations.map(convertRawInvitationToInternalInvitation) });
 };
 
-/** @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),
-        });
-    }
+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);
+        } });
 };
 
-/*
- * This is a simple utility that infers the value of isDeleted based on the
- * value of includeDeleted
+/* begin_public_function
+  id: invitation.get
+*/
+/**
+ * ```js
+ * import { getInvitation } from '@amityco/ts-sdk'
+ * const { invitation } = await getInvitation(targetType, targetId)
+ * ```
  *
- * 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
+ * Get a {@link Amity.Invitation} object
  *
- *  Although this is a very simple utility, it's only purpose is to keep things
- *  DRY
+ * @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 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 getInvitation = async (targetType, targetId) => {
     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]);
+    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 PaginationController {
+    constructor(queryParams) {
+        const { http } = getActiveClient();
+        this.queryParams = queryParams;
+        this.http = http;
     }
-    if (!cache) {
-        cache = pullFromCache(['message', 'get', messageId]);
+    loadFirstPage() {
+        return this.onFetch("first" /* Amity.LiveCollectionPageDirection.FIRST */);
     }
-    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 };
-        });
+    loadNextPage() {
+        return this.onFetch("next" /* Amity.LiveCollectionPageDirection.NEXT */);
     }
-    if (reactors && reactors.length && event) {
-        // mqtt event
-        prepareMessagePayloadForCache(out, reactors, event);
+    loadPreviousPage() {
+        return this.onFetch("prev" /* Amity.LiveCollectionPageDirection.PREV */);
     }
-    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]);
+    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;
         }
-        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);
-        });
+        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;
     }
-    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);
+    getNextToken() {
+        return this.nextToken;
     }
-    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;
+    getPrevToken() {
+        return this.previousToken;
     }
-    if (type) {
-        out.dataType = type;
+}
+
+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 (excludingTags) {
-        out.excludeTags = excludingTags;
+}
+
+class QueryStreamController {
+    constructor(query, cacheKey) {
+        this.query = query;
+        this.cacheKey = cacheKey;
     }
-    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);
-        try {
-            await getSubChannelMarkers(markerIds);
+class InvitationsQueryStreamController 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 });
         }
-        catch (e) {
-            // empty block (from the spec, allow marker fetch to fail without having to do anything)
+    }
+    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'))]),
+                ] }));
         }
     }
-    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;
+    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) {
+                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 });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
     }
-    return out;
 }
 
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
 /**
- * ```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
+ *  convert all object getter property to static value
  */
-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,
-        };
+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;
     }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            pushToTombstone('subChannel', subChannelId);
+    const entries = Object.entries(obj).map(([key, value]) => {
+        if (typeof value === 'function') {
+            return [key, undefined];
         }
-        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,
-    };
+        return [key, value];
+    });
+    return Object.fromEntries(entries);
 };
 
-const convertDateStringToTimestamp = (dateString) => {
-    return new Date(dateString).getTime();
-};
+class PaginationNoPageController {
+    constructor(queryParams) {
+        const { http } = getActiveClient();
+        this.queryParams = queryParams;
+        this.http = http;
+    }
+    async onFetch() {
+        const queryResponse = await this.getRequest(this.queryParams);
+        return queryResponse;
+    }
+}
 
-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 LiveCollectionController {
+    constructor(paginationController, queryStreamId, cacheKey, callback) {
+        this.paginationController = paginationController;
+        this.queryStreamId = queryStreamId;
+        this.cacheKey = cacheKey;
+        this.callback = callback;
     }
-    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,
+    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,
             });
-        return;
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false });
+        }
+        catch (e) {
+            this.notifyChange({ origin: "server" /* Amity.LiveDataOrigin.SERVER */, loading: false, error: e });
+        }
     }
-    // 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,
-        });
+    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();
+        }
     }
-};
-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,
-        });
+    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 });
+        }
     }
-};
-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,
-        });
+    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 });
+        }
     }
-};
-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 }));
+    shouldNotify(data) {
+        const newData = data.map(convertGetterPropsToStatic).map(removeFunctionProperties);
+        if (isEqual(this.snapshot, newData))
+            return false;
+        this.snapshot = newData;
+        return true;
     }
-    /** 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 }));
+    getCacheKey() {
+        return this.cacheKey;
     }
+}
+
+/**
+ * ```js
+ * import { onLocalInvitationCreated } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationCreated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.InvitationPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Invitation Events
+ */
+const onLocalInvitationCreated = (callback) => {
+    const client = getActiveClient();
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationCreated', 'local.invitation.created', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
-function convertRawUserToInternalUser(rawUser) {
-    return Object.assign(Object.assign({}, rawUser), { isGlobalBanned: (rawUser === null || rawUser === void 0 ? void 0 : rawUser.isGlobalBan) || false });
-}
+/**
+ * ```js
+ * import { onLocalInvitationUpdated } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationUpdated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * 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 onLocalInvitationUpdated = (callback) => {
+    const client = getActiveClient();
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationUpdated', 'local.invitation.updated', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
 
-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;
+/**
+ * ```js
+ * import { onLocalInvitationDeleted } from '@amityco/ts-sdk'
+ * const dispose = onLocalInvitationDeleted(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * 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 onLocalInvitationDeleted = (callback) => {
+    const client = getActiveClient();
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationDeleted', 'local.invitation.deleted', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
+};
+
+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 });
     }
-    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;
+    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,
+            });
         }
-        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);
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
     }
-    if (client.useLegacyUnreadCount) {
-        updateChannelUnread({
-            channels: rawPayload.channels,
-            channelUsers: rawPayload.channelUsers,
-            currentUserId: client.userId,
+    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,
         });
     }
-    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)
-            }
+    applyFilter(data) {
+        let invitations = data;
+        if (this.query.targetId) {
+            invitations = invitations.filter(invitation => invitation.targetId === this.query.targetId);
         }
-    }
-    // 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 });
-};
+        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;
+    }
+}
 
 /**
- * ```js
- * import { getSubChannelMarkers } from '@amityco/ts-sdk'
- * const subChannelMarkers = await getSubChannelMarkers(['sch1', 'sch2'])
- * ```
- *
- * Fetches a paginable list of {@link Amity.SubChannelMarker} objects
+ * Get invitations
  *
- * @param messageFeedIds the feed IDs of the {@link Amity.RawSubChannel} marker to fetch
- * @param page
- * @returns A page of {@link Amity.SubChannelMarker} objects
+ * @param params the query parameters
+ * @param callback the callback to be called when the invitations are updated
+ * @returns invitations
  *
- * @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$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.
+ * @category Invitation Live Collection
  *
- * 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;
+const getInvitations = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
     }
-    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 getCachedMarker = (entityId) => {
-    var _a;
-    const key = {
-        entityId,
-        userId: getActiveUser()._id,
+    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());
     };
-    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(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 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;
+        } });
 };
 
-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 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,
 };
 
 const constructChannelObject = (channel) => {
@@ -10249,38 +10787,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
@@ -10894,68 +11400,16 @@ 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"]);
         const options = token ? { token } : { limit };
         const client = getActiveClient();
         const path = client.userId === userId ? `/api/v4/me/followers` : `/api/v4/users/${userId}/followers`;
-        const { data: queryResponse } = await this.http.get(path, {
-            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
-        });
-        return queryResponse;
-    }
-}
-
-class QueryStreamController {
-    constructor(query, cacheKey) {
-        this.query = query;
-        this.cacheKey = cacheKey;
+        const { data: queryResponse } = await this.http.get(path, {
+            params: Object.assign(Object.assign({}, params), { options, isDeleted: false }),
+        });
+        return queryResponse;
     }
 }
 
@@ -11026,109 +11480,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) => {
@@ -18727,12 +19078,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();
@@ -18819,7 +19173,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}
@@ -18903,7 +19257,7 @@ getCommunity$1.locally = (communityId) => {
     if (!cached)
         return;
     return {
-        data: cached.data,
+        data: LinkedObject.community(cached.data),
         cachedAt: cached.cachedAt,
     };
 };
@@ -26628,34 +26982,204 @@ var index$1 = /*#__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;
+    }
+}
+
 /**
- * ```js
- * import { onLocalInvitationCreated } from '@amityco/ts-sdk'
- * const dispose = onLocalInvitationCreated(data => {
- *   // ...
- * })
- * ```
+ * Get my community invitations
  *
- * Fired when an {@link Amity.InvitationPayload} has been created
+ * @param params the query parameters
+ * @param callback the callback to be called when the invitations are fetched
+ * @returns invitations
  *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
+ * @category My Community Invitations Live Collection
  *
- * @category Invitation Events
  */
-const onLocalInvitationCreated = (callback) => {
-    const client = getActiveClient();
-    const disposers = [
-        createEventSubscriber(client, 'onLocalInvitationCreated', 'local.invitation.created', payload => callback(payload)),
-    ];
+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
+  onLocalInvitationCreated: onLocalInvitationCreated,
+  onLocalInvitationUpdated: onLocalInvitationUpdated,
+  onLocalInvitationDeleted: onLocalInvitationDeleted,
+  getMyCommunityInvitations: getMyCommunityInvitations
 });
 
 exports.API_REGIONS = API_REGIONS;