@stream-io/node-sdk 0.4.26 → 0.5.0

package/src/gen/model-decoders/{index.ts → decoders.ts}

@@ -4,8 +4,10 @@ type TypeMapping = Record<string, { type: string; isSingle: boolean }>;
 
 export const decoders: Record<string, Decoder> = {};
 
-const decodeDatetimeType = (input: number) =>
-  new Date(Math.floor(input / 1000000));
+const decodeDatetimeType = (input: number | string) =>
+  typeof input === 'number'
+    ? new Date(Math.floor(input / 1000000))
+    : new Date(input);
 
 decoders.DatetimeType = decodeDatetimeType;
 
@@ -32,6 +34,20 @@ const decode = (typeMappings: TypeMapping, input?: Record<string, any>) => {
   return input;
 };
 
+decoders.AcceptFeedMemberInviteResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    member: { type: 'FeedMemberResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.AcceptFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ActionLogResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -45,326 +61,376 @@ decoders.ActionLogResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.AppResponseFields = (input?: Record<string, any>) => {
+decoders.ActivityAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    event_hooks: { type: 'EventHook', isSingle: false },
-
-    call_types: { type: 'CallType', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    channel_configs: { type: 'ChannelConfig', isSingle: false },
+    activity: { type: 'ActivityResponse', isSingle: true },
 
-    push_notifications: { type: 'PushNotificationFields', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.AutomodDetails = (input?: Record<string, any>) => {
+decoders.ActivityDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    result: { type: 'MessageModerationResult', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Ban = (input?: Record<string, any>) => {
+decoders.ActivityMarkEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    expires: { type: 'DatetimeType', isSingle: true },
-
-    channel: { type: 'Channel', isSingle: true },
-
-    created_by: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    target: { type: 'User', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BanResponse = (input?: Record<string, any>) => {
+decoders.ActivityMarkedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
-
-    expires: { type: 'DatetimeType', isSingle: true },
-
-    banned_by: { type: 'UserResponse', isSingle: true },
-
-    channel: { type: 'ChannelResponse', isSingle: true },
-
-    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BlockListResponse = (input?: Record<string, any>) => {
+decoders.ActivityPinResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BlockUsersResponse = (input?: Record<string, any>) => {
+decoders.ActivityPinnedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_activity: { type: 'PinActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.BlockedUserResponse = (input?: Record<string, any>) => {
+decoders.ActivityReactionAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    blocked_user: { type: 'UserResponse', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallParticipantResponse = (input?: Record<string, any>) => {
+decoders.ActivityReactionDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    joined_at: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallRecording = (input?: Record<string, any>) => {
+decoders.ActivityReactionUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    end_time: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    start_time: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallReportResponse = (input?: Record<string, any>) => {
+decoders.ActivityRemovedFromFeedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    ended_at: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    started_at: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallResponse = (input?: Record<string, any>) => {
+decoders.ActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
 
-    created_by: { type: 'UserResponse', isSingle: true },
+    comments: { type: 'CommentResponse', isSingle: false },
 
-    ended_at: { type: 'DatetimeType', isSingle: true },
+    latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    starts_at: { type: 'DatetimeType', isSingle: true },
+    mentioned_users: { type: 'UserResponse', isSingle: false },
 
-    session: { type: 'CallSessionResponse', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
+    own_bookmarks: { type: 'BookmarkResponse', isSingle: false },
 
-decoders.CallSessionResponse = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    participants: { type: 'CallParticipantResponse', isSingle: false },
+    own_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    accepted_by: { type: 'DatetimeType', isSingle: false },
+    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
 
-    missed_by: { type: 'DatetimeType', isSingle: false },
+    user: { type: 'UserResponse', isSingle: true },
 
-    rejected_by: { type: 'DatetimeType', isSingle: false },
+    deleted_at: { type: 'DatetimeType', isSingle: true },
 
-    ended_at: { type: 'DatetimeType', isSingle: true },
+    edited_at: { type: 'DatetimeType', isSingle: true },
 
-    live_ended_at: { type: 'DatetimeType', isSingle: true },
+    expires_at: { type: 'DatetimeType', isSingle: true },
 
-    live_started_at: { type: 'DatetimeType', isSingle: true },
+    current_feed: { type: 'FeedResponse', isSingle: true },
 
-    started_at: { type: 'DatetimeType', isSingle: true },
+    parent: { type: 'ActivityResponse', isSingle: true },
 
-    timer_ends_at: { type: 'DatetimeType', isSingle: true },
+    poll: { type: 'PollResponseData', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallStateResponseFields = (input?: Record<string, any>) => {
+decoders.ActivitySelectorConfig = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    members: { type: 'MemberResponse', isSingle: false },
-
-    call: { type: 'CallResponse', isSingle: true },
+    cutoff_time: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallStatsReportSummaryResponse = (input?: Record<string, any>) => {
+decoders.ActivityUnpinnedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    first_stats_time: { type: 'DatetimeType', isSingle: true },
-
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_activity: { type: 'PinActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallTranscription = (input?: Record<string, any>) => {
+decoders.ActivityUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    end_time: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    start_time: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallType = (input?: Record<string, any>) => {
+decoders.AddActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CallTypeResponse = (input?: Record<string, any>) => {
+decoders.AddBookmarkResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CampaignResponse = (input?: Record<string, any>) => {
+decoders.AddCommentReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    segments: { type: 'Segment', isSingle: false },
-
-    users: { type: 'UserResponse', isSingle: false },
-
-    stats: { type: 'CampaignStatsResponse', isSingle: true },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    scheduled_for: { type: 'DatetimeType', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    stop_at: { type: 'DatetimeType', isSingle: true },
+decoders.AddCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    sender: { type: 'UserResponse', isSingle: true },
+decoders.AddCommentsBatchResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'CommentResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CampaignStatsResponse = (input?: Record<string, any>) => {
+decoders.AddReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    stats_completed_at: { type: 'DatetimeType', isSingle: true },
+    activity: { type: 'ActivityResponse', isSingle: true },
 
-    stats_started_at: { type: 'DatetimeType', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Channel = (input?: Record<string, any>) => {
+decoders.AggregatedActivityResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_message_at: { type: 'DatetimeType', isSingle: true },
+    activities: { type: 'ActivityResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
 
-    active_live_locations: { type: 'SharedLocation', isSingle: false },
+decoders.AnyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    invites: { type: 'ChannelMember', isSingle: false },
+decoders.AppResponseFields = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    event_hooks: { type: 'EventHook', isSingle: false },
 
-    members: { type: 'ChannelMember', isSingle: false },
+    call_types: { type: 'CallType', isSingle: false },
 
-    config: { type: 'ChannelConfig', isSingle: true },
+    channel_configs: { type: 'ChannelConfig', isSingle: false },
 
-    created_by: { type: 'User', isSingle: true },
+    push_notifications: { type: 'PushNotificationFields', isSingle: true },
 
-    truncated_by: { type: 'User', isSingle: true },
+    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelConfig = (input?: Record<string, any>) => {
+decoders.AsyncBulkImageModerationEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
+
+    started_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelConfigWithInfo = (input?: Record<string, any>) => {
+decoders.AsyncExportChannelsEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    commands: { type: 'Command', isSingle: false },
+    started_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMember = (input?: Record<string, any>) => {
+decoders.AsyncExportErrorEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    archived_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    ban_expires: { type: 'DatetimeType', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+decoders.AsyncExportModerationLogsEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    pinned_at: { type: 'DatetimeType', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMemberResponse = (input?: Record<string, any>) => {
+decoders.AsyncExportUsersEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    finished_at: { type: 'DatetimeType', isSingle: true },
 
-    archived_at: { type: 'DatetimeType', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
 
-    ban_expires: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
+decoders.AutomodDetails = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    result: { type: 'MessageModerationResult', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+decoders.Ban = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+    expires: { type: 'DatetimeType', isSingle: true },
 
-    pinned_at: { type: 'DatetimeType', isSingle: true },
+    channel: { type: 'Channel', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    created_by: { type: 'User', isSingle: true },
+
+    target: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMute = (input?: Record<string, any>) => {
+decoders.BanResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
     expires: { type: 'DatetimeType', isSingle: true },
 
+    banned_by: { type: 'UserResponse', isSingle: true },
+
     channel: { type: 'ChannelResponse', isSingle: true },
 
     user: { type: 'UserResponse', isSingle: true },
@@ -372,143 +438,1370 @@ decoders.ChannelMute = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.ChannelPushPreferences = (input?: Record<string, any>) => {
+decoders.BlockListResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    disabled_until: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelResponse = (input?: Record<string, any>) => {
+decoders.BlockUsersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+decoders.BlockedUserEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    deleted_at: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
+
+    blocked_by_user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BlockedUserResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    blocked_user: { type: 'UserResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkFolderDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkFolderResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkFolderUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+
+    folder: { type: 'BookmarkFolderResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.BookmarkUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallAcceptedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallClosedCaptionsFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallClosedCaptionsStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallClosedCaptionsStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallCreatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallEndedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingFrameReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    captured_at: { type: 'DatetimeType', isSingle: true },
+
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    users: { type: 'UserResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallFrameRecordingStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallHLSBroadcastingFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallHLSBroadcastingStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallHLSBroadcastingStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallLiveStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberRemovedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMemberUpdatedPermissionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallMissedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallModerationBlurEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallModerationWarningEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallNotificationEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallParticipantResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    joined_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallReactionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    reaction: { type: 'ReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecording = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    end_time: { type: 'DatetimeType', isSingle: true },
+
+    start_time: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call_recording: { type: 'CallRecording', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRecordingStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRejectedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallReportResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    ended_at: { type: 'DatetimeType', isSingle: true },
+
+    started_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'UserResponse', isSingle: true },
+
+    ended_at: { type: 'DatetimeType', isSingle: true },
+
+    starts_at: { type: 'DatetimeType', isSingle: true },
+
+    session: { type: 'CallSessionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRingEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRtmpBroadcastFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRtmpBroadcastStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallRtmpBroadcastStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionEndedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionParticipantJoinedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    participant: { type: 'CallParticipantResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionParticipantLeftEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    participant: { type: 'CallParticipantResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    participants: { type: 'CallParticipantResponse', isSingle: false },
+
+    accepted_by: { type: 'DatetimeType', isSingle: false },
+
+    missed_by: { type: 'DatetimeType', isSingle: false },
+
+    rejected_by: { type: 'DatetimeType', isSingle: false },
+
+    ended_at: { type: 'DatetimeType', isSingle: true },
+
+    live_ended_at: { type: 'DatetimeType', isSingle: true },
+
+    live_started_at: { type: 'DatetimeType', isSingle: true },
+
+    started_at: { type: 'DatetimeType', isSingle: true },
+
+    timer_ends_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallSessionStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallStateResponseFields = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'MemberResponse', isSingle: false },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallStatsReportReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallStatsReportSummaryResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    first_stats_time: { type: 'DatetimeType', isSingle: true },
+
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscription = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    end_time: { type: 'DatetimeType', isSingle: true },
+
+    start_time: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionFailedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionReadyEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call_transcription: { type: 'CallTranscription', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTranscriptionStoppedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallType = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallTypeResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallUserFeedbackSubmittedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CallUserMutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignCompletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    campaign: { type: 'CampaignResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    segments: { type: 'Segment', isSingle: false },
+
+    users: { type: 'UserResponse', isSingle: false },
+
+    stats: { type: 'CampaignStatsResponse', isSingle: true },
+
+    scheduled_for: { type: 'DatetimeType', isSingle: true },
+
+    stop_at: { type: 'DatetimeType', isSingle: true },
+
+    sender: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignStartedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    campaign: { type: 'CampaignResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CampaignStatsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    stats_completed_at: { type: 'DatetimeType', isSingle: true },
+
+    stats_started_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Channel = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    last_message_at: { type: 'DatetimeType', isSingle: true },
+
+    active_live_locations: { type: 'SharedLocation', isSingle: false },
+
+    invites: { type: 'ChannelMember', isSingle: false },
+
+    members: { type: 'ChannelMember', isSingle: false },
+
+    config: { type: 'ChannelConfig', isSingle: true },
+
+    created_by: { type: 'User', isSingle: true },
+
+    truncated_by: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelConfig = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelConfigWithInfo = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    commands: { type: 'Command', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelCreatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelFrozenEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelHiddenEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMember = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    archived_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMemberResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    archived_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
+
+    pinned_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMute = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    expires: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelMutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelPushPreferences = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    disabled_until: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+
+    last_message_at: { type: 'DatetimeType', isSingle: true },
+
+    mute_expires_at: { type: 'DatetimeType', isSingle: true },
+
+    truncated_at: { type: 'DatetimeType', isSingle: true },
+
+    members: { type: 'ChannelMember', isSingle: false },
+
+    config: { type: 'ChannelConfigWithInfo', isSingle: true },
+
+    created_by: { type: 'UserResponse', isSingle: true },
+
+    truncated_by: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelStateResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'ChannelMember', isSingle: false },
+
+    messages: { type: 'MessageResponse', isSingle: false },
+
+    pinned_messages: { type: 'MessageResponse', isSingle: false },
+
+    threads: { type: 'ThreadStateResponse', isSingle: false },
+
+    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+
+    active_live_locations: {
+      type: 'SharedLocationResponseData',
+      isSingle: false,
+    },
+
+    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+
+    read: { type: 'ReadStateResponse', isSingle: false },
+
+    watchers: { type: 'UserResponse', isSingle: false },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    draft: { type: 'DraftResponse', isSingle: true },
+
+    membership: { type: 'ChannelMember', isSingle: true },
+
+    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelStateResponseFields = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'ChannelMember', isSingle: false },
+
+    messages: { type: 'MessageResponse', isSingle: false },
+
+    pinned_messages: { type: 'MessageResponse', isSingle: false },
+
+    threads: { type: 'ThreadStateResponse', isSingle: false },
 
     hide_messages_before: { type: 'DatetimeType', isSingle: true },
 
-    last_message_at: { type: 'DatetimeType', isSingle: true },
+    active_live_locations: {
+      type: 'SharedLocationResponseData',
+      isSingle: false,
+    },
+
+    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+
+    read: { type: 'ReadStateResponse', isSingle: false },
+
+    watchers: { type: 'UserResponse', isSingle: false },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    draft: { type: 'DraftResponse', isSingle: true },
+
+    membership: { type: 'ChannelMember', isSingle: true },
+
+    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelTruncatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelTypeConfig = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    commands: { type: 'Command', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelUnFrozenEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelUnmutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChannelVisibleEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ChatActivityStatsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    messages: { type: 'MessageStatsResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CheckResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ClosedCaptionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Command = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    mute_expires_at: { type: 'DatetimeType', isSingle: true },
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    truncated_at: { type: 'DatetimeType', isSingle: true },
+decoders.CommentAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    members: { type: 'ChannelMember', isSingle: false },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    config: { type: 'ChannelConfigWithInfo', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    created_by: { type: 'UserResponse', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    truncated_by: { type: 'UserResponse', isSingle: true },
+decoders.CommentDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    comment: { type: 'CommentResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelStateResponse = (input?: Record<string, any>) => {
+decoders.CommentReactionAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    members: { type: 'ChannelMember', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    messages: { type: 'MessageResponse', isSingle: false },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    pinned_messages: { type: 'MessageResponse', isSingle: false },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
-    threads: { type: 'ThreadStateResponse', isSingle: false },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    active_live_locations: {
-      type: 'SharedLocationResponseData',
-      isSingle: false,
-    },
+decoders.CommentReactionDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    read: { type: 'ReadStateResponse', isSingle: false },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
-    watchers: { type: 'UserResponse', isSingle: false },
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    channel: { type: 'ChannelResponse', isSingle: true },
+decoders.CommentReactionUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    draft: { type: 'DraftResponse', isSingle: true },
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    membership: { type: 'ChannelMember', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
 
-    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelStateResponseFields = (input?: Record<string, any>) => {
+decoders.CommentResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    members: { type: 'ChannelMember', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    messages: { type: 'MessageResponse', isSingle: false },
+    updated_at: { type: 'DatetimeType', isSingle: true },
 
-    pinned_messages: { type: 'MessageResponse', isSingle: false },
+    mentioned_users: { type: 'UserResponse', isSingle: false },
 
-    threads: { type: 'ThreadStateResponse', isSingle: false },
+    own_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    hide_messages_before: { type: 'DatetimeType', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
 
-    active_live_locations: {
-      type: 'SharedLocationResponseData',
-      isSingle: false,
-    },
+    deleted_at: { type: 'DatetimeType', isSingle: true },
 
-    pending_messages: { type: 'PendingMessageResponse', isSingle: false },
+    latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    read: { type: 'ReadStateResponse', isSingle: false },
+    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
 
-    watchers: { type: 'UserResponse', isSingle: false },
+decoders.CommentUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    comment: { type: 'CommentResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ConfigResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CountByMinuteResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    start_ts: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateBlockListResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    blocklist: { type: 'BlockListResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateCallTypeResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateChannelTypeResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateCommandResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    command: { type: 'Command', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateFeedViewResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_view: { type: 'FeedViewResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateFeedsBatchResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feeds: { type: 'FeedResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateGuestResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateImportResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    import_task: { type: 'ImportTask', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CreateRoleResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    role: { type: 'Role', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CustomCheckResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.CustomVideoEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeactivateUserResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteActivityReactionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteBookmarkResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
+decoders.DeleteCallResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    call: { type: 'CallResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteChannelResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
     channel: { type: 'ChannelResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    draft: { type: 'DraftResponse', isSingle: true },
+decoders.DeleteCommentReactionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
 
-    membership: { type: 'ChannelMember', isSingle: true },
+    reaction: { type: 'FeedsReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteMessageResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    message: { type: 'MessageResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeleteReactionResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    message: { type: 'MessageResponse', isSingle: true },
+
+    reaction: { type: 'ReactionResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Device = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.DeviceResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
 
-    push_preferences: { type: 'ChannelPushPreferences', isSingle: true },
+decoders.DraftPayloadResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    mentioned_users: { type: 'UserResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ChannelTypeConfig = (input?: Record<string, any>) => {
+decoders.DraftResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    message: { type: 'DraftPayloadResponse', isSingle: true },
 
-    commands: { type: 'Command', isSingle: false },
-  };
-  return decode(typeMappings, input);
-};
+    channel: { type: 'ChannelResponse', isSingle: true },
 
-decoders.ChatActivityStatsResponse = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    messages: { type: 'MessageStatsResponse', isSingle: true },
+    parent_message: { type: 'MessageResponse', isSingle: true },
+
+    quoted_message: { type: 'MessageResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CheckResponse = (input?: Record<string, any>) => {
+decoders.EgressRTMPResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+    started_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Command = (input?: Record<string, any>) => {
+decoders.EntityCreatorResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     updated_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    deactivated_at: { type: 'DatetimeType', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    last_active: { type: 'DatetimeType', isSingle: true },
+
+    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
+
+    devices: { type: 'DeviceResponse', isSingle: false },
+
+    push_notifications: {
+      type: 'PushNotificationSettingsResponse',
+      isSingle: true,
+    },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ConfigResponse = (input?: Record<string, any>) => {
+decoders.EventHook = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
@@ -517,216 +1810,259 @@ decoders.ConfigResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.CountByMinuteResponse = (input?: Record<string, any>) => {
+decoders.EventResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    start_ts: { type: 'DatetimeType', isSingle: true },
+    event: { type: 'WSEvent', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateBlockListResponse = (input?: Record<string, any>) => {
+decoders.ExportUserResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    blocklist: { type: 'BlockListResponse', isSingle: true },
+    messages: { type: 'MessageResponse', isSingle: false },
+
+    reactions: { type: 'ReactionResponse', isSingle: false },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateCallTypeResponse = (input?: Record<string, any>) => {
+decoders.FeedCreatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    members: { type: 'FeedMemberResponse', isSingle: false },
+
+    feed: { type: 'FeedResponse', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateChannelTypeResponse = (input?: Record<string, any>) => {
+decoders.FeedDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateCommandResponse = (input?: Record<string, any>) => {
+decoders.FeedGroupChangedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    command: { type: 'Command', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateGuestResponse = (input?: Record<string, any>) => {
+decoders.FeedGroupDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    user: { type: 'UserResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateImportResponse = (input?: Record<string, any>) => {
+decoders.FeedGroupResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    import_task: { type: 'ImportTask', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CreateRoleResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberAddedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    role: { type: 'Role', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'FeedMemberResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.CustomCheckResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberRemovedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    item: { type: 'ReviewQueueItemResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeactivateUserResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
     user: { type: 'UserResponse', isSingle: true },
+
+    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteCallResponse = (input?: Record<string, any>) => {
+decoders.FeedMemberUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    call: { type: 'CallResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'FeedMemberResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteChannelResponse = (input?: Record<string, any>) => {
+decoders.FeedResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    channel: { type: 'ChannelResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'UserResponse', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteMessageResponse = (input?: Record<string, any>) => {
+decoders.FeedUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    message: { type: 'MessageResponse', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    feed: { type: 'FeedResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponseCommonFields', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeleteReactionResponse = (input?: Record<string, any>) => {
+decoders.FeedViewResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    message: { type: 'MessageResponse', isSingle: true },
+    last_used_at: { type: 'DatetimeType', isSingle: true },
 
-    reaction: { type: 'ReactionResponse', isSingle: true },
+    activity_selectors: { type: 'ActivitySelectorConfig', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Device = (input?: Record<string, any>) => {
+decoders.FeedsReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DeviceResponse = (input?: Record<string, any>) => {
+decoders.FlagDetails = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
+    automod: { type: 'AutomodDetails', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DraftPayloadResponse = (input?: Record<string, any>) => {
+decoders.FlagFeedback = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    mentioned_users: { type: 'UserResponse', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.DraftResponse = (input?: Record<string, any>) => {
+decoders.FlagUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    message: { type: 'DraftPayloadResponse', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
 
-    channel: { type: 'ChannelResponse', isSingle: true },
+    created_by: { type: 'UserResponse', isSingle: true },
 
-    parent_message: { type: 'MessageResponse', isSingle: true },
+    message: { type: 'MessageResponse', isSingle: true },
 
-    quoted_message: { type: 'MessageResponse', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.EgressRTMPResponse = (input?: Record<string, any>) => {
+decoders.FollowBatchResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    started_at: { type: 'DatetimeType', isSingle: true },
+    follows: { type: 'FollowResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
 
-decoders.EntityCreatorResponse = (input?: Record<string, any>) => {
+decoders.FollowCreatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    ban_expires: { type: 'DatetimeType', isSingle: true },
-
-    deactivated_at: { type: 'DatetimeType', isSingle: true },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_active: { type: 'DatetimeType', isSingle: true },
-
-    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
-
-    devices: { type: 'DeviceResponse', isSingle: false },
+    follow: { type: 'FollowResponse', isSingle: true },
 
-    push_notifications: {
-      type: 'PushNotificationSettingsResponse',
-      isSingle: true,
-    },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.EventHook = (input?: Record<string, any>) => {
+decoders.FollowDeletedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
+    follow: { type: 'FollowResponse', isSingle: true },
 
-decoders.EventResponse = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    event: { type: 'WSEvent', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ExportUserResponse = (input?: Record<string, any>) => {
+decoders.FollowResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    messages: { type: 'MessageResponse', isSingle: false },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    reactions: { type: 'ReactionResponse', isSingle: false },
+    updated_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
+    source_feed: { type: 'FeedResponse', isSingle: true },
 
-decoders.FlagDetails = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    automod: { type: 'AutomodDetails', isSingle: true },
+    target_feed: { type: 'FeedResponse', isSingle: true },
+
+    request_accepted_at: { type: 'DatetimeType', isSingle: true },
+
+    request_rejected_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.FlagFeedback = (input?: Record<string, any>) => {
+decoders.FollowUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
+
+    follow: { type: 'FollowResponse', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -765,6 +2101,13 @@ decoders.GetActiveCallsStatusResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetApplicationResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     app: { type: 'AppResponseFields', isSingle: true },
@@ -833,6 +2176,27 @@ decoders.GetCommandResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetCommentRepliesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'ThreadedCommentResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetCommentsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'ThreadedCommentResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetConfigResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     config: { type: 'ConfigResponse', isSingle: true },
@@ -847,6 +2211,27 @@ decoders.GetDraftResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetFeedViewResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_view: { type: 'FeedViewResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.GetFollowSuggestionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    suggestions: { type: 'FeedResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetImportResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     import_task: { type: 'ImportTask', isSingle: true },
@@ -877,6 +2262,34 @@ decoders.GetOrCreateCallResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.GetOrCreateFeedResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activities: { type: 'ActivityResponse', isSingle: false },
+
+    aggregated_activities: {
+      type: 'AggregatedActivityResponse',
+      isSingle: false,
+    },
+
+    followers: { type: 'FollowResponse', isSingle: false },
+
+    following: { type: 'FollowResponse', isSingle: false },
+
+    members: { type: 'FeedMemberResponse', isSingle: false },
+
+    pinned_activities: { type: 'ActivityPinResponse', isSingle: false },
+
+    feed: { type: 'FeedResponse', isSingle: true },
+
+    own_follows: { type: 'FollowResponse', isSingle: false },
+
+    notification_status: { type: 'NotificationStatusResponse', isSingle: true },
+
+    own_membership: { type: 'FeedMemberResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.GetPushTemplatesResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     templates: { type: 'PushTemplate', isSingle: false },
@@ -988,6 +2401,20 @@ decoders.ListDevicesResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ListFeedGroupsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    groups: { type: 'FeedGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ListFeedViewsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    views: { type: 'FeedViewResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ListImportsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     import_tasks: { type: 'ImportTask', isSingle: false },
@@ -1030,6 +2457,28 @@ decoders.MarkReadResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MemberAddedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'ChannelMember', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MemberRemovedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'ChannelMember', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MemberResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1043,6 +2492,17 @@ decoders.MemberResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MemberUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    member: { type: 'ChannelMember', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MembersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     members: { type: 'ChannelMember', isSingle: false },
@@ -1089,6 +2549,19 @@ decoders.Message = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageFlagResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1116,6 +2589,19 @@ decoders.MessageFlagResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageFlaggedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageHistoryEntryResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     message_updated_at: { type: 'DatetimeType', isSingle: true },
@@ -1132,6 +2618,19 @@ decoders.MessageModerationResult = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageNewEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageReadEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1210,6 +2709,45 @@ decoders.MessageStatsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.MessageUnblockedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MessageUndeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.MessageUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MessageWithChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1253,6 +2791,26 @@ decoders.MessageWithChannelResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ModerationCheckCompletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ModerationCustomActionEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ModerationFlagResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
@@ -1262,6 +2820,26 @@ decoders.ModerationFlagResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ModerationFlaggedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ModerationMarkReviewedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.MuteChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel_mutes: { type: 'ChannelMute', isSingle: false },
@@ -1282,6 +2860,26 @@ decoders.MuteResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.NotificationMarkUnreadEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    last_read_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'ChannelResponse', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.NotificationStatusResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    last_seen_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.OwnUser = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1346,6 +2944,21 @@ decoders.ParticipantCountOverTimeResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.PendingMessageEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    channel: { type: 'Channel', isSingle: true },
+
+    message: { type: 'Message', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.PendingMessageResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel: { type: 'ChannelResponse', isSingle: true },
@@ -1357,6 +2970,24 @@ decoders.PendingMessageResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.PermissionRequestEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.PinActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Poll = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1484,6 +3115,20 @@ decoders.PushTemplate = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryActivitiesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activities: { type: 'ActivityResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryActivityReactionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    reactions: { type: 'FeedsReactionResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryBannedUsersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     bans: { type: 'BanResponse', isSingle: false },
@@ -1491,6 +3136,20 @@ decoders.QueryBannedUsersResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryBookmarkFoldersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark_folders: { type: 'BookmarkFolderResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryBookmarksResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmarks: { type: 'BookmarkResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryCallMembersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     members: { type: 'MemberResponse', isSingle: false },
@@ -1537,6 +3196,20 @@ decoders.QueryChannelsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryCommentReactionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    reactions: { type: 'FeedsReactionResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryCommentsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comments: { type: 'CommentResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryDraftsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     drafts: { type: 'DraftResponse', isSingle: false },
@@ -1544,6 +3217,13 @@ decoders.QueryDraftsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryFeedMembersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    members: { type: 'FeedMemberResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryFeedModerationTemplate = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1562,6 +3242,20 @@ decoders.QueryFeedModerationTemplatesResponse = (
   return decode(typeMappings, input);
 };
 
+decoders.QueryFeedsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feeds: { type: 'FeedResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.QueryFollowsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follows: { type: 'FollowResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryMessageFlagsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     flags: { type: 'MessageFlagResponse', isSingle: false },
@@ -1646,40 +3340,83 @@ decoders.QueryThreadsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.QueryUsersResponse = (input?: Record<string, any>) => {
+decoders.QueryUsersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    users: { type: 'FullUserResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.Reaction = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ReactionDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    reaction: { type: 'Reaction', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ReactionGroupResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    users: { type: 'FullUserResponse', isSingle: false },
+    first_reaction_at: { type: 'DatetimeType', isSingle: true },
+
+    last_reaction_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.Reaction = (input?: Record<string, any>) => {
+decoders.ReactionNewEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    thread_participants: { type: 'User', isSingle: false },
+
+    message: { type: 'Message', isSingle: true },
+
+    reaction: { type: 'Reaction', isSingle: true },
 
     user: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ReactionGroupResponse = (input?: Record<string, any>) => {
+decoders.ReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    first_reaction_at: { type: 'DatetimeType', isSingle: true },
+    created_at: { type: 'DatetimeType', isSingle: true },
 
-    last_reaction_at: { type: 'DatetimeType', isSingle: true },
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
 
-decoders.ReactionResponse = (input?: Record<string, any>) => {
+decoders.ReactionUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    message: { type: 'Message', isSingle: true },
 
-    user: { type: 'UserResponse', isSingle: true },
+    reaction: { type: 'Reaction', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1700,6 +3437,20 @@ decoders.ReadStateResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.RejectFeedMemberInviteResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    member: { type: 'FeedMemberResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.RejectFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ReminderResponseData = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1717,6 +3468,19 @@ decoders.ReminderResponseData = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ReviewQueueItemNewEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    action: { type: 'ActionLogResponse', isSingle: true },
+
+    review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1746,6 +3510,19 @@ decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ReviewQueueItemUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+
+    action: { type: 'ActionLogResponse', isSingle: true },
+
+    review_queue_item: { type: 'ReviewQueueItemResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Role = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1905,6 +3682,13 @@ decoders.SharedLocationsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.SingleFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.StopLiveResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     call: { type: 'CallResponse', isSingle: true },
@@ -1982,6 +3766,40 @@ decoders.ThreadStateResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ThreadUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    thread: { type: 'ThreadResponse', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.ThreadedCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    updated_at: { type: 'DatetimeType', isSingle: true },
+
+    mentioned_users: { type: 'UserResponse', isSingle: false },
+
+    own_reactions: { type: 'FeedsReactionResponse', isSingle: false },
+
+    user: { type: 'UserResponse', isSingle: true },
+
+    deleted_at: { type: 'DatetimeType', isSingle: true },
+
+    latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
+
+    replies: { type: 'ThreadedCommentResponse', isSingle: false },
+
+    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.TruncateChannelResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel: { type: 'ChannelResponse', isSingle: true },
@@ -1991,6 +3809,22 @@ decoders.TruncateChannelResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UnblockedUserEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UnpinActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UnreadCountsBatchResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     counts_by_user: { type: 'UnreadCountsResponse', isSingle: false },
@@ -2021,6 +3855,20 @@ decoders.UnreadCountsThread = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateActivityPartialResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateActivityResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateBlockListResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     blocklist: { type: 'BlockListResponse', isSingle: true },
@@ -2028,6 +3876,20 @@ decoders.UpdateBlockListResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateBookmarkFolderResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark_folder: { type: 'BookmarkFolderResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateBookmarkResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    bookmark: { type: 'BookmarkResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateCallMembersResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     members: { type: 'MemberResponse', isSingle: false },
@@ -2089,6 +3951,50 @@ decoders.UpdateCommandResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdateCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_group: { type: 'FeedGroupResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedMembersResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    added: { type: 'FeedMemberResponse', isSingle: false },
+
+    updated: { type: 'FeedMemberResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed: { type: 'FeedResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFeedViewResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    feed_view: { type: 'FeedViewResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpdateFollowResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    follow: { type: 'FollowResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpdateMemberPartialResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     channel_member: { type: 'ChannelMemberResponse', isSingle: true },
@@ -2131,6 +4037,22 @@ decoders.UpdateUsersResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UpdatedCallPermissionsEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'UserResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UpsertActivitiesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activities: { type: 'ActivityResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UpsertConfigResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     config: { type: 'ConfigResponse', isSingle: true },
@@ -2189,6 +4111,48 @@ decoders.User = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserBannedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'User', isSingle: true },
+
+    expiration: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserDeactivatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    created_by: { type: 'User', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserDeletedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserFlaggedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UserMute = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -2219,6 +4183,24 @@ decoders.UserMuteResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserMutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserReactivatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UserResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -2262,6 +4244,42 @@ decoders.UserResponseCommonFields = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserUnbannedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserUnmutedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserUnreadReminderEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    user: { type: 'User', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
+decoders.UserUpdatedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.VideoReactionOverTimeResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     by_minute: { type: 'CountByMinuteResponse', isSingle: false },