@stream-io/node-sdk 0.7.42 → 0.7.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/node-sdk",
-  "version": "0.7.42",
+  "version": "0.7.43",
   "description": "",
   "exports": {
     ".": {

package/src/gen/chat/ChatApi.ts

@@ -70,6 +70,8 @@ import {
   QuerySegmentTargetsResponse,
   QuerySegmentsRequest,
   QuerySegmentsResponse,
+  QueryTeamUsageStatsRequest,
+  QueryTeamUsageStatsResponse,
   QueryThreadsRequest,
   QueryThreadsResponse,
   ReminderResponseData,
@@ -91,6 +93,8 @@ import {
   TranslateMessageRequest,
   TruncateChannelRequest,
   TruncateChannelResponse,
+  UndeleteMessageRequest,
+  UndeleteMessageResponse,
   UnmuteChannelRequest,
   UnmuteResponse,
   UnreadCountsBatchRequest,
@@ -203,7 +207,7 @@ export class ChatApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async scheduleCampaign(
+  async stopCampaign(
     request: StopCampaignRequest & { id: string },
   ): Promise<StreamResponse<CampaignResponse>> {
     const pathParams = {
@@ -1609,19 +1613,17 @@ export class ChatApi {
   }
 
   async undeleteMessage(
-    request: UpdateMessageRequest & { id: string },
-  ): Promise<StreamResponse<UpdateMessageResponse>> {
+    request: UndeleteMessageRequest & { id: string },
+  ): Promise<StreamResponse<UndeleteMessageResponse>> {
     const pathParams = {
       id: request?.id,
     };
     const body = {
-      message: request?.message,
-      skip_enrich_url: request?.skip_enrich_url,
-      skip_push: request?.skip_push,
+      undeleted_by: request?.undeleted_by,
     };
 
     const response = await this.apiClient.sendRequest<
-      StreamResponse<UpdateMessageResponse>
+      StreamResponse<UndeleteMessageResponse>
     >(
       'POST',
       '/api/v2/chat/messages/{id}/undelete',
@@ -1631,7 +1633,7 @@ export class ChatApi {
       'application/json',
     );
 
-    decoders.UpdateMessageResponse?.(response.body);
+    decoders.UndeleteMessageResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
   }
@@ -2094,6 +2096,33 @@ export class ChatApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async queryTeamUsageStats(
+    request?: QueryTeamUsageStatsRequest,
+  ): Promise<StreamResponse<QueryTeamUsageStatsResponse>> {
+    const body = {
+      end_date: request?.end_date,
+      limit: request?.limit,
+      month: request?.month,
+      next: request?.next,
+      start_date: request?.start_date,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryTeamUsageStatsResponse>
+    >(
+      'POST',
+      '/api/v2/chat/stats/team_usage',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryTeamUsageStatsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryThreads(
     request?: QueryThreadsRequest,
   ): Promise<StreamResponse<QueryThreadsResponse>> {

package/src/gen/common/CommonApi.ts

@@ -1,5 +1,7 @@
 import { ApiClient, StreamResponse } from '../../gen-imports';
 import {
+  AddUserGroupMembersRequest,
+  AddUserGroupMembersResponse,
   BlockUsersRequest,
   BlockUsersResponse,
   CheckExternalStorageResponse,
@@ -26,6 +28,8 @@ import {
   CreatePollRequest,
   CreateRoleRequest,
   CreateRoleResponse,
+  CreateUserGroupRequest,
+  CreateUserGroupResponse,
   DeactivateUserRequest,
   DeactivateUserResponse,
   DeactivateUsersRequest,
@@ -49,6 +53,7 @@ import {
   GetPushTemplatesResponse,
   GetRateLimitsResponse,
   GetTaskResponse,
+  GetUserGroupResponse,
   ImageUploadRequest,
   ImageUploadResponse,
   ListBlockListResponse,
@@ -59,6 +64,7 @@ import {
   ListPermissionsResponse,
   ListPushProvidersResponse,
   ListRolesResponse,
+  ListUserGroupsResponse,
   PollOptionResponse,
   PollResponse,
   PollVotesResponse,
@@ -71,8 +77,10 @@ import {
   ReactivateUserResponse,
   ReactivateUsersRequest,
   ReactivateUsersResponse,
+  RemoveUserGroupMembersResponse,
   Response,
   RestoreUsersRequest,
+  SearchUserGroupsResponse,
   SharedLocationResponse,
   SharedLocationsResponse,
   UnblockUsersRequest,
@@ -86,6 +94,8 @@ import {
   UpdatePollOptionRequest,
   UpdatePollPartialRequest,
   UpdatePollRequest,
+  UpdateUserGroupRequest,
+  UpdateUserGroupResponse,
   UpdateUsersPartialRequest,
   UpdateUsersRequest,
   UpdateUsersResponse,
@@ -131,6 +141,7 @@ export class CommonApi {
       max_aggregated_activities_length:
         request?.max_aggregated_activities_length,
       migrate_permissions_to_v2: request?.migrate_permissions_to_v2,
+      moderation_analytics_enabled: request?.moderation_analytics_enabled,
       moderation_enabled: request?.moderation_enabled,
       moderation_webhook_url: request?.moderation_webhook_url,
       multi_tenant_enabled: request?.multi_tenant_enabled,
@@ -623,6 +634,7 @@ export class CommonApi {
     const body = {
       mode: request?.mode,
       path: request?.path,
+      merge_custom: request?.merge_custom,
     };
 
     const response = await this.apiClient.sendRequest<
@@ -1371,6 +1383,193 @@ export class CommonApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async listUserGroups(request?: {
+    limit?: number;
+    id_gt?: string;
+    created_at_gt?: string;
+    team_id?: string;
+  }): Promise<StreamResponse<ListUserGroupsResponse>> {
+    const queryParams = {
+      limit: request?.limit,
+      id_gt: request?.id_gt,
+      created_at_gt: request?.created_at_gt,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ListUserGroupsResponse>
+    >('GET', '/api/v2/usergroups', undefined, queryParams);
+
+    decoders.ListUserGroupsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async createUserGroup(
+    request: CreateUserGroupRequest,
+  ): Promise<StreamResponse<CreateUserGroupResponse>> {
+    const body = {
+      name: request?.name,
+      description: request?.description,
+      id: request?.id,
+      team_id: request?.team_id,
+      member_ids: request?.member_ids,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CreateUserGroupResponse>
+    >(
+      'POST',
+      '/api/v2/usergroups',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.CreateUserGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async searchUserGroups(request: {
+    query: string;
+    limit?: number;
+    name_gt?: string;
+    id_gt?: string;
+    team_id?: string;
+  }): Promise<StreamResponse<SearchUserGroupsResponse>> {
+    const queryParams = {
+      query: request?.query,
+      limit: request?.limit,
+      name_gt: request?.name_gt,
+      id_gt: request?.id_gt,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<SearchUserGroupsResponse>
+    >('GET', '/api/v2/usergroups/search', undefined, queryParams);
+
+    decoders.SearchUserGroupsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteUserGroup(request: {
+    id: string;
+    team_id?: string;
+  }): Promise<StreamResponse<Response>> {
+    const queryParams = {
+      team_id: request?.team_id,
+    };
+    const pathParams = {
+      id: request?.id,
+    };
+
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
+      'DELETE',
+      '/api/v2/usergroups/{id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.Response?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getUserGroup(request: {
+    id: string;
+    team_id?: string;
+  }): Promise<StreamResponse<GetUserGroupResponse>> {
+    const queryParams = {
+      team_id: request?.team_id,
+    };
+    const pathParams = {
+      id: request?.id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetUserGroupResponse>
+    >('GET', '/api/v2/usergroups/{id}', pathParams, queryParams);
+
+    decoders.GetUserGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateUserGroup(
+    request: UpdateUserGroupRequest & { id: string },
+  ): Promise<StreamResponse<UpdateUserGroupResponse>> {
+    const pathParams = {
+      id: request?.id,
+    };
+    const body = {
+      description: request?.description,
+      name: request?.name,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateUserGroupResponse>
+    >(
+      'PUT',
+      '/api/v2/usergroups/{id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateUserGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async removeUserGroupMembers(request: {
+    id: string;
+  }): Promise<StreamResponse<RemoveUserGroupMembersResponse>> {
+    const pathParams = {
+      id: request?.id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<RemoveUserGroupMembersResponse>
+    >('DELETE', '/api/v2/usergroups/{id}/members', pathParams, undefined);
+
+    decoders.RemoveUserGroupMembersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async addUserGroupMembers(
+    request: AddUserGroupMembersRequest & { id: string },
+  ): Promise<StreamResponse<AddUserGroupMembersResponse>> {
+    const pathParams = {
+      id: request?.id,
+    };
+    const body = {
+      member_ids: request?.member_ids,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<AddUserGroupMembersResponse>
+    >(
+      'POST',
+      '/api/v2/usergroups/{id}/members',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddUserGroupMembersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryUsers(request?: {
     payload?: QueryUsersPayload;
   }): Promise<StreamResponse<QueryUsersResponse>> {

package/src/gen/feeds/FeedsApi.ts

@@ -105,6 +105,7 @@ import {
   Response,
   RestoreActivityRequest,
   RestoreActivityResponse,
+  RestoreFeedGroupResponse,
   SingleFollowResponse,
   UnfollowBatchRequest,
   UnfollowBatchResponse,
@@ -828,13 +829,13 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async readCollections(request: {
-    collection_refs: string[];
+  async readCollections(request?: {
     user_id?: string;
+    collection_refs?: string[];
   }): Promise<StreamResponse<ReadCollectionsResponse>> {
     const queryParams = {
-      collection_refs: request?.collection_refs,
       user_id: request?.user_id,
+      collection_refs: request?.collection_refs,
     };
 
     const response = await this.apiClient.sendRequest<
@@ -1670,6 +1671,27 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async restoreFeedGroup(request: {
+    feed_group_id: string;
+  }): Promise<StreamResponse<RestoreFeedGroupResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<RestoreFeedGroupResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/restore',
+      pathParams,
+      undefined,
+    );
+
+    decoders.RestoreFeedGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async deleteFeedGroup(request: {
     id: string;
     hard_delete?: boolean;

package/src/gen/model-decoders/decoders.ts

@@ -324,6 +324,13 @@ decoders.AddReactionResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.AddUserGroupMembersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_group: { type: 'UserGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.AggregatedActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1080,6 +1087,8 @@ decoders.CallStatsParticipantSession = (input?: Record<string, any>) => {
 decoders.CallStatsReportReadyEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    participants_overview: { type: 'CallStatsParticipant', isSingle: false },
   };
   return decode(typeMappings, input);
 };
@@ -1830,6 +1839,13 @@ decoders.CreateSIPTrunkResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.CreateUserGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_group: { type: 'UserGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.CustomCheckResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     item: { type: 'ReviewQueueItemResponse', isSingle: true },
@@ -2086,6 +2102,15 @@ decoders.FeedGroupResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.FeedGroupRestoredEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.FeedMemberAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -2653,6 +2678,13 @@ decoders.GetThreadResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetUserGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_group: { type: 'UserGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GoLiveResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     call: { type: 'CallResponse', isSingle: true },
@@ -2827,9 +2859,31 @@ decoders.ListTranscriptionsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ListUserGroupsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_groups: { type: 'UserGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MarkReadResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    event: { type: 'MessageReadEvent', isSingle: true },
+    event: { type: 'MarkReadResponseEvent', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MarkReadResponseEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel_last_message_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    thread: { type: 'ThreadResponse', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -3016,7 +3070,7 @@ decoders.MessageReadEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    channel_last_message_at: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
     channel: { type: 'ChannelResponse', isSingle: true },
 
@@ -3225,6 +3279,15 @@ decoders.ModerationRuleV2Response = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ModerationRulesTriggeredEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MuteChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel_mutes: { type: 'ChannelMute', isSingle: false },
@@ -4012,6 +4075,13 @@ decoders.ReminderUpdatedEvent = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.RemoveUserGroupMembersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_group: { type: 'UserGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ResolveSipInboundResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     sip_routing_rule: { type: 'SIPInboundRoutingRuleResponse', isSingle: true },
@@ -4028,6 +4098,13 @@ decoders.RestoreActivityResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.RestoreFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ReviewQueueItemNewEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -4174,6 +4251,13 @@ decoders.SearchResultMessage = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.SearchUserGroupsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_groups: { type: 'UserGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Segment = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -4424,6 +4508,13 @@ decoders.UnblockedUserEvent = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UndeleteMessageResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    message: { type: 'MessageResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UnfollowBatchResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     follows: { type: 'FollowResponse', isSingle: false },
@@ -4692,6 +4783,13 @@ decoders.UpdateThreadPartialResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateUserGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user_group: { type: 'UserGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateUsersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     users: { type: 'FullUserResponse', isSingle: false },
@@ -4818,6 +4916,79 @@ decoders.UserFlaggedEvent = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserGroupCreatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserGroupDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserGroupMember = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserGroupMemberAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserGroupMemberRemovedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'UserGroupMember', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserGroupUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UserMessagesDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },