@stream-io/feeds-client 0.2.0 → 0.2.1

package/dist/src/feed/event-handlers/activity/handle-activity-deleted.d.ts

@@ -1,8 +1,17 @@
 import type { Feed } from '../../../feed';
-import type { ActivityResponse } from '../../../gen/models';
+import type { ActivityPinResponse, ActivityResponse } from '../../../gen/models';
 import type { EventPayload } from '../../../types-internal';
-export declare const removeActivityFromState: (activityResponse: ActivityResponse, activities: ActivityResponse[]) => {
+export declare const removeActivityFromState: (activityResponse: ActivityResponse, activities: ActivityResponse[] | undefined) => {
     changed: boolean;
-    activities: ActivityResponse[];
+    activities: ActivityResponse[] | undefined;
+};
+export declare const removePinnedActivityFromState: (activityResponse: ActivityResponse, pinnedActivities: ActivityPinResponse[] | undefined) => {
+    changed: boolean;
+    activities: ActivityPinResponse[];
+    pinned_activities?: undefined;
+} | {
+    changed: boolean;
+    pinned_activities: ActivityPinResponse[] | undefined;
+    activities?: undefined;
 };
 export declare function handleActivityDeleted(this: Feed, event: EventPayload<'feeds.activity.deleted'>): void;

package/dist/src/feed/event-handlers/activity/handle-activity-pinned.d.ts

@@ -0,0 +1,3 @@
+import { EventPayload } from '../../../types-internal';
+import { Feed } from '../../feed';
+export declare function handleActivityPinned(this: Feed, event: EventPayload<'feeds.activity.pinned'>): void;

package/dist/src/feed/event-handlers/activity/handle-activity-reaction-added.d.ts

@@ -1,8 +1,12 @@
 import type { Feed } from '../../../feed';
-import type { ActivityReactionAddedEvent, ActivityResponse } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-export declare const addReactionToActivity: (event: ActivityReactionAddedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const addReactionToActivities: (event: ActivityReactionAddedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
+import type { ActivityPinResponse, ActivityReactionAddedEvent, ActivityResponse } from '../../../gen/models';
+import type { EventPayload } from '../../../types-internal';
+export declare const addReactionToActivities: (event: ActivityReactionAddedEvent, activities: ActivityResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityResponse[] | undefined;
+};
+export declare const addReactionToPinnedActivities: (event: ActivityReactionAddedEvent, pinnedActivities: ActivityPinResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityPinResponse[] | undefined;
+};
 export declare function handleActivityReactionAdded(this: Feed, event: EventPayload<'feeds.activity.reaction.added'>): void;

package/dist/src/feed/event-handlers/activity/handle-activity-reaction-deleted.d.ts

@@ -1,8 +1,12 @@
 import type { Feed } from '../../../feed';
-import type { ActivityReactionDeletedEvent, ActivityResponse } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-export declare const removeReactionFromActivity: (event: ActivityReactionDeletedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const removeReactionFromActivities: (event: ActivityReactionDeletedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
+import { ActivityPinResponse, ActivityReactionDeletedEvent, ActivityResponse } from '../../../gen/models';
+import type { EventPayload } from '../../../types-internal';
+export declare const removeReactionFromActivities: (event: ActivityReactionDeletedEvent, activities: ActivityResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityResponse[] | undefined;
+};
+export declare const removeReactionFromPinnedActivities: (event: ActivityReactionDeletedEvent, activities: ActivityPinResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityPinResponse[] | undefined;
+};
 export declare function handleActivityReactionDeleted(this: Feed, event: EventPayload<'feeds.activity.reaction.deleted'>): void;

package/dist/src/feed/event-handlers/activity/handle-activity-unpinned.d.ts

@@ -0,0 +1,3 @@
+import { EventPayload } from '../../../types-internal';
+import { Feed } from '../../feed';
+export declare function handleActivityUnpinned(this: Feed, event: EventPayload<'feeds.activity.unpinned'>): void;

package/dist/src/feed/event-handlers/activity/handle-activity-updated.d.ts

@@ -1,8 +1,12 @@
 import { Feed } from '../../../feed';
-import { ActivityResponse } from '../../../gen/models';
+import { ActivityPinResponse, ActivityResponse, ActivityUpdatedEvent } from '../../../gen/models';
 import { EventPayload } from '../../../types-internal';
-export declare const updateActivityInState: (updatedActivityResponse: ActivityResponse, activities: ActivityResponse[], replaceCompletely?: boolean) => {
+export declare const updateActivityInState: (event: ActivityUpdatedEvent, activities: ActivityResponse[] | undefined) => {
     changed: boolean;
-    activities: ActivityResponse[];
+    entities: ActivityResponse[] | undefined;
+};
+export declare const updatePinnedActivityInState: (event: ActivityUpdatedEvent, pinnedActivities: ActivityPinResponse[] | undefined) => {
+    changed: boolean;
+    entities: ActivityPinResponse[] | undefined;
 };
 export declare function handleActivityUpdated(this: Feed, event: EventPayload<'feeds.activity.updated'>): void;

package/dist/src/feed/event-handlers/bookmark/handle-bookmark-added.d.ts

@@ -1,8 +1,12 @@
 import type { Feed } from '../../../feed';
-import type { ActivityResponse, BookmarkAddedEvent } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-export declare const addBookmarkToActivity: (event: BookmarkAddedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const addBookmarkToActivities: (event: BookmarkAddedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
+import type { ActivityPinResponse, ActivityResponse, BookmarkAddedEvent } from '../../../gen/models';
+import type { EventPayload } from '../../../types-internal';
+export declare const addBookmarkToActivities: (event: BookmarkAddedEvent, activities: ActivityResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityResponse[] | undefined;
+};
+export declare const addBookmarkToPinnedActivities: (event: BookmarkAddedEvent, pinnedActivities: ActivityPinResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityPinResponse[] | undefined;
+};
 export declare function handleBookmarkAdded(this: Feed, event: EventPayload<'feeds.bookmark.added'>): void;

package/dist/src/feed/event-handlers/bookmark/handle-bookmark-deleted.d.ts

@@ -1,9 +1,13 @@
 import type { Feed } from '../../../feed';
-import type { ActivityResponse, BookmarkDeletedEvent, BookmarkResponse } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type { ActivityPinResponse, ActivityResponse, BookmarkDeletedEvent, BookmarkResponse } from '../../../gen/models';
+import type { EventPayload } from '../../../types-internal';
 export declare const isSameBookmark: (bookmark1: BookmarkResponse, bookmark2: BookmarkResponse) => boolean;
-export declare const removeBookmarkFromActivities: (event: BookmarkDeletedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
-export declare const removeBookmarkFromActivity: (event: BookmarkDeletedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
+export declare const removeBookmarkFromActivities: (event: BookmarkDeletedEvent, activities: ActivityResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityResponse[] | undefined;
+};
+export declare const removeBookmarkFromPinnedActivities: (event: BookmarkDeletedEvent, pinnedActivities: ActivityPinResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityPinResponse[] | undefined;
+};
 export declare function handleBookmarkDeleted(this: Feed, event: EventPayload<'feeds.bookmark.deleted'>): void;

package/dist/src/feed/event-handlers/bookmark/handle-bookmark-updated.d.ts

@@ -1,8 +1,12 @@
 import type { Feed } from '../../../feed';
-import type { ActivityResponse, BookmarkUpdatedEvent } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
-export declare const updateBookmarkInActivity: (event: BookmarkUpdatedEvent, activity: ActivityResponse, isCurrentUser: boolean) => UpdateStateResult<ActivityResponse>;
-export declare const updateBookmarkInActivities: (event: BookmarkUpdatedEvent, activities: ActivityResponse[] | undefined, isCurrentUser: boolean) => UpdateStateResult<{
-    activities: ActivityResponse[];
-}>;
+import type { ActivityPinResponse, ActivityResponse, BookmarkUpdatedEvent } from '../../../gen/models';
+import type { EventPayload } from '../../../types-internal';
+export declare const updateBookmarkInActivities: (event: BookmarkUpdatedEvent, activities: ActivityResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityResponse[] | undefined;
+};
+export declare const updateBookmarkInPinnedActivities: (event: BookmarkUpdatedEvent, pinnedActivities: ActivityPinResponse[] | undefined, eventBelongsToCurrentUser: boolean) => {
+    changed: boolean;
+    entities: ActivityPinResponse[] | undefined;
+};
 export declare function handleBookmarkUpdated(this: Feed, event: EventPayload<'feeds.bookmark.updated'>): void;

package/dist/src/gen/models/index.d.ts

@@ -379,6 +379,7 @@ export interface AggregatedActivityResponse {
 }
 export interface AggregationConfig {
     format?: string;
+    group_size?: number;
 }
 export interface AppEventResponse {
     auto_translation_enabled: boolean;
@@ -839,6 +840,8 @@ export interface Channel {
     last_campaigns?: string;
     last_message_at?: Date;
     member_count?: number;
+    message_count?: number;
+    message_count_updated_at?: Date;
     team?: string;
     active_live_locations?: SharedLocation[];
     invites?: ChannelMember[];
@@ -852,6 +855,7 @@ export interface ChannelConfig {
     automod: 'disabled' | 'simple' | 'AI';
     automod_behavior: 'flag' | 'block' | 'shadow_block';
     connect_events: boolean;
+    count_messages: boolean;
     created_at: Date;
     custom_events: boolean;
     mark_messages_pending: boolean;
@@ -886,6 +890,7 @@ export interface ChannelConfigWithInfo {
     automod: 'disabled' | 'simple' | 'AI';
     automod_behavior: 'flag' | 'block' | 'shadow_block';
     connect_events: boolean;
+    count_messages: boolean;
     created_at: Date;
     custom_events: boolean;
     mark_messages_pending: boolean;
@@ -936,6 +941,7 @@ export interface ChannelMember {
     role?: 'member' | 'moderator' | 'admin' | 'owner';
     status?: string;
     user_id?: string;
+    deleted_messages?: string[];
     user?: UserResponse;
 }
 export interface ChannelMute {
@@ -1002,6 +1008,7 @@ export interface ChannelResponse {
     hide_messages_before?: Date;
     last_message_at?: Date;
     member_count?: number;
+    message_count?: number;
     mute_expires_at?: Date;
     muted?: boolean;
     team?: string;
@@ -1117,6 +1124,7 @@ export interface ConfigOverrides {
     grants: Record<string, string[]>;
     blocklist?: string;
     blocklist_behavior?: 'flag' | 'block';
+    count_messages?: boolean;
     max_message_length?: number;
     quotes?: boolean;
     reactions?: boolean;
@@ -1140,6 +1148,7 @@ export interface ConfigResponse {
     automod_semantic_filters_config?: AutomodSemanticFiltersConfig;
     automod_toxicity_config?: AutomodToxicityConfig;
     block_list_config?: BlockListConfig;
+    llm_config?: LLMConfig;
     rule_builder_config?: RuleBuilderConfig;
     velocity_filter_config?: VelocityFilterConfig;
     video_call_rule_config?: VideoCallRuleConfig;
@@ -1541,6 +1550,7 @@ export interface FeedMemberResponse {
     invite_accepted_at?: Date;
     invite_rejected_at?: Date;
     custom?: Record<string, any>;
+    membership_level?: MembershipLevelResponse;
 }
 export interface FeedMemberUpdatedEvent {
     created_at: Date;
@@ -2011,6 +2021,18 @@ export interface IngressVideoLayerResponse {
     max_dimension: number;
     min_dimension: number;
 }
+export interface LLMConfig {
+    enabled: boolean;
+    rules: LLMRule[];
+    async?: boolean;
+    severity_descriptions?: Record<string, string>;
+}
+export interface LLMRule {
+    action: 'flag' | 'shadow' | 'remove' | 'bounce' | 'bounce_flag' | 'bounce_remove' | 'keep';
+    description: string;
+    label: string;
+    severity_rules: BodyguardSeverityRule[];
+}
 export interface LabelThresholds {
     block?: number;
     flag?: number;
@@ -2056,6 +2078,16 @@ export interface MarkReviewedRequest {
 export interface MemberLookup {
     limit: number;
 }
+export interface MembershipLevelResponse {
+    created_at: Date;
+    id: string;
+    name: string;
+    priority: number;
+    updated_at: Date;
+    tags: string[];
+    description?: string;
+    custom?: Record<string, any>;
+}
 export interface Message {
     cid: string;
     created_at: Date;
@@ -2081,6 +2113,7 @@ export interface Message {
     before_message_send_failed?: boolean;
     command?: string;
     deleted_at?: Date;
+    deleted_for_me?: boolean;
     message_text_updated_at?: Date;
     mml?: string;
     parent_id?: string;
@@ -2136,6 +2169,7 @@ export interface MessageResponse {
     user: UserResponse;
     command?: string;
     deleted_at?: Date;
+    deleted_for_me?: boolean;
     message_text_updated_at?: Date;
     mml?: string;
     parent_id?: string;
@@ -2178,11 +2212,11 @@ export interface ModerationFlagResponse {
     type: string;
     updated_at: string;
     user_id: string;
+    result: Array<Record<string, any>>;
     entity_creator_id?: string;
     reason?: string;
     review_queue_item_id?: string;
     labels?: string[];
-    result?: Array<Record<string, any>>;
     custom?: Record<string, any>;
     moderation_payload?: ModerationPayload;
     review_queue_item?: ReviewQueueItemResponse;
@@ -3313,6 +3347,7 @@ export interface UpsertConfigRequest {
     block_list_config?: BlockListConfig;
     bodyguard_config?: AITextConfig;
     google_vision_config?: GoogleVisionConfig;
+    llm_config?: LLMConfig;
     rule_builder_config?: RuleBuilderConfig;
     velocity_filter_config?: VelocityFilterConfig;
     video_call_rule_config?: VideoCallRuleConfig;

package/dist/src/test-utils/response-generators.d.ts

@@ -1,4 +1,5 @@
-import { FeedResponse, FollowResponse, OwnUser, OwnUserResponse, UserResponse } from '../gen/models';
+import { ActivityPinResponse, ActivityResponse, BookmarkFolderResponse, BookmarkResponse, FeedResponse, FeedsReactionResponse, FollowResponse, OwnUser, OwnUserResponse, UserResponse } from '../gen/models';
+import { EventPayload } from '../types-internal';
 export declare const getHumanId: () => string;
 export declare const generateUserResponse: (overrides?: Partial<UserResponse>) => UserResponse;
 export declare const generateOwnUserResponse: (overrides?: Partial<OwnUserResponse>) => OwnUserResponse;
@@ -7,3 +8,47 @@ export declare const generateFeedResponse: (overrides?: Omit<Partial<FeedRespons
     created_by?: Partial<UserResponse>;
 }) => FeedResponse;
 export declare const generateFollowResponse: (overrides?: Partial<FollowResponse>) => FollowResponse;
+export declare const generateActivityResponse: (overrides?: Omit<Partial<ActivityResponse>, "user"> & {
+    user?: Partial<UserResponse>;
+}) => ActivityResponse;
+export declare const generateFeedReactionResponse: (overrides?: Omit<Partial<FeedsReactionResponse>, "user"> & {
+    user?: Partial<UserResponse>;
+}) => FeedsReactionResponse;
+export declare const generateActivityPinResponse: (overrides?: Omit<Partial<ActivityPinResponse>, "activity" | "user"> & {
+    activity?: Partial<ActivityResponse>;
+    user?: Partial<UserResponse>;
+}) => ActivityPinResponse;
+export declare const generateBookmarkFolderResponse: (overrides?: Partial<BookmarkFolderResponse>) => BookmarkFolderResponse;
+export declare const generateBookmarkResponse: (overrides?: Omit<Partial<BookmarkResponse>, "activity" | "user"> & {
+    activity?: Partial<ActivityResponse>;
+    user?: Partial<UserResponse>;
+}) => BookmarkResponse;
+export declare function generateActivityReactionAddedEvent(overrides?: Omit<Partial<EventPayload<'feeds.activity.reaction.added'>>, 'activity' | 'type' | 'reaction' | 'user'> & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+    reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+}): EventPayload<'feeds.activity.reaction.added'>;
+export declare function generateActivityReactionDeletedEvent(overrides?: Omit<Partial<EventPayload<'feeds.activity.reaction.deleted'>>, 'user' | 'activity' | 'reaction'> & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+    reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+}): EventPayload<'feeds.activity.reaction.deleted'>;
+export declare function generateActivityUpdatedEvent(overrides?: Omit<Partial<EventPayload<'feeds.activity.updated'>>, 'activity' | 'type'> & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+}): EventPayload<'feeds.activity.updated'>;
+export declare function generateBookmarkAddedEvent(overrides?: Omit<Partial<EventPayload<'feeds.bookmark.added'>>, 'bookmark' | 'user'> & {
+    bookmark?: Parameters<typeof generateBookmarkResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+}): EventPayload<'feeds.bookmark.added'>;
+export declare function generateBookmarkDeletedEvent(overrides?: Omit<Partial<EventPayload<'feeds.bookmark.deleted'>>, 'bookmark' | 'user'> & {
+    bookmark?: Parameters<typeof generateBookmarkResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+}): EventPayload<'feeds.bookmark.deleted'>;
+export declare function generateBookmarkUpdatedEvent(overrides?: Omit<Partial<EventPayload<'feeds.bookmark.updated'>>, 'bookmark' | 'user'> & {
+    bookmark?: Parameters<typeof generateBookmarkResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+}): EventPayload<'feeds.bookmark.updated'>;
+export declare function generateActivityPinnedEvent(overrides?: Omit<Partial<EventPayload<'feeds.activity.pinned'>>, 'pinned_activity' | 'user'> & {
+    pinned_activity?: Parameters<typeof generateActivityPinResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+}): EventPayload<'feeds.activity.pinned'>;

package/dist/src/utils/index.d.ts

@@ -3,3 +3,4 @@ export * from './unique-array-merge';
 export * from './constants';
 export * from './type-assertions';
 export * from './state-update-queue';
+export * from './update-entity-in-array';

package/dist/src/utils/update-entity-in-array.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility function through which you can update an entity in an array;
+ *
+ * - if the entity is not found, it returns the original array unchanged
+ * - if the entity is found and updated, it returns a new array with the updated entity
+ * - if the entity is found but not updated (updater returns `matchedEntity`), it returns the original array unchanged
+ *
+ * - `changed: boolean` indicates whether the array has changed or not - this is QOL enhancement, you
+ * can compare returned array to the original one
+ *
+ */
+export declare function updateEntityInArray<T>(_: {
+    matcher: (entity: T) => boolean;
+    entities: T[];
+    updater: (currentEntity: T) => T;
+}): {
+    changed: boolean;
+    entities: T[];
+};
+export declare function updateEntityInArray<T>(_: {
+    matcher: (entity: T) => boolean;
+    entities: T[] | undefined;
+    updater: (currentEntity: T) => T;
+}): {
+    changed: boolean;
+    entities: T[] | undefined;
+};