@amityco/ts-sdk-react-native 7.23.1-c573a00.0 → 7.24.1-c018455.0

package/dist/index.esm.js

@@ -300,8 +300,8 @@ var NotificationRolesFilterTypeEnum;
 
 function getVersion() {
     try {
-        // the string ''v7.23.0-esm'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.23.0-esm';
+        // the string ''v7.24.0-esm'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.24.0-esm';
     }
     catch (error) {
         return '__dev__';
@@ -29564,562 +29564,571 @@ var index$r = /*#__PURE__*/Object.freeze({
     getMyFollowInfo: getMyFollowInfo
 });
 
-class StoryComputedValue {
-    constructor(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt) {
-        this._syncingStoriesCount = 0;
-        this._errorStoriesCount = 0;
-        this._targetId = targetId;
-        this._lastStoryExpiresAt = lastStoryExpiresAt;
-        this._lastStorySeenExpiresAt = lastStorySeenExpiresAt;
-        this.cacheStoryExpireTime = pullFromCache([
-            "story-expire" /* STORY_KEY_CACHE.EXPIRE */,
-            this._targetId,
-        ]);
-        this.cacheStoreSeenTime = pullFromCache([
-            "story-last-seen" /* STORY_KEY_CACHE.LAST_SEEN */,
-            this._targetId,
-        ]);
-        this.getTotalStoryByStatus();
-    }
-    get lastStoryExpiresAt() {
-        return this._lastStoryExpiresAt ? new Date(this._lastStoryExpiresAt).getTime() : 0;
-    }
-    get lastStorySeenExpiresAt() {
-        return this._lastStorySeenExpiresAt ? new Date(this._lastStorySeenExpiresAt).getTime() : 0;
-    }
-    get localLastStoryExpires() {
-        var _a, _b;
-        return ((_a = this.cacheStoryExpireTime) === null || _a === void 0 ? void 0 : _a.data)
-            ? new Date((_b = this.cacheStoryExpireTime) === null || _b === void 0 ? void 0 : _b.data).getTime()
-            : 0;
-    }
-    get localLastStorySeenExpiresAt() {
-        var _a, _b;
-        return ((_a = this.cacheStoreSeenTime) === null || _a === void 0 ? void 0 : _a.data) ? new Date((_b = this.cacheStoreSeenTime) === null || _b === void 0 ? void 0 : _b.data).getTime() : 0;
-    }
-    get isContainUnSyncedStory() {
-        const currentSyncingState = pullFromCache([
-            "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
-            this._targetId,
-        ]);
-        if (!(currentSyncingState === null || currentSyncingState === void 0 ? void 0 : currentSyncingState.data))
-            return false;
-        return ["syncing" /* Amity.SyncState.Syncing */, "error" /* Amity.SyncState.Error */].includes(currentSyncingState.data);
-    }
-    getLocalLastSortingDate() {
-        if (this.isContainUnSyncedStory) {
-            return this.localLastStoryExpires;
-        }
-        return this.lastStoryExpiresAt;
-    }
-    getHasUnseenFlag() {
-        const now = new Date().getTime();
-        const highestSeen = Math.max(this.lastStorySeenExpiresAt, this.localLastStorySeenExpiresAt);
-        pullFromCache([
-            "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
-            this._targetId,
+/*
+ * verifies membership status
+ */
+function isMember(membership) {
+    return membership !== 'none';
+}
+/*
+ * checks if currently logged in user is part of the community
+ */
+function isCurrentUserPartOfCommunity(c, m) {
+    const { userId } = getActiveUser();
+    return c.communityId === m.communityId && m.userId === userId;
+}
+/*
+ * For mqtt events server will not send user specific data as it's broadcasted
+ * to multiple users and it also does not include communityUser
+ *
+ * Client SDK needs to check for the existing isJoined field in cache data before calculating.
+ * Althought this can be calculated, it's not scalable.
+ */
+function updateMembershipStatus(communities, communityUsers) {
+    return communities.map(c => {
+        const cachedCommunity = pullFromCache([
+            'community',
+            'get',
+            c.communityId,
         ]);
-        if (this.isContainUnSyncedStory) {
-            return this.localLastStoryExpires > now && this.localLastStoryExpires > highestSeen;
-        }
-        return this.lastStoryExpiresAt > now && this.lastStoryExpiresAt > highestSeen;
-    }
-    getTotalStoryByStatus() {
-        const stories = queryCache(["story" /* STORY_KEY_CACHE.STORY */, 'get']);
-        if (!stories) {
-            this._errorStoriesCount = 0;
-            this._syncingStoriesCount = 0;
-            return;
+        if ((cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data) && (cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data.hasOwnProperty('isJoined'))) {
+            return Object.assign(Object.assign({}, cachedCommunity.data), c);
         }
-        const groupByType = stories.reduce((acc, story) => {
-            const { data: { targetId, syncState, isDeleted }, } = story;
-            if (targetId === this._targetId && !isDeleted) {
-                acc[syncState] += 1;
-            }
-            return acc;
-        }, {
-            syncing: 0,
-            error: 0,
-            synced: 0,
+        const isJoined = c.isJoined !== undefined
+            ? c.isJoined
+            : communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
+        return Object.assign(Object.assign({}, c), { isJoined });
+    });
+}
+
+const getMatchPostSetting = (value) => {
+    var _a;
+    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
+};
+function addPostSetting({ communities }) {
+    return communities.map((_a) => {
+        var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
+        return (Object.assign({ postSetting: getMatchPostSetting({
+                needApprovalOnPostCreation,
+                onlyAdminCanPost,
+            }) }, restCommunityPayload));
+    });
+}
+const prepareCommunityPayload = (rawPayload) => {
+    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+    // Convert users to internal format
+    const internalUsers = rawPayload.users.map(convertRawUserToInternalUser);
+    // map users with community
+    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
+        const user = internalUsers.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareCommunityJoinRequestPayload = (rawPayload) => {
+    const mappedJoinRequests = rawPayload.joinRequests.map(joinRequest => {
+        return Object.assign(Object.assign({}, joinRequest), { joinRequestId: joinRequest._id });
+    });
+    const users = rawPayload.users.map(convertRawUserToInternalUser);
+    return Object.assign(Object.assign({}, rawPayload), { joinRequests: mappedJoinRequests, users });
+};
+const prepareCommunityMembershipPayload = (rawPayload) => {
+    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
+    // map users with community
+    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
+        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
+        return Object.assign(Object.assign({}, communityUser), { user });
+    });
+    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
+    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
+};
+const prepareCommunityRequest = (params) => {
+    const { postSetting = undefined, storySetting } = params, restParam = __rest(params, ["postSetting", "storySetting"]);
+    return Object.assign(Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)), { 
+        // Convert story setting to the actual value. (Allow by default)
+        allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
+};
+const prepareSemanticSearchCommunityPayload = (_a) => {
+    var communityPayload = __rest(_a, ["searchResult"]);
+    const processedCommunityPayload = prepareCommunityPayload(communityPayload);
+    return Object.assign({}, processedCommunityPayload);
+};
+
+/* begin_public_function
+  id: joinRequest.approve
+*/
+/**
+ * ```js
+ * import { joinRequest } from '@amityco/ts-sdk-react-native'
+ * const isAccepted = await joinRequest.approve()
+ * ```
+ *
+ * Accepts a {@link Amity.JoinRequest} object
+ *
+ * @param joinRequest the {@link Amity.JoinRequest} to accept
+ * @returns A success boolean if the {@link Amity.JoinRequest} was accepted
+ *
+ * @category Join Request API
+ * @async
+ */
+const approveJoinRequest = async (joinRequest) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('joinRequest/approveJoinRequest', joinRequest.joinRequestId);
+    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/approve`, {
+        userId: joinRequest.requestorInternalId,
+    });
+    const joinRequestCache = (_a = pullFromCache([
+        'joinRequest',
+        'get',
+        joinRequest.joinRequestId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (joinRequestCache) {
+        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+            status: "approved" /* JoinRequestStatusEnum.Approved */,
         });
-        this._errorStoriesCount = groupByType.error;
-        this._syncingStoriesCount = groupByType.syncing;
-    }
-    get syncingStoriesCount() {
-        return this._syncingStoriesCount;
-    }
-    get failedStoriesCount() {
-        return this._errorStoriesCount;
+        fireEvent('local.joinRequest.updated', [joinRequestCache]);
     }
-}
+    return data.success;
+};
+/* end_public_function */
 
-const storyTargetLinkedObject = (storyTarget) => {
-    const { targetType, targetId, lastStoryExpiresAt, lastStorySeenExpiresAt, targetUpdatedAt, localFilter, } = storyTarget;
-    const computedValue = new StoryComputedValue(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt);
-    return {
-        targetType,
-        targetId,
-        lastStoryExpiresAt,
-        updatedAt: targetUpdatedAt,
-        // Additional data
-        hasUnseen: computedValue.getHasUnseenFlag(),
-        syncingStoriesCount: computedValue.syncingStoriesCount,
-        failedStoriesCount: computedValue.failedStoriesCount,
-        localFilter,
-        localLastExpires: computedValue.localLastStoryExpires,
-        localLastSeen: computedValue.localLastStorySeenExpiresAt,
-        localSortingDate: computedValue.getLocalLastSortingDate(),
-    };
+/* begin_public_function
+  id: joinRequest.cancel
+*/
+/**
+ * ```js
+ * import { joinRequest } from '@amityco/ts-sdk-react-native'
+ * const isCanceled = await joinRequest.cancel()
+ * ```
+ *
+ * Cancels a {@link Amity.JoinRequest} object
+ *
+ * @param joinRequest the {@link Amity.JoinRequest} to cancel
+ * @returns A success boolean if the {@link Amity.JoinRequest} was canceled
+ *
+ * @category Join Request API
+ * @async
+ */
+const cancelJoinRequest = async (joinRequest) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('joinRequest/cancelJoinRequest', joinRequest.joinRequestId);
+    const { data } = await client.http.delete(`/api/v4/communities/${joinRequest.targetId}/join`);
+    const joinRequestCache = (_a = pullFromCache([
+        'joinRequest',
+        'get',
+        joinRequest.joinRequestId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (joinRequestCache) {
+        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+            status: "cancelled" /* JoinRequestStatusEnum.Cancelled */,
+        });
+        fireEvent('local.joinRequest.deleted', [joinRequestCache]);
+    }
+    return data.success;
 };
+/* end_public_function */
 
-const storyLinkedObject = (story) => {
-    const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
-    const storyTargetCache = pullFromCache([
-        "storyTarget" /* STORY_KEY_CACHE.STORY_TARGET */,
+/* begin_public_function
+  id: joinRequest.reject
+*/
+/**
+ * ```js
+ * import { joinRequest } from '@amityco/ts-sdk-react-native'
+ * const isRejected = await joinRequest.reject()
+ * ```
+ *
+ * Rejects a {@link Amity.JoinRequest} object
+ *
+ * @param joinRequest the {@link Amity.JoinRequest} to reject
+ * @returns A success boolean if the {@link Amity.JoinRequest} was rejected
+ *
+ * @category Join Request API
+ * @async
+ */
+const rejectJoinRequest = async (joinRequest) => {
+    var _a;
+    const client = getActiveClient();
+    client.log('joinRequest/rejectJoinRequest', joinRequest.joinRequestId);
+    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/reject`, {
+        userId: joinRequest.requestorInternalId,
+    });
+    const joinRequestCache = (_a = pullFromCache([
+        'joinRequest',
         'get',
-        story.targetId,
-    ]);
-    const communityCacheData = pullFromCache(['community', 'get', story.targetId]);
-    return Object.assign(Object.assign({}, story), { analytics: {
-            markAsSeen: () => {
-                if (!story.expiresAt)
-                    return;
-                if (story.syncState !== "synced" /* Amity.SyncState.Synced */)
-                    return;
-                analyticsEngineInstance.markStoryAsViewed(story);
-            },
-            markLinkAsClicked: () => {
-                if (!story.expiresAt)
-                    return;
-                if (story.syncState !== "synced" /* Amity.SyncState.Synced */)
-                    return;
-                analyticsEngineInstance.markStoryAsClicked(story);
-            },
-        }, get videoData() {
-            var _a, _b;
-            const cache = pullFromCache([
-                'file',
-                'get',
-                (_b = (_a = story.data) === null || _a === void 0 ? void 0 : _a.videoFileId) === null || _b === void 0 ? void 0 : _b.original,
-            ]);
-            if (!cache)
-                return undefined;
-            const { data } = cache;
-            return data || undefined;
-        },
-        get imageData() {
-            var _a, _b;
-            if (!((_a = story.data) === null || _a === void 0 ? void 0 : _a.fileId))
-                return undefined;
-            const cache = pullFromCache(['file', 'get', (_b = story.data) === null || _b === void 0 ? void 0 : _b.fileId]);
-            if (!cache)
-                return undefined;
-            const { data } = cache;
-            if (!data)
-                return undefined;
-            return Object.assign(Object.assign({}, data), { fileUrl: `${data.fileUrl}?size=full` });
-        },
-        get community() {
-            if (story.targetType !== 'community')
-                return undefined;
-            if (!communityCacheData)
-                return undefined;
-            return (communityCacheData === null || communityCacheData === void 0 ? void 0 : communityCacheData.data) || undefined;
-        },
-        get communityCategories() {
-            if (story.targetType !== 'community')
-                return undefined;
-            if (!communityCacheData)
-                return undefined;
-            const { data: { categoryIds }, } = communityCacheData;
-            if (categoryIds.length === 0)
+        joinRequest.joinRequestId,
+    ])) === null || _a === void 0 ? void 0 : _a.data;
+    if (joinRequestCache) {
+        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
+            status: "rejected" /* JoinRequestStatusEnum.Rejected */,
+        });
+        fireEvent('local.joinRequest.updated', [joinRequestCache]);
+    }
+    return data.success;
+};
+/* end_public_function */
+
+const joinRequestLinkedObject = (joinRequest) => {
+    return Object.assign(Object.assign({}, joinRequest), { get user() {
+            var _a;
+            const user = (_a = pullFromCache([
+                'user',
+                'get',
+                joinRequest.requestorPublicId,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            if (!user)
                 return undefined;
-            return categoryIds
-                .map(categoryId => {
-                const categoryCacheData = pullFromCache(['category', 'get', categoryId]);
-                return (categoryCacheData === null || categoryCacheData === void 0 ? void 0 : categoryCacheData.data) || undefined;
-            })
-                .filter(category => category !== undefined);
-        },
-        get creator() {
-            const cacheData = pullFromCache(['user', 'get', story.creatorPublicId]);
-            if (!(cacheData === null || cacheData === void 0 ? void 0 : cacheData.data))
-                return;
-            return userLinkedObject(cacheData.data);
-        },
-        get storyTarget() {
-            if (!(storyTargetCache === null || storyTargetCache === void 0 ? void 0 : storyTargetCache.data))
-                return;
-            return storyTargetLinkedObject(storyTargetCache.data);
-        },
-        get isSeen() {
-            const cacheData = pullFromCache(["story-last-seen" /* STORY_KEY_CACHE.LAST_SEEN */, story.targetId]);
-            if (!(storyTargetCache === null || storyTargetCache === void 0 ? void 0 : storyTargetCache.data))
-                return false;
-            const localLastSeen = (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data) ? new Date(cacheData.data).getTime() : 0;
-            const serverLastSeen = new Date(storyTargetCache === null || storyTargetCache === void 0 ? void 0 : storyTargetCache.data.lastStorySeenExpiresAt).getTime() || 0;
-            const expiresAt = new Date(story.expiresAt).getTime();
-            return Math.max(localLastSeen, serverLastSeen) >= expiresAt;
+            return userLinkedObject(user);
+        }, cancel: async () => {
+            await cancelJoinRequest(joinRequest);
+        }, approve: async () => {
+            await approveJoinRequest(joinRequest);
+        }, reject: async () => {
+            await rejectJoinRequest(joinRequest);
         } });
 };
 
 /* begin_public_function
-  id: channel.create
+  id: community.getMyJoinRequest
 */
 /**
  * ```js
- * import { createChannel } from '@amityco/ts-sdk-react-native'
- * const created = await createChannel({ displayName: 'foobar' })
+ * import { community } from '@amityco/ts-sdk-react-native'
+ * const isJoined = await community.getMyJoinRequest('foobar')
  * ```
  *
- * Creates an {@link Amity.Channel}
+ * Joins a {@link Amity.Community} object
  *
- * @param bundle The data necessary to create a new {@link Amity.Channel}
- * @returns The newly created {@link Amity.Channel}
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A success boolean if the {@link Amity.Community} was joined
  *
- * @category Channel API
+ * @category Community API
  * @async
  */
-const createChannel = async (bundle) => {
+const getMyJoinRequest = async (communityId) => {
     const client = getActiveClient();
-    client.log('user/createChannel', bundle);
-    let payload;
-    /* c8 ignore next */
-    if ((bundle === null || bundle === void 0 ? void 0 : bundle.type) === 'conversation') {
-        payload = await client.http.post('/api/v3/channels/conversation', Object.assign(Object.assign({}, bundle), { isDistinct: true }));
-    }
-    else {
-        const { isPublic } = bundle, restParams = __rest(bundle, ["isPublic"]);
-        payload = await client.http.post('/api/v3/channels', Object.assign(Object.assign({}, restParams), { 
-            /* c8 ignore next */
-            isPublic: (bundle === null || bundle === void 0 ? void 0 : bundle.type) === 'community' ? isPublic : undefined }));
-    }
-    const data = await prepareChannelPayload(payload.data);
+    client.log('community/myJoinRequest', communityId);
+    const { data: payload } = await client.http.get(`/api/v4/communities/${communityId}/join/me`);
+    const data = prepareCommunityJoinRequestPayload(payload);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    const { channels } = data;
     return {
-        data: constructChannelObject(channels[0]),
+        data: data.joinRequests[0] ? joinRequestLinkedObject(data.joinRequests[0]) : undefined,
         cachedAt,
     };
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: community.join
+*/
 /**
  * ```js
- * import { getChannel } from '@amityco/ts-sdk-react-native'
- * const channel = await getChannel('foobar')
+ * import { community } from '@amityco/ts-sdk-react-native'
+ * const isJoined = await community.join('foobar')
  * ```
  *
- * Fetches a {@link Amity.Channel} object
+ * Joins a {@link Amity.Community} object
  *
- * @param channelId the ID of the {@link Amity.Channel} to fetch
- * @returns the associated {@link Amity.Channel} object
+ * @param communityId the {@link Amity.Community} to join
+ * @returns A status join result
  *
- * @category Channel API
+ * @category Community API
  * @async
  */
-const getChannel$1 = async (channelId) => {
+const joinRequest = async (communityId) => {
+    var _a;
     const client = getActiveClient();
-    client.log('channel/getChannel', channelId);
-    isInTombstone('channel', channelId);
-    let data;
-    try {
-        const { data: payload } = await client.http.get(`/api/v3/channels/${encodeURIComponent(channelId)}`);
-        data = await prepareChannelPayload(payload);
-        if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-            prepareUnreadCountInfo(payload);
+    client.log('community/joinRequest', communityId);
+    const { data: payload } = await client.http.post(`/api/v4/communities/${communityId}/join`);
+    const data = prepareCommunityJoinRequestPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const status = data.joinRequests[0].status === "approved" /* JoinRequestStatusEnum.Approved */
+        ? "success" /* JoinResultStatusEnum.Success */
+        : "pending" /* JoinResultStatusEnum.Pending */;
+    if (status === "success" /* JoinResultStatusEnum.Success */ && client.cache) {
+        const community = (_a = pullFromCache(['community', 'get', communityId])) === null || _a === void 0 ? void 0 : _a.data;
+        if (community) {
+            const updatedCommunity = Object.assign(Object.assign({}, community), { isJoined: true });
+            upsertInCache(['community', 'get', communityId], updatedCommunity);
         }
     }
-    catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
-            // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
-            pushToTombstone('channel', channelId);
+    fireEvent('v4.local.community.joined', data.joinRequests);
+    return status === "success" /* JoinResultStatusEnum.Success */
+        ? { status }
+        : { status, request: joinRequestLinkedObject(data.joinRequests[0]) };
+};
+/* end_public_function */
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+class JoinRequestsPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = 20, communityId } = queryParams, params = __rest(queryParams, ["limit", "communityId"]);
+        const options = token ? { token } : { limit };
+        const { data: queryResponse } = await this.http.get(`/api/v4/communities/${communityId}/join`, {
+            params: Object.assign(Object.assign({}, params), { options }),
+        });
+        return queryResponse;
+    }
+}
+
+var EnumJoinRequestAction$1;
+(function (EnumJoinRequestAction) {
+    EnumJoinRequestAction["OnLocalJoinRequestCreated"] = "OnLocalJoinRequestCreated";
+    EnumJoinRequestAction["OnLocalJoinRequestUpdated"] = "OnLocalJoinRequestUpdated";
+    EnumJoinRequestAction["OnLocalJoinRequestDeleted"] = "OnLocalJoinRequestDeleted";
+})(EnumJoinRequestAction$1 || (EnumJoinRequestAction$1 = {}));
+
+class JoinRequestsQueryStreamController 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 });
         }
-        throw error;
     }
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const { channels } = data;
-    return {
-        data: channels.find(channel => channel.channelId === channelId),
-        cachedAt,
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const joinRequests = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [
+                    ...new Set([
+                        ...joinRequests,
+                        ...response.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
+                    ]),
+                ] }));
+        }
+    }
+    reactor(action) {
+        return (joinRequest) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection)
+                return;
+            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestUpdated) {
+                const isExist = collection.data.find(id => id === joinRequest[0].joinRequestId);
+                if (!isExist)
+                    return;
+            }
+            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestCreated) {
+                collection.data = [
+                    ...new Set([
+                        ...joinRequest.map(joinRequest => joinRequest.joinRequestId),
+                        ...collection.data,
+                    ]),
+                ];
+            }
+            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestDeleted) {
+                collection.data = collection.data.filter(id => id !== joinRequest[0].joinRequestId);
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+/**
+ * ```js
+ * import { onJoinRequestCreated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onJoinRequestCreated(data => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category JoinRequest Events
+ */
+const onJoinRequestCreated = (callback) => {
+    const client = getActiveClient();
+    const disposers = [
+        createEventSubscriber(client, 'onJoinRequestCreated', 'local.joinRequest.created', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
     };
 };
+
 /**
- * ```js
- * import { getChannel } from '@amityco/ts-sdk-react-native'
- * const channel = getChannel.locally('foobar')
+ * ```js
+ * import { onJoinRequestUpdated } from '@amityco/ts-sdk-react-native'
+ * const dispose = onJoinRequestUpdated(data => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a {@link Amity.Channel} object from cache
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
  *
- * @param channelId the ID of the {@link Amity.Channel} to fetch
- * @returns the associated {@link Amity.Channel} object
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Channel API
+ * @category JoinRequest Events
  */
-getChannel$1.locally = (channelId) => {
-    var _a;
+const onJoinRequestUpdated = (callback) => {
     const client = getActiveClient();
-    client.log('channel/getChannel.locally', channelId);
-    if (!client.cache)
-        return;
-    // use queryCache to get all channel caches and filter by channelPublicId since we use channelPrivateId as cache key
-    const cached = (_a = queryCache(['channel', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
-        return data.channelPublicId === channelId;
-    });
-    if (!cached || (cached === null || cached === void 0 ? void 0 : cached.length) === 0)
-        return;
-    return {
-        data: cached[0].data,
-        cachedAt: cached[0].cachedAt,
+    const disposers = [
+        createEventSubscriber(client, 'onJoinRequestUpdated', 'local.joinRequest.updated', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
     };
 };
 
 /**
  * ```js
- * import { getStream } from '@amityco/ts-sdk-react-native'
- * const stream = await getStream('foobar')
+ * import { onJoinRequestDeleted } from '@amityco/ts-sdk-react-native'
+ * const dispose = onJoinRequestDeleted(data => {
+ *   // ...
+ * })
  * ```
  *
- * Fetches a {@link Amity.Channel} object linked with a current stream
+ * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
  *
- * @param stream {@link Amity.Stream} that has linked live channel
- * @returns the associated {@link Amity.Channel<'live'>} object
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Stream API
- * @async
+ * @category JoinRequest Events
  */
-const getLiveChat$1 = async (stream) => {
-    var _a;
+const onJoinRequestDeleted = (callback) => {
     const client = getActiveClient();
-    client.log('stream/getLiveChat', stream.streamId);
-    if (stream.channelId) {
-        const channel = (_a = pullFromCache([
-            'channel',
-            'get',
-            stream.channelId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (channel)
-            return channelLinkedObject(constructChannelObject(channel));
-        const { data } = await getChannel$1(stream.channelId);
-        return channelLinkedObject(constructChannelObject(data));
-    }
-    // No Channel ID
-    // streamer: create a new live channel
-    if (stream.userId === client.userId) {
-        const { data: channel } = await createChannel({
-            type: 'live',
-            postId: stream.postId,
-            videoStreamId: stream.streamId,
-        });
-        // Update channelId to stream object in cache
-        mergeInCache(['stream', 'get', stream.streamId], {
-            channelId: channel.channelId,
-        });
-        return channel;
-    }
-    // watcher: return undefined
-    return undefined;
-};
-
-const GET_WATCHER_URLS = Symbol('getWatcherUrls');
-const streamLinkedObject = (stream) => {
-    return Object.assign(Object.assign({}, stream), { get moderation() {
-            var _a;
-            return (_a = pullFromCache(['streamModeration', 'get', stream.streamId])) === null || _a === void 0 ? void 0 : _a.data;
-        },
-        get post() {
-            var _a;
-            if (stream.referenceType !== 'post')
-                return;
-            return (_a = pullFromCache(['post', 'get', stream.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
-        },
-        get community() {
-            var _a;
-            if (stream.targetType !== 'community')
-                return;
-            return (_a = pullFromCache(['community', 'get', stream.targetId])) === null || _a === void 0 ? void 0 : _a.data;
-        },
-        get user() {
-            var _a;
-            return (_a = pullFromCache(['user', 'get', stream.userId])) === null || _a === void 0 ? void 0 : _a.data;
-        },
-        get childStreams() {
-            if (!stream.childStreamIds || stream.childStreamIds.length === 0)
-                return [];
-            return stream.childStreamIds
-                .map(id => {
-                var _a;
-                const streamCache = (_a = pullFromCache(['stream', 'get', id])) === null || _a === void 0 ? void 0 : _a.data;
-                if (!streamCache)
-                    return undefined;
-                return streamLinkedObject(streamCache);
-            })
-                .filter(isNonNullable);
-        }, getLiveChat: () => getLiveChat$1(stream), isBanned: !stream.watcherUrl, watcherUrl: null, get [GET_WATCHER_URLS]() {
-            return stream.watcherUrl;
-        } });
-};
-
-const categoryLinkedObject = (category) => {
-    return Object.assign(Object.assign({}, category), { get avatar() {
-            var _a;
-            if (!category.avatarFileId)
-                return undefined;
-            const avatar = (_a = pullFromCache([
-                'file',
-                'get',
-                `${category.avatarFileId}`,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
-            return avatar;
-        } });
-};
-
-const commentLinkedObject = (comment) => {
-    return Object.assign(Object.assign({}, comment), { get target() {
-            const commentTypes = {
-                type: comment.targetType,
-            };
-            if (comment.targetType === 'user') {
-                return Object.assign(Object.assign({}, commentTypes), { userId: comment.targetId });
-            }
-            if (commentTypes.type === 'content') {
-                return Object.assign(Object.assign({}, commentTypes), { contentId: comment.targetId });
-            }
-            if (commentTypes.type === 'community') {
-                const cacheData = pullFromCache([
-                    'communityUsers',
-                    'get',
-                    `${comment.targetId}#${comment.userId}`,
-                ]);
-                return Object.assign(Object.assign({}, commentTypes), { communityId: comment.targetId, creatorMember: cacheData === null || cacheData === void 0 ? void 0 : cacheData.data });
-            }
-            return {
-                type: 'unknown',
-            };
-        },
-        get creator() {
-            const cacheData = pullFromCache(['user', 'get', comment.userId]);
-            if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
-                return userLinkedObject(cacheData.data);
-            return undefined;
-        },
-        get childrenComment() {
-            return comment.children
-                .map(childCommentId => {
-                const commentCache = pullFromCache([
-                    'comment',
-                    'get',
-                    childCommentId,
-                ]);
-                if (!(commentCache === null || commentCache === void 0 ? void 0 : commentCache.data))
-                    return;
-                return commentCache === null || commentCache === void 0 ? void 0 : commentCache.data;
-            })
-                .filter(isNonNullable)
-                .map(item => commentLinkedObject(item));
-        } });
+    const disposers = [
+        createEventSubscriber(client, 'onJoinRequestDeleted', 'local.joinRequest.deleted', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
+    };
 };
 
-function isAmityImagePost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'fileId' in post.data &&
-        post.dataType === 'image');
-}
-function isAmityFilePost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'fileId' in post.data &&
-        post.dataType === 'file');
-}
-function isAmityVideoPost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'videoFileId' in post.data &&
-        'thumbnailFileId' in post.data &&
-        post.dataType === 'video');
-}
-function isAmityLivestreamPost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'streamId' in post.data &&
-        post.dataType === 'liveStream');
-}
-function isAmityPollPost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'pollId' in post.data &&
-        post.dataType === 'poll');
-}
-function isAmityClipPost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'fileId' in post.data &&
-        post.dataType === 'clip');
-}
-function isAmityAudioPost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'fileId' in post.data &&
-        post.dataType === 'audio');
-}
-function isAmityRoomPost(post) {
-    return !!(post.data &&
-        typeof post.data !== 'string' &&
-        'roomId' in post.data &&
-        post.dataType === 'room');
+class JoinRequestsLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(query);
+        const cacheKey = ['joinRequest', 'collection', queryStreamId];
+        const paginationController = new JoinRequestsPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new JoinRequestsQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommunityJoinRequestPayload);
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    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, }) {
+        const joinRequestResponse = response;
+        this.queryStreamController.appendToQueryStream(joinRequestResponse, direction, refresh);
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            { fn: onJoinRequestCreated, action: EnumJoinRequestAction$1.OnLocalJoinRequestCreated },
+            { fn: onJoinRequestUpdated, action: EnumJoinRequestAction$1.OnLocalJoinRequestUpdated },
+            { fn: onJoinRequestDeleted, action: EnumJoinRequestAction$1.OnLocalJoinRequestDeleted },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = this.applyFilter(collection.data
+            .map(id => pullFromCache(['joinRequest', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)
+            .map(joinRequestLinkedObject));
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    applyFilter(data) {
+        let joinRequest = data;
+        if (this.query.status) {
+            joinRequest = joinRequest.filter(joinRequest => joinRequest.status === this.query.status);
+        }
+        const sortFn = (() => {
+            switch (this.query.sortBy) {
+                case 'firstCreated':
+                    return sortByFirstCreated;
+                case 'lastCreated':
+                    return sortByLastCreated;
+                default:
+                    return sortByLastCreated;
+            }
+        })();
+        joinRequest = joinRequest.sort(sortFn);
+        return joinRequest;
+    }
 }
 
 /**
- * ```js
- * import { RoomRepository } from '@amityco/ts-sdk-react-native'
- * const stream = await getStream('foobar')
- * ```
+ * Get Join Requests
  *
- * Fetches a {@link Amity.Channel} object linked with a current stream
+ * @param params the query parameters
+ * @param callback the callback to be called when the join request are updated
+ * @returns joinRequests
  *
- * @param stream {@link Amity.Stream} that has linked live channel
- * @returns the associated {@link Amity.Channel<'live'>} object
+ * @category joinRequest Live Collection
  *
- * @category Stream API
- * @async
  */
-const getLiveChat = async (room) => {
-    var _a;
-    const client = getActiveClient();
-    client.log('room/getLiveChat', room.roomId);
-    if (room.liveChannelId) {
-        const channel = (_a = pullFromCache([
-            'channel',
-            'get',
-            room.liveChannelId,
-        ])) === null || _a === void 0 ? void 0 : _a.data;
-        if (channel)
-            return channelLinkedObject(constructChannelObject(channel));
-        const { data } = await getChannel$1(room.liveChannelId);
-        return channelLinkedObject(constructChannelObject(data));
-    }
-    // No Channel ID
-    // streamer: create a new live channel
-    if (room.createdBy === client.userId) {
-        const { data: channel } = await createChannel({
-            type: 'live',
-            postId: room.referenceId,
-            roomId: room.roomId,
-        });
-        // Update channelId to stream object in cache
-        mergeInCache(['room', 'get', room.roomId], {
-            liveChannelId: channel.channelId,
-        });
-        return channel;
+const getJoinRequests = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
     }
-    // watcher: return undefined
-    return undefined;
+    const timestamp = Date.now();
+    log(`getJoinRequests: (tmpid: ${timestamp}) > listen`);
+    const joinRequestLiveCollection = new JoinRequestsLiveCollectionController(params, callback);
+    const disposers = joinRequestLiveCollection.startSubscription();
+    const cacheKey = joinRequestLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getJoinRequests (tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
 };
 
 const convertRawInvitationToInternalInvitation = (rawInvitation) => {
@@ -30274,1391 +30283,1382 @@ const invitationLinkedObject = (invitation) => {
         } });
 };
 
-/* begin_public_function
-  id: invitation.get
-*/
+/* begin_public_function
+  id: invitation.get
+*/
+/**
+ * ```js
+ * import { getInvitation } from '@amityco/ts-sdk-react-native'
+ * const { invitation } = await getInvitation(targetType, targetId)
+ * ```
+ *
+ * Get a {@link Amity.Invitation} object
+ *
+ * @param targetType The type of the target of the {@link Amity.Invitation}
+ * @param targetId The ID of the target of the {@link Amity.Invitation}
+ * @returns A {@link Amity.Invitation} object
+ *
+ * @category Invitation API
+ * @async
+ */
+const getInvitation = async (params) => {
+    const client = getActiveClient();
+    client.log('invitation/getInvitation', params.targetType, params.targetId, params.type);
+    const { data: payload } = await client.http.get(`/api/v1/invitations/me`, { params });
+    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["OnLocalInvitationCanceled"] = "onLocalInvitationCanceled";
+})(InvitationActionsEnum || (InvitationActionsEnum = {}));
+
+class InvitationsPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
+        const options = token ? { token } : { limit };
+        const { data } = await this.http.get('/api/v1/invitations', { params: Object.assign(Object.assign({}, params), { options }) });
+        return data;
+    }
+}
+
+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 });
+        }
+    }
+    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) {
+                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)));
+    }
+}
+
+/**
+ * ```js
+ * import { onLocalInvitationCreated } from '@amityco/ts-sdk-react-native'
+ * 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());
+    };
+};
+
+/**
+ * ```js
+ * import { onLocalInvitationUpdated } from '@amityco/ts-sdk-react-native'
+ * 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());
+    };
+};
+
 /**
  * ```js
- * import { getInvitation } from '@amityco/ts-sdk-react-native'
- * const { invitation } = await getInvitation(targetType, targetId)
+ * import { onLocalInvitationCanceled } from '@amityco/ts-sdk-react-native'
+ * const dispose = onLocalInvitationCanceled(data => {
+ *   // ...
+ * })
  * ```
  *
- * Get a {@link Amity.Invitation} object
+ * Fired when an {@link Amity.InvitationPayload} has been deleted
  *
- * @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
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
- * @category Invitation API
- * @async
+ * @category Invitation Events
  */
-const getInvitation = async (params) => {
+const onLocalInvitationCanceled = (callback) => {
     const client = getActiveClient();
-    client.log('invitation/getInvitation', params.targetType, params.targetId, params.type);
-    const { data: payload } = await client.http.get(`/api/v1/invitations/me`, { params });
-    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,
+    const disposers = [
+        createEventSubscriber(client, 'onLocalInvitationCanceled', 'local.invitation.canceled', payload => callback(payload)),
+    ];
+    return () => {
+        disposers.forEach(fn => fn());
     };
 };
-/* end_public_function */
 
-/**
- * WatchSessionStorage manages watch session data in memory
- * Similar to UsageCollector for stream watch minutes
- */
-class WatchSessionStorage {
-    constructor() {
-        this.sessions = new Map();
-    }
-    /**
-     * Add a new watch session
-     */
-    addSession(session) {
-        this.sessions.set(session.sessionId, session);
-    }
-    /**
-     * Get a watch session by sessionId
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
+class InvitationsLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash(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 });
     }
-    /**
-     * Update a watch session
-     */
-    updateSession(sessionId, updates) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            this.sessions.set(sessionId, Object.assign(Object.assign({}, session), updates));
+    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,
+            });
         }
     }
-    /**
-     * Get all sessions with a specific sync state
-     */
-    getSessionsByState(state) {
-        return Array.from(this.sessions.values()).filter(session => session.syncState === state);
-    }
-    /**
-     * Delete a session
-     */
-    deleteSession(sessionId) {
-        this.sessions.delete(sessionId);
-    }
-    /**
-     * Get all pending sessions
-     */
-    getPendingSessions() {
-        return this.getSessionsByState('PENDING');
-    }
-    /**
-     * Get all syncing sessions
-     */
-    getSyncingSessions() {
-        return this.getSessionsByState('SYNCING');
-    }
-}
-// Singleton instance
-let storageInstance = null;
-const getWatchSessionStorage = () => {
-    if (!storageInstance) {
-        storageInstance = new WatchSessionStorage();
-    }
-    return storageInstance;
-};
-
-const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDAARz+hmBgi8pJ\nQb8LeY41gtHhk+ACMwRfhsn7GqpqRQNG2qU0755mzZuVDUqjQMGSo8THJB7O+OJs\nflbZRkFXlFoFOVNw1UpNOgwEQZ6wB9oRwzepTJAfF1sVhm/o/ixvXh1zDFNDy6yZ\npXyiiJHUVxqyjllZhxnwdvjoVtDs6hW6awG09bB9nh/TTejlUKXoAgzqVwu/1QMu\nUVViET495elEe19aUarEy+oL2iKeXCEvqda/pWNBdbieFyJvvZ08HN8dPuT88wq2\njZLEAth1vrwQ2IAa4ktaLcBQdLJgIkrbDvAiVZ8lQAjS/bq5vXQikTGvoPlC5bbn\nvuOM/3eLAgMBAAECggEAVZ+peHAghq2QVj71nX5lxsNCKaCyYwixSJBpfouTt7Rz\nE6PpzMOXFi1W1o+I22jDakuSM2SOQKqI/u0QefB0r0O/KVk5NrZHXk0mkrdYtxOp\nUgaGyf8UvmjB+8VqHrNKyZdk9qtmbnNj01kTTcAtmE4H39zPR7eR/8Rul94vaZbs\nwCnKJS3mLT3JxyGug6lxanveKkjG+CKC1nJQYWaxCJxaFSzbwXQPvDhB+TvrIbee\npd5v4EAyEJohpr+T9oDGGJkb/KARBZCtwLyB976PKJwwBA8MRVL1i5QwawuMiMq5\nUtnOnbGKtCeFzaLbNU0Qi8bqyims84EQxC6DOu1fkQKBgQDdvsoBsEhsOXV7hlIJ\naEd0eSJZVkdqimxH8uGoMM2FeNaOrcB6yBXqTSP0R3OIyf8eaY6yjRvP30ZNXcll\n/gD3O1Mu6YmWQdt1W2WA6pKOsUuPXasf0pdOF7IiFZKlSabz5YHXFqwVuqm8loaj\nsXel3YWqPVdHiankE7tz+3ssnQKBgQDdqi4TNdD1MdEpihx19jr0QjUiXW3939FK\nqp30HESPEGDGQzXdmJgif9HhZb+cJSuWaHEbjgBrYahvgCF+y6LbEpOD+D/dmT+s\nDEAQaR84sah6dokwPjV8fjBSrcVFjCS+doxv0d3p/9OUEeyUhFrY03nxtIEYkLIE\n/Zvn37b4RwKBgQCLENVFe9XfsaVhQ5r9dV2iyTlmh7qgMZG5CbTFs12hQGhm8McO\n+Z7s41YSJCFr/yq1WwP4LJDtrBw99vyQr1zRsG35tNLp3gGRNzGQSQyC2uQFVHw2\np+7mNewsfhUK/gbrXNsyFnDz6635rPlhfbII3sWuP2wWXFqkxE9CbMwR7QKBgQC6\nawDMzxmo2/iYArrkyevSuEuPVxvFwpF1RgAI6C0QVCnPE38dmdN4UB7mfHekje4W\nVEercMURidPp0cxZolCYBQtilUjAyL0vqC3In1/Ogjq6oy3FEMxSop1pKxMY5j+Q\nnoqFD+6deLUrddeNH7J3X4LSr4dSbX4JjG+tlgt+yQKBgQCuwTL4hA6KqeInQ0Ta\n9VQX5Qr8hFlqJz1gpymi/k63tW/Ob8yedbg3WWNWyShwRMFYyY9S81ITFWM95uL6\nvF3x9rmRjwElJw9PMwVu6dmf/CO0Z1wzXSp2VVD12gbrUD/0/d7MUoJ9LgC8X8f/\nn0txLHYGHbx+nf95+JUg6lV3hg==\n-----END PRIVATE KEY-----";
-/*
- * The crypto algorithm used for importing key and signing string
- */
-const ALGORITHM = {
-    name: 'RSASSA-PKCS1-v1_5',
-    hash: { name: 'SHA-256' },
-};
-/*
- * IMPORTANT!
- * If you are recieving key from other platforms use an online tool to convert
- * the PKCS1 to PKCS8. For instance the key from Android SDK is of the format
- * PKCS1.
- *
- * If recieving from the platform, verify if it's already in the expected
- * format. Otherwise the crypto.subtle.importKey will throw a DOMException
- */
-const PRIVATE_KEY_SIGNATURE = 'pkcs8';
-/*
- * Ensure that the private key in the .env follows this format
- */
-const PEM_HEADER = '-----BEGIN PRIVATE KEY-----';
-const PEM_FOOTER = '-----END PRIVATE KEY-----';
-/*
- * The crypto.subtle.sign function returns an ArrayBuffer whereas the server
- * expects a base64 string. This util helps facilitate that process
- */
-function base64FromArrayBuffer(buffer) {
-    const uint8Array = new Uint8Array(buffer);
-    let binary = '';
-    uint8Array.forEach(byte => {
-        binary += String.fromCharCode(byte);
-    });
-    return btoa(binary);
-}
-/*
- * Encode ASN.1 length field
- */
-function encodeLength(length) {
-    if (length < 128) {
-        return new Uint8Array([length]);
+    async persistModel(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
     }
-    if (length < 256) {
-        return new Uint8Array([0x81, length]);
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
-    // eslint-disable-next-line no-bitwise
-    return new Uint8Array([0x82, (length >> 8) & 0xff, length & 0xff]);
-}
-/*
- * Convert PKCS1 private key to PKCS8 format
- * PKCS1 is RSA-specific format, PKCS8 is generic format that crypto.subtle requires
- * Android uses PKCS8EncodedKeySpec which expects PKCS8 format
- */
-function pkcs1ToPkcs8(pkcs1) {
-    // Algorithm identifier for RSA
-    const algorithmIdentifier = new Uint8Array([
-        0x30,
-        0x0d,
-        0x06,
-        0x09,
-        0x2a,
-        0x86,
-        0x48,
-        0x86,
-        0xf7,
-        0x0d,
-        0x01,
-        0x01,
-        0x01,
-        0x05,
-        0x00, // NULL
-    ]);
-    // Version (INTEGER 0)
-    const version = new Uint8Array([0x02, 0x01, 0x00]);
-    // OCTET STRING tag + length + pkcs1 data
-    const octetStringTag = 0x04;
-    const octetStringLength = encodeLength(pkcs1.length);
-    // Calculate total content length (version + algorithm + octet string)
-    const contentLength = version.length + algorithmIdentifier.length + 1 + octetStringLength.length + pkcs1.length;
-    // SEQUENCE tag + length
-    const sequenceTag = 0x30;
-    const sequenceLength = encodeLength(contentLength);
-    // Build the PKCS8 structure
-    const pkcs8 = new Uint8Array(1 + sequenceLength.length + contentLength);
-    let offset = 0;
-    pkcs8[offset] = sequenceTag;
-    offset += 1;
-    pkcs8.set(sequenceLength, offset);
-    offset += sequenceLength.length;
-    pkcs8.set(version, offset);
-    offset += version.length;
-    pkcs8.set(algorithmIdentifier, offset);
-    offset += algorithmIdentifier.length;
-    pkcs8[offset] = octetStringTag;
-    offset += 1;
-    pkcs8.set(octetStringLength, offset);
-    offset += octetStringLength.length;
-    pkcs8.set(pkcs1, offset);
-    return pkcs8;
-}
-async function importPrivateKey(keyString) {
-    // Remove PEM headers if present and any whitespace
-    let base64Key = keyString;
-    if (keyString.includes(PEM_HEADER)) {
-        base64Key = keyString
-            .substring(PEM_HEADER.length, keyString.length - PEM_FOOTER.length)
-            .replace(/\s/g, '');
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE([
+            {
+                fn: onLocalInvitationCreated,
+                action: InvitationActionsEnum.OnLocalInvitationCreated,
+            },
+            {
+                fn: onLocalInvitationUpdated,
+                action: InvitationActionsEnum.OnLocalInvitationUpdated,
+            },
+            {
+                fn: onLocalInvitationCanceled,
+                action: InvitationActionsEnum.OnLocalInvitationCanceled,
+            },
+        ]);
     }
-    else {
-        base64Key = keyString.replace(/\s/g, '');
+    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,
+        });
     }
-    // Base64 decode to get binary data
-    const binaryDerString = atob(base64Key);
-    // Convert to Uint8Array for manipulation
-    const pkcs1 = new Uint8Array(binaryDerString.length);
-    for (let i = 0; i < binaryDerString.length; i += 1) {
-        pkcs1[i] = binaryDerString.charCodeAt(i);
+    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;
     }
-    // Convert PKCS1 to PKCS8 (crypto.subtle requires PKCS8)
-    const pkcs8 = pkcs1ToPkcs8(pkcs1);
-    // Import the key
-    const key = await crypto.subtle.importKey(PRIVATE_KEY_SIGNATURE, pkcs8.buffer, ALGORITHM, false, ['sign']);
-    return key;
-}
-async function createSignature({ timestamp, rooms, }) {
-    const dataStr = rooms
-        .map(item => Object.keys(item)
-        .sort()
-        .map(key => `${key}=${item[key]}`)
-        .join('&'))
-        .join(';');
-    /*
-     * nonceStr needs to be unique for each request
-     */
-    const nonceStr = uuid$1.v4();
-    const signStr = `nonceStr=${nonceStr}&timestamp=${timestamp}&data=${dataStr}==`;
-    const encoder = new TextEncoder();
-    const data = encoder.encode(signStr);
-    const key = await importPrivateKey(privateKey);
-    const sign = await crypto.subtle.sign(ALGORITHM, key, data);
-    return { signature: base64FromArrayBuffer(sign), nonceStr };
 }
 
 /**
- * Sync pending watch sessions to backend
- * This function implements the full sync flow with network resilience
+ * Get invitations
+ *
+ * @param params the query parameters
+ * @param callback the callback to be called when the invitations are updated
+ * @returns invitations
+ *
+ * @category Invitation Live Collection
+ *
  */
-async function syncWatchSessions() {
-    const storage = getWatchSessionStorage();
-    // Get all pending sessions
-    const pendingSessions = storage.getPendingSessions();
-    if (pendingSessions.length === 0) {
-        return true;
+const getInvitations$1 = (params, callback, config) => {
+    const { log, cache } = getActiveClient();
+    if (!cache) {
+        console.log(ENABLE_CACHE_MESSAGE);
     }
-    try {
-        const timestamp = new Date().toISOString();
-        // Convert sessions to API format - always include all fields like syncUsage does
-        const rooms = pendingSessions.map(session => ({
-            sessionId: session.sessionId,
-            roomId: session.roomId,
-            watchSeconds: session.watchSeconds,
-            startTime: session.startTime.toISOString(),
-            endTime: session.endTime ? session.endTime.toISOString() : '',
-        }));
-        // Create signature (reuse from stream feature) - pass directly like syncUsage
-        const signatureData = await createSignature({
-            timestamp,
-            rooms,
-        });
-        if (!signatureData || !signatureData.signature) {
-            throw new Error('Signature is undefined');
-        }
-        // Update sync state to SYNCING
-        pendingSessions.forEach(session => {
-            storage.updateSession(session.sessionId, { syncState: 'SYNCING' });
-        });
-        const payload = {
-            signature: signatureData.signature,
-            nonceStr: signatureData.nonceStr,
-            timestamp,
-            rooms,
-        };
-        const client = getActiveClient();
-        // Send to backend
-        await client.http.post('/api/v3/user-event/room', payload);
-        // Success - update to SYNCED
-        pendingSessions.forEach(session => {
-            storage.updateSession(session.sessionId, {
-                syncState: 'SYNCED',
-                syncedAt: new Date(),
+    const timestamp = Date.now();
+    log(`getInvitations: (tmpid: ${timestamp}) > listen`);
+    const invitationsLiveCollection = new InvitationsLiveCollectionController(params, callback);
+    const disposers = invitationsLiveCollection.startSubscription();
+    const cacheKey = invitationsLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`getInvitations (tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+
+const categoryLinkedObject = (category) => {
+    return Object.assign(Object.assign({}, category), { get avatar() {
+            var _a;
+            if (!category.avatarFileId)
+                return undefined;
+            const avatar = (_a = pullFromCache([
+                'file',
+                'get',
+                `${category.avatarFileId}`,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            return avatar;
+        } });
+};
+
+const communityLinkedObject = (community) => {
+    return Object.assign(Object.assign({}, community), { get categories() {
+            var _a;
+            return ((_a = community === null || community === void 0 ? void 0 : community.categoryIds) !== null && _a !== void 0 ? _a : [])
+                .map(categoryId => {
+                const cacheData = pullFromCache(['category', 'get', categoryId]);
+                if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
+                    return categoryLinkedObject(cacheData.data);
+                return undefined;
+            })
+                .filter(category => !!category);
+        },
+        get avatar() {
+            var _a;
+            if (!community.avatarFileId)
+                return undefined;
+            const avatar = (_a = pullFromCache([
+                'file',
+                'get',
+                community.avatarFileId,
+            ])) === null || _a === void 0 ? void 0 : _a.data;
+            return avatar;
+        }, createInvitations: async (userIds) => {
+            await createInvitations({
+                type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */,
+                targetType: 'community',
+                targetId: community.communityId,
+                userIds,
             });
-        });
-        return true;
+        }, getMemberInvitations: (params, callback) => {
+            return getInvitations$1(Object.assign(Object.assign({}, params), { targetId: community.communityId, targetType: 'community', type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */ }), callback);
+        }, getInvitation: async () => {
+            const { data } = await getInvitation({
+                targetType: 'community',
+                targetId: community.communityId,
+            });
+            return data;
+        }, join: async () => joinRequest(community.communityId), getJoinRequests: (params, callback) => {
+            return getJoinRequests(Object.assign(Object.assign({}, params), { communityId: community.communityId }), callback);
+        }, getMyJoinRequest: async () => {
+            const { data } = await getMyJoinRequest(community.communityId);
+            return data;
+        } });
+};
+
+class StoryComputedValue {
+    constructor(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt) {
+        this._syncingStoriesCount = 0;
+        this._errorStoriesCount = 0;
+        this._targetId = targetId;
+        this._lastStoryExpiresAt = lastStoryExpiresAt;
+        this._lastStorySeenExpiresAt = lastStorySeenExpiresAt;
+        this.cacheStoryExpireTime = pullFromCache([
+            "story-expire" /* STORY_KEY_CACHE.EXPIRE */,
+            this._targetId,
+        ]);
+        this.cacheStoreSeenTime = pullFromCache([
+            "story-last-seen" /* STORY_KEY_CACHE.LAST_SEEN */,
+            this._targetId,
+        ]);
+        this.getTotalStoryByStatus();
     }
-    catch (err) {
-        console.error('[SDK syncWatchSessions] ERROR caught:', (err === null || err === void 0 ? void 0 : err.message) || err);
-        // Failure - update back to PENDING and increment retry count
-        pendingSessions.forEach(session => {
-            const currentSession = storage.getSession(session.sessionId);
-            if (currentSession) {
-                const newRetryCount = currentSession.retryCount + 1;
-                if (newRetryCount >= 3) {
-                    // Delete session if retry count exceeds 3
-                    storage.deleteSession(session.sessionId);
-                }
-                else {
-                    // Update to PENDING with incremented retry count
-                    storage.updateSession(session.sessionId, {
-                        syncState: 'PENDING',
-                        retryCount: newRetryCount,
-                    });
-                }
-            }
-        });
-        return false;
+    get lastStoryExpiresAt() {
+        return this._lastStoryExpiresAt ? new Date(this._lastStoryExpiresAt).getTime() : 0;
+    }
+    get lastStorySeenExpiresAt() {
+        return this._lastStorySeenExpiresAt ? new Date(this._lastStorySeenExpiresAt).getTime() : 0;
+    }
+    get localLastStoryExpires() {
+        var _a, _b;
+        return ((_a = this.cacheStoryExpireTime) === null || _a === void 0 ? void 0 : _a.data)
+            ? new Date((_b = this.cacheStoryExpireTime) === null || _b === void 0 ? void 0 : _b.data).getTime()
+            : 0;
+    }
+    get localLastStorySeenExpiresAt() {
+        var _a, _b;
+        return ((_a = this.cacheStoreSeenTime) === null || _a === void 0 ? void 0 : _a.data) ? new Date((_b = this.cacheStoreSeenTime) === null || _b === void 0 ? void 0 : _b.data).getTime() : 0;
+    }
+    get isContainUnSyncedStory() {
+        const currentSyncingState = pullFromCache([
+            "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
+            this._targetId,
+        ]);
+        if (!(currentSyncingState === null || currentSyncingState === void 0 ? void 0 : currentSyncingState.data))
+            return false;
+        return ["syncing" /* Amity.SyncState.Syncing */, "error" /* Amity.SyncState.Error */].includes(currentSyncingState.data);
     }
-}
-
-/**
- * Room statuses that are considered watchable
- */
-const WATCHABLE_ROOM_STATUSES = ['live', 'recorded'];
-/**
- * Generate a random jitter delay between 5 and 30 seconds
- */
-const getJitterDelay = () => {
-    const minDelay = 5000; // 5 seconds
-    const maxDelay = 30000; // 30 seconds
-    return Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
-};
-/**
- * Wait for network connection with timeout
- * @param maxWaitTime Maximum time to wait in milliseconds (default: 60000 = 60 seconds)
- * @returns Promise that resolves when network is available or timeout is reached
- */
-const waitForNetwork = (maxWaitTime = 60000) => {
-    return new Promise(resolve => {
-        // Simple check - if navigator.onLine is available, use it
-        // Otherwise, assume network is available
-        if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
-            resolve();
-            return;
+    getLocalLastSortingDate() {
+        if (this.isContainUnSyncedStory) {
+            return this.localLastStoryExpires;
         }
-        const startTime = Date.now();
-        const checkInterval = 1000; // 1 second
-        const checkConnection = () => {
-            if (navigator.onLine || Date.now() - startTime >= maxWaitTime) {
-                resolve();
-            }
-            else {
-                setTimeout(checkConnection, checkInterval);
-            }
-        };
-        checkConnection();
-    });
-};
-/**
- * AmityRoomAnalytics provides analytics capabilities for room watch sessions
- */
-class AmityRoomAnalytics {
-    constructor(room) {
-        this.storage = getWatchSessionStorage();
-        this.client = getActiveClient();
-        this.room = room;
+        return this.lastStoryExpiresAt;
     }
-    /**
-     * Create a new watch session for the current room
-     * @param startedAt The timestamp when watching started
-     * @returns Promise<string> sessionId unique identifier for this watch session
-     * @throws ASCApiError if room is not in watchable state (not LIVE or RECORDED)
-     */
-    async createWatchSession(startedAt) {
-        // Validate room status
-        if (!WATCHABLE_ROOM_STATUSES.includes(this.room.status)) {
-            throw new ASCApiError('room is not in watchable state', 500000 /* Amity.ServerError.BUSINESS_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+    getHasUnseenFlag() {
+        const now = new Date().getTime();
+        const highestSeen = Math.max(this.lastStorySeenExpiresAt, this.localLastStorySeenExpiresAt);
+        pullFromCache([
+            "story-sync-state" /* STORY_KEY_CACHE.SYNC_STATE */,
+            this._targetId,
+        ]);
+        if (this.isContainUnSyncedStory) {
+            return this.localLastStoryExpires > now && this.localLastStoryExpires > highestSeen;
         }
-        // Generate session ID with prefix
-        const prefix = this.room.status === 'live' ? 'room_' : 'room_playback_';
-        const sessionId = prefix + uuid$1.v4();
-        // Create watch session entity
-        const session = {
-            sessionId,
-            roomId: this.room.roomId,
-            watchSeconds: 0,
-            startTime: startedAt,
-            endTime: null,
-            syncState: 'PENDING',
-            syncedAt: null,
-            retryCount: 0,
-        };
-        // Persist to storage
-        this.storage.addSession(session);
-        return sessionId;
+        return this.lastStoryExpiresAt > now && this.lastStoryExpiresAt > highestSeen;
     }
-    /**
-     * Update an existing watch session with duration
-     * @param sessionId The unique identifier of the watch session
-     * @param duration The total watch duration in seconds
-     * @param endedAt The timestamp when this update occurred
-     * @returns Promise<void> Completion status
-     */
-    async updateWatchSession(sessionId, duration, endedAt) {
-        const session = this.storage.getSession(sessionId);
-        if (!session) {
-            throw new Error(`Watch session ${sessionId} not found`);
+    getTotalStoryByStatus() {
+        const stories = queryCache(["story" /* STORY_KEY_CACHE.STORY */, 'get']);
+        if (!stories) {
+            this._errorStoriesCount = 0;
+            this._syncingStoriesCount = 0;
+            return;
         }
-        // Update session
-        this.storage.updateSession(sessionId, {
-            watchSeconds: duration,
-            endTime: endedAt,
+        const groupByType = stories.reduce((acc, story) => {
+            const { data: { targetId, syncState, isDeleted }, } = story;
+            if (targetId === this._targetId && !isDeleted) {
+                acc[syncState] += 1;
+            }
+            return acc;
+        }, {
+            syncing: 0,
+            error: 0,
+            synced: 0,
         });
+        this._errorStoriesCount = groupByType.error;
+        this._syncingStoriesCount = groupByType.syncing;
     }
-    /**
-     * Sync all pending watch sessions to backend
-     * This function uses jitter delay and handles network resilience
-     */
-    syncPendingWatchSessions() {
-        // Execute with jitter delay (5-30 seconds)
-        const jitterDelay = getJitterDelay();
-        this.client.log('room/RoomAnalytics: syncPendingWatchSessions called, jitter delay:', `${jitterDelay}ms`);
-        setTimeout(async () => {
-            this.client.log('room/RoomAnalytics: Jitter delay completed, starting sync process');
-            try {
-                // Reset any SYNCING sessions back to PENDING
-                const syncingSessions = this.storage.getSyncingSessions();
-                this.client.log('room/RoomAnalytics: SYNCING sessions to reset:', syncingSessions.length);
-                syncingSessions.forEach(session => {
-                    this.storage.updateSession(session.sessionId, { syncState: 'PENDING' });
-                });
-                // Wait for network connection (max 60 seconds)
-                await waitForNetwork(60000);
-                this.client.log('room/RoomAnalytics: Network available');
-                // Sync pending sessions
-                this.client.log('room/RoomAnalytics: Calling syncWatchSessions()');
-                await syncWatchSessions();
-                this.client.log('room/RoomAnalytics: syncWatchSessions completed');
-            }
-            catch (error) {
-                // Error is already handled in syncWatchSessions
-                console.error('Failed to sync watch sessions:', error);
-            }
-        }, jitterDelay);
+    get syncingStoriesCount() {
+        return this._syncingStoriesCount;
+    }
+    get failedStoriesCount() {
+        return this._errorStoriesCount;
     }
 }
 
-const roomLinkedObject = (room) => {
-    return Object.assign(Object.assign({}, room), { get post() {
-            var _a;
-            if (room.referenceType !== 'post')
-                return;
-            return (_a = pullFromCache(['post', 'get', room.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+const storyTargetLinkedObject = (storyTarget) => {
+    const { targetType, targetId, lastStoryExpiresAt, lastStorySeenExpiresAt, targetUpdatedAt, localFilter, } = storyTarget;
+    const computedValue = new StoryComputedValue(targetId, lastStoryExpiresAt, lastStorySeenExpiresAt);
+    return {
+        targetType,
+        targetId,
+        lastStoryExpiresAt,
+        updatedAt: targetUpdatedAt,
+        // Additional data
+        hasUnseen: computedValue.getHasUnseenFlag(),
+        syncingStoriesCount: computedValue.syncingStoriesCount,
+        failedStoriesCount: computedValue.failedStoriesCount,
+        localFilter,
+        localLastExpires: computedValue.localLastStoryExpires,
+        localLastSeen: computedValue.localLastStorySeenExpiresAt,
+        localSortingDate: computedValue.getLocalLastSortingDate(),
+    };
+};
+
+const storyLinkedObject = (story) => {
+    const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
+    const storyTargetCache = pullFromCache([
+        "storyTarget" /* STORY_KEY_CACHE.STORY_TARGET */,
+        'get',
+        story.targetId,
+    ]);
+    const communityCacheData = pullFromCache(['community', 'get', story.targetId]);
+    return Object.assign(Object.assign({}, story), { analytics: {
+            markAsSeen: () => {
+                if (!story.expiresAt)
+                    return;
+                if (story.syncState !== "synced" /* Amity.SyncState.Synced */)
+                    return;
+                analyticsEngineInstance.markStoryAsViewed(story);
+            },
+            markLinkAsClicked: () => {
+                if (!story.expiresAt)
+                    return;
+                if (story.syncState !== "synced" /* Amity.SyncState.Synced */)
+                    return;
+                analyticsEngineInstance.markStoryAsClicked(story);
+            },
+        }, get videoData() {
+            var _a, _b;
+            const cache = pullFromCache([
+                'file',
+                'get',
+                (_b = (_a = story.data) === null || _a === void 0 ? void 0 : _a.videoFileId) === null || _b === void 0 ? void 0 : _b.original,
+            ]);
+            if (!cache)
+                return undefined;
+            const { data } = cache;
+            return data || undefined;
+        },
+        get imageData() {
+            var _a, _b;
+            if (!((_a = story.data) === null || _a === void 0 ? void 0 : _a.fileId))
+                return undefined;
+            const cache = pullFromCache(['file', 'get', (_b = story.data) === null || _b === void 0 ? void 0 : _b.fileId]);
+            if (!cache)
+                return undefined;
+            const { data } = cache;
+            if (!data)
+                return undefined;
+            return Object.assign(Object.assign({}, data), { fileUrl: `${data.fileUrl}?size=full` });
         },
         get community() {
-            var _a;
-            if (room.targetType !== 'community')
+            if (story.targetType !== 'community')
+                return undefined;
+            if (!(communityCacheData === null || communityCacheData === void 0 ? void 0 : communityCacheData.data))
+                return undefined;
+            return communityLinkedObject(communityCacheData.data);
+        },
+        get communityCategories() {
+            if (story.targetType !== 'community')
+                return undefined;
+            if (!communityCacheData)
+                return undefined;
+            const { data: { categoryIds }, } = communityCacheData;
+            if (categoryIds.length === 0)
+                return undefined;
+            return categoryIds
+                .map(categoryId => {
+                const categoryCacheData = pullFromCache(['category', 'get', categoryId]);
+                return (categoryCacheData === null || categoryCacheData === void 0 ? void 0 : categoryCacheData.data) || undefined;
+            })
+                .filter(category => category !== undefined);
+        },
+        get creator() {
+            const cacheData = pullFromCache(['user', 'get', story.creatorPublicId]);
+            if (!(cacheData === null || cacheData === void 0 ? void 0 : cacheData.data))
                 return;
-            return (_a = pullFromCache(['community', 'get', room.targetId])) === null || _a === void 0 ? void 0 : _a.data;
+            return userLinkedObject(cacheData.data);
         },
-        get user() {
-            var _a;
-            const user = (_a = pullFromCache(['user', 'get', room.createdBy])) === null || _a === void 0 ? void 0 : _a.data;
-            return user ? userLinkedObject(user) : user;
+        get storyTarget() {
+            if (!(storyTargetCache === null || storyTargetCache === void 0 ? void 0 : storyTargetCache.data))
+                return;
+            return storyTargetLinkedObject(storyTargetCache.data);
         },
-        get childRooms() {
-            if (!room.childRoomIds || room.childRoomIds.length === 0)
-                return [];
-            return room.childRoomIds
-                .map(id => {
-                var _a;
-                const roomCache = (_a = pullFromCache(['room', 'get', id])) === null || _a === void 0 ? void 0 : _a.data;
-                if (!roomCache)
-                    return undefined;
-                return roomLinkedObject(roomCache);
-            })
-                .filter(isNonNullable);
-        }, participants: room.participants.map(participant => (Object.assign(Object.assign({}, participant), { get user() {
-                var _a;
-                const user = (_a = pullFromCache(['user', 'get', participant.userId])) === null || _a === void 0 ? void 0 : _a.data;
-                return user ? userLinkedObject(user) : user;
-            } }))), getLiveChat: () => getLiveChat(room), createInvitation: (userId) => createInvitations({
-            type: "livestreamCohostInvite" /* InvitationTypeEnum.LivestreamCohostInvite */,
-            targetType: 'room',
-            targetId: room.roomId,
-            userIds: [userId],
-        }), getInvitations: async () => {
-            const { data } = await getInvitation({
-                targetId: room.roomId,
-                targetType: 'room',
-                type: "livestreamCohostInvite" /* InvitationTypeEnum.LivestreamCohostInvite */,
-            });
-            return data;
-        }, analytics() {
-            // Use 'this' to avoid creating a new room object
-            return new AmityRoomAnalytics(this);
+        get isSeen() {
+            const cacheData = pullFromCache(["story-last-seen" /* STORY_KEY_CACHE.LAST_SEEN */, story.targetId]);
+            if (!(storyTargetCache === null || storyTargetCache === void 0 ? void 0 : storyTargetCache.data))
+                return false;
+            const localLastSeen = (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data) ? new Date(cacheData.data).getTime() : 0;
+            const serverLastSeen = new Date(storyTargetCache === null || storyTargetCache === void 0 ? void 0 : storyTargetCache.data.lastStorySeenExpiresAt).getTime() || 0;
+            const expiresAt = new Date(story.expiresAt).getTime();
+            return Math.max(localLastSeen, serverLastSeen) >= expiresAt;
         } });
 };
 
-const pollLinkedObject = (poll) => {
-    return Object.assign(Object.assign({}, poll), { answers: poll.answers.map(answer => (Object.assign(Object.assign({}, answer), { get image() {
-                var _a;
-                if (!answer.fileId)
-                    return undefined;
-                return (_a = pullFromCache(['file', 'get', answer.fileId])) === null || _a === void 0 ? void 0 : _a.data;
-            } }))) });
-};
-
-/*
- * verifies membership status
- */
-function isMember(membership) {
-    return membership !== 'none';
-}
-/*
- * checks if currently logged in user is part of the community
- */
-function isCurrentUserPartOfCommunity(c, m) {
-    const { userId } = getActiveUser();
-    return c.communityId === m.communityId && m.userId === userId;
-}
-/*
- * For mqtt events server will not send user specific data as it's broadcasted
- * to multiple users and it also does not include communityUser
- *
- * Client SDK needs to check for the existing isJoined field in cache data before calculating.
- * Althought this can be calculated, it's not scalable.
- */
-function updateMembershipStatus(communities, communityUsers) {
-    return communities.map(c => {
-        const cachedCommunity = pullFromCache([
-            'community',
-            'get',
-            c.communityId,
-        ]);
-        if ((cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data) && (cachedCommunity === null || cachedCommunity === void 0 ? void 0 : cachedCommunity.data.hasOwnProperty('isJoined'))) {
-            return Object.assign(Object.assign({}, cachedCommunity.data), c);
-        }
-        const isJoined = c.isJoined !== undefined
-            ? c.isJoined
-            : communityUsers.some(m => isCurrentUserPartOfCommunity(c, m) && isMember(m.communityMembership));
-        return Object.assign(Object.assign({}, c), { isJoined });
-    });
-}
-
-const getMatchPostSetting = (value) => {
-    var _a;
-    return (_a = Object.keys(CommunityPostSettingMaps).find(key => value.needApprovalOnPostCreation ===
-        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
-        value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost)) !== null && _a !== void 0 ? _a : DefaultCommunityPostSetting;
-};
-function addPostSetting({ communities }) {
-    return communities.map((_a) => {
-        var { needApprovalOnPostCreation, onlyAdminCanPost } = _a, restCommunityPayload = __rest(_a, ["needApprovalOnPostCreation", "onlyAdminCanPost"]);
-        return (Object.assign({ postSetting: getMatchPostSetting({
-                needApprovalOnPostCreation,
-                onlyAdminCanPost,
-            }) }, restCommunityPayload));
-    });
-}
-const prepareCommunityPayload = (rawPayload) => {
-    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
-    // Convert users to internal format
-    const internalUsers = rawPayload.users.map(convertRawUserToInternalUser);
-    // map users with community
-    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
-        const user = internalUsers.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
-    });
-    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
-    return Object.assign(Object.assign({}, rawPayload), { users: rawPayload.users.map(convertRawUserToInternalUser), communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
-};
-const prepareCommunityJoinRequestPayload = (rawPayload) => {
-    const mappedJoinRequests = rawPayload.joinRequests.map(joinRequest => {
-        return Object.assign(Object.assign({}, joinRequest), { joinRequestId: joinRequest._id });
-    });
-    const users = rawPayload.users.map(convertRawUserToInternalUser);
-    return Object.assign(Object.assign({}, rawPayload), { joinRequests: mappedJoinRequests, users });
-};
-const prepareCommunityMembershipPayload = (rawPayload) => {
-    const communitiesWithPostSetting = addPostSetting({ communities: rawPayload.communities });
-    // map users with community
-    const mappedCommunityUsers = rawPayload.communityUsers.map(communityUser => {
-        const user = rawPayload.users.find(user => user.userId === communityUser.userId);
-        return Object.assign(Object.assign({}, communityUser), { user });
-    });
-    const communityWithMembershipStatus = updateMembershipStatus(communitiesWithPostSetting, mappedCommunityUsers);
-    return Object.assign(Object.assign({}, rawPayload), { communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
-};
-const prepareCommunityRequest = (params) => {
-    const { postSetting = undefined, storySetting } = params, restParam = __rest(params, ["postSetting", "storySetting"]);
-    return Object.assign(Object.assign(Object.assign({}, restParam), (postSetting ? CommunityPostSettingMaps[postSetting] : undefined)), { 
-        // Convert story setting to the actual value. (Allow by default)
-        allowCommentInStory: typeof (storySetting === null || storySetting === void 0 ? void 0 : storySetting.enableComment) === 'boolean' ? storySetting.enableComment : true });
-};
-const prepareSemanticSearchCommunityPayload = (_a) => {
-    var communityPayload = __rest(_a, ["searchResult"]);
-    const processedCommunityPayload = prepareCommunityPayload(communityPayload);
-    return Object.assign({}, processedCommunityPayload);
-};
-
 /* begin_public_function
-  id: joinRequest.approve
+  id: channel.create
 */
 /**
  * ```js
- * import { joinRequest } from '@amityco/ts-sdk-react-native'
- * const isAccepted = await joinRequest.approve()
+ * import { createChannel } from '@amityco/ts-sdk-react-native'
+ * const created = await createChannel({ displayName: 'foobar' })
  * ```
  *
- * Accepts a {@link Amity.JoinRequest} object
+ * Creates an {@link Amity.Channel}
  *
- * @param joinRequest the {@link Amity.JoinRequest} to accept
- * @returns A success boolean if the {@link Amity.JoinRequest} was accepted
+ * @param bundle The data necessary to create a new {@link Amity.Channel}
+ * @returns The newly created {@link Amity.Channel}
  *
- * @category Join Request API
+ * @category Channel API
  * @async
  */
-const approveJoinRequest = async (joinRequest) => {
-    var _a;
+const createChannel = async (bundle) => {
     const client = getActiveClient();
-    client.log('joinRequest/approveJoinRequest', joinRequest.joinRequestId);
-    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/approve`, {
-        userId: joinRequest.requestorInternalId,
-    });
-    const joinRequestCache = (_a = pullFromCache([
-        'joinRequest',
-        'get',
-        joinRequest.joinRequestId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (joinRequestCache) {
-        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
-            status: "approved" /* JoinRequestStatusEnum.Approved */,
-        });
-        fireEvent('local.joinRequest.updated', [joinRequestCache]);
+    client.log('user/createChannel', bundle);
+    let payload;
+    /* c8 ignore next */
+    if ((bundle === null || bundle === void 0 ? void 0 : bundle.type) === 'conversation') {
+        payload = await client.http.post('/api/v3/channels/conversation', Object.assign(Object.assign({}, bundle), { isDistinct: true }));
     }
-    return data.success;
+    else {
+        const { isPublic } = bundle, restParams = __rest(bundle, ["isPublic"]);
+        payload = await client.http.post('/api/v3/channels', Object.assign(Object.assign({}, restParams), { 
+            /* c8 ignore next */
+            isPublic: (bundle === null || bundle === void 0 ? void 0 : bundle.type) === 'community' ? isPublic : undefined }));
+    }
+    const data = await prepareChannelPayload(payload.data);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { channels } = data;
+    return {
+        data: constructChannelObject(channels[0]),
+        cachedAt,
+    };
 };
 /* end_public_function */
 
-/* begin_public_function
-  id: joinRequest.cancel
-*/
 /**
  * ```js
- * import { joinRequest } from '@amityco/ts-sdk-react-native'
- * const isCanceled = await joinRequest.cancel()
+ * import { getChannel } from '@amityco/ts-sdk-react-native'
+ * const channel = await getChannel('foobar')
  * ```
  *
- * Cancels a {@link Amity.JoinRequest} object
+ * Fetches a {@link Amity.Channel} object
  *
- * @param joinRequest the {@link Amity.JoinRequest} to cancel
- * @returns A success boolean if the {@link Amity.JoinRequest} was canceled
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
  *
- * @category Join Request API
+ * @category Channel API
  * @async
  */
-const cancelJoinRequest = async (joinRequest) => {
-    var _a;
+const getChannel$1 = async (channelId) => {
     const client = getActiveClient();
-    client.log('joinRequest/cancelJoinRequest', joinRequest.joinRequestId);
-    const { data } = await client.http.delete(`/api/v4/communities/${joinRequest.targetId}/join`);
-    const joinRequestCache = (_a = pullFromCache([
-        'joinRequest',
-        'get',
-        joinRequest.joinRequestId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (joinRequestCache) {
-        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
-            status: "cancelled" /* JoinRequestStatusEnum.Cancelled */,
-        });
-        fireEvent('local.joinRequest.deleted', [joinRequestCache]);
+    client.log('channel/getChannel', channelId);
+    isInTombstone('channel', channelId);
+    let data;
+    try {
+        const { data: payload } = await client.http.get(`/api/v3/channels/${encodeURIComponent(channelId)}`);
+        data = await prepareChannelPayload(payload);
+        if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+            prepareUnreadCountInfo(payload);
+        }
     }
-    return data.success;
+    catch (error) {
+        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+            // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
+            pushToTombstone('channel', channelId);
+        }
+        throw error;
+    }
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    const { channels } = data;
+    return {
+        data: channels.find(channel => channel.channelId === channelId),
+        cachedAt,
+    };
 };
-/* end_public_function */
-
-/* begin_public_function
-  id: joinRequest.reject
-*/
 /**
  * ```js
- * import { joinRequest } from '@amityco/ts-sdk-react-native'
- * const isRejected = await joinRequest.reject()
+ * import { getChannel } from '@amityco/ts-sdk-react-native'
+ * const channel = getChannel.locally('foobar')
  * ```
  *
- * Rejects a {@link Amity.JoinRequest} object
+ * Fetches a {@link Amity.Channel} object from cache
  *
- * @param joinRequest the {@link Amity.JoinRequest} to reject
- * @returns A success boolean if the {@link Amity.JoinRequest} was rejected
+ * @param channelId the ID of the {@link Amity.Channel} to fetch
+ * @returns the associated {@link Amity.Channel} object
  *
- * @category Join Request API
- * @async
+ * @category Channel API
  */
-const rejectJoinRequest = async (joinRequest) => {
+getChannel$1.locally = (channelId) => {
     var _a;
     const client = getActiveClient();
-    client.log('joinRequest/rejectJoinRequest', joinRequest.joinRequestId);
-    const { data } = await client.http.post(`/api/v4/communities/${joinRequest.targetId}/join/reject`, {
-        userId: joinRequest.requestorInternalId,
+    client.log('channel/getChannel.locally', channelId);
+    if (!client.cache)
+        return;
+    // use queryCache to get all channel caches and filter by channelPublicId since we use channelPrivateId as cache key
+    const cached = (_a = queryCache(['channel', 'get'])) === null || _a === void 0 ? void 0 : _a.filter(({ data }) => {
+        return data.channelPublicId === channelId;
     });
-    const joinRequestCache = (_a = pullFromCache([
-        'joinRequest',
-        'get',
-        joinRequest.joinRequestId,
-    ])) === null || _a === void 0 ? void 0 : _a.data;
-    if (joinRequestCache) {
-        upsertInCache(['joinRequest', 'get', joinRequest.joinRequestId], {
-            status: "rejected" /* JoinRequestStatusEnum.Rejected */,
-        });
-        fireEvent('local.joinRequest.updated', [joinRequestCache]);
-    }
-    return data.success;
-};
-/* end_public_function */
-
-const joinRequestLinkedObject = (joinRequest) => {
-    return Object.assign(Object.assign({}, joinRequest), { get user() {
-            var _a;
-            const user = (_a = pullFromCache([
-                'user',
-                'get',
-                joinRequest.requestorPublicId,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
-            if (!user)
-                return undefined;
-            return userLinkedObject(user);
-        }, cancel: async () => {
-            await cancelJoinRequest(joinRequest);
-        }, approve: async () => {
-            await approveJoinRequest(joinRequest);
-        }, reject: async () => {
-            await rejectJoinRequest(joinRequest);
-        } });
+    if (!cached || (cached === null || cached === void 0 ? void 0 : cached.length) === 0)
+        return;
+    return {
+        data: cached[0].data,
+        cachedAt: cached[0].cachedAt,
+    };
 };
 
-/* begin_public_function
-  id: community.getMyJoinRequest
-*/
 /**
  * ```js
- * import { community } from '@amityco/ts-sdk-react-native'
- * const isJoined = await community.getMyJoinRequest('foobar')
+ * import { getStream } from '@amityco/ts-sdk-react-native'
+ * const stream = await getStream('foobar')
  * ```
  *
- * Joins a {@link Amity.Community} object
+ * Fetches a {@link Amity.Channel} object linked with a current stream
  *
- * @param communityId the {@link Amity.Community} to join
- * @returns A success boolean if the {@link Amity.Community} was joined
+ * @param stream {@link Amity.Stream} that has linked live channel
+ * @returns the associated {@link Amity.Channel<'live'>} object
  *
- * @category Community API
+ * @category Stream API
  * @async
  */
-const getMyJoinRequest = async (communityId) => {
+const getLiveChat$1 = async (stream) => {
+    var _a;
     const client = getActiveClient();
-    client.log('community/myJoinRequest', communityId);
-    const { data: payload } = await client.http.get(`/api/v4/communities/${communityId}/join/me`);
-    const data = prepareCommunityJoinRequestPayload(payload);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    return {
-        data: data.joinRequests[0] ? joinRequestLinkedObject(data.joinRequests[0]) : undefined,
-        cachedAt,
-    };
+    client.log('stream/getLiveChat', stream.streamId);
+    if (stream.channelId) {
+        const channel = (_a = pullFromCache([
+            'channel',
+            'get',
+            stream.channelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (channel)
+            return channelLinkedObject(constructChannelObject(channel));
+        const { data } = await getChannel$1(stream.channelId);
+        return channelLinkedObject(constructChannelObject(data));
+    }
+    // No Channel ID
+    // streamer: create a new live channel
+    if (stream.userId === client.userId) {
+        const { data: channel } = await createChannel({
+            type: 'live',
+            postId: stream.postId,
+            videoStreamId: stream.streamId,
+        });
+        // Update channelId to stream object in cache
+        mergeInCache(['stream', 'get', stream.streamId], {
+            channelId: channel.channelId,
+        });
+        return channel;
+    }
+    // watcher: return undefined
+    return undefined;
 };
-/* end_public_function */
 
-/* begin_public_function
-  id: community.join
-*/
+const GET_WATCHER_URLS = Symbol('getWatcherUrls');
+const streamLinkedObject = (stream) => {
+    return Object.assign(Object.assign({}, stream), { get moderation() {
+            var _a;
+            return (_a = pullFromCache(['streamModeration', 'get', stream.streamId])) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        get post() {
+            var _a;
+            if (stream.referenceType !== 'post')
+                return;
+            return (_a = pullFromCache(['post', 'get', stream.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        get community() {
+            var _a;
+            if (stream.targetType !== 'community')
+                return;
+            return (_a = pullFromCache(['community', 'get', stream.targetId])) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        get user() {
+            var _a;
+            return (_a = pullFromCache(['user', 'get', stream.userId])) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        get childStreams() {
+            if (!stream.childStreamIds || stream.childStreamIds.length === 0)
+                return [];
+            return stream.childStreamIds
+                .map(id => {
+                var _a;
+                const streamCache = (_a = pullFromCache(['stream', 'get', id])) === null || _a === void 0 ? void 0 : _a.data;
+                if (!streamCache)
+                    return undefined;
+                return streamLinkedObject(streamCache);
+            })
+                .filter(isNonNullable);
+        }, getLiveChat: () => getLiveChat$1(stream), isBanned: !stream.watcherUrl, watcherUrl: null, get [GET_WATCHER_URLS]() {
+            return stream.watcherUrl;
+        } });
+};
+
+const commentLinkedObject = (comment) => {
+    return Object.assign(Object.assign({}, comment), { get target() {
+            const commentTypes = {
+                type: comment.targetType,
+            };
+            if (comment.targetType === 'user') {
+                return Object.assign(Object.assign({}, commentTypes), { userId: comment.targetId });
+            }
+            if (commentTypes.type === 'content') {
+                return Object.assign(Object.assign({}, commentTypes), { contentId: comment.targetId });
+            }
+            if (commentTypes.type === 'community') {
+                const cacheData = pullFromCache([
+                    'communityUsers',
+                    'get',
+                    `${comment.targetId}#${comment.userId}`,
+                ]);
+                return Object.assign(Object.assign({}, commentTypes), { communityId: comment.targetId, creatorMember: cacheData === null || cacheData === void 0 ? void 0 : cacheData.data });
+            }
+            return {
+                type: 'unknown',
+            };
+        },
+        get creator() {
+            const cacheData = pullFromCache(['user', 'get', comment.userId]);
+            if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
+                return userLinkedObject(cacheData.data);
+            return undefined;
+        },
+        get childrenComment() {
+            return comment.children
+                .map(childCommentId => {
+                const commentCache = pullFromCache([
+                    'comment',
+                    'get',
+                    childCommentId,
+                ]);
+                if (!(commentCache === null || commentCache === void 0 ? void 0 : commentCache.data))
+                    return;
+                return commentCache === null || commentCache === void 0 ? void 0 : commentCache.data;
+            })
+                .filter(isNonNullable)
+                .map(item => commentLinkedObject(item));
+        } });
+};
+
+function isAmityImagePost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'fileId' in post.data &&
+        post.dataType === 'image');
+}
+function isAmityFilePost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'fileId' in post.data &&
+        post.dataType === 'file');
+}
+function isAmityVideoPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'videoFileId' in post.data &&
+        'thumbnailFileId' in post.data &&
+        post.dataType === 'video');
+}
+function isAmityLivestreamPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'streamId' in post.data &&
+        post.dataType === 'liveStream');
+}
+function isAmityPollPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'pollId' in post.data &&
+        post.dataType === 'poll');
+}
+function isAmityClipPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'fileId' in post.data &&
+        post.dataType === 'clip');
+}
+function isAmityAudioPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'fileId' in post.data &&
+        post.dataType === 'audio');
+}
+function isAmityRoomPost(post) {
+    return !!(post.data &&
+        typeof post.data !== 'string' &&
+        'roomId' in post.data &&
+        post.dataType === 'room');
+}
+
 /**
  * ```js
- * import { community } from '@amityco/ts-sdk-react-native'
- * const isJoined = await community.join('foobar')
+ * import { RoomRepository } from '@amityco/ts-sdk-react-native'
+ * const stream = await getStream('foobar')
  * ```
  *
- * Joins a {@link Amity.Community} object
+ * Fetches a {@link Amity.Channel} object linked with a current stream
  *
- * @param communityId the {@link Amity.Community} to join
- * @returns A status join result
+ * @param stream {@link Amity.Stream} that has linked live channel
+ * @returns the associated {@link Amity.Channel<'live'>} object
  *
- * @category Community API
+ * @category Stream API
  * @async
  */
-const joinRequest = async (communityId) => {
+const getLiveChat = async (room) => {
     var _a;
     const client = getActiveClient();
-    client.log('community/joinRequest', communityId);
-    const { data: payload } = await client.http.post(`/api/v4/communities/${communityId}/join`);
-    const data = prepareCommunityJoinRequestPayload(payload);
-    const cachedAt = client.cache && Date.now();
-    if (client.cache)
-        ingestInCache(data, { cachedAt });
-    const status = data.joinRequests[0].status === "approved" /* JoinRequestStatusEnum.Approved */
-        ? "success" /* JoinResultStatusEnum.Success */
-        : "pending" /* JoinResultStatusEnum.Pending */;
-    if (status === "success" /* JoinResultStatusEnum.Success */ && client.cache) {
-        const community = (_a = pullFromCache(['community', 'get', communityId])) === null || _a === void 0 ? void 0 : _a.data;
-        if (community) {
-            const updatedCommunity = Object.assign(Object.assign({}, community), { isJoined: true });
-            upsertInCache(['community', 'get', communityId], updatedCommunity);
-        }
+    client.log('room/getLiveChat', room.roomId);
+    if (room.liveChannelId) {
+        const channel = (_a = pullFromCache([
+            'channel',
+            'get',
+            room.liveChannelId,
+        ])) === null || _a === void 0 ? void 0 : _a.data;
+        if (channel)
+            return channelLinkedObject(constructChannelObject(channel));
+        const { data } = await getChannel$1(room.liveChannelId);
+        return channelLinkedObject(constructChannelObject(data));
     }
-    fireEvent('v4.local.community.joined', data.joinRequests);
-    return status === "success" /* JoinResultStatusEnum.Success */
-        ? { status }
-        : { status, request: joinRequestLinkedObject(data.joinRequests[0]) };
-};
-/* end_public_function */
-
-/**
- * TODO: handle cache receive cache option, and cache policy
- * TODO: check if querybyIds is supported
- */
-class JoinRequestsPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = 20, communityId } = queryParams, params = __rest(queryParams, ["limit", "communityId"]);
-        const options = token ? { token } : { limit };
-        const { data: queryResponse } = await this.http.get(`/api/v4/communities/${communityId}/join`, {
-            params: Object.assign(Object.assign({}, params), { options }),
+    // No Channel ID
+    // streamer: create a new live channel
+    if (room.createdBy === client.userId) {
+        const { data: channel } = await createChannel({
+            type: 'live',
+            postId: room.referenceId,
+            roomId: room.roomId,
         });
-        return queryResponse;
-    }
-}
-
-var EnumJoinRequestAction$1;
-(function (EnumJoinRequestAction) {
-    EnumJoinRequestAction["OnLocalJoinRequestCreated"] = "OnLocalJoinRequestCreated";
-    EnumJoinRequestAction["OnLocalJoinRequestUpdated"] = "OnLocalJoinRequestUpdated";
-    EnumJoinRequestAction["OnLocalJoinRequestDeleted"] = "OnLocalJoinRequestDeleted";
-})(EnumJoinRequestAction$1 || (EnumJoinRequestAction$1 = {}));
-
-class JoinRequestsQueryStreamController 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.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
-            });
-        }
-        else {
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            const joinRequests = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [
-                    ...new Set([
-                        ...joinRequests,
-                        ...response.joinRequests.map(joinRequest => getResolver('joinRequest')({ joinRequestId: joinRequest._id })),
-                    ]),
-                ] }));
-        }
-    }
-    reactor(action) {
-        return (joinRequest) => {
-            var _a;
-            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-            if (!collection)
-                return;
-            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestUpdated) {
-                const isExist = collection.data.find(id => id === joinRequest[0].joinRequestId);
-                if (!isExist)
-                    return;
-            }
-            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestCreated) {
-                collection.data = [
-                    ...new Set([
-                        ...joinRequest.map(joinRequest => joinRequest.joinRequestId),
-                        ...collection.data,
-                    ]),
-                ];
-            }
-            if (action === EnumJoinRequestAction$1.OnLocalJoinRequestDeleted) {
-                collection.data = collection.data.filter(id => id !== joinRequest[0].joinRequestId);
-            }
-            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)));
+        // Update channelId to stream object in cache
+        mergeInCache(['room', 'get', room.roomId], {
+            liveChannelId: channel.channelId,
+        });
+        return channel;
     }
-}
-
-/**
- * ```js
- * import { onJoinRequestCreated } from '@amityco/ts-sdk-react-native'
- * const dispose = onJoinRequestCreated(data => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category JoinRequest Events
- */
-const onJoinRequestCreated = (callback) => {
-    const client = getActiveClient();
-    const disposers = [
-        createEventSubscriber(client, 'onJoinRequestCreated', 'local.joinRequest.created', payload => callback(payload)),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-/**
- * ```js
- * import { onJoinRequestUpdated } from '@amityco/ts-sdk-react-native'
- * const dispose = onJoinRequestUpdated(data => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category JoinRequest Events
- */
-const onJoinRequestUpdated = (callback) => {
-    const client = getActiveClient();
-    const disposers = [
-        createEventSubscriber(client, 'onJoinRequestUpdated', 'local.joinRequest.updated', payload => callback(payload)),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
+    // watcher: return undefined
+    return undefined;
 };
 
 /**
- * ```js
- * import { onJoinRequestDeleted } from '@amityco/ts-sdk-react-native'
- * const dispose = onJoinRequestDeleted(data => {
- *   // ...
- * })
- * ```
- *
- * Fired when an {@link Amity.CommunityJoinRequestPayload} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category JoinRequest Events
+ * WatchSessionStorage manages watch session data in memory
+ * Similar to UsageCollector for stream watch minutes
  */
-const onJoinRequestDeleted = (callback) => {
-    const client = getActiveClient();
-    const disposers = [
-        createEventSubscriber(client, 'onJoinRequestDeleted', 'local.joinRequest.deleted', payload => callback(payload)),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-class JoinRequestsLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash(query);
-        const cacheKey = ['joinRequest', 'collection', queryStreamId];
-        const paginationController = new JoinRequestsPaginationController(query);
-        super(paginationController, queryStreamId, cacheKey, callback);
-        this.query = query;
-        this.queryStreamController = new JoinRequestsQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this), prepareCommunityJoinRequestPayload);
-        this.callback = callback.bind(this);
-        this.loadPage({ initial: true });
+class WatchSessionStorage {
+    constructor() {
+        this.sessions = new Map();
     }
-    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,
-            });
-        }
+    /**
+     * Add a new watch session
+     */
+    addSession(session) {
+        this.sessions.set(session.sessionId, session);
+    }
+    /**
+     * Get a watch session by sessionId
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
     }
-    async persistModel(queryPayload) {
-        await this.queryStreamController.saveToMainDB(queryPayload);
+    /**
+     * Update a watch session
+     */
+    updateSession(sessionId, updates) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            this.sessions.set(sessionId, Object.assign(Object.assign({}, session), updates));
+        }
     }
-    persistQueryStream({ response, direction, refresh, }) {
-        const joinRequestResponse = response;
-        this.queryStreamController.appendToQueryStream(joinRequestResponse, direction, refresh);
+    /**
+     * Get all sessions with a specific sync state
+     */
+    getSessionsByState(state) {
+        return Array.from(this.sessions.values()).filter(session => session.syncState === state);
     }
-    startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onJoinRequestCreated, action: EnumJoinRequestAction$1.OnLocalJoinRequestCreated },
-            { fn: onJoinRequestUpdated, action: EnumJoinRequestAction$1.OnLocalJoinRequestUpdated },
-            { fn: onJoinRequestDeleted, action: EnumJoinRequestAction$1.OnLocalJoinRequestDeleted },
-        ]);
+    /**
+     * Delete a session
+     */
+    deleteSession(sessionId) {
+        this.sessions.delete(sessionId);
     }
-    notifyChange({ origin, loading, error }) {
-        var _a;
-        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!collection)
-            return;
-        const data = this.applyFilter(collection.data
-            .map(id => pullFromCache(['joinRequest', 'get', id]))
-            .filter(isNonNullable)
-            .map(({ data }) => data)
-            .map(joinRequestLinkedObject));
-        if (!this.shouldNotify(data) && origin === 'event')
-            return;
-        this.callback({
-            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
-            data,
-            hasNextPage: !!this.paginationController.getNextToken(),
-            loading,
-            error,
-        });
+    /**
+     * Get all pending sessions
+     */
+    getPendingSessions() {
+        return this.getSessionsByState('PENDING');
     }
-    applyFilter(data) {
-        let joinRequest = data;
-        if (this.query.status) {
-            joinRequest = joinRequest.filter(joinRequest => joinRequest.status === this.query.status);
-        }
-        const sortFn = (() => {
-            switch (this.query.sortBy) {
-                case 'firstCreated':
-                    return sortByFirstCreated;
-                case 'lastCreated':
-                    return sortByLastCreated;
-                default:
-                    return sortByLastCreated;
-            }
-        })();
-        joinRequest = joinRequest.sort(sortFn);
-        return joinRequest;
+    /**
+     * Get all syncing sessions
+     */
+    getSyncingSessions() {
+        return this.getSessionsByState('SYNCING');
     }
 }
+// Singleton instance
+let storageInstance = null;
+const getWatchSessionStorage = () => {
+    if (!storageInstance) {
+        storageInstance = new WatchSessionStorage();
+    }
+    return storageInstance;
+};
 
-/**
- * Get Join Requests
- *
- * @param params the query parameters
- * @param callback the callback to be called when the join request are updated
- * @returns joinRequests
- *
- * @category joinRequest Live Collection
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDAARz+hmBgi8pJ\nQb8LeY41gtHhk+ACMwRfhsn7GqpqRQNG2qU0755mzZuVDUqjQMGSo8THJB7O+OJs\nflbZRkFXlFoFOVNw1UpNOgwEQZ6wB9oRwzepTJAfF1sVhm/o/ixvXh1zDFNDy6yZ\npXyiiJHUVxqyjllZhxnwdvjoVtDs6hW6awG09bB9nh/TTejlUKXoAgzqVwu/1QMu\nUVViET495elEe19aUarEy+oL2iKeXCEvqda/pWNBdbieFyJvvZ08HN8dPuT88wq2\njZLEAth1vrwQ2IAa4ktaLcBQdLJgIkrbDvAiVZ8lQAjS/bq5vXQikTGvoPlC5bbn\nvuOM/3eLAgMBAAECggEAVZ+peHAghq2QVj71nX5lxsNCKaCyYwixSJBpfouTt7Rz\nE6PpzMOXFi1W1o+I22jDakuSM2SOQKqI/u0QefB0r0O/KVk5NrZHXk0mkrdYtxOp\nUgaGyf8UvmjB+8VqHrNKyZdk9qtmbnNj01kTTcAtmE4H39zPR7eR/8Rul94vaZbs\nwCnKJS3mLT3JxyGug6lxanveKkjG+CKC1nJQYWaxCJxaFSzbwXQPvDhB+TvrIbee\npd5v4EAyEJohpr+T9oDGGJkb/KARBZCtwLyB976PKJwwBA8MRVL1i5QwawuMiMq5\nUtnOnbGKtCeFzaLbNU0Qi8bqyims84EQxC6DOu1fkQKBgQDdvsoBsEhsOXV7hlIJ\naEd0eSJZVkdqimxH8uGoMM2FeNaOrcB6yBXqTSP0R3OIyf8eaY6yjRvP30ZNXcll\n/gD3O1Mu6YmWQdt1W2WA6pKOsUuPXasf0pdOF7IiFZKlSabz5YHXFqwVuqm8loaj\nsXel3YWqPVdHiankE7tz+3ssnQKBgQDdqi4TNdD1MdEpihx19jr0QjUiXW3939FK\nqp30HESPEGDGQzXdmJgif9HhZb+cJSuWaHEbjgBrYahvgCF+y6LbEpOD+D/dmT+s\nDEAQaR84sah6dokwPjV8fjBSrcVFjCS+doxv0d3p/9OUEeyUhFrY03nxtIEYkLIE\n/Zvn37b4RwKBgQCLENVFe9XfsaVhQ5r9dV2iyTlmh7qgMZG5CbTFs12hQGhm8McO\n+Z7s41YSJCFr/yq1WwP4LJDtrBw99vyQr1zRsG35tNLp3gGRNzGQSQyC2uQFVHw2\np+7mNewsfhUK/gbrXNsyFnDz6635rPlhfbII3sWuP2wWXFqkxE9CbMwR7QKBgQC6\nawDMzxmo2/iYArrkyevSuEuPVxvFwpF1RgAI6C0QVCnPE38dmdN4UB7mfHekje4W\nVEercMURidPp0cxZolCYBQtilUjAyL0vqC3In1/Ogjq6oy3FEMxSop1pKxMY5j+Q\nnoqFD+6deLUrddeNH7J3X4LSr4dSbX4JjG+tlgt+yQKBgQCuwTL4hA6KqeInQ0Ta\n9VQX5Qr8hFlqJz1gpymi/k63tW/Ob8yedbg3WWNWyShwRMFYyY9S81ITFWM95uL6\nvF3x9rmRjwElJw9PMwVu6dmf/CO0Z1wzXSp2VVD12gbrUD/0/d7MUoJ9LgC8X8f/\nn0txLHYGHbx+nf95+JUg6lV3hg==\n-----END PRIVATE KEY-----";
+/*
+ * The crypto algorithm used for importing key and signing string
+ */
+const ALGORITHM = {
+    name: 'RSASSA-PKCS1-v1_5',
+    hash: { name: 'SHA-256' },
+};
+/*
+ * IMPORTANT!
+ * If you are recieving key from other platforms use an online tool to convert
+ * the PKCS1 to PKCS8. For instance the key from Android SDK is of the format
+ * PKCS1.
  *
+ * If recieving from the platform, verify if it's already in the expected
+ * format. Otherwise the crypto.subtle.importKey will throw a DOMException
  */
-const getJoinRequests = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
-    }
-    const timestamp = Date.now();
-    log(`getJoinRequests: (tmpid: ${timestamp}) > listen`);
-    const joinRequestLiveCollection = new JoinRequestsLiveCollectionController(params, callback);
-    const disposers = joinRequestLiveCollection.startSubscription();
-    const cacheKey = joinRequestLiveCollection.getCacheKey();
-    disposers.push(() => {
-        dropFromCache(cacheKey);
+const PRIVATE_KEY_SIGNATURE = 'pkcs8';
+/*
+ * Ensure that the private key in the .env follows this format
+ */
+const PEM_HEADER = '-----BEGIN PRIVATE KEY-----';
+const PEM_FOOTER = '-----END PRIVATE KEY-----';
+/*
+ * The crypto.subtle.sign function returns an ArrayBuffer whereas the server
+ * expects a base64 string. This util helps facilitate that process
+ */
+function base64FromArrayBuffer(buffer) {
+    const uint8Array = new Uint8Array(buffer);
+    let binary = '';
+    uint8Array.forEach(byte => {
+        binary += String.fromCharCode(byte);
     });
-    return () => {
-        log(`getJoinRequests (tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
-};
-
-var InvitationActionsEnum;
-(function (InvitationActionsEnum) {
-    InvitationActionsEnum["OnLocalInvitationCreated"] = "onLocalInvitationCreated";
-    InvitationActionsEnum["OnLocalInvitationUpdated"] = "onLocalInvitationUpdated";
-    InvitationActionsEnum["OnLocalInvitationCanceled"] = "onLocalInvitationCanceled";
-})(InvitationActionsEnum || (InvitationActionsEnum = {}));
-
-class InvitationsPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT } = queryParams, params = __rest(queryParams, ["limit"]);
-        const options = token ? { token } : { limit };
-        const { data } = await this.http.get('/api/v1/invitations', { params: Object.assign(Object.assign({}, params), { options }) });
-        return data;
-    }
+    return btoa(binary);
 }
-
-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 });
-        }
+/*
+ * Encode ASN.1 length field
+ */
+function encodeLength(length) {
+    if (length < 128) {
+        return new Uint8Array([length]);
     }
-    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'))]),
-                ] }));
-        }
+    if (length < 256) {
+        return new Uint8Array([0x81, length]);
     }
-    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 });
-        };
+    // eslint-disable-next-line no-bitwise
+    return new Uint8Array([0x82, (length >> 8) & 0xff, length & 0xff]);
+}
+/*
+ * Convert PKCS1 private key to PKCS8 format
+ * PKCS1 is RSA-specific format, PKCS8 is generic format that crypto.subtle requires
+ * Android uses PKCS8EncodedKeySpec which expects PKCS8 format
+ */
+function pkcs1ToPkcs8(pkcs1) {
+    // Algorithm identifier for RSA
+    const algorithmIdentifier = new Uint8Array([
+        0x30,
+        0x0d,
+        0x06,
+        0x09,
+        0x2a,
+        0x86,
+        0x48,
+        0x86,
+        0xf7,
+        0x0d,
+        0x01,
+        0x01,
+        0x01,
+        0x05,
+        0x00, // NULL
+    ]);
+    // Version (INTEGER 0)
+    const version = new Uint8Array([0x02, 0x01, 0x00]);
+    // OCTET STRING tag + length + pkcs1 data
+    const octetStringTag = 0x04;
+    const octetStringLength = encodeLength(pkcs1.length);
+    // Calculate total content length (version + algorithm + octet string)
+    const contentLength = version.length + algorithmIdentifier.length + 1 + octetStringLength.length + pkcs1.length;
+    // SEQUENCE tag + length
+    const sequenceTag = 0x30;
+    const sequenceLength = encodeLength(contentLength);
+    // Build the PKCS8 structure
+    const pkcs8 = new Uint8Array(1 + sequenceLength.length + contentLength);
+    let offset = 0;
+    pkcs8[offset] = sequenceTag;
+    offset += 1;
+    pkcs8.set(sequenceLength, offset);
+    offset += sequenceLength.length;
+    pkcs8.set(version, offset);
+    offset += version.length;
+    pkcs8.set(algorithmIdentifier, offset);
+    offset += algorithmIdentifier.length;
+    pkcs8[offset] = octetStringTag;
+    offset += 1;
+    pkcs8.set(octetStringLength, offset);
+    offset += octetStringLength.length;
+    pkcs8.set(pkcs1, offset);
+    return pkcs8;
+}
+async function importPrivateKey(keyString) {
+    // Remove PEM headers if present and any whitespace
+    let base64Key = keyString;
+    if (keyString.includes(PEM_HEADER)) {
+        base64Key = keyString
+            .substring(PEM_HEADER.length, keyString.length - PEM_FOOTER.length)
+            .replace(/\s/g, '');
     }
-    subscribeRTE(createSubscriber) {
-        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    else {
+        base64Key = keyString.replace(/\s/g, '');
+    }
+    // Base64 decode to get binary data
+    const binaryDerString = atob(base64Key);
+    // Convert to Uint8Array for manipulation
+    const pkcs1 = new Uint8Array(binaryDerString.length);
+    for (let i = 0; i < binaryDerString.length; i += 1) {
+        pkcs1[i] = binaryDerString.charCodeAt(i);
     }
+    // Convert PKCS1 to PKCS8 (crypto.subtle requires PKCS8)
+    const pkcs8 = pkcs1ToPkcs8(pkcs1);
+    // Import the key
+    const key = await crypto.subtle.importKey(PRIVATE_KEY_SIGNATURE, pkcs8.buffer, ALGORITHM, false, ['sign']);
+    return key;
+}
+async function createSignature({ timestamp, rooms, }) {
+    const dataStr = rooms
+        .map(item => Object.keys(item)
+        .sort()
+        .map(key => `${key}=${item[key]}`)
+        .join('&'))
+        .join(';');
+    /*
+     * nonceStr needs to be unique for each request
+     */
+    const nonceStr = uuid$1.v4();
+    const signStr = `nonceStr=${nonceStr}&timestamp=${timestamp}&data=${dataStr}==`;
+    const encoder = new TextEncoder();
+    const data = encoder.encode(signStr);
+    const key = await importPrivateKey(privateKey);
+    const sign = await crypto.subtle.sign(ALGORITHM, key, data);
+    return { signature: base64FromArrayBuffer(sign), nonceStr };
 }
 
 /**
- * ```js
- * import { onLocalInvitationCreated } from '@amityco/ts-sdk-react-native'
- * 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());
-    };
-};
-
-/**
- * ```js
- * import { onLocalInvitationUpdated } from '@amityco/ts-sdk-react-native'
- * 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());
-    };
-};
-
-/**
- * ```js
- * import { onLocalInvitationCanceled } from '@amityco/ts-sdk-react-native'
- * const dispose = onLocalInvitationCanceled(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
+ * Sync pending watch sessions to backend
+ * This function implements the full sync flow with network resilience
  */
-const onLocalInvitationCanceled = (callback) => {
-    const client = getActiveClient();
-    const disposers = [
-        createEventSubscriber(client, 'onLocalInvitationCanceled', 'local.invitation.canceled', payload => callback(payload)),
-    ];
-    return () => {
-        disposers.forEach(fn => fn());
-    };
-};
-
-class InvitationsLiveCollectionController extends LiveCollectionController {
-    constructor(query, callback) {
-        const queryStreamId = hash(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 });
+async function syncWatchSessions() {
+    const storage = getWatchSessionStorage();
+    // Get all pending sessions
+    const pendingSessions = storage.getPendingSessions();
+    if (pendingSessions.length === 0) {
+        return 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,
-            });
+    try {
+        const timestamp = new Date().toISOString();
+        // Convert sessions to API format - always include all fields like syncUsage does
+        const rooms = pendingSessions.map(session => ({
+            sessionId: session.sessionId,
+            roomId: session.roomId,
+            watchSeconds: session.watchSeconds,
+            startTime: session.startTime.toISOString(),
+            endTime: session.endTime ? session.endTime.toISOString() : '',
+        }));
+        // Create signature (reuse from stream feature) - pass directly like syncUsage
+        const signatureData = await createSignature({
+            timestamp,
+            rooms,
+        });
+        if (!signatureData || !signatureData.signature) {
+            throw new Error('Signature is undefined');
         }
-    }
-    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: onLocalInvitationCanceled,
-                action: InvitationActionsEnum.OnLocalInvitationCanceled,
-            },
-        ]);
-    }
-    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,
+        // Update sync state to SYNCING
+        pendingSessions.forEach(session => {
+            storage.updateSession(session.sessionId, { syncState: 'SYNCING' });
+        });
+        const payload = {
+            signature: signatureData.signature,
+            nonceStr: signatureData.nonceStr,
+            timestamp,
+            rooms,
+        };
+        const client = getActiveClient();
+        // Send to backend
+        await client.http.post('/api/v3/user-event/room', payload);
+        // Success - update to SYNCED
+        pendingSessions.forEach(session => {
+            storage.updateSession(session.sessionId, {
+                syncState: 'SYNCED',
+                syncedAt: new Date(),
+            });
         });
+        return true;
     }
-    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;
+    catch (err) {
+        console.error('[SDK syncWatchSessions] ERROR caught:', (err === null || err === void 0 ? void 0 : err.message) || err);
+        // Failure - update back to PENDING and increment retry count
+        pendingSessions.forEach(session => {
+            const currentSession = storage.getSession(session.sessionId);
+            if (currentSession) {
+                const newRetryCount = currentSession.retryCount + 1;
+                if (newRetryCount >= 3) {
+                    // Delete session if retry count exceeds 3
+                    storage.deleteSession(session.sessionId);
+                }
+                else {
+                    // Update to PENDING with incremented retry count
+                    storage.updateSession(session.sessionId, {
+                        syncState: 'PENDING',
+                        retryCount: newRetryCount,
+                    });
+                }
             }
-        })();
-        invitations = invitations.sort(sortFn);
-        return invitations;
+        });
+        return false;
     }
 }
 
 /**
- * Get invitations
- *
- * @param params the query parameters
- * @param callback the callback to be called when the invitations are updated
- * @returns invitations
- *
- * @category Invitation Live Collection
- *
+ * Room statuses that are considered watchable
  */
-const getInvitations$1 = (params, callback, config) => {
-    const { log, cache } = getActiveClient();
-    if (!cache) {
-        console.log(ENABLE_CACHE_MESSAGE);
-    }
-    const timestamp = Date.now();
-    log(`getInvitations: (tmpid: ${timestamp}) > listen`);
-    const invitationsLiveCollection = new InvitationsLiveCollectionController(params, callback);
-    const disposers = invitationsLiveCollection.startSubscription();
-    const cacheKey = invitationsLiveCollection.getCacheKey();
-    disposers.push(() => {
-        dropFromCache(cacheKey);
+const WATCHABLE_ROOM_STATUSES = ['live', 'recorded'];
+/**
+ * Generate a random jitter delay between 5 and 30 seconds
+ */
+const getJitterDelay = () => {
+    const minDelay = 5000; // 5 seconds
+    const maxDelay = 30000; // 30 seconds
+    return Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
+};
+/**
+ * Wait for network connection with timeout
+ * @param maxWaitTime Maximum time to wait in milliseconds (default: 60000 = 60 seconds)
+ * @returns Promise that resolves when network is available or timeout is reached
+ */
+const waitForNetwork = (maxWaitTime = 60000) => {
+    return new Promise(resolve => {
+        // Simple check - if navigator.onLine is available, use it
+        // Otherwise, assume network is available
+        if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
+            resolve();
+            return;
+        }
+        const startTime = Date.now();
+        const checkInterval = 1000; // 1 second
+        const checkConnection = () => {
+            if (navigator.onLine || Date.now() - startTime >= maxWaitTime) {
+                resolve();
+            }
+            else {
+                setTimeout(checkConnection, checkInterval);
+            }
+        };
+        checkConnection();
     });
-    return () => {
-        log(`getInvitations (tmpid: ${timestamp}) > dispose`);
-        disposers.forEach(fn => fn());
-    };
 };
+/**
+ * AmityRoomAnalytics provides analytics capabilities for room watch sessions
+ */
+class AmityRoomAnalytics {
+    constructor(room) {
+        this.storage = getWatchSessionStorage();
+        this.client = getActiveClient();
+        this.room = room;
+    }
+    /**
+     * Create a new watch session for the current room
+     * @param startedAt The timestamp when watching started
+     * @returns Promise<string> sessionId unique identifier for this watch session
+     * @throws ASCApiError if room is not in watchable state (not LIVE or RECORDED)
+     */
+    async createWatchSession(startedAt) {
+        // Validate room status
+        if (!WATCHABLE_ROOM_STATUSES.includes(this.room.status)) {
+            throw new ASCApiError('room is not in watchable state', 500000 /* Amity.ServerError.BUSINESS_ERROR */, "error" /* Amity.ErrorLevel.ERROR */);
+        }
+        // Generate session ID with prefix
+        const prefix = this.room.status === 'live' ? 'room_' : 'room_playback_';
+        const sessionId = prefix + uuid$1.v4();
+        // Create watch session entity
+        const session = {
+            sessionId,
+            roomId: this.room.roomId,
+            watchSeconds: 0,
+            startTime: startedAt,
+            endTime: null,
+            syncState: 'PENDING',
+            syncedAt: null,
+            retryCount: 0,
+        };
+        // Persist to storage
+        this.storage.addSession(session);
+        return sessionId;
+    }
+    /**
+     * Update an existing watch session with duration
+     * @param sessionId The unique identifier of the watch session
+     * @param duration The total watch duration in seconds
+     * @param endedAt The timestamp when this update occurred
+     * @returns Promise<void> Completion status
+     */
+    async updateWatchSession(sessionId, duration, endedAt) {
+        const session = this.storage.getSession(sessionId);
+        if (!session) {
+            throw new Error(`Watch session ${sessionId} not found`);
+        }
+        // Update session
+        this.storage.updateSession(sessionId, {
+            watchSeconds: duration,
+            endTime: endedAt,
+        });
+    }
+    /**
+     * Sync all pending watch sessions to backend
+     * This function uses jitter delay and handles network resilience
+     */
+    syncPendingWatchSessions() {
+        // Execute with jitter delay (5-30 seconds)
+        const jitterDelay = getJitterDelay();
+        this.client.log('room/RoomAnalytics: syncPendingWatchSessions called, jitter delay:', `${jitterDelay}ms`);
+        setTimeout(async () => {
+            this.client.log('room/RoomAnalytics: Jitter delay completed, starting sync process');
+            try {
+                // Reset any SYNCING sessions back to PENDING
+                const syncingSessions = this.storage.getSyncingSessions();
+                this.client.log('room/RoomAnalytics: SYNCING sessions to reset:', syncingSessions.length);
+                syncingSessions.forEach(session => {
+                    this.storage.updateSession(session.sessionId, { syncState: 'PENDING' });
+                });
+                // Wait for network connection (max 60 seconds)
+                await waitForNetwork(60000);
+                this.client.log('room/RoomAnalytics: Network available');
+                // Sync pending sessions
+                this.client.log('room/RoomAnalytics: Calling syncWatchSessions()');
+                await syncWatchSessions();
+                this.client.log('room/RoomAnalytics: syncWatchSessions completed');
+            }
+            catch (error) {
+                // Error is already handled in syncWatchSessions
+                console.error('Failed to sync watch sessions:', error);
+            }
+        }, jitterDelay);
+    }
+}
 
-const communityLinkedObject = (community) => {
-    return Object.assign(Object.assign({}, community), { get categories() {
+const roomLinkedObject = (room) => {
+    return Object.assign(Object.assign({}, room), { get post() {
             var _a;
-            return ((_a = community === null || community === void 0 ? void 0 : community.categoryIds) !== null && _a !== void 0 ? _a : [])
-                .map(categoryId => {
-                const cacheData = pullFromCache(['category', 'get', categoryId]);
-                if (cacheData === null || cacheData === void 0 ? void 0 : cacheData.data)
-                    return categoryLinkedObject(cacheData.data);
-                return undefined;
-            })
-                .filter(category => !!category);
+            if (room.referenceType !== 'post')
+                return;
+            return (_a = pullFromCache(['post', 'get', room.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
         },
-        get avatar() {
+        get community() {
             var _a;
-            if (!community.avatarFileId)
-                return undefined;
-            const avatar = (_a = pullFromCache([
-                'file',
-                'get',
-                community.avatarFileId,
-            ])) === null || _a === void 0 ? void 0 : _a.data;
-            return avatar;
-        }, createInvitations: async (userIds) => {
-            await createInvitations({
-                type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */,
-                targetType: 'community',
-                targetId: community.communityId,
-                userIds,
-            });
-        }, getMemberInvitations: (params, callback) => {
-            return getInvitations$1(Object.assign(Object.assign({}, params), { targetId: community.communityId, targetType: 'community', type: "communityMemberInvite" /* InvitationTypeEnum.CommunityMemberInvite */ }), callback);
-        }, getInvitation: async () => {
+            if (room.targetType !== 'community')
+                return;
+            return (_a = pullFromCache(['community', 'get', room.targetId])) === null || _a === void 0 ? void 0 : _a.data;
+        },
+        get user() {
+            var _a;
+            const user = (_a = pullFromCache(['user', 'get', room.createdBy])) === null || _a === void 0 ? void 0 : _a.data;
+            return user ? userLinkedObject(user) : user;
+        },
+        get childRooms() {
+            if (!room.childRoomIds || room.childRoomIds.length === 0)
+                return [];
+            return room.childRoomIds
+                .map(id => {
+                var _a;
+                const roomCache = (_a = pullFromCache(['room', 'get', id])) === null || _a === void 0 ? void 0 : _a.data;
+                if (!roomCache)
+                    return undefined;
+                return roomLinkedObject(roomCache);
+            })
+                .filter(isNonNullable);
+        }, participants: room.participants.map(participant => (Object.assign(Object.assign({}, participant), { get user() {
+                var _a;
+                const user = (_a = pullFromCache(['user', 'get', participant.userId])) === null || _a === void 0 ? void 0 : _a.data;
+                return user ? userLinkedObject(user) : user;
+            } }))), getLiveChat: () => getLiveChat(room), createInvitation: (userId) => createInvitations({
+            type: "livestreamCohostInvite" /* InvitationTypeEnum.LivestreamCohostInvite */,
+            targetType: 'room',
+            targetId: room.roomId,
+            userIds: [userId],
+        }), getInvitations: async () => {
             const { data } = await getInvitation({
-                targetType: 'community',
-                targetId: community.communityId,
+                targetId: room.roomId,
+                targetType: 'room',
+                type: "livestreamCohostInvite" /* InvitationTypeEnum.LivestreamCohostInvite */,
             });
             return data;
-        }, join: async () => joinRequest(community.communityId), getJoinRequests: (params, callback) => {
-            return getJoinRequests(Object.assign(Object.assign({}, params), { communityId: community.communityId }), callback);
-        }, getMyJoinRequest: async () => {
-            const { data } = await getMyJoinRequest(community.communityId);
-            return data;
+        }, analytics() {
+            // Use 'this' to avoid creating a new room object
+            return new AmityRoomAnalytics(this);
         } });
 };
 
+const pollLinkedObject = (poll) => {
+    return Object.assign(Object.assign({}, poll), { answers: poll.answers.map(answer => (Object.assign(Object.assign({}, answer), { get image() {
+                var _a;
+                if (!answer.fileId)
+                    return undefined;
+                return (_a = pullFromCache(['file', 'get', answer.fileId])) === null || _a === void 0 ? void 0 : _a.data;
+            } }))) });
+};
+
 const productLinkedObject = (product) => {
     const analyticsEngineInstance = AnalyticsEngine$1.getInstance();
     return Object.assign(Object.assign({}, product), { analytics: {