@stream-io/feeds-client 0.1.10 → 0.2.0

package/dist/index-react-bindings.browser.js

@@ -905,6 +905,7 @@ decoders.FeedResponse = (input) => {
         updated_at: { type: 'DatetimeType', isSingle: true },
         created_by: { type: 'UserResponse', isSingle: true },
         deleted_at: { type: 'DatetimeType', isSingle: true },
+        own_follows: { type: 'FollowResponse', isSingle: false },
     };
     return decode(typeMappings, input);
 };
@@ -1123,6 +1124,13 @@ decoders.ModerationCustomActionEvent = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.ModerationFlagResponse = (input) => {
+    const typeMappings = {
+        review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
+        user: { type: 'UserResponse', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.ModerationFlaggedEvent = (input) => {
     const typeMappings = {
         created_at: { type: 'DatetimeType', isSingle: true },
@@ -1159,6 +1167,7 @@ decoders.NotificationFeedUpdatedEvent = (input) => {
 };
 decoders.NotificationStatusResponse = (input) => {
     const typeMappings = {
+        last_read_at: { type: 'DatetimeType', isSingle: true },
         last_seen_at: { type: 'DatetimeType', isSingle: true },
     };
     return decode(typeMappings, input);
@@ -1426,6 +1435,7 @@ decoders.ReviewQueueItemResponse = (input) => {
         updated_at: { type: 'DatetimeType', isSingle: true },
         actions: { type: 'ActionLogResponse', isSingle: false },
         bans: { type: 'Ban', isSingle: false },
+        flags: { type: 'ModerationFlagResponse', isSingle: false },
         completed_at: { type: 'DatetimeType', isSingle: true },
         reviewed_at: { type: 'DatetimeType', isSingle: true },
         assigned_to: { type: 'UserResponse', isSingle: true },
@@ -1502,6 +1512,12 @@ decoders.ThreadedCommentResponse = (input) => {
     };
     return decode(typeMappings, input);
 };
+decoders.UnfollowResponse = (input) => {
+    const typeMappings = {
+        follow: { type: 'FollowResponse', isSingle: true },
+    };
+    return decode(typeMappings, input);
+};
 decoders.UnpinActivityResponse = (input) => {
     const typeMappings = {
         activity: { type: 'ActivityResponse', isSingle: true },
@@ -1742,7 +1758,7 @@ class FeedsApi {
     async addActivity(request) {
         const body = {
             type: request?.type,
-            fids: request?.fids,
+            feeds: request?.feeds,
             expires_at: request?.expires_at,
             id: request?.id,
             parent_id: request?.parent_id,
@@ -1772,7 +1788,7 @@ class FeedsApi {
     }
     async deleteActivities(request) {
         const body = {
-            activity_ids: request?.activity_ids,
+            ids: request?.ids,
             hard_delete: request?.hard_delete,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/activities/delete', undefined, undefined, body, 'application/json');
@@ -1791,56 +1807,6 @@ class FeedsApi {
         decoders.QueryActivitiesResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
-    async deleteActivity(request) {
-        const queryParams = {
-            hard_delete: request?.hard_delete,
-        };
-        const pathParams = {
-            activity_id: request?.activity_id,
-        };
-        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/activities/{activity_id}', pathParams, queryParams);
-        decoders.DeleteActivityResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
-    }
-    async getActivity(request) {
-        const pathParams = {
-            activity_id: request?.activity_id,
-        };
-        const response = await this.apiClient.sendRequest('GET', '/api/v2/feeds/activities/{activity_id}', pathParams, undefined);
-        decoders.GetActivityResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
-    }
-    async updateActivityPartial(request) {
-        const pathParams = {
-            activity_id: request?.activity_id,
-        };
-        const body = {
-            unset: request?.unset,
-            set: request?.set,
-        };
-        const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/activities/{activity_id}', pathParams, undefined, body, 'application/json');
-        decoders.UpdateActivityPartialResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
-    }
-    async updateActivity(request) {
-        const pathParams = {
-            activity_id: request?.activity_id,
-        };
-        const body = {
-            expires_at: request?.expires_at,
-            poll_id: request?.poll_id,
-            text: request?.text,
-            visibility: request?.visibility,
-            attachments: request?.attachments,
-            filter_tags: request?.filter_tags,
-            interest_tags: request?.interest_tags,
-            custom: request?.custom,
-            location: request?.location,
-        };
-        const response = await this.apiClient.sendRequest('PUT', '/api/v2/feeds/activities/{activity_id}', pathParams, undefined, body, 'application/json');
-        decoders.UpdateActivityResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
-    }
     async deleteBookmark(request) {
         const queryParams = {
             folder_id: request?.folder_id,
@@ -1879,6 +1845,21 @@ class FeedsApi {
         decoders.AddBookmarkResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
+    async activityFeedback(request) {
+        const pathParams = {
+            activity_id: request?.activity_id,
+        };
+        const body = {
+            hide: request?.hide,
+            mute_user: request?.mute_user,
+            reason: request?.reason,
+            report: request?.report,
+            show_less: request?.show_less,
+        };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/activities/{activity_id}/feedback', pathParams, undefined, body, 'application/json');
+        decoders.ActivityFeedbackResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
     async castPollVote(request) {
         const pathParams = {
             activity_id: request?.activity_id,
@@ -1941,6 +1922,56 @@ class FeedsApi {
         decoders.DeleteActivityReactionResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
+    async deleteActivity(request) {
+        const queryParams = {
+            hard_delete: request?.hard_delete,
+        };
+        const pathParams = {
+            id: request?.id,
+        };
+        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/activities/{id}', pathParams, queryParams);
+        decoders.DeleteActivityResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
+    async getActivity(request) {
+        const pathParams = {
+            id: request?.id,
+        };
+        const response = await this.apiClient.sendRequest('GET', '/api/v2/feeds/activities/{id}', pathParams, undefined);
+        decoders.GetActivityResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
+    async updateActivityPartial(request) {
+        const pathParams = {
+            id: request?.id,
+        };
+        const body = {
+            unset: request?.unset,
+            set: request?.set,
+        };
+        const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/activities/{id}', pathParams, undefined, body, 'application/json');
+        decoders.UpdateActivityPartialResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
+    async updateActivity(request) {
+        const pathParams = {
+            id: request?.id,
+        };
+        const body = {
+            expires_at: request?.expires_at,
+            poll_id: request?.poll_id,
+            text: request?.text,
+            visibility: request?.visibility,
+            attachments: request?.attachments,
+            filter_tags: request?.filter_tags,
+            interest_tags: request?.interest_tags,
+            custom: request?.custom,
+            location: request?.location,
+        };
+        const response = await this.apiClient.sendRequest('PUT', '/api/v2/feeds/activities/{id}', pathParams, undefined, body, 'application/json');
+        decoders.UpdateActivityResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
+    }
     async queryBookmarkFolders(request) {
         const body = {
             limit: request?.limit,
@@ -2036,49 +2067,52 @@ class FeedsApi {
         return { ...response.body, metadata: response.metadata };
     }
     async deleteComment(request) {
+        const queryParams = {
+            hard_delete: request?.hard_delete,
+        };
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
         };
-        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/comments/{comment_id}', pathParams, undefined);
+        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/comments/{id}', pathParams, queryParams);
         decoders.DeleteCommentResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
     async getComment(request) {
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
         };
-        const response = await this.apiClient.sendRequest('GET', '/api/v2/feeds/comments/{comment_id}', pathParams, undefined);
+        const response = await this.apiClient.sendRequest('GET', '/api/v2/feeds/comments/{id}', pathParams, undefined);
         decoders.GetCommentResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
     async updateComment(request) {
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
         };
         const body = {
             comment: request?.comment,
             custom: request?.custom,
         };
-        const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/comments/{comment_id}', pathParams, undefined, body, 'application/json');
+        const response = await this.apiClient.sendRequest('PATCH', '/api/v2/feeds/comments/{id}', pathParams, undefined, body, 'application/json');
         decoders.UpdateCommentResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
     async addCommentReaction(request) {
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
         };
         const body = {
             type: request?.type,
             create_notification_activity: request?.create_notification_activity,
             custom: request?.custom,
         };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/comments/{comment_id}/reactions', pathParams, undefined, body, 'application/json');
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/comments/{id}/reactions', pathParams, undefined, body, 'application/json');
         decoders.AddCommentReactionResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
     async queryCommentReactions(request) {
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
         };
         const body = {
             limit: request?.limit,
@@ -2087,16 +2121,16 @@ class FeedsApi {
             sort: request?.sort,
             filter: request?.filter,
         };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/comments/{comment_id}/reactions/query', pathParams, undefined, body, 'application/json');
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/comments/{id}/reactions/query', pathParams, undefined, body, 'application/json');
         decoders.QueryCommentReactionsResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
     async deleteCommentReaction(request) {
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
             type: request?.type,
         };
-        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/comments/{comment_id}/reactions/{type}', pathParams, undefined);
+        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/feeds/comments/{id}/reactions/{type}', pathParams, undefined);
         decoders.DeleteCommentReactionResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
@@ -2110,9 +2144,9 @@ class FeedsApi {
             next: request?.next,
         };
         const pathParams = {
-            comment_id: request?.comment_id,
+            id: request?.id,
         };
-        const response = await this.apiClient.sendRequest('GET', '/api/v2/feeds/comments/{comment_id}/replies', pathParams, queryParams);
+        const response = await this.apiClient.sendRequest('GET', '/api/v2/feeds/comments/{id}/replies', pathParams, queryParams);
         decoders.GetCommentRepliesResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
@@ -2161,7 +2195,6 @@ class FeedsApi {
             feed_id: request?.feed_id,
         };
         const body = {
-            created_by_id: request?.created_by_id,
             custom: request?.custom,
         };
         const response = await this.apiClient.sendRequest('PUT', '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}', pathParams, undefined, body, 'application/json');
@@ -2177,6 +2210,7 @@ class FeedsApi {
             mark_all_read: request?.mark_all_read,
             mark_all_seen: request?.mark_all_seen,
             mark_read: request?.mark_read,
+            mark_seen: request?.mark_seen,
             mark_watched: request?.mark_watched,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/activities/mark/batch', pathParams, undefined, body, 'application/json');
@@ -2287,7 +2321,7 @@ class FeedsApi {
         decoders.CreateFeedsBatchResponse?.(response.body);
         return { ...response.body, metadata: response.metadata };
     }
-    async feedsQueryFeeds(request) {
+    async _queryFeeds(request) {
         const queryParams = {
             connection_id: request?.connection_id,
         };
@@ -2330,8 +2364,8 @@ class FeedsApi {
     }
     async acceptFollow(request) {
         const body = {
-            source_fid: request?.source_fid,
-            target_fid: request?.target_fid,
+            source: request?.source,
+            target: request?.target,
             follower_role: request?.follower_role,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/follows/accept', undefined, undefined, body, 'application/json');
@@ -2360,8 +2394,8 @@ class FeedsApi {
     }
     async rejectFollow(request) {
         const body = {
-            source_fid: request?.source_fid,
-            target_fid: request?.target_fid,
+            source: request?.source,
+            target: request?.target,
         };
         const response = await this.apiClient.sendRequest('POST', '/api/v2/feeds/follows/reject', undefined, undefined, body, 'application/json');
         decoders.RejectFollowResponse?.(response.body);
@@ -3741,1624 +3775,1692 @@ const decodeWSEvent = (data) => {
     }
 };
 
-class FeedApi {
-    constructor(feedsApi, group, id) {
-        this.feedsApi = feedsApi;
-        this.group = group;
-        this.id = id;
+class ModerationApi {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
     }
-    delete(request) {
-        return this.feedsApi.deleteFeed({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
+    async ban(request) {
+        const body = {
+            target_user_id: request?.target_user_id,
+            banned_by_id: request?.banned_by_id,
+            channel_cid: request?.channel_cid,
+            delete_messages: request?.delete_messages,
+            ip_ban: request?.ip_ban,
+            reason: request?.reason,
+            shadow: request?.shadow,
+            timeout: request?.timeout,
+            banned_by: request?.banned_by,
+        };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/ban', undefined, undefined, body, 'application/json');
+        decoders.BanResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    getOrCreate(request) {
-        return this.feedsApi.getOrCreateFeed({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
+    async upsertConfig(request) {
+        const body = {
+            key: request?.key,
+            async: request?.async,
+            team: request?.team,
+            ai_image_config: request?.ai_image_config,
+            ai_text_config: request?.ai_text_config,
+            ai_video_config: request?.ai_video_config,
+            automod_platform_circumvention_config: request?.automod_platform_circumvention_config,
+            automod_semantic_filters_config: request?.automod_semantic_filters_config,
+            automod_toxicity_config: request?.automod_toxicity_config,
+            aws_rekognition_config: request?.aws_rekognition_config,
+            block_list_config: request?.block_list_config,
+            bodyguard_config: request?.bodyguard_config,
+            google_vision_config: request?.google_vision_config,
+            rule_builder_config: request?.rule_builder_config,
+            velocity_filter_config: request?.velocity_filter_config,
+            video_call_rule_config: request?.video_call_rule_config,
+        };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/config', undefined, undefined, body, 'application/json');
+        decoders.UpsertConfigResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    update(request) {
-        return this.feedsApi.updateFeed({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
+    async deleteConfig(request) {
+        const queryParams = {
+            team: request?.team,
+        };
+        const pathParams = {
+            key: request?.key,
+        };
+        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/moderation/config/{key}', pathParams, queryParams);
+        decoders.DeleteModerationConfigResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    markActivity(request) {
-        return this.feedsApi.markActivity({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
+    async getConfig(request) {
+        const queryParams = {
+            team: request?.team,
+        };
+        const pathParams = {
+            key: request?.key,
+        };
+        const response = await this.apiClient.sendRequest('GET', '/api/v2/moderation/config/{key}', pathParams, queryParams);
+        decoders.GetConfigResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    unpinActivity(request) {
-        return this.feedsApi.unpinActivity({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
+    async queryModerationConfigs(request) {
+        const body = {
+            limit: request?.limit,
+            next: request?.next,
+            prev: request?.prev,
+            sort: request?.sort,
+            filter: request?.filter,
+        };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/configs', undefined, undefined, body, 'application/json');
+        decoders.QueryModerationConfigsResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    pinActivity(request) {
-        return this.feedsApi.pinActivity({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
+    async flag(request) {
+        const body = {
+            entity_id: request?.entity_id,
+            entity_type: request?.entity_type,
+            entity_creator_id: request?.entity_creator_id,
+            reason: request?.reason,
+            custom: request?.custom,
+            moderation_payload: request?.moderation_payload,
+        };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/flag', undefined, undefined, body, 'application/json');
+        decoders.FlagResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    updateFeedMembers(request) {
-        return this.feedsApi.updateFeedMembers({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
-    }
-    acceptFeedMemberInvite(request) {
-        return this.feedsApi.acceptFeedMemberInvite({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
-    }
-    queryFeedMembers(request) {
-        return this.feedsApi.queryFeedMembers({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
-    }
-    rejectFeedMemberInvite(request) {
-        return this.feedsApi.rejectFeedMemberInvite({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
-    }
-    stopWatching(request) {
-        return this.feedsApi.stopWatchingFeed({
-            feed_id: this.id,
-            feed_group_id: this.group,
-            ...request,
-        });
-    }
-}
-
-const addActivitiesToState = (newActivities, activities, position) => {
-    let result;
-    if (activities === undefined) {
-        activities = [];
-        result = {
-            changed: true,
-            activities,
+    async mute(request) {
+        const body = {
+            target_ids: request?.target_ids,
+            timeout: request?.timeout,
         };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/mute', undefined, undefined, body, 'application/json');
+        decoders.MuteResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    else {
-        result = {
-            changed: false,
-            activities,
+    async queryReviewQueue(request) {
+        const body = {
+            limit: request?.limit,
+            lock_count: request?.lock_count,
+            lock_duration: request?.lock_duration,
+            lock_items: request?.lock_items,
+            next: request?.next,
+            prev: request?.prev,
+            stats_only: request?.stats_only,
+            sort: request?.sort,
+            filter: request?.filter,
         };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/review_queue', undefined, undefined, body, 'application/json');
+        decoders.QueryReviewQueueResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-    const newActivitiesDeduplicated = [];
-    newActivities.forEach((newActivityResponse) => {
-        const index = activities.findIndex((a) => a.id === newActivityResponse.id);
-        if (index === -1) {
-            newActivitiesDeduplicated.push(newActivityResponse);
-        }
-    });
-    if (newActivitiesDeduplicated.length > 0) {
-        // TODO: since feed activities are not necessarily ordered by created_at (personalization) we don't order by created_at
-        // Maybe we can add a flag to the JS client to support order by created_at
-        const updatedActivities = [
-            ...(position === 'start' ? newActivitiesDeduplicated : []),
-            ...activities,
-            ...(position === 'end' ? newActivitiesDeduplicated : []),
-        ];
-        result = { changed: true, activities: updatedActivities };
-    }
-    return result;
-};
-const updateActivityInState = (updatedActivityResponse, activities) => {
-    const index = activities.findIndex((a) => a.id === updatedActivityResponse.id);
-    if (index !== -1) {
-        const newActivities = [...activities];
-        const activity = activities[index];
-        newActivities[index] = {
-            ...updatedActivityResponse,
-            own_reactions: activity.own_reactions,
-            own_bookmarks: activity.own_bookmarks,
-            latest_reactions: activity.latest_reactions,
-            reaction_groups: activity.reaction_groups,
+    async submitAction(request) {
+        const body = {
+            action_type: request?.action_type,
+            item_id: request?.item_id,
+            ban: request?.ban,
+            custom: request?.custom,
+            delete_activity: request?.delete_activity,
+            delete_message: request?.delete_message,
+            delete_reaction: request?.delete_reaction,
+            delete_user: request?.delete_user,
+            mark_reviewed: request?.mark_reviewed,
+            unban: request?.unban,
         };
-        return { changed: true, activities: newActivities };
-    }
-    else {
-        return { changed: false, activities };
-    }
-};
-const removeActivityFromState = (activityResponse, activities) => {
-    const index = activities.findIndex((a) => a.id === activityResponse.id);
-    if (index !== -1) {
-        const newActivities = [...activities];
-        newActivities.splice(index, 1);
-        return { changed: true, activities: newActivities };
-    }
-    else {
-        return { changed: false, activities };
+        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/submit_action', undefined, undefined, body, 'application/json');
+        decoders.SubmitActionResponse?.(response.body);
+        return { ...response.body, metadata: response.metadata };
     }
-};
+}
 
-const updateActivityInActivities$1 = (updatedActivity, activities) => {
-    const index = activities.findIndex((a) => a.id === updatedActivity.id);
-    if (index !== -1) {
-        const newActivities = [...activities];
-        newActivities[index] = updatedActivity;
-        return { changed: true, activities: newActivities };
-    }
-    else {
-        return { changed: false, activities };
-    }
-};
-const addReactionToActivity = (event, activity, isCurrentUser) => {
-    // Update own_reactions if the reaction is from the current user
-    const ownReactions = [...(activity.own_reactions || [])];
-    if (isCurrentUser) {
-        ownReactions.push(event.reaction);
-    }
-    return {
-        ...activity,
-        own_reactions: ownReactions,
-        latest_reactions: event.activity.latest_reactions,
-        reaction_groups: event.activity.reaction_groups,
-        changed: true,
-    };
-};
-const removeReactionFromActivity = (event, activity, isCurrentUser) => {
-    // Update own_reactions if the reaction is from the current user
-    const ownReactions = isCurrentUser
-        ? (activity.own_reactions || []).filter((r) => !(r.type === event.reaction.type &&
-            r.user.id === event.reaction.user.id))
-        : activity.own_reactions;
-    return {
-        ...activity,
-        own_reactions: ownReactions,
-        latest_reactions: event.activity.latest_reactions,
-        reaction_groups: event.activity.reaction_groups,
-        changed: true,
-    };
-};
-const addReactionToActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = addReactionToActivity(event, activity, isCurrentUser);
-    return updateActivityInActivities$1(updatedActivity, activities);
-};
-const removeReactionFromActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = removeReactionFromActivity(event, activity, isCurrentUser);
-    return updateActivityInActivities$1(updatedActivity, activities);
-};
+class ModerationClient extends ModerationApi {
+}
 
-// Helper function to check if two bookmarks are the same
-// A bookmark is identified by activity_id + folder_id + user_id
-const isSameBookmark = (bookmark1, bookmark2) => {
-    return (bookmark1.user.id === bookmark2.user.id &&
-        bookmark1.activity.id === bookmark2.activity.id &&
-        bookmark1.folder?.id === bookmark2.folder?.id);
-};
-const updateActivityInActivities = (updatedActivity, activities) => {
-    const index = activities.findIndex((a) => a.id === updatedActivity.id);
-    if (index !== -1) {
-        const newActivities = [...activities];
-        newActivities[index] = updatedActivity;
-        return { changed: true, activities: newActivities };
-    }
-    else {
-        return { changed: false, activities };
-    }
-};
-const addBookmarkToActivity = (event, activity, isCurrentUser) => {
-    // Update own_bookmarks if the bookmark is from the current user
-    const ownBookmarks = [...(activity.own_bookmarks || [])];
-    if (isCurrentUser) {
-        ownBookmarks.push(event.bookmark);
-    }
-    return {
-        ...activity,
-        own_bookmarks: ownBookmarks,
-        changed: true,
-    };
-};
-const removeBookmarkFromActivity = (event, activity, isCurrentUser) => {
-    // Update own_bookmarks if the bookmark is from the current user
-    const ownBookmarks = isCurrentUser
-        ? (activity.own_bookmarks || []).filter((bookmark) => !isSameBookmark(bookmark, event.bookmark))
-        : activity.own_bookmarks;
-    return {
-        ...activity,
-        own_bookmarks: ownBookmarks,
-        changed: true,
-    };
-};
-const updateBookmarkInActivity = (event, activity, isCurrentUser) => {
-    // Update own_bookmarks if the bookmark is from the current user
-    let ownBookmarks = activity.own_bookmarks || [];
-    if (isCurrentUser) {
-        const bookmarkIndex = ownBookmarks.findIndex((bookmark) => isSameBookmark(bookmark, event.bookmark));
-        if (bookmarkIndex !== -1) {
-            ownBookmarks = [...ownBookmarks];
-            ownBookmarks[bookmarkIndex] = event.bookmark;
-        }
-    }
-    return {
-        ...activity,
-        own_bookmarks: ownBookmarks,
-        changed: true,
-    };
-};
-const addBookmarkToActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = addBookmarkToActivity(event, activity, isCurrentUser);
-    return updateActivityInActivities(updatedActivity, activities);
-};
-const removeBookmarkFromActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = removeBookmarkFromActivity(event, activity, isCurrentUser);
-    return updateActivityInActivities(updatedActivity, activities);
-};
-const updateBookmarkInActivities = (event, activities, isCurrentUser) => {
-    if (!activities) {
-        return { changed: false, activities: [] };
-    }
-    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
-    if (activityIndex === -1) {
-        return { changed: false, activities };
-    }
-    const activity = activities[activityIndex];
-    const updatedActivity = updateBookmarkInActivity(event, activity, isCurrentUser);
-    return updateActivityInActivities(updatedActivity, activities);
-};
-
-const isFeedResponse = (follow) => {
-    return 'created_by' in follow;
-};
-const handleFollowCreated = (follow, currentState, currentFeedId, connectedUserId) => {
-    // filter non-accepted follows (the way getOrCreate does by default)
-    if (follow.status !== 'accepted') {
-        return { changed: false, data: currentState };
-    }
-    let newState = { ...currentState };
-    // this feed followed someone
-    if (follow.source_feed.fid === currentFeedId) {
-        newState = {
-            ...newState,
-            // Update FeedResponse fields, that has the new follower/following count
-            ...follow.source_feed,
+const isPollUpdatedEvent = (e) => e.type === 'feeds.poll.updated';
+const isPollClosedEventEvent = (e) => e.type === 'feeds.poll.closed';
+const isPollVoteCastedEvent = (e) => e.type === 'feeds.poll.vote_casted';
+const isPollVoteChangedEvent = (e) => e.type === 'feeds.poll.vote_changed';
+const isPollVoteRemovedEvent = (e) => e.type === 'feeds.poll.vote_removed';
+const isVoteAnswer = (vote) => !!vote?.answer_text;
+class StreamPoll {
+    constructor({ client, poll }) {
+        this.getInitialStateFromPollResponse = (poll) => {
+            const { own_votes, id, ...pollResponseForState } = poll;
+            const { ownAnswer, ownVotes } = own_votes?.reduce((acc, voteOrAnswer) => {
+                if (isVoteAnswer(voteOrAnswer)) {
+                    acc.ownAnswer = voteOrAnswer;
+                }
+                else {
+                    acc.ownVotes.push(voteOrAnswer);
+                }
+                return acc;
+            }, { ownVotes: [] }) ?? { ownVotes: [] };
+            return {
+                ...pollResponseForState,
+                last_activity_at: new Date(),
+                max_voted_option_ids: getMaxVotedOptionIds(pollResponseForState.vote_counts_by_option),
+                own_answer: ownAnswer,
+                own_votes_by_option_id: getOwnVotesByOptionId(ownVotes),
+            };
         };
-        // Only update if following array already exists
-        if (currentState.following !== undefined) {
-            newState.following = [follow, ...currentState.following];
-        }
-    }
-    else if (
-    // someone followed this feed
-    follow.target_feed.fid === currentFeedId) {
-        const source = follow.source_feed;
-        newState = {
-            ...newState,
-            // Update FeedResponse fields, that has the new follower/following count
-            ...follow.target_feed,
+        this.reinitializeState = (poll) => {
+            this.state.partialNext(this.getInitialStateFromPollResponse(poll));
         };
-        if (source.created_by.id === connectedUserId) {
-            newState.own_follows = currentState.own_follows
-                ? currentState.own_follows.concat(follow)
-                : [follow];
-        }
-        // Only update if followers array already exists
-        if (currentState.followers !== undefined) {
-            newState.followers = [follow, ...currentState.followers];
-        }
-    }
-    return { changed: true, data: newState };
-};
-const handleFollowDeleted = (follow, currentState, currentFeedId, connectedUserId) => {
-    let newState = { ...currentState };
-    // this feed unfollowed someone
-    if (follow.source_feed.fid === currentFeedId) {
-        newState = {
-            ...newState,
-            // Update FeedResponse fields, that has the new follower/following count
-            ...follow.source_feed,
+        this.handlePollUpdated = (event) => {
+            if (event.poll?.id && event.poll.id !== this.id)
+                return;
+            if (!isPollUpdatedEvent(event))
+                return;
+            const { id, ...pollData } = event.poll;
+            // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+            this.state.partialNext({
+                ...pollData,
+                last_activity_at: new Date(event.created_at),
+            });
         };
-        // Only update if following array already exists
-        if (currentState.following !== undefined) {
-            newState.following = currentState.following.filter((followItem) => followItem.target_feed.fid !== follow.target_feed.fid);
-        }
-    }
-    else if (
-    // someone unfollowed this feed
-    follow.target_feed.fid === currentFeedId) {
-        const source = follow.source_feed;
-        newState = {
-            ...newState,
-            // Update FeedResponse fields, that has the new follower/following count
-            ...follow.target_feed,
+        this.handlePollClosed = (event) => {
+            if (event.poll?.id && event.poll.id !== this.id)
+                return;
+            if (!isPollClosedEventEvent(event))
+                return;
+            this.state.partialNext({
+                is_closed: true,
+                last_activity_at: new Date(event.created_at),
+            });
         };
-        if (isFeedResponse(source) &&
-            source.created_by.id === connectedUserId &&
-            currentState.own_follows !== undefined) {
-            newState.own_follows = currentState.own_follows.filter((followItem) => followItem.source_feed.fid !== follow.source_feed.fid);
-        }
-        // Only update if followers array already exists
-        if (currentState.followers !== undefined) {
-            newState.followers = currentState.followers.filter((followItem) => followItem.source_feed.fid !== follow.source_feed.fid);
-        }
-    }
-    return { changed: true, data: newState };
-};
-const handleFollowUpdated = (currentState) => {
-    // For now, we'll treat follow updates as no-ops since the current implementation does
-    // This can be enhanced later if needed
-    return { changed: false, data: currentState };
-};
-
-const checkHasAnotherPage = (v, cursor) => (typeof v === 'undefined' && typeof cursor === 'undefined') ||
-    typeof cursor === 'string';
-const isCommentResponse = (entity) => {
-    return typeof entity?.object_id === 'string';
-};
-const Constants = {
-    DEFAULT_COMMENT_PAGINATION: 'first',
-};
-const uniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
-    const existing = new Set();
-    existingArray.forEach((value) => {
-        const key = getKey(value);
-        existing.add(key);
-    });
-    const filteredArrayToMerge = arrayToMerge.filter((value) => {
-        const key = getKey(value);
-        return !existing.has(key);
-    });
-    return existingArray.concat(filteredArrayToMerge);
-};
-
-const shouldUpdateState = ({ stateUpdateId, stateUpdateQueue, watch, }) => {
-    if (!watch) {
-        return true;
-    }
-    if (watch && stateUpdateQueue.has(stateUpdateId)) {
-        stateUpdateQueue.delete(stateUpdateId);
-        return false;
-    }
-    stateUpdateQueue.add(stateUpdateId);
-    return true;
-};
-const getStateUpdateQueueIdForFollow = (follow) => {
-    return `follow${follow.source_feed.fid}-${follow.target_feed.fid}`;
-};
-const getStateUpdateQueueIdForUnfollow = (follow) => {
-    return `unfollow${follow.source_feed.fid}-${follow.target_feed.fid}`;
-};
-
-class Feed extends FeedApi {
-    constructor(client, groupId, id, data, watch = false) {
-        super(client, groupId, id);
-        this.stateUpdateQueue = new Set();
-        this.eventHandlers = {
-            'feeds.activity.added': (event) => {
-                const currentActivities = this.currentState.activities;
-                const result = addActivitiesToState([event.activity], currentActivities, 'start');
-                if (result.changed) {
-                    this.client.hydratePollCache([event.activity]);
-                    this.state.partialNext({ activities: result.activities });
-                }
-            },
-            'feeds.activity.deleted': (event) => {
-                const currentActivities = this.currentState.activities;
-                if (currentActivities) {
-                    const result = removeActivityFromState(event.activity, currentActivities);
-                    if (result.changed) {
-                        this.state.partialNext({ activities: result.activities });
-                    }
+        this.handleVoteCasted = (event) => {
+            if (event.poll?.id && event.poll.id !== this.id)
+                return;
+            if (!isPollVoteCastedEvent(event))
+                return;
+            const currentState = this.data;
+            const isOwnVote = event.poll_vote.user_id ===
+                this.client.state.getLatestValue().connected_user?.id;
+            let latestAnswers = [...currentState.latest_answers];
+            let ownAnswer = currentState.own_answer;
+            const ownVotesByOptionId = currentState.own_votes_by_option_id;
+            let maxVotedOptionIds = currentState.max_voted_option_ids;
+            if (isOwnVote) {
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                if (isVoteAnswer(event.poll_vote)) {
+                    // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                    ownAnswer = event.poll_vote;
                 }
-            },
-            'feeds.activity.reaction.added': (event) => {
-                const currentActivities = this.currentState.activities;
-                const connectedUser = this.client.state.getLatestValue().connected_user;
-                const isCurrentUser = Boolean(connectedUser && event.reaction.user.id === connectedUser.id);
-                const result = addReactionToActivities(event, currentActivities, isCurrentUser);
-                if (result.changed) {
-                    this.state.partialNext({ activities: result.activities });
+                else if (event.poll_vote.option_id) {
+                    // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                    ownVotesByOptionId[event.poll_vote.option_id] = event.poll_vote;
                 }
-            },
-            'feeds.activity.reaction.deleted': (event) => {
-                const currentActivities = this.currentState.activities;
-                const connectedUser = this.client.state.getLatestValue().connected_user;
-                const isCurrentUser = Boolean(connectedUser && event.reaction.user.id === connectedUser.id);
-                const result = removeReactionFromActivities(event, currentActivities, isCurrentUser);
-                if (result.changed) {
-                    this.state.partialNext({ activities: result.activities });
+            }
+            // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+            if (isVoteAnswer(event.poll_vote)) {
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                latestAnswers = [event.poll_vote, ...latestAnswers];
+            }
+            else {
+                maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
+            }
+            const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option, } = event.poll;
+            this.state.partialNext({
+                answers_count,
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                latest_votes_by_option,
+                vote_count,
+                vote_counts_by_option,
+                latest_answers: latestAnswers,
+                last_activity_at: new Date(event.created_at),
+                own_answer: ownAnswer,
+                own_votes_by_option_id: ownVotesByOptionId,
+                max_voted_option_ids: maxVotedOptionIds,
+            });
+        };
+        this.handleVoteChanged = (event) => {
+            // this event is triggered only when event.poll.enforce_unique_vote === true
+            if (event.poll?.id && event.poll.id !== this.id)
+                return;
+            if (!isPollVoteChangedEvent(event))
+                return;
+            const currentState = this.data;
+            const isOwnVote = event.poll_vote.user_id ===
+                this.client.state.getLatestValue().connected_user?.id;
+            let latestAnswers = [...currentState.latest_answers];
+            let ownAnswer = currentState.own_answer;
+            let ownVotesByOptionId = currentState.own_votes_by_option_id;
+            let maxVotedOptionIds = currentState.max_voted_option_ids;
+            if (isOwnVote) {
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                if (isVoteAnswer(event.poll_vote)) {
+                    latestAnswers = [
+                        // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                        event.poll_vote,
+                        ...latestAnswers.filter((answer) => answer.id !== event.poll_vote.id),
+                    ];
+                    // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                    ownAnswer = event.poll_vote;
                 }
-            },
-            'feeds.activity.reaction.updated': Feed.noop,
-            'feeds.activity.removed_from_feed': (event) => {
-                const currentActivities = this.currentState.activities;
-                if (currentActivities) {
-                    const result = removeActivityFromState(event.activity, currentActivities);
-                    if (result.changed) {
-                        this.state.partialNext({ activities: result.activities });
+                else if (event.poll_vote.option_id) {
+                    if (event.poll.enforce_unique_vote) {
+                        // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                        ownVotesByOptionId = { [event.poll_vote.option_id]: event.poll_vote };
                     }
-                }
-            },
-            'feeds.activity.updated': (event) => {
-                const currentActivities = this.currentState.activities;
-                if (currentActivities) {
-                    const result = updateActivityInState(event.activity, currentActivities);
-                    if (result.changed) {
-                        this.client.hydratePollCache([event.activity]);
-                        this.state.partialNext({ activities: result.activities });
+                    else {
+                        ownVotesByOptionId = Object.entries(ownVotesByOptionId).reduce((acc, [optionId, vote]) => {
+                            if (optionId !== event.poll_vote.option_id &&
+                                vote.id === event.poll_vote.id) {
+                                return acc;
+                            }
+                            acc[optionId] = vote;
+                            return acc;
+                        }, {});
+                        // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                        ownVotesByOptionId[event.poll_vote.option_id] = event.poll_vote;
+                    }
+                    if (ownAnswer?.id === event.poll_vote.id) {
+                        ownAnswer = undefined;
                     }
+                    maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
                 }
-            },
-            'feeds.bookmark.added': this.handleBookmarkAdded.bind(this),
-            'feeds.bookmark.deleted': this.handleBookmarkDeleted.bind(this),
-            'feeds.bookmark.updated': this.handleBookmarkUpdated.bind(this),
-            'feeds.bookmark_folder.deleted': Feed.noop,
-            'feeds.bookmark_folder.updated': Feed.noop,
-            'feeds.comment.added': (event) => {
-                const { comment } = event;
-                const forId = comment.parent_id ?? comment.object_id;
-                this.state.next((currentState) => {
-                    const entityState = currentState.comments_by_entity_id[forId];
-                    const newComments = entityState?.comments?.concat([]) ?? [];
-                    if (entityState?.pagination?.sort === 'last' &&
-                        !checkHasAnotherPage(entityState.comments, entityState?.pagination.next)) {
-                        newComments.unshift(comment);
-                    }
-                    else if (entityState?.pagination?.sort === 'first') {
-                        newComments.push(comment);
-                    }
-                    else {
-                        // no other sorting option is supported yet
-                        return currentState;
-                    }
-                    return {
-                        ...currentState,
-                        comments_by_entity_id: {
-                            ...currentState.comments_by_entity_id,
-                            [forId]: {
-                                ...currentState.comments_by_entity_id[forId],
-                                comments: newComments,
-                            },
-                        },
-                    };
-                });
-            },
-            'feeds.comment.deleted': ({ comment }) => {
-                const forId = comment.parent_id ?? comment.object_id;
-                this.state.next((currentState) => {
-                    const newCommentsByEntityId = {
-                        ...currentState.comments_by_entity_id,
-                        [forId]: {
-                            ...currentState.comments_by_entity_id[forId],
-                        },
-                    };
-                    const index = this.getCommentIndex(comment, currentState);
-                    if (newCommentsByEntityId?.[forId]?.comments?.length && index !== -1) {
-                        newCommentsByEntityId[forId].comments = [
-                            ...newCommentsByEntityId[forId].comments,
-                        ];
-                        newCommentsByEntityId[forId]?.comments?.splice(index, 1);
-                    }
-                    delete newCommentsByEntityId[comment.id];
-                    return {
-                        ...currentState,
-                        comments_by_entity_id: newCommentsByEntityId,
-                    };
-                });
-            },
-            'feeds.comment.updated': (event) => {
-                const { comment } = event;
-                const forId = comment.parent_id ?? comment.object_id;
-                this.state.next((currentState) => {
-                    const entityState = currentState.comments_by_entity_id[forId];
-                    if (!entityState?.comments?.length)
-                        return currentState;
-                    const index = this.getCommentIndex(comment, currentState);
-                    if (index === -1)
-                        return currentState;
-                    const newComments = [...entityState.comments];
-                    newComments[index] = comment;
-                    return {
-                        ...currentState,
-                        comments_by_entity_id: {
-                            ...currentState.comments_by_entity_id,
-                            [forId]: {
-                                ...currentState.comments_by_entity_id[forId],
-                                comments: newComments,
-                            },
-                        },
-                    };
-                });
-            },
-            'feeds.feed.created': Feed.noop,
-            'feeds.feed.deleted': Feed.noop,
-            'feeds.feed.updated': (event) => {
-                this.state.partialNext({ ...event.feed });
-            },
-            'feeds.feed_group.changed': Feed.noop,
-            'feeds.feed_group.deleted': Feed.noop,
-            'feeds.follow.created': (event) => {
-                this.handleFollowCreated(event.follow);
-            },
-            'feeds.follow.deleted': (event) => {
-                this.handleFollowDeleted(event.follow);
-            },
-            'feeds.follow.updated': (_event) => {
-                handleFollowUpdated(this.currentState);
-            },
-            'feeds.comment.reaction.added': this.handleCommentReactionEvent.bind(this),
-            'feeds.comment.reaction.deleted': this.handleCommentReactionEvent.bind(this),
-            'feeds.comment.reaction.updated': Feed.noop,
-            'feeds.feed_member.added': (event) => {
-                const { connected_user: connectedUser } = this.client.state.getLatestValue();
-                this.state.next((currentState) => {
-                    let newState;
-                    if (typeof currentState.members !== 'undefined') {
-                        newState ?? (newState = {
-                            ...currentState,
-                        });
-                        newState.members = [event.member, ...currentState.members];
-                    }
-                    if (connectedUser?.id === event.member.user.id) {
-                        newState ?? (newState = {
-                            ...currentState,
-                        });
-                        newState.own_membership = event.member;
-                    }
-                    return newState ?? currentState;
-                });
-            },
-            'feeds.feed_member.removed': (event) => {
-                const { connected_user: connectedUser } = this.client.state.getLatestValue();
-                this.state.next((currentState) => {
-                    const newState = {
-                        ...currentState,
-                        members: currentState.members?.filter((member) => member.user.id !== event.user?.id),
-                    };
-                    if (connectedUser?.id === event.member_id) {
-                        delete newState.own_membership;
-                    }
-                    return newState;
-                });
-            },
-            'feeds.feed_member.updated': (event) => {
-                const { connected_user: connectedUser } = this.client.state.getLatestValue();
-                this.state.next((currentState) => {
-                    const memberIndex = currentState.members?.findIndex((member) => member.user.id === event.member.user.id) ?? -1;
-                    let newState;
-                    if (memberIndex !== -1) {
-                        // if there's an index, there's a member to update
-                        const newMembers = [...currentState.members];
-                        newMembers[memberIndex] = event.member;
-                        newState ?? (newState = {
-                            ...currentState,
-                        });
-                        newState.members = newMembers;
-                    }
-                    if (connectedUser?.id === event.member.user.id) {
-                        newState ?? (newState = {
-                            ...currentState,
-                        });
-                        newState.own_membership = event.member;
-                    }
-                    return newState ?? currentState;
-                });
-            },
-            'feeds.notification_feed.updated': (event) => {
-                console.info('notification feed updated', event);
-                // TODO: handle notification feed updates
-            },
-            // the poll events should be removed from here
-            'feeds.poll.closed': Feed.noop,
-            'feeds.poll.deleted': Feed.noop,
-            'feeds.poll.updated': Feed.noop,
-            'feeds.poll.vote_casted': Feed.noop,
-            'feeds.poll.vote_changed': Feed.noop,
-            'feeds.poll.vote_removed': Feed.noop,
-            'feeds.activity.pinned': Feed.noop,
-            'feeds.activity.unpinned': Feed.noop,
-            'feeds.activity.marked': Feed.noop,
-            'moderation.custom_action': Feed.noop,
-            'moderation.flagged': Feed.noop,
-            'moderation.mark_reviewed': Feed.noop,
-            'health.check': Feed.noop,
-            'app.updated': Feed.noop,
-            'user.banned': Feed.noop,
-            'user.deactivated': Feed.noop,
-            'user.muted': Feed.noop,
-            'user.reactivated': Feed.noop,
-            'user.updated': Feed.noop,
-        };
-        this.eventDispatcher = new EventDispatcher();
-        this.on = this.eventDispatcher.on;
-        this.off = this.eventDispatcher.off;
-        this.state = new StateStore({
-            fid: `${groupId}:${id}`,
-            group_id: groupId,
-            id,
-            ...(data ?? {}),
-            is_loading: false,
-            is_loading_activities: false,
-            comments_by_entity_id: {},
-            watch,
-        });
-        this.client = client;
-    }
-    get fid() {
-        return `${this.group}:${this.id}`;
-    }
-    get currentState() {
-        return this.state.getLatestValue();
-    }
-    handleCommentReactionEvent(event) {
-        const { comment, reaction } = event;
-        const connectedUser = this.client.state.getLatestValue().connected_user;
-        this.state.next((currentState) => {
-            const forId = comment.parent_id ?? comment.object_id;
-            const entityState = currentState.comments_by_entity_id[forId];
-            const commentIndex = this.getCommentIndex(comment, currentState);
-            if (commentIndex === -1)
-                return currentState;
-            const newComments = entityState?.comments?.concat([]) ?? [];
-            const commentCopy = { ...comment };
-            delete commentCopy.own_reactions;
-            const newComment = {
-                ...newComments[commentIndex],
-                ...commentCopy,
-                // TODO: FIXME this should be handled by the backend
-                latest_reactions: commentCopy.latest_reactions ?? [],
-                reaction_groups: commentCopy.reaction_groups ?? {},
-            };
-            newComments[commentIndex] = newComment;
-            if (reaction.user.id === connectedUser?.id) {
-                if (event.type === 'feeds.comment.reaction.added') {
-                    newComment.own_reactions = newComment.own_reactions.concat(reaction) ?? [reaction];
-                }
-                else if (event.type === 'feeds.comment.reaction.deleted') {
-                    newComment.own_reactions = newComment.own_reactions.filter((r) => r.type !== reaction.type);
-                }
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
             }
-            return {
-                ...currentState,
-                comments_by_entity_id: {
-                    ...currentState.comments_by_entity_id,
-                    [forId]: {
-                        ...entityState,
-                        comments: newComments,
-                    },
-                },
-            };
-        });
-    }
-    async synchronize() {
-        const { last_get_or_create_request_config } = this.state.getLatestValue();
-        if (last_get_or_create_request_config?.watch) {
-            await this.getOrCreate(last_get_or_create_request_config);
-        }
-    }
-    async getOrCreate(request) {
-        if (this.currentState.is_loading_activities) {
-            throw new Error('Only one getOrCreate call is allowed at a time');
-        }
-        this.state.partialNext({
-            is_loading: !request?.next,
-            is_loading_activities: true,
-        });
-        // TODO: pull comments/comment_pagination from activities and comment_sort from request
-        // and pre-populate comments_by_entity_id (once comment_sort and comment_limit are supported)
-        try {
-            const response = await super.getOrCreate(request);
-            if (request?.next) {
-                const { activities: currentActivities = [] } = this.currentState;
-                const result = addActivitiesToState(response.activities, currentActivities, 'end');
-                if (result.changed) {
-                    this.state.partialNext({
-                        activities: result.activities,
-                        next: response.next,
-                        prev: response.prev,
-                    });
+            else if (isVoteAnswer(event.poll_vote)) {
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                latestAnswers = [event.poll_vote, ...latestAnswers];
+            }
+            else {
+                maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
+            }
+            const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option, } = event.poll;
+            this.state.partialNext({
+                answers_count,
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                latest_votes_by_option,
+                vote_count,
+                vote_counts_by_option,
+                latest_answers: latestAnswers,
+                last_activity_at: new Date(event.created_at),
+                own_answer: ownAnswer,
+                own_votes_by_option_id: ownVotesByOptionId,
+                max_voted_option_ids: maxVotedOptionIds,
+            });
+        };
+        this.handleVoteRemoved = (event) => {
+            if (event.poll?.id && event.poll.id !== this.id)
+                return;
+            if (!isPollVoteRemovedEvent(event))
+                return;
+            const currentState = this.data;
+            const isOwnVote = event.poll_vote.user_id ===
+                this.client.state.getLatestValue().connected_user?.id;
+            let latestAnswers = [...currentState.latest_answers];
+            let ownAnswer = currentState.own_answer;
+            const ownVotesByOptionId = { ...currentState.own_votes_by_option_id };
+            let maxVotedOptionIds = currentState.max_voted_option_ids;
+            // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+            if (isVoteAnswer(event.poll_vote)) {
+                latestAnswers = latestAnswers.filter((answer) => answer.id !== event.poll_vote.id);
+                if (isOwnVote) {
+                    ownAnswer = undefined;
                 }
             }
             else {
-                // Empty queue when reinitializing the state
-                this.stateUpdateQueue.clear();
-                const responseCopy = {
-                    ...response,
-                    ...response.feed,
-                };
-                delete responseCopy.feed;
-                delete responseCopy.metadata;
-                delete responseCopy.duration;
-                this.state.next((currentState) => {
-                    const nextState = {
-                        ...currentState,
-                        ...responseCopy,
-                    };
-                    if (!request?.followers_pagination?.limit) {
-                        delete nextState.followers;
-                    }
-                    if (!request?.following_pagination?.limit) {
-                        delete nextState.following;
-                    }
-                    if (response.members.length === 0 && response.feed.member_count > 0) {
-                        delete nextState.members;
-                    }
-                    nextState.last_get_or_create_request_config = request;
-                    nextState.watch = request?.watch ? request.watch : currentState.watch;
-                    return nextState;
-                });
+                maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
+                if (isOwnVote && event.poll_vote.option_id) {
+                    delete ownVotesByOptionId[event.poll_vote.option_id];
+                }
             }
-            this.client.hydratePollCache(response.activities);
-            return response;
-        }
-        finally {
+            const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option, } = event.poll;
             this.state.partialNext({
-                is_loading: false,
-                is_loading_activities: false,
+                answers_count,
+                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
+                latest_votes_by_option,
+                vote_count,
+                vote_counts_by_option,
+                latest_answers: latestAnswers,
+                last_activity_at: new Date(event.created_at),
+                own_answer: ownAnswer,
+                own_votes_by_option_id: ownVotesByOptionId,
+                max_voted_option_ids: maxVotedOptionIds,
             });
-        }
+        };
+        this.client = client;
+        this.id = poll.id;
+        this.state = new StateStore(this.getInitialStateFromPollResponse(poll));
     }
-    /**
-     * @internal
-     */
-    handleFollowCreated(follow) {
-        if (!shouldUpdateState({
-            stateUpdateId: getStateUpdateQueueIdForFollow(follow),
-            stateUpdateQueue: this.stateUpdateQueue,
-            watch: this.currentState.watch,
-        })) {
-            return;
-        }
-        const connectedUser = this.client.state.getLatestValue().connected_user;
-        const result = handleFollowCreated(follow, this.currentState, this.fid, connectedUser?.id);
-        if (result.changed) {
-            this.state.next(result.data);
-        }
+    get data() {
+        return this.state.getLatestValue();
     }
-    /**
-     * @internal
-     */
-    handleFollowDeleted(follow) {
-        if (!shouldUpdateState({
-            stateUpdateId: getStateUpdateQueueIdForUnfollow(follow),
-            stateUpdateQueue: this.stateUpdateQueue,
-            watch: this.currentState.watch,
-        })) {
-            return;
+}
+function getMaxVotedOptionIds(voteCountsByOption) {
+    let maxVotes = 0;
+    let winningOptions = [];
+    for (const [id, count] of Object.entries(voteCountsByOption ?? {})) {
+        if (count > maxVotes) {
+            winningOptions = [id];
+            maxVotes = count;
         }
-        const connectedUser = this.client.state.getLatestValue().connected_user;
-        const result = handleFollowDeleted(follow, this.currentState, this.fid, connectedUser?.id);
-        {
-            this.state.next(result.data);
+        else if (count === maxVotes) {
+            winningOptions.push(id);
         }
     }
-    /**
-     * @internal
-     */
-    handleWatchStopped() {
-        this.state.partialNext({
-            watch: false,
-        });
-    }
-    /**
-     * @internal
-     */
-    handleWatchStarted() {
-        this.state.partialNext({
-            watch: true,
+    return winningOptions;
+}
+function getOwnVotesByOptionId(ownVotes) {
+    return !ownVotes
+        ? {}
+        : ownVotes.reduce((acc, vote) => {
+            if (isVoteAnswer(vote) || !vote.option_id)
+                return acc;
+            acc[vote.option_id] = vote;
+            return acc;
+        }, {});
+}
+
+class FeedApi {
+    constructor(feedsApi, group, id) {
+        this.feedsApi = feedsApi;
+        this.group = group;
+        this.id = id;
+    }
+    delete(request) {
+        return this.feedsApi.deleteFeed({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
         });
     }
-    handleBookmarkAdded(event) {
-        const currentActivities = this.currentState.activities;
-        const { connected_user: connectedUser } = this.client.state.getLatestValue();
-        const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-        const result = addBookmarkToActivities(event, currentActivities, isCurrentUser);
-        if (result.changed) {
-            this.state.partialNext({ activities: result.activities });
-        }
+    getOrCreate(request) {
+        return this.feedsApi.getOrCreateFeed({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
     }
-    handleBookmarkDeleted(event) {
-        const currentActivities = this.currentState.activities;
-        const { connected_user: connectedUser } = this.client.state.getLatestValue();
-        const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-        const result = removeBookmarkFromActivities(event, currentActivities, isCurrentUser);
-        if (result.changed) {
-            this.state.partialNext({ activities: result.activities });
-        }
+    update(request) {
+        return this.feedsApi.updateFeed({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
     }
-    handleBookmarkUpdated(event) {
-        const currentActivities = this.currentState.activities;
-        const { connected_user: connectedUser } = this.client.state.getLatestValue();
-        const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-        const result = updateBookmarkInActivities(event, currentActivities, isCurrentUser);
-        if (result.changed) {
-            this.state.partialNext({ activities: result.activities });
-        }
+    markActivity(request) {
+        return this.feedsApi.markActivity({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
     }
-    /**
-     * Returns index of the provided comment object.
-     */
-    getCommentIndex(comment, state) {
-        const { comments_by_entity_id = {} } = state ?? this.currentState;
-        const currentComments = comments_by_entity_id[comment.parent_id ?? comment.object_id]?.comments;
-        if (!currentComments?.length) {
-            return -1;
-        }
-        // @ts-expect-error this will just fail if the comment is not object from state
-        let commentIndex = currentComments.indexOf(comment);
-        // fast lookup failed, try slower approach
-        if (commentIndex === -1) {
-            commentIndex = currentComments.findIndex((comment_) => comment_.id === comment.id);
-        }
-        return commentIndex;
+    unpinActivity(request) {
+        return this.feedsApi.unpinActivity({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
     }
-    /**
-     * Load child comments of entity (activity or comment) into the state, if the target entity is comment,
-     * `entityParentId` should be provided (`CommentResponse.parent_id ?? CommentResponse.object_id`).
-     */
-    loadCommentsIntoState(data) {
-        // add initial (top level) object for processing
-        const traverseArray = [
-            {
-                entityId: data.entityId,
-                entityParentId: data.entityParentId,
-                comments: data.comments,
-                next: data.next,
-            },
-        ];
-        this.state.next((currentState) => {
-            const newCommentsByEntityId = {
-                ...currentState.comments_by_entity_id,
-            };
-            while (traverseArray.length) {
-                const item = traverseArray.pop();
-                const entityId = item.entityId;
-                // go over entity comments and generate new objects
-                // for further processing if there are any replies
-                item.comments.forEach((comment) => {
-                    if (!comment.replies?.length)
-                        return;
-                    traverseArray.push({
-                        entityId: comment.id,
-                        entityParentId: entityId,
-                        comments: comment.replies,
-                        next: comment.meta?.next_cursor,
-                    });
-                });
-                // omit replies & meta from the comments (transform ThreadedCommentResponse to CommentResponse)
-                // this is somehow faster than copying the whole
-                // object and deleting the desired properties
-                const newComments = item.comments.map(({ replies: _r, meta: _m, ...restOfTheCommentResponse }) => restOfTheCommentResponse);
-                newCommentsByEntityId[entityId] = {
-                    ...newCommentsByEntityId[entityId],
-                    entity_parent_id: item.entityParentId,
-                    pagination: {
-                        ...newCommentsByEntityId[entityId]?.pagination,
-                        next: item.next,
-                        sort: data.sort,
-                    },
-                    comments: newCommentsByEntityId[entityId]?.comments
-                        ? newCommentsByEntityId[entityId].comments?.concat(newComments)
-                        : newComments,
-                };
-            }
-            return {
-                ...currentState,
-                comments_by_entity_id: newCommentsByEntityId,
-            };
+    pinActivity(request) {
+        return this.feedsApi.pinActivity({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
         });
     }
-    async loadNextPageComments({ entityId, base, sort, entityParentId, }) {
-        let error;
-        try {
-            this.state.next((currentState) => ({
-                ...currentState,
-                comments_by_entity_id: {
-                    ...currentState.comments_by_entity_id,
-                    [entityId]: {
-                        ...currentState.comments_by_entity_id[entityId],
-                        pagination: {
-                            ...currentState.comments_by_entity_id[entityId]?.pagination,
-                            loading_next_page: true,
-                        },
-                    },
-                },
-            }));
-            const { next, comments } = await base();
-            this.loadCommentsIntoState({
-                entityId,
-                comments,
-                entityParentId,
-                next,
-                sort,
-            });
-        }
-        catch (e) {
-            error = e;
-        }
-        finally {
-            this.state.next((currentState) => ({
-                ...currentState,
-                comments_by_entity_id: {
-                    ...currentState.comments_by_entity_id,
-                    [entityId]: {
-                        ...currentState.comments_by_entity_id[entityId],
-                        pagination: {
-                            ...currentState.comments_by_entity_id[entityId]?.pagination,
-                            loading_next_page: false,
-                        },
-                    },
-                },
-            }));
-        }
-        if (error) {
-            throw error;
-        }
+    updateFeedMembers(request) {
+        return this.feedsApi.updateFeedMembers({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
     }
-    async loadNextPageActivityComments(activity, request) {
-        const currentEntityState = this.currentState.comments_by_entity_id[activity.id];
-        const currentPagination = currentEntityState?.pagination;
-        const currentNextCursor = currentPagination?.next;
-        const currentSort = currentPagination?.sort;
-        const isLoading = currentPagination?.loading_next_page;
-        const sort = currentSort ?? request?.sort ?? Constants.DEFAULT_COMMENT_PAGINATION;
-        if (isLoading ||
-            !checkHasAnotherPage(currentEntityState?.comments, currentNextCursor)) {
-            return;
-        }
-        await this.loadNextPageComments({
-            entityId: activity.id,
-            base: () => this.client.getComments({
-                ...request,
-                sort,
-                object_id: activity.id,
-                object_type: 'activity',
-                next: currentNextCursor,
-            }),
-            sort,
+    acceptFeedMemberInvite(request) {
+        return this.feedsApi.acceptFeedMemberInvite({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
         });
     }
-    async loadNextPageCommentReplies(comment, request) {
-        const currentEntityState = this.currentState.comments_by_entity_id[comment.id];
-        const currentPagination = currentEntityState?.pagination;
-        const currentNextCursor = currentPagination?.next;
-        const currentSort = currentPagination?.sort;
-        const isLoading = currentPagination?.loading_next_page;
-        const sort = currentSort ?? request?.sort ?? Constants.DEFAULT_COMMENT_PAGINATION;
-        if (isLoading ||
-            !checkHasAnotherPage(currentEntityState?.comments, currentNextCursor)) {
-            return;
-        }
-        await this.loadNextPageComments({
-            entityId: comment.id,
-            base: () => this.client.getCommentReplies({
-                ...request,
-                comment_id: comment.id,
-                // use known sort first (prevents broken pagination)
-                sort: currentSort ??
-                    request?.sort ??
-                    Constants.DEFAULT_COMMENT_PAGINATION,
-                next: currentNextCursor,
-            }),
-            entityParentId: comment.parent_id ?? comment.object_id,
-            sort,
+    queryFeedMembers(request) {
+        return this.feedsApi.queryFeedMembers({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
         });
     }
-    async loadNextPageFollows(type, request) {
-        const paginationKey = `${type}_pagination`;
-        const method = `query${capitalize(type)}`;
-        const currentFollows = this.currentState[type];
-        const currentNextCursor = this.currentState[paginationKey]?.next;
-        const isLoading = this.currentState[paginationKey]?.loading_next_page;
-        const sort = this.currentState[paginationKey]?.sort ?? request.sort;
-        let error;
-        if (isLoading || !checkHasAnotherPage(currentFollows, currentNextCursor)) {
-            return;
-        }
-        try {
-            this.state.next((currentState) => {
-                return {
-                    ...currentState,
-                    [paginationKey]: {
-                        ...currentState[paginationKey],
-                        loading_next_page: true,
-                    },
-                };
-            });
-            const { next: newNextCursor, follows } = await this[method]({
-                ...request,
-                next: currentNextCursor,
-                sort,
-            });
-            this.state.next((currentState) => {
-                return {
-                    ...currentState,
-                    [type]: currentState[type] === undefined
-                        ? follows
-                        : uniqueArrayMerge(currentState[type], follows, (follow) => `${follow.source_feed.fid}-${follow.target_feed.fid}`),
-                    [paginationKey]: {
-                        ...currentState[paginationKey],
-                        next: newNextCursor,
-                        sort,
-                    },
-                };
-            });
+    rejectFeedMemberInvite(request) {
+        return this.feedsApi.rejectFeedMemberInvite({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
+    }
+    stopWatching(request) {
+        return this.feedsApi.stopWatchingFeed({
+            feed_id: this.id,
+            feed_group_id: this.group,
+            ...request,
+        });
+    }
+}
+
+const checkHasAnotherPage = (v, cursor) => (typeof v === 'undefined' && typeof cursor === 'undefined') ||
+    typeof cursor === 'string';
+
+const uniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
+    const existing = new Set();
+    existingArray.forEach((value) => {
+        const key = getKey(value);
+        existing.add(key);
+    });
+    const filteredArrayToMerge = arrayToMerge.filter((value) => {
+        const key = getKey(value);
+        return !existing.has(key);
+    });
+    return existingArray.concat(filteredArrayToMerge);
+};
+
+const Constants = {
+    DEFAULT_COMMENT_PAGINATION: 'first',
+};
+
+const isFollowResponse = (data) => {
+    return 'source_feed' in data && 'target_feed' in data;
+};
+const isCommentResponse = (entity) => {
+    return typeof entity?.object_id === 'string';
+};
+
+const shouldUpdateState = ({ stateUpdateQueueId, stateUpdateQueue, watch, }) => {
+    if (!watch) {
+        return true;
+    }
+    if (watch && stateUpdateQueue.has(stateUpdateQueueId)) {
+        stateUpdateQueue.delete(stateUpdateQueueId);
+        return false;
+    }
+    stateUpdateQueue.add(stateUpdateQueueId);
+    return true;
+};
+function getStateUpdateQueueId(data, prefix) {
+    if (isFollowResponse(data)) {
+        const toJoin = [data.source_feed.feed, data.target_feed.feed];
+        if (prefix) {
+            toJoin.unshift(prefix);
         }
-        catch (e) {
-            error = e;
+        return toJoin.join('-');
+    }
+    // else if (isMemberResponse(data)) {
+    // }
+    throw new Error(`Cannot create state update queueId for data: ${JSON.stringify(data)}`);
+}
+
+const updateStateFollowCreated = (follow, currentState, currentFeedId, connectedUserId) => {
+    // filter non-accepted follows (the way getOrCreate does by default)
+    if (follow.status !== 'accepted') {
+        return { changed: false, data: currentState };
+    }
+    let newState = { ...currentState };
+    // this feed followed someone
+    if (follow.source_feed.feed === currentFeedId) {
+        newState = {
+            ...newState,
+            // Update FeedResponse fields, that has the new follower/following count
+            ...follow.source_feed,
+        };
+        // Only update if following array already exists
+        if (currentState.following !== undefined) {
+            newState.following = [follow, ...currentState.following];
         }
-        finally {
-            this.state.next((currentState) => {
-                return {
-                    ...currentState,
-                    [paginationKey]: {
-                        ...currentState[paginationKey],
-                        loading_next_page: false,
-                    },
-                };
-            });
+    }
+    else if (
+    // someone followed this feed
+    follow.target_feed.feed === currentFeedId) {
+        const source = follow.source_feed;
+        newState = {
+            ...newState,
+            // Update FeedResponse fields, that has the new follower/following count
+            ...follow.target_feed,
+        };
+        if (source.created_by.id === connectedUserId) {
+            newState.own_follows = currentState.own_follows
+                ? currentState.own_follows.concat(follow)
+                : [follow];
         }
-        if (error) {
-            throw error;
+        // Only update if followers array already exists
+        if (currentState.followers !== undefined) {
+            newState.followers = [follow, ...currentState.followers];
         }
     }
-    async loadNextPageFollowers(request) {
-        await this.loadNextPageFollows('followers', request);
+    return { changed: true, data: newState };
+};
+function handleFollowCreated(eventOrResponse) {
+    const follow = eventOrResponse.follow;
+    if (!shouldUpdateState({
+        stateUpdateQueueId: getStateUpdateQueueId(follow, 'created'),
+        stateUpdateQueue: this.stateUpdateQueue,
+        watch: this.currentState.watch,
+    })) {
+        return;
     }
-    async loadNextPageFollowing(request) {
-        await this.loadNextPageFollows('following', request);
+    const connectedUser = this.client.state.getLatestValue().connected_user;
+    const result = updateStateFollowCreated(follow, this.currentState, this.feed, connectedUser?.id);
+    if (result.changed) {
+        this.state.next(result.data);
     }
-    async loadNextPageMembers(request) {
-        const currentMembers = this.currentState.members;
-        const currentNextCursor = this.currentState.member_pagination?.next;
-        const isLoading = this.currentState.member_pagination?.loading_next_page;
-        const sort = this.currentState.member_pagination?.sort ?? request.sort;
-        let error;
-        if (isLoading || !checkHasAnotherPage(currentMembers, currentNextCursor)) {
-            return;
+}
+
+const updateStateFollowDeleted = (follow, currentState, currentFeedId, connectedUserId) => {
+    let newState = { ...currentState };
+    // this feed unfollowed someone
+    if (follow.source_feed.feed === currentFeedId) {
+        newState = {
+            ...newState,
+            // Update FeedResponse fields, that has the new follower/following count
+            ...follow.source_feed,
+        };
+        // Only update if following array already exists
+        if (currentState.following !== undefined) {
+            newState.following = currentState.following.filter((followItem) => followItem.target_feed.feed !== follow.target_feed.feed);
         }
-        try {
-            this.state.next((currentState) => ({
+    }
+    else if (
+    // someone unfollowed this feed
+    follow.target_feed.feed === currentFeedId) {
+        const source = follow.source_feed;
+        newState = {
+            ...newState,
+            // Update FeedResponse fields, that has the new follower/following count
+            ...follow.target_feed,
+        };
+        if (source.created_by.id === connectedUserId &&
+            currentState.own_follows !== undefined) {
+            newState.own_follows = currentState.own_follows.filter((followItem) => followItem.source_feed.feed !== follow.source_feed.feed);
+        }
+        // Only update if followers array already exists
+        if (currentState.followers !== undefined) {
+            newState.followers = currentState.followers.filter((followItem) => followItem.source_feed.feed !== follow.source_feed.feed);
+        }
+    }
+    return { changed: true, data: newState };
+};
+function handleFollowDeleted(eventOrResponse) {
+    const follow = eventOrResponse.follow;
+    if (!shouldUpdateState({
+        stateUpdateQueueId: getStateUpdateQueueId(follow, 'deleted'),
+        stateUpdateQueue: this.stateUpdateQueue,
+        watch: this.currentState.watch,
+    })) {
+        return;
+    }
+    const connectedUser = this.client.state.getLatestValue().connected_user;
+    const result = updateStateFollowDeleted(follow, this.currentState, this.feed, connectedUser?.id);
+    {
+        this.state.next(result.data);
+    }
+}
+
+function handleFollowUpdated(eventOrResponse) {
+    const follow = eventOrResponse.follow;
+    const connectedUserId = this.client.state.getLatestValue().connected_user?.id;
+    const currentFeedId = this.feed;
+    if (!shouldUpdateState({
+        stateUpdateQueueId: getStateUpdateQueueId(follow, 'updated'),
+        stateUpdateQueue: this.stateUpdateQueue,
+        watch: this.currentState.watch,
+    })) {
+        return;
+    }
+    this.state.next((currentState) => {
+        let newState;
+        // this feed followed someone
+        if (follow.source_feed.feed === currentFeedId) {
+            newState ?? (newState = {
                 ...currentState,
-                member_pagination: {
-                    ...currentState.member_pagination,
-                    loading_next_page: true,
-                },
-            }));
-            const { next: newNextCursor, members } = await this.client.queryFeedMembers({
-                ...request,
-                sort,
-                feed_id: this.id,
-                feed_group_id: this.group,
-                next: currentNextCursor,
+                // Update FeedResponse fields, that has the new follower/following count
+                ...follow.source_feed,
             });
-            this.state.next((currentState) => ({
+            const index = currentState.following?.findIndex((f) => f.target_feed.feed === follow.target_feed.feed) ?? -1;
+            if (index >= 0) {
+                newState.following = [...newState.following];
+                newState.following[index] = follow;
+            }
+        }
+        else if (
+        // someone followed this feed
+        follow.target_feed.feed === currentFeedId) {
+            const source = follow.source_feed;
+            newState ?? (newState = {
                 ...currentState,
-                members: currentState.members
-                    ? uniqueArrayMerge(currentState.members, members, ({ user }) => user.id)
-                    : members,
-                member_pagination: {
-                    ...currentState.member_pagination,
-                    next: newNextCursor,
-                    // set sort if not defined yet
-                    sort: currentState.member_pagination?.sort ?? request.sort,
-                },
-            }));
+                // Update FeedResponse fields, that has the new follower/following count
+                ...follow.target_feed,
+            });
+            if (source.created_by.id === connectedUserId &&
+                currentState.own_follows) {
+                const index = currentState.own_follows.findIndex((f) => f.source_feed.feed === follow.source_feed.feed);
+                if (index >= 0) {
+                    newState.own_follows = [...currentState.own_follows];
+                    newState.own_follows[index] = follow;
+                }
+            }
+            const index = currentState.followers?.findIndex((f) => f.source_feed.feed === follow.source_feed.feed) ?? -1;
+            if (index >= 0) {
+                newState.followers = [...newState.followers];
+                newState.followers[index] = follow;
+            }
         }
-        catch (e) {
-            error = e;
+        return newState ?? currentState;
+    });
+}
+
+function handleCommentAdded(event) {
+    const { comment } = event;
+    const entityId = comment.parent_id ?? comment.object_id;
+    this.state.next((currentState) => {
+        const entityState = currentState.comments_by_entity_id[entityId];
+        if (typeof entityState?.comments === 'undefined') {
+            return currentState;
         }
-        finally {
-            this.state.next((currentState) => ({
-                ...currentState,
-                member_pagination: {
-                    ...currentState.member_pagination,
-                    loading_next_page: false,
-                },
-            }));
+        const newComments = entityState?.comments ? [...entityState.comments] : [];
+        if (entityState.pagination?.sort === 'last') {
+            newComments.unshift(comment);
         }
-        if (error) {
-            throw error;
+        else {
+            // 'first' and other sort options
+            newComments.push(comment);
         }
-    }
-    /**
-     * Method which queries followers of this feed (feeds which target this feed).
-     *
-     * _Note: Useful only for feeds with `groupId` of `user` value._
-     */
-    async queryFollowers(request) {
-        const filter = {
-            target_feed: this.fid,
-        };
-        const response = await this.client.queryFollows({
-            filter,
-            ...request,
-        });
-        return response;
-    }
-    /**
-     * Method which queries following of this feed (target feeds of this feed).
-     *
-     * _Note: Useful only for feeds with `groupId` of `timeline` value._
-     */
-    async queryFollowing(request) {
-        const filter = {
-            source_feed: this.fid,
+        return {
+            ...currentState,
+            comments_by_entity_id: {
+                ...currentState.comments_by_entity_id,
+                [entityId]: {
+                    ...currentState.comments_by_entity_id[entityId],
+                    comments: newComments,
+                },
+            },
         };
-        const response = await this.client.queryFollows({
-            filter,
-            ...request,
-        });
-        return response;
-    }
-    async follow(feedOrFid, options) {
-        const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.fid;
-        const response = await this.client.follow({
-            ...options,
-            source: this.fid,
-            target: fid,
-        });
-        return response;
-    }
-    async unfollow(feedOrFid) {
-        const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.fid;
-        const response = await this.client.unfollow({
-            source: this.fid,
-            target: fid,
-        });
-        return response;
-    }
-    async getNextPage() {
-        const currentState = this.currentState;
-        return await this.getOrCreate({
-            member_pagination: {
-                limit: 0,
+    });
+}
+
+function handleCommentDeleted({ comment }) {
+    const entityId = comment.parent_id ?? comment.object_id;
+    this.state.next((currentState) => {
+        const newCommentsByEntityId = {
+            ...currentState.comments_by_entity_id,
+            [entityId]: {
+                ...currentState.comments_by_entity_id[entityId],
             },
-            followers_pagination: {
-                limit: 0,
+        };
+        const index = this.getCommentIndex(comment, currentState);
+        if (newCommentsByEntityId?.[entityId]?.comments?.length && index !== -1) {
+            newCommentsByEntityId[entityId].comments = [
+                ...newCommentsByEntityId[entityId].comments,
+            ];
+            newCommentsByEntityId[entityId]?.comments?.splice(index, 1);
+        }
+        delete newCommentsByEntityId[comment.id];
+        return {
+            ...currentState,
+            comments_by_entity_id: newCommentsByEntityId,
+        };
+    });
+}
+
+function handleCommentUpdated(event) {
+    const { comment } = event;
+    const entityId = comment.parent_id ?? comment.object_id;
+    this.state.next((currentState) => {
+        const entityState = currentState.comments_by_entity_id[entityId];
+        if (!entityState?.comments?.length)
+            return currentState;
+        const index = this.getCommentIndex(comment, currentState);
+        if (index === -1)
+            return currentState;
+        const newComments = [...entityState.comments];
+        newComments[index] = comment;
+        return {
+            ...currentState,
+            comments_by_entity_id: {
+                ...currentState.comments_by_entity_id,
+                [entityId]: {
+                    ...currentState.comments_by_entity_id[entityId],
+                    comments: newComments,
+                },
             },
-            following_pagination: {
-                limit: 0,
+        };
+    });
+}
+
+function handleCommentReaction(event) {
+    const { comment, reaction } = event;
+    const connectedUser = this.client.state.getLatestValue().connected_user;
+    this.state.next((currentState) => {
+        const forId = comment.parent_id ?? comment.object_id;
+        const entityState = currentState.comments_by_entity_id[forId];
+        const commentIndex = this.getCommentIndex(comment, currentState);
+        if (commentIndex === -1)
+            return currentState;
+        const newComments = entityState?.comments?.concat([]) ?? [];
+        const commentCopy = { ...comment };
+        delete commentCopy.own_reactions;
+        const newComment = {
+            ...newComments[commentIndex],
+            ...commentCopy,
+            // TODO: FIXME this should be handled by the backend
+            latest_reactions: commentCopy.latest_reactions ?? [],
+            reaction_groups: commentCopy.reaction_groups ?? {},
+        };
+        newComments[commentIndex] = newComment;
+        if (reaction.user.id === connectedUser?.id) {
+            if (event.type === 'feeds.comment.reaction.added') {
+                newComment.own_reactions = newComment.own_reactions.concat(reaction) ?? [reaction];
+            }
+            else if (event.type === 'feeds.comment.reaction.deleted') {
+                newComment.own_reactions = newComment.own_reactions.filter((r) => r.type !== reaction.type);
+            }
+        }
+        return {
+            ...currentState,
+            comments_by_entity_id: {
+                ...currentState.comments_by_entity_id,
+                [forId]: {
+                    ...entityState,
+                    comments: newComments,
+                },
             },
-            next: currentState.next,
-            limit: currentState.last_get_or_create_request_config?.limit ?? 20,
-        });
-    }
-    addActivity(request) {
-        return this.feedsApi.addActivity({
-            ...request,
-            fids: [this.fid],
-        });
-    }
-    handleWSEvent(event) {
-        const eventHandler = this.eventHandlers[event.type];
-        // no need to run noop function
-        if (eventHandler !== Feed.noop) {
-            // @ts-expect-error intersection of handler arguments results to never
-            eventHandler?.(event);
+        };
+    });
+}
+
+function handleFeedMemberAdded(event) {
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    this.state.next((currentState) => {
+        let newState;
+        if (typeof currentState.members !== 'undefined') {
+            newState ?? (newState = {
+                ...currentState,
+            });
+            newState.members = [event.member, ...currentState.members];
         }
-        if (typeof eventHandler === 'undefined') {
-            console.warn(`Received unknown event type: ${event.type}`, event);
+        if (connectedUser?.id === event.member.user.id) {
+            newState ?? (newState = {
+                ...currentState,
+            });
+            newState.own_membership = event.member;
         }
-        this.eventDispatcher.dispatch(event);
-    }
+        return newState ?? currentState;
+    });
 }
-Feed.noop = () => { };
 
-class ModerationApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    async ban(request) {
-        const body = {
-            target_user_id: request?.target_user_id,
-            banned_by_id: request?.banned_by_id,
-            channel_cid: request?.channel_cid,
-            delete_messages: request?.delete_messages,
-            ip_ban: request?.ip_ban,
-            reason: request?.reason,
-            shadow: request?.shadow,
-            timeout: request?.timeout,
-            banned_by: request?.banned_by,
-        };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/ban', undefined, undefined, body, 'application/json');
-        decoders.BanResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
-    }
-    async upsertConfig(request) {
-        const body = {
-            key: request?.key,
-            async: request?.async,
-            team: request?.team,
-            ai_image_config: request?.ai_image_config,
-            ai_text_config: request?.ai_text_config,
-            ai_video_config: request?.ai_video_config,
-            automod_platform_circumvention_config: request?.automod_platform_circumvention_config,
-            automod_semantic_filters_config: request?.automod_semantic_filters_config,
-            automod_toxicity_config: request?.automod_toxicity_config,
-            aws_rekognition_config: request?.aws_rekognition_config,
-            block_list_config: request?.block_list_config,
-            bodyguard_config: request?.bodyguard_config,
-            google_vision_config: request?.google_vision_config,
-            rule_builder_config: request?.rule_builder_config,
-            velocity_filter_config: request?.velocity_filter_config,
-            video_call_rule_config: request?.video_call_rule_config,
+function handleFeedMemberUpdated(event) {
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    this.state.next((currentState) => {
+        const memberIndex = currentState.members?.findIndex((member) => member.user.id === event.member.user.id) ?? -1;
+        let newState;
+        if (memberIndex !== -1) {
+            // if there's an index, there's a member to update
+            const newMembers = [...currentState.members];
+            newMembers[memberIndex] = event.member;
+            newState ?? (newState = {
+                ...currentState,
+            });
+            newState.members = newMembers;
+        }
+        if (connectedUser?.id === event.member.user.id) {
+            newState ?? (newState = {
+                ...currentState,
+            });
+            newState.own_membership = event.member;
+        }
+        return newState ?? currentState;
+    });
+}
+
+function handleFeedMemberRemoved(event) {
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    this.state.next((currentState) => {
+        const newState = {
+            ...currentState,
+            members: currentState.members?.filter((member) => member.user.id !== event.user?.id),
+        };
+        if (connectedUser?.id === event.member_id) {
+            delete newState.own_membership;
+        }
+        return newState;
+    });
+}
+
+const addActivitiesToState = (newActivities, activities, position) => {
+    let result;
+    if (activities === undefined) {
+        activities = [];
+        result = {
+            changed: true,
+            activities,
         };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/config', undefined, undefined, body, 'application/json');
-        decoders.UpsertConfigResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
     }
-    async deleteConfig(request) {
-        const queryParams = {
-            team: request?.team,
-        };
-        const pathParams = {
-            key: request?.key,
+    else {
+        result = {
+            changed: false,
+            activities,
         };
-        const response = await this.apiClient.sendRequest('DELETE', '/api/v2/moderation/config/{key}', pathParams, queryParams);
-        decoders.DeleteModerationConfigResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
     }
-    async getConfig(request) {
-        const queryParams = {
-            team: request?.team,
-        };
-        const pathParams = {
-            key: request?.key,
-        };
-        const response = await this.apiClient.sendRequest('GET', '/api/v2/moderation/config/{key}', pathParams, queryParams);
-        decoders.GetConfigResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
+    const newActivitiesDeduplicated = [];
+    newActivities.forEach((newActivityResponse) => {
+        const index = activities.findIndex((a) => a.id === newActivityResponse.id);
+        if (index === -1) {
+            newActivitiesDeduplicated.push(newActivityResponse);
+        }
+    });
+    if (newActivitiesDeduplicated.length > 0) {
+        // TODO: since feed activities are not necessarily ordered by created_at (personalization) we don't order by created_at
+        // Maybe we can add a flag to the JS client to support order by created_at
+        const updatedActivities = [
+            ...(position === 'start' ? newActivitiesDeduplicated : []),
+            ...activities,
+            ...(position === 'end' ? newActivitiesDeduplicated : []),
+        ];
+        result = { changed: true, activities: updatedActivities };
     }
-    async queryModerationConfigs(request) {
-        const body = {
-            limit: request?.limit,
-            next: request?.next,
-            prev: request?.prev,
-            sort: request?.sort,
-            filter: request?.filter,
-        };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/configs', undefined, undefined, body, 'application/json');
-        decoders.QueryModerationConfigsResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
+    return result;
+};
+function handleActivityAdded(event) {
+    const currentActivities = this.currentState.activities;
+    const result = addActivitiesToState([event.activity], currentActivities, 'start');
+    if (result.changed) {
+        this.client.hydratePollCache([event.activity]);
+        this.state.partialNext({ activities: result.activities });
     }
-    async flag(request) {
-        const body = {
-            entity_id: request?.entity_id,
-            entity_type: request?.entity_type,
-            entity_creator_id: request?.entity_creator_id,
-            reason: request?.reason,
-            custom: request?.custom,
-            moderation_payload: request?.moderation_payload,
-        };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/flag', undefined, undefined, body, 'application/json');
-        decoders.FlagResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
+}
+
+const removeActivityFromState = (activityResponse, activities) => {
+    const index = activities.findIndex((a) => a.id === activityResponse.id);
+    if (index !== -1) {
+        const newActivities = [...activities];
+        newActivities.splice(index, 1);
+        return { changed: true, activities: newActivities };
     }
-    async mute(request) {
-        const body = {
-            target_ids: request?.target_ids,
-            timeout: request?.timeout,
-        };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/mute', undefined, undefined, body, 'application/json');
-        decoders.MuteResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
+    else {
+        return { changed: false, activities };
     }
-    async queryReviewQueue(request) {
-        const body = {
-            limit: request?.limit,
-            lock_count: request?.lock_count,
-            lock_duration: request?.lock_duration,
-            lock_items: request?.lock_items,
-            next: request?.next,
-            prev: request?.prev,
-            stats_only: request?.stats_only,
-            sort: request?.sort,
-            filter: request?.filter,
-        };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/review_queue', undefined, undefined, body, 'application/json');
-        decoders.QueryReviewQueueResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
+};
+function handleActivityDeleted(event) {
+    const currentActivities = this.currentState.activities;
+    if (currentActivities) {
+        const result = removeActivityFromState(event.activity, currentActivities);
+        if (result.changed) {
+            this.state.partialNext({ activities: result.activities });
+        }
     }
-    async submitAction(request) {
-        const body = {
-            action_type: request?.action_type,
-            item_id: request?.item_id,
-            ban: request?.ban,
-            custom: request?.custom,
-            delete_activity: request?.delete_activity,
-            delete_message: request?.delete_message,
-            delete_reaction: request?.delete_reaction,
-            delete_user: request?.delete_user,
-            mark_reviewed: request?.mark_reviewed,
-            unban: request?.unban,
-        };
-        const response = await this.apiClient.sendRequest('POST', '/api/v2/moderation/submit_action', undefined, undefined, body, 'application/json');
-        decoders.SubmitActionResponse?.(response.body);
-        return { ...response.body, metadata: response.metadata };
+}
+
+function handleActivityRemovedFromFeed(event) {
+    const currentActivities = this.currentState.activities;
+    if (currentActivities) {
+        const result = removeActivityFromState(event.activity, currentActivities);
+        if (result.changed) {
+            this.state.partialNext({ activities: result.activities });
+        }
     }
 }
 
-class ModerationClient extends ModerationApi {
+const updateActivityInState = (updatedActivityResponse, activities, replaceCompletely = false) => {
+    const index = activities.findIndex((a) => a.id === updatedActivityResponse.id);
+    if (index !== -1) {
+        const newActivities = [...activities];
+        const activity = activities[index];
+        if (replaceCompletely) {
+            newActivities[index] = updatedActivityResponse;
+        }
+        else {
+            newActivities[index] = {
+                ...updatedActivityResponse,
+                own_reactions: activity.own_reactions,
+                own_bookmarks: activity.own_bookmarks,
+                latest_reactions: activity.latest_reactions,
+                reaction_groups: activity.reaction_groups,
+            };
+        }
+        return { changed: true, activities: newActivities };
+    }
+    else {
+        return { changed: false, activities };
+    }
+};
+function handleActivityUpdated(event) {
+    const currentActivities = this.currentState.activities;
+    if (currentActivities) {
+        const result = updateActivityInState(event.activity, currentActivities);
+        if (result.changed) {
+            this.client.hydratePollCache([event.activity]);
+            this.state.partialNext({ activities: result.activities });
+        }
+    }
 }
 
-const isPollUpdatedEvent = (e) => e.type === 'feeds.poll.updated';
-const isPollClosedEventEvent = (e) => e.type === 'feeds.poll.closed';
-const isPollVoteCastedEvent = (e) => e.type === 'feeds.poll.vote_casted';
-const isPollVoteChangedEvent = (e) => e.type === 'feeds.poll.vote_changed';
-const isPollVoteRemovedEvent = (e) => e.type === 'feeds.poll.vote_removed';
-const isVoteAnswer = (vote) => !!vote?.answer_text;
-class StreamPoll {
-    constructor({ client, poll }) {
-        this.getInitialStateFromPollResponse = (poll) => {
-            const { own_votes, id, ...pollResponseForState } = poll;
-            const { ownAnswer, ownVotes } = own_votes?.reduce((acc, voteOrAnswer) => {
-                if (isVoteAnswer(voteOrAnswer)) {
-                    acc.ownAnswer = voteOrAnswer;
-                }
-                else {
-                    acc.ownVotes.push(voteOrAnswer);
-                }
-                return acc;
-            }, { ownVotes: [] }) ?? { ownVotes: [] };
-            return {
-                ...pollResponseForState,
-                last_activity_at: new Date(),
-                max_voted_option_ids: getMaxVotedOptionIds(pollResponseForState.vote_counts_by_option),
-                own_answer: ownAnswer,
-                own_votes_by_option_id: getOwnVotesByOptionId(ownVotes),
-            };
-        };
-        this.reinitializeState = (poll) => {
-            this.state.partialNext(this.getInitialStateFromPollResponse(poll));
-        };
-        this.handlePollUpdated = (event) => {
-            if (event.poll?.id && event.poll.id !== this.id)
-                return;
-            if (!isPollUpdatedEvent(event))
-                return;
-            const { id, ...pollData } = event.poll;
-            // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-            this.state.partialNext({
-                ...pollData,
-                last_activity_at: new Date(event.created_at),
-            });
-        };
-        this.handlePollClosed = (event) => {
-            if (event.poll?.id && event.poll.id !== this.id)
-                return;
-            if (!isPollClosedEventEvent(event))
-                return;
-            this.state.partialNext({
-                is_closed: true,
-                last_activity_at: new Date(event.created_at),
-            });
-        };
-        this.handleVoteCasted = (event) => {
-            if (event.poll?.id && event.poll.id !== this.id)
-                return;
-            if (!isPollVoteCastedEvent(event))
-                return;
-            const currentState = this.data;
-            const isOwnVote = event.poll_vote.user_id ===
-                this.client.state.getLatestValue().connected_user?.id;
-            let latestAnswers = [...currentState.latest_answers];
-            let ownAnswer = currentState.own_answer;
-            const ownVotesByOptionId = currentState.own_votes_by_option_id;
-            let maxVotedOptionIds = currentState.max_voted_option_ids;
-            if (isOwnVote) {
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                if (isVoteAnswer(event.poll_vote)) {
-                    // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                    ownAnswer = event.poll_vote;
-                }
-                else if (event.poll_vote.option_id) {
-                    // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                    ownVotesByOptionId[event.poll_vote.option_id] = event.poll_vote;
-                }
-            }
-            // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-            if (isVoteAnswer(event.poll_vote)) {
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                latestAnswers = [event.poll_vote, ...latestAnswers];
-            }
-            else {
-                maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
-            }
-            const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option, } = event.poll;
-            this.state.partialNext({
-                answers_count,
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                latest_votes_by_option,
-                vote_count,
-                vote_counts_by_option,
-                latest_answers: latestAnswers,
-                last_activity_at: new Date(event.created_at),
-                own_answer: ownAnswer,
-                own_votes_by_option_id: ownVotesByOptionId,
-                max_voted_option_ids: maxVotedOptionIds,
-            });
+const addReactionToActivity = (event, activity, isCurrentUser) => {
+    // Update own_reactions if the reaction is from the current user
+    const ownReactions = [...(activity.own_reactions || [])];
+    if (isCurrentUser) {
+        ownReactions.push(event.reaction);
+    }
+    return {
+        ...activity,
+        own_reactions: ownReactions,
+        latest_reactions: event.activity.latest_reactions,
+        reaction_groups: event.activity.reaction_groups,
+        changed: true,
+    };
+};
+const addReactionToActivities = (event, activities, isCurrentUser) => {
+    if (!activities) {
+        return { changed: false, activities: [] };
+    }
+    const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
+    if (activityIndex === -1) {
+        return { changed: false, activities };
+    }
+    const activity = activities[activityIndex];
+    const updatedActivity = addReactionToActivity(event, activity, isCurrentUser);
+    return updateActivityInState(updatedActivity, activities, true);
+};
+function handleActivityReactionAdded(event) {
+    const currentActivities = this.currentState.activities;
+    const connectedUser = this.client.state.getLatestValue().connected_user;
+    const isCurrentUser = Boolean(connectedUser && event.reaction.user.id === connectedUser.id);
+    const result = addReactionToActivities(event, currentActivities, isCurrentUser);
+    if (result.changed) {
+        this.state.partialNext({ activities: result.activities });
+    }
+}
+
+const removeReactionFromActivity = (event, activity, isCurrentUser) => {
+    // Update own_reactions if the reaction is from the current user
+    const ownReactions = isCurrentUser
+        ? (activity.own_reactions || []).filter((r) => !(r.type === event.reaction.type &&
+            r.user.id === event.reaction.user.id))
+        : activity.own_reactions;
+    return {
+        ...activity,
+        own_reactions: ownReactions,
+        latest_reactions: event.activity.latest_reactions,
+        reaction_groups: event.activity.reaction_groups,
+        changed: true,
+    };
+};
+const removeReactionFromActivities = (event, activities, isCurrentUser) => {
+    if (!activities) {
+        return { changed: false, activities: [] };
+    }
+    const activityIndex = activities.findIndex((a) => a.id === event.activity.id);
+    if (activityIndex === -1) {
+        return { changed: false, activities };
+    }
+    const activity = activities[activityIndex];
+    const updatedActivity = removeReactionFromActivity(event, activity, isCurrentUser);
+    return updateActivityInState(updatedActivity, activities, true);
+};
+function handleActivityReactionDeleted(event) {
+    const currentActivities = this.currentState.activities;
+    const connectedUser = this.client.state.getLatestValue().connected_user;
+    const isCurrentUser = Boolean(connectedUser && event.reaction.user.id === connectedUser.id);
+    const result = removeReactionFromActivities(event, currentActivities, isCurrentUser);
+    if (result.changed) {
+        this.state.partialNext({ activities: result.activities });
+    }
+}
+
+const addBookmarkToActivity = (event, activity, isCurrentUser) => {
+    // Update own_bookmarks if the bookmark is from the current user
+    const ownBookmarks = [...(activity.own_bookmarks || [])];
+    if (isCurrentUser) {
+        ownBookmarks.push(event.bookmark);
+    }
+    return {
+        ...activity,
+        own_bookmarks: ownBookmarks,
+        changed: true,
+    };
+};
+const addBookmarkToActivities = (event, activities, isCurrentUser) => {
+    if (!activities) {
+        return { changed: false, activities: [] };
+    }
+    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
+    if (activityIndex === -1) {
+        return { changed: false, activities };
+    }
+    const activity = activities[activityIndex];
+    const updatedActivity = addBookmarkToActivity(event, activity, isCurrentUser);
+    return updateActivityInState(updatedActivity, activities, true);
+};
+function handleBookmarkAdded(event) {
+    const currentActivities = this.currentState.activities;
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+    const result = addBookmarkToActivities(event, currentActivities, isCurrentUser);
+    if (result.changed) {
+        this.state.partialNext({ activities: result.activities });
+    }
+}
+
+// Helper function to check if two bookmarks are the same
+// A bookmark is identified by activity_id + folder_id + user_id
+const isSameBookmark = (bookmark1, bookmark2) => {
+    return (bookmark1.user.id === bookmark2.user.id &&
+        bookmark1.activity.id === bookmark2.activity.id &&
+        bookmark1.folder?.id === bookmark2.folder?.id);
+};
+const removeBookmarkFromActivities = (event, activities, isCurrentUser) => {
+    if (!activities) {
+        return { changed: false, activities: [] };
+    }
+    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
+    if (activityIndex === -1) {
+        return { changed: false, activities };
+    }
+    const activity = activities[activityIndex];
+    const updatedActivity = removeBookmarkFromActivity(event, activity, isCurrentUser);
+    return updateActivityInState(updatedActivity, activities, true);
+};
+const removeBookmarkFromActivity = (event, activity, isCurrentUser) => {
+    // Update own_bookmarks if the bookmark is from the current user
+    const ownBookmarks = isCurrentUser
+        ? (activity.own_bookmarks || []).filter((bookmark) => !isSameBookmark(bookmark, event.bookmark))
+        : activity.own_bookmarks;
+    return {
+        ...activity,
+        own_bookmarks: ownBookmarks,
+        changed: true,
+    };
+};
+function handleBookmarkDeleted(event) {
+    const currentActivities = this.currentState.activities;
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+    const result = removeBookmarkFromActivities(event, currentActivities, isCurrentUser);
+    if (result.changed) {
+        this.state.partialNext({ activities: result.activities });
+    }
+}
+
+const updateBookmarkInActivity = (event, activity, isCurrentUser) => {
+    // Update own_bookmarks if the bookmark is from the current user
+    let ownBookmarks = activity.own_bookmarks || [];
+    if (isCurrentUser) {
+        const bookmarkIndex = ownBookmarks.findIndex((bookmark) => isSameBookmark(bookmark, event.bookmark));
+        if (bookmarkIndex !== -1) {
+            ownBookmarks = [...ownBookmarks];
+            ownBookmarks[bookmarkIndex] = event.bookmark;
+        }
+    }
+    return {
+        ...activity,
+        own_bookmarks: ownBookmarks,
+        changed: true,
+    };
+};
+const updateBookmarkInActivities = (event, activities, isCurrentUser) => {
+    if (!activities) {
+        return { changed: false, activities: [] };
+    }
+    const activityIndex = activities.findIndex((a) => a.id === event.bookmark.activity.id);
+    if (activityIndex === -1) {
+        return { changed: false, activities };
+    }
+    const activity = activities[activityIndex];
+    const updatedActivity = updateBookmarkInActivity(event, activity, isCurrentUser);
+    return updateActivityInState(updatedActivity, activities, true);
+};
+function handleBookmarkUpdated(event) {
+    const currentActivities = this.currentState.activities;
+    const { connected_user: connectedUser } = this.client.state.getLatestValue();
+    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+    const result = updateBookmarkInActivities(event, currentActivities, isCurrentUser);
+    if (result.changed) {
+        this.state.partialNext({ activities: result.activities });
+    }
+}
+
+function handleFeedUpdated(event) {
+    this.state.partialNext({ ...event.feed });
+}
+
+function handleNotificationFeedUpdated(event) {
+    console.info('notification feed updated', event);
+    // TODO: handle notification feed updates
+}
+
+function handleWatchStarted() {
+    this.state.partialNext({ watch: true });
+}
+
+function handleWatchStopped() {
+    this.state.partialNext({ watch: false });
+}
+
+class Feed extends FeedApi {
+    constructor(client, groupId, id, data, watch = false) {
+        super(client, groupId, id);
+        this.stateUpdateQueue = new Set();
+        this.eventHandlers = {
+            'feeds.activity.added': handleActivityAdded.bind(this),
+            'feeds.activity.deleted': handleActivityDeleted.bind(this),
+            'feeds.activity.reaction.added': handleActivityReactionAdded.bind(this),
+            'feeds.activity.reaction.deleted': handleActivityReactionDeleted.bind(this),
+            'feeds.activity.reaction.updated': Feed.noop,
+            'feeds.activity.removed_from_feed': handleActivityRemovedFromFeed.bind(this),
+            'feeds.activity.updated': handleActivityUpdated.bind(this),
+            'feeds.bookmark.added': handleBookmarkAdded.bind(this),
+            'feeds.bookmark.deleted': handleBookmarkDeleted.bind(this),
+            'feeds.bookmark.updated': handleBookmarkUpdated.bind(this),
+            'feeds.bookmark_folder.deleted': Feed.noop,
+            'feeds.bookmark_folder.updated': Feed.noop,
+            'feeds.comment.added': handleCommentAdded.bind(this),
+            'feeds.comment.deleted': handleCommentDeleted.bind(this),
+            'feeds.comment.updated': handleCommentUpdated.bind(this),
+            'feeds.feed.created': Feed.noop,
+            'feeds.feed.deleted': Feed.noop,
+            'feeds.feed.updated': handleFeedUpdated.bind(this),
+            'feeds.feed_group.changed': Feed.noop,
+            'feeds.feed_group.deleted': Feed.noop,
+            'feeds.follow.created': handleFollowCreated.bind(this),
+            'feeds.follow.deleted': handleFollowDeleted.bind(this),
+            'feeds.follow.updated': handleFollowUpdated.bind(this),
+            'feeds.comment.reaction.added': handleCommentReaction.bind(this),
+            'feeds.comment.reaction.deleted': handleCommentReaction.bind(this),
+            'feeds.comment.reaction.updated': Feed.noop,
+            'feeds.feed_member.added': handleFeedMemberAdded.bind(this),
+            'feeds.feed_member.removed': handleFeedMemberRemoved.bind(this),
+            'feeds.feed_member.updated': handleFeedMemberUpdated.bind(this),
+            'feeds.notification_feed.updated': handleNotificationFeedUpdated.bind(this),
+            // the poll events should be removed from here
+            'feeds.poll.closed': Feed.noop,
+            'feeds.poll.deleted': Feed.noop,
+            'feeds.poll.updated': Feed.noop,
+            'feeds.poll.vote_casted': Feed.noop,
+            'feeds.poll.vote_changed': Feed.noop,
+            'feeds.poll.vote_removed': Feed.noop,
+            'feeds.activity.pinned': Feed.noop,
+            'feeds.activity.unpinned': Feed.noop,
+            'feeds.activity.marked': Feed.noop,
+            'moderation.custom_action': Feed.noop,
+            'moderation.flagged': Feed.noop,
+            'moderation.mark_reviewed': Feed.noop,
+            'health.check': Feed.noop,
+            'app.updated': Feed.noop,
+            'user.banned': Feed.noop,
+            'user.deactivated': Feed.noop,
+            'user.muted': Feed.noop,
+            'user.reactivated': Feed.noop,
+            'user.updated': Feed.noop,
         };
-        this.handleVoteChanged = (event) => {
-            // this event is triggered only when event.poll.enforce_unique_vote === true
-            if (event.poll?.id && event.poll.id !== this.id)
-                return;
-            if (!isPollVoteChangedEvent(event))
-                return;
-            const currentState = this.data;
-            const isOwnVote = event.poll_vote.user_id ===
-                this.client.state.getLatestValue().connected_user?.id;
-            let latestAnswers = [...currentState.latest_answers];
-            let ownAnswer = currentState.own_answer;
-            let ownVotesByOptionId = currentState.own_votes_by_option_id;
-            let maxVotedOptionIds = currentState.max_voted_option_ids;
-            if (isOwnVote) {
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                if (isVoteAnswer(event.poll_vote)) {
-                    latestAnswers = [
-                        // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                        event.poll_vote,
-                        ...latestAnswers.filter((answer) => answer.id !== event.poll_vote.id),
-                    ];
-                    // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                    ownAnswer = event.poll_vote;
+        this.eventDispatcher = new EventDispatcher();
+        this.on = this.eventDispatcher.on;
+        this.off = this.eventDispatcher.off;
+        this.state = new StateStore({
+            feed: `${groupId}:${id}`,
+            group_id: groupId,
+            id,
+            ...(data ?? {}),
+            is_loading: false,
+            is_loading_activities: false,
+            comments_by_entity_id: {},
+            watch,
+        });
+        this.client = client;
+    }
+    get feed() {
+        return `${this.group}:${this.id}`;
+    }
+    get currentState() {
+        return this.state.getLatestValue();
+    }
+    async synchronize() {
+        const { last_get_or_create_request_config } = this.state.getLatestValue();
+        if (last_get_or_create_request_config?.watch) {
+            await this.getOrCreate(last_get_or_create_request_config);
+        }
+    }
+    async getOrCreate(request) {
+        if (this.currentState.is_loading_activities) {
+            throw new Error('Only one getOrCreate call is allowed at a time');
+        }
+        this.state.partialNext({
+            is_loading: !request?.next,
+            is_loading_activities: true,
+        });
+        // TODO: pull comments/comment_pagination from activities and comment_sort from request
+        // and pre-populate comments_by_entity_id (once comment_sort and comment_limit are supported)
+        try {
+            const response = await super.getOrCreate(request);
+            if (request?.next) {
+                const { activities: currentActivities = [] } = this.currentState;
+                const result = addActivitiesToState(response.activities, currentActivities, 'end');
+                if (result.changed) {
+                    this.state.partialNext({
+                        activities: result.activities,
+                        next: response.next,
+                        prev: response.prev,
+                    });
                 }
-                else if (event.poll_vote.option_id) {
-                    if (event.poll.enforce_unique_vote) {
-                        // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                        ownVotesByOptionId = { [event.poll_vote.option_id]: event.poll_vote };
+            }
+            else {
+                // Empty queue when reinitializing the state
+                this.stateUpdateQueue.clear();
+                const responseCopy = {
+                    ...response,
+                    ...response.feed,
+                };
+                delete responseCopy.feed;
+                delete responseCopy.metadata;
+                delete responseCopy.duration;
+                // TODO: lazy-load comments from activities when comment_sort and comment_pagination are supported
+                this.state.next((currentState) => {
+                    const nextState = {
+                        ...currentState,
+                        ...responseCopy,
+                    };
+                    if (!request?.followers_pagination?.limit) {
+                        delete nextState.followers;
                     }
-                    else {
-                        ownVotesByOptionId = Object.entries(ownVotesByOptionId).reduce((acc, [optionId, vote]) => {
-                            if (optionId !== event.poll_vote.option_id &&
-                                vote.id === event.poll_vote.id) {
-                                return acc;
-                            }
-                            acc[optionId] = vote;
-                            return acc;
-                        }, {});
-                        // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                        ownVotesByOptionId[event.poll_vote.option_id] = event.poll_vote;
+                    if (!request?.following_pagination?.limit) {
+                        delete nextState.following;
                     }
-                    if (ownAnswer?.id === event.poll_vote.id) {
-                        ownAnswer = undefined;
+                    if (response.members.length === 0 && response.feed.member_count > 0) {
+                        delete nextState.members;
                     }
-                    maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
-                }
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-            }
-            else if (isVoteAnswer(event.poll_vote)) {
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                latestAnswers = [event.poll_vote, ...latestAnswers];
-            }
-            else {
-                maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
+                    nextState.last_get_or_create_request_config = request;
+                    nextState.watch = request?.watch ? request.watch : currentState.watch;
+                    return nextState;
+                });
             }
-            const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option, } = event.poll;
+            this.client.hydratePollCache(response.activities);
+            return response;
+        }
+        finally {
             this.state.partialNext({
-                answers_count,
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                latest_votes_by_option,
-                vote_count,
-                vote_counts_by_option,
-                latest_answers: latestAnswers,
-                last_activity_at: new Date(event.created_at),
-                own_answer: ownAnswer,
-                own_votes_by_option_id: ownVotesByOptionId,
-                max_voted_option_ids: maxVotedOptionIds,
+                is_loading: false,
+                is_loading_activities: false,
+            });
+        }
+    }
+    /**
+     * Returns index of the provided comment object.
+     */
+    getCommentIndex(comment, state) {
+        const { comments_by_entity_id = {} } = state ?? this.currentState;
+        const currentComments = comments_by_entity_id[comment.parent_id ?? comment.object_id]?.comments;
+        if (!currentComments?.length) {
+            return -1;
+        }
+        // @ts-expect-error this will just fail if the comment is not object from state
+        let commentIndex = currentComments.indexOf(comment);
+        // fast lookup failed, try slower approach
+        if (commentIndex === -1) {
+            commentIndex = currentComments.findIndex((comment_) => comment_.id === comment.id);
+        }
+        return commentIndex;
+    }
+    /**
+     * Load child comments of entity (activity or comment) into the state, if the target entity is comment,
+     * `entityParentId` should be provided (`CommentResponse.parent_id ?? CommentResponse.object_id`).
+     */
+    loadCommentsIntoState(data) {
+        // add initial (top level) object for processing
+        const traverseArray = [
+            {
+                entityId: data.entityId,
+                entityParentId: data.entityParentId,
+                comments: data.comments,
+                next: data.next,
+            },
+        ];
+        this.state.next((currentState) => {
+            const newCommentsByEntityId = {
+                ...currentState.comments_by_entity_id,
+            };
+            while (traverseArray.length) {
+                const item = traverseArray.pop();
+                const entityId = item.entityId;
+                // go over entity comments and generate new objects
+                // for further processing if there are any replies
+                item.comments.forEach((comment) => {
+                    if (!comment.replies?.length)
+                        return;
+                    traverseArray.push({
+                        entityId: comment.id,
+                        entityParentId: entityId,
+                        comments: comment.replies,
+                        next: comment.meta?.next_cursor,
+                    });
+                });
+                // omit replies & meta from the comments (transform ThreadedCommentResponse to CommentResponse)
+                // this is somehow faster than copying the whole
+                // object and deleting the desired properties
+                const newComments = item.comments.map(({ replies: _r, meta: _m, ...restOfTheCommentResponse }) => restOfTheCommentResponse);
+                const existingComments = newCommentsByEntityId[entityId]?.comments;
+                newCommentsByEntityId[entityId] = {
+                    ...newCommentsByEntityId[entityId],
+                    entity_parent_id: item.entityParentId,
+                    pagination: {
+                        ...newCommentsByEntityId[entityId]?.pagination,
+                        next: item.next,
+                        sort: data.sort,
+                    },
+                    comments: existingComments
+                        ? uniqueArrayMerge(existingComments, newComments, (comment) => comment.id)
+                        : newComments,
+                };
+            }
+            return {
+                ...currentState,
+                comments_by_entity_id: newCommentsByEntityId,
+            };
+        });
+    }
+    async loadNextPageComments({ entityId, base, sort, entityParentId, }) {
+        let error;
+        try {
+            this.state.next((currentState) => ({
+                ...currentState,
+                comments_by_entity_id: {
+                    ...currentState.comments_by_entity_id,
+                    [entityId]: {
+                        ...currentState.comments_by_entity_id[entityId],
+                        pagination: {
+                            ...currentState.comments_by_entity_id[entityId]?.pagination,
+                            loading_next_page: true,
+                        },
+                    },
+                },
+            }));
+            const { next, comments } = await base();
+            this.loadCommentsIntoState({
+                entityId,
+                comments,
+                entityParentId,
+                next,
+                sort,
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        finally {
+            this.state.next((currentState) => ({
+                ...currentState,
+                comments_by_entity_id: {
+                    ...currentState.comments_by_entity_id,
+                    [entityId]: {
+                        ...currentState.comments_by_entity_id[entityId],
+                        pagination: {
+                            ...currentState.comments_by_entity_id[entityId]?.pagination,
+                            loading_next_page: false,
+                        },
+                    },
+                },
+            }));
+        }
+        if (error) {
+            throw error;
+        }
+    }
+    async loadNextPageActivityComments(activity, request) {
+        const currentEntityState = this.currentState.comments_by_entity_id[activity.id];
+        const currentPagination = currentEntityState?.pagination;
+        const currentNextCursor = currentPagination?.next;
+        const currentSort = currentPagination?.sort;
+        const isLoading = currentPagination?.loading_next_page;
+        const sort = currentSort ?? request?.sort ?? Constants.DEFAULT_COMMENT_PAGINATION;
+        if (isLoading ||
+            !checkHasAnotherPage(currentEntityState?.comments, currentNextCursor)) {
+            return;
+        }
+        await this.loadNextPageComments({
+            entityId: activity.id,
+            base: () => this.client.getComments({
+                ...request,
+                sort,
+                object_id: activity.id,
+                object_type: 'activity',
+                next: currentNextCursor,
+            }),
+            sort,
+        });
+    }
+    async loadNextPageCommentReplies(comment, request) {
+        const currentEntityState = this.currentState.comments_by_entity_id[comment.id];
+        const currentPagination = currentEntityState?.pagination;
+        const currentNextCursor = currentPagination?.next;
+        const currentSort = currentPagination?.sort;
+        const isLoading = currentPagination?.loading_next_page;
+        const sort = currentSort ?? request?.sort ?? Constants.DEFAULT_COMMENT_PAGINATION;
+        if (isLoading ||
+            !checkHasAnotherPage(currentEntityState?.comments, currentNextCursor)) {
+            return;
+        }
+        await this.loadNextPageComments({
+            entityId: comment.id,
+            base: () => this.client.getCommentReplies({
+                ...request,
+                id: comment.id,
+                // use known sort first (prevents broken pagination)
+                sort,
+                next: currentNextCursor,
+            }),
+            entityParentId: comment.parent_id ?? comment.object_id,
+            sort,
+        });
+    }
+    async loadNextPageFollows(type, request) {
+        const paginationKey = `${type}_pagination`;
+        const method = `query${capitalize(type)}`;
+        const currentFollows = this.currentState[type];
+        const currentNextCursor = this.currentState[paginationKey]?.next;
+        const isLoading = this.currentState[paginationKey]?.loading_next_page;
+        const sort = this.currentState[paginationKey]?.sort ?? request.sort;
+        let error;
+        if (isLoading || !checkHasAnotherPage(currentFollows, currentNextCursor)) {
+            return;
+        }
+        try {
+            this.state.next((currentState) => {
+                return {
+                    ...currentState,
+                    [paginationKey]: {
+                        ...currentState[paginationKey],
+                        loading_next_page: true,
+                    },
+                };
             });
-        };
-        this.handleVoteRemoved = (event) => {
-            if (event.poll?.id && event.poll.id !== this.id)
-                return;
-            if (!isPollVoteRemovedEvent(event))
-                return;
-            const currentState = this.data;
-            const isOwnVote = event.poll_vote.user_id ===
-                this.client.state.getLatestValue().connected_user?.id;
-            let latestAnswers = [...currentState.latest_answers];
-            let ownAnswer = currentState.own_answer;
-            const ownVotesByOptionId = { ...currentState.own_votes_by_option_id };
-            let maxVotedOptionIds = currentState.max_voted_option_ids;
-            // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-            if (isVoteAnswer(event.poll_vote)) {
-                latestAnswers = latestAnswers.filter((answer) => answer.id !== event.poll_vote.id);
-                if (isOwnVote) {
-                    ownAnswer = undefined;
-                }
-            }
-            else {
-                maxVotedOptionIds = getMaxVotedOptionIds(event.poll.vote_counts_by_option);
-                if (isOwnVote && event.poll_vote.option_id) {
-                    delete ownVotesByOptionId[event.poll_vote.option_id];
-                }
-            }
-            const { answers_count, latest_votes_by_option, vote_count, vote_counts_by_option, } = event.poll;
-            this.state.partialNext({
-                answers_count,
-                // @ts-expect-error Incompatibility between PollResponseData and Poll due to teams_role, remove when OpenAPI spec is fixed
-                latest_votes_by_option,
-                vote_count,
-                vote_counts_by_option,
-                latest_answers: latestAnswers,
-                last_activity_at: new Date(event.created_at),
-                own_answer: ownAnswer,
-                own_votes_by_option_id: ownVotesByOptionId,
-                max_voted_option_ids: maxVotedOptionIds,
+            const { next: newNextCursor, follows } = await this[method]({
+                ...request,
+                next: currentNextCursor,
+                sort,
+            });
+            this.state.next((currentState) => {
+                return {
+                    ...currentState,
+                    [type]: currentState[type] === undefined
+                        ? follows
+                        : uniqueArrayMerge(currentState[type], follows, (follow) => `${follow.source_feed.feed}-${follow.target_feed.feed}`),
+                    [paginationKey]: {
+                        ...currentState[paginationKey],
+                        next: newNextCursor,
+                        sort,
+                    },
+                };
+            });
+        }
+        catch (e) {
+            error = e;
+        }
+        finally {
+            this.state.next((currentState) => {
+                return {
+                    ...currentState,
+                    [paginationKey]: {
+                        ...currentState[paginationKey],
+                        loading_next_page: false,
+                    },
+                };
+            });
+        }
+        if (error) {
+            throw error;
+        }
+    }
+    async loadNextPageFollowers(request) {
+        await this.loadNextPageFollows('followers', request);
+    }
+    async loadNextPageFollowing(request) {
+        await this.loadNextPageFollows('following', request);
+    }
+    async loadNextPageMembers(request) {
+        const currentMembers = this.currentState.members;
+        const currentNextCursor = this.currentState.member_pagination?.next;
+        const isLoading = this.currentState.member_pagination?.loading_next_page;
+        const sort = this.currentState.member_pagination?.sort ?? request.sort;
+        let error;
+        if (isLoading || !checkHasAnotherPage(currentMembers, currentNextCursor)) {
+            return;
+        }
+        try {
+            this.state.next((currentState) => ({
+                ...currentState,
+                member_pagination: {
+                    ...currentState.member_pagination,
+                    loading_next_page: true,
+                },
+            }));
+            const { next: newNextCursor, members } = await this.client.queryFeedMembers({
+                ...request,
+                sort,
+                feed_id: this.id,
+                feed_group_id: this.group,
+                next: currentNextCursor,
             });
+            this.state.next((currentState) => ({
+                ...currentState,
+                members: currentState.members
+                    ? uniqueArrayMerge(currentState.members, members, ({ user }) => user.id)
+                    : members,
+                member_pagination: {
+                    ...currentState.member_pagination,
+                    next: newNextCursor,
+                    // set sort if not defined yet
+                    sort: currentState.member_pagination?.sort ?? request.sort,
+                },
+            }));
+        }
+        catch (e) {
+            error = e;
+        }
+        finally {
+            this.state.next((currentState) => ({
+                ...currentState,
+                member_pagination: {
+                    ...currentState.member_pagination,
+                    loading_next_page: false,
+                },
+            }));
+        }
+        if (error) {
+            throw error;
+        }
+    }
+    /**
+     * Method which queries followers of this feed (feeds which target this feed).
+     *
+     * _Note: Useful only for feeds with `groupId` of `user` value._
+     */
+    async queryFollowers(request) {
+        const filter = {
+            target_feed: this.feed,
         };
-        this.client = client;
-        this.id = poll.id;
-        this.state = new StateStore(this.getInitialStateFromPollResponse(poll));
+        const response = await this.client.queryFollows({
+            filter,
+            ...request,
+        });
+        return response;
     }
-    get data() {
-        return this.state.getLatestValue();
+    /**
+     * Method which queries following of this feed (target feeds of this feed).
+     *
+     * _Note: Useful only for feeds with `groupId` of `timeline` value._
+     */
+    async queryFollowing(request) {
+        const filter = {
+            source_feed: this.feed,
+        };
+        const response = await this.client.queryFollows({
+            filter,
+            ...request,
+        });
+        return response;
     }
-}
-function getMaxVotedOptionIds(voteCountsByOption) {
-    let maxVotes = 0;
-    let winningOptions = [];
-    for (const [id, count] of Object.entries(voteCountsByOption ?? {})) {
-        if (count > maxVotes) {
-            winningOptions = [id];
-            maxVotes = count;
+    async follow(feedOrFid, options) {
+        const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.feed;
+        const response = await this.client.follow({
+            ...options,
+            source: this.feed,
+            target: fid,
+        });
+        return response;
+    }
+    async unfollow(feedOrFid) {
+        const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.feed;
+        const response = await this.client.unfollow({
+            source: this.feed,
+            target: fid,
+        });
+        return response;
+    }
+    async getNextPage() {
+        const currentState = this.currentState;
+        return await this.getOrCreate({
+            member_pagination: {
+                limit: 0,
+            },
+            followers_pagination: {
+                limit: 0,
+            },
+            following_pagination: {
+                limit: 0,
+            },
+            next: currentState.next,
+            limit: currentState.last_get_or_create_request_config?.limit ?? 20,
+        });
+    }
+    addActivity(request) {
+        return this.feedsApi.addActivity({
+            ...request,
+            feeds: [this.feed],
+        });
+    }
+    handleWSEvent(event) {
+        const eventHandler = this.eventHandlers[event.type];
+        // no need to run noop function
+        if (eventHandler !== Feed.noop) {
+            // @ts-expect-error intersection of handler arguments results to never
+            eventHandler?.(event);
         }
-        else if (count === maxVotes) {
-            winningOptions.push(id);
+        if (typeof eventHandler === 'undefined') {
+            console.warn(`Received unknown event type: ${event.type}`, event);
         }
+        this.eventDispatcher.dispatch(event);
     }
-    return winningOptions;
 }
-function getOwnVotesByOptionId(ownVotes) {
-    return !ownVotes
-        ? {}
-        : ownVotes.reduce((acc, vote) => {
-            if (isVoteAnswer(vote) || !vote.option_id)
-                return acc;
-            acc[vote.option_id] = vote;
-            return acc;
-        }, {});
+Feed.noop = () => { };
+
+function handleUserUpdated(event) {
+    this.state.next((currentState) => {
+        let newState;
+        const { connected_user } = currentState;
+        if (connected_user && connected_user.id === event.user.id) {
+            newState ?? (newState = {
+                ...currentState,
+            });
+            newState.connected_user = {
+                ...connected_user,
+                ...event.user,
+            };
+        }
+        // TODO: update other users in user map (if/once applicable)
+        return newState ?? currentState;
+    });
 }
 
 class FeedsClient extends FeedsApi {
@@ -5468,7 +5570,7 @@ class FeedsClient extends FeedsApi {
             if (this.activeFeeds[fid]) {
                 const feed = this.activeFeeds[fid];
                 if (watch && !feed.currentState.watch) {
-                    feed.handleWatchStarted();
+                    handleWatchStarted.bind(feed)();
                 }
                 return feed;
             }
@@ -5504,7 +5606,7 @@ class FeedsClient extends FeedsApi {
                     }
                     else {
                         for (const activeFeed of Object.values(this.activeFeeds)) {
-                            activeFeed.handleWatchStopped();
+                            handleWatchStopped.bind(activeFeed)();
                         }
                     }
                     break;
@@ -5584,6 +5686,10 @@ class FeedsClient extends FeedsApi {
                     feeds.forEach((f) => f.handleWSEvent(event));
                     break;
                 }
+                case 'user.updated': {
+                    handleUserUpdated.call(this, event);
+                    break;
+                }
                 default: {
                     feed?.handleWSEvent(event);
                 }
@@ -5609,7 +5715,7 @@ class FeedsClient extends FeedsApi {
         }
     }
     async queryFeeds(request) {
-        const response = await this.feedsQueryFeeds(request);
+        const response = await this._queryFeeds(request);
         const feeds = response.feeds.map((f) => this.getOrCreateActiveFeed(f.group_id, f.id, f, request?.watch));
         return {
             feeds,
@@ -5619,13 +5725,29 @@ class FeedsClient extends FeedsApi {
             duration: response.duration,
         };
     }
+    async updateFollow(request) {
+        const response = await super.updateFollow(request);
+        [
+            response.follow.source_feed.feed,
+            response.follow.target_feed.feed,
+        ].forEach((fid) => {
+            const feed = this.activeFeeds[fid];
+            if (feed) {
+                handleFollowUpdated.bind(feed)(response);
+            }
+        });
+        return response;
+    }
     // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
     async follow(request) {
         const response = await super.follow(request);
-        [response.follow.source_feed.fid, response.follow.target_feed.fid].forEach((fid) => {
+        [
+            response.follow.source_feed.feed,
+            response.follow.target_feed.feed,
+        ].forEach((fid) => {
             const feed = this.activeFeeds[fid];
             if (feed) {
-                feed.handleFollowCreated(response.follow);
+                handleFollowCreated.bind(feed)(response);
             }
         });
         return response;
@@ -5633,9 +5755,9 @@ class FeedsClient extends FeedsApi {
     async followBatch(request) {
         const response = await super.followBatch(request);
         response.follows.forEach((follow) => {
-            const feed = this.activeFeeds[follow.source_feed.fid];
+            const feed = this.activeFeeds[follow.source_feed.feed];
             if (feed) {
-                feed.handleFollowCreated(follow);
+                handleFollowCreated.bind(feed)({ follow });
             }
         });
         return response;
@@ -5645,10 +5767,7 @@ class FeedsClient extends FeedsApi {
         [request.source, request.target].forEach((fid) => {
             const feed = this.activeFeeds[fid];
             if (feed) {
-                feed.handleFollowDeleted({
-                    source_feed: { fid: request.source },
-                    target_feed: { fid: request.target },
-                });
+                handleFollowDeleted.bind(feed)(response);
             }
         });
         return response;
@@ -5661,7 +5780,7 @@ class FeedsClient extends FeedsApi {
         });
         const feed = this.activeFeeds[`${request.feed_group_id}:${request.feed_id}`];
         if (feed) {
-            feed.handleWatchStopped();
+            handleWatchStopped.bind(feed)();
         }
         return response;
     }
@@ -6055,12 +6174,12 @@ const useReactionActions = ({ entity, type, }) => {
     const hasOwnReaction = useMemo(() => !!entity.own_reactions?.find((r) => r.type === type), [entity.own_reactions, type]);
     const addReaction = useStableCallback(async () => {
         await (isComment
-            ? client?.addCommentReaction({ comment_id: entity.id, type })
+            ? client?.addCommentReaction({ id: entity.id, type })
             : client?.addReaction({ activity_id: entity.id, type }));
     });
     const removeReaction = useStableCallback(async () => {
         await (isComment
-            ? client?.deleteCommentReaction({ comment_id: entity.id, type })
+            ? client?.deleteCommentReaction({ id: entity.id, type })
             : client?.deleteActivityReaction({
                 activity_id: entity.id,
                 type,