stream-chat 5.6.0 → 6.2.0

package/src/channel.ts

@@ -23,14 +23,12 @@ import {
   GetReactionsAPIResponse,
   GetRepliesAPIResponse,
   InviteOptions,
-  LiteralStringForUnion,
   MarkReadOptions,
   MemberSort,
   Message,
   MessageFilters,
   MessageResponse,
   MuteChannelAPIResponse,
-  PaginationOptions,
   PartialUpdateChannel,
   PartialUpdateChannelAPIResponse,
   QueryMembersOptions,
@@ -43,40 +41,29 @@ import {
   SendMessageAPIResponse,
   TruncateChannelAPIResponse,
   TruncateOptions,
-  UR,
   UpdateChannelAPIResponse,
   UserFilters,
   UserResponse,
+  ExtendableGenerics,
+  DefaultGenerics,
   PinnedMessagePaginationOptions,
   PinnedMessagesSort,
+  MessagePaginationOptions,
 } from './types';
 import { Role } from './permissions';
 
 /**
  * Channel - The Channel class manages it's own state.
  */
-export class Channel<
-  AttachmentType extends UR = UR,
-  ChannelType extends UR = UR,
-  CommandType extends string = LiteralStringForUnion,
-  EventType extends UR = UR,
-  MessageType extends UR = UR,
-  ReactionType extends UR = UR,
-  UserType extends UR = UR
-> {
-  _client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
+export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+  _client: StreamChat<StreamChatGenerics>;
   type: string;
   id: string | undefined;
-  data: ChannelData<ChannelType> | ChannelResponse<ChannelType, CommandType, UserType> | undefined;
-  _data: ChannelData<ChannelType> | ChannelResponse<ChannelType, CommandType, UserType>;
+  data: ChannelData<StreamChatGenerics> | ChannelResponse<StreamChatGenerics> | undefined;
+  _data: ChannelData<StreamChatGenerics> | ChannelResponse<StreamChatGenerics>;
   cid: string;
-  listeners: {
-    [key: string]: (
-      | string
-      | EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
-    )[];
-  };
-  state: ChannelState<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
+  listeners: { [key: string]: (string | EventHandler<StreamChatGenerics>)[] };
+  state: ChannelState<StreamChatGenerics>;
   initialized: boolean;
   lastKeyStroke?: Date;
   lastTypingEvent: Date | null;
@@ -86,18 +73,18 @@ export class Channel<
   /**
    * constructor - Create a channel
    *
-   * @param {StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>} client the chat client
+   * @param {StreamChat<StreamChatGenerics>} client the chat client
    * @param {string} type  the type of channel
    * @param {string} [id]  the id of the chat
-   * @param {ChannelData<ChannelType>} data any additional custom params
+   * @param {ChannelData<StreamChatGenerics>} data any additional custom params
    *
-   * @return {Channel<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>} Returns a new uninitialized channel
+   * @return {Channel<StreamChatGenerics>} Returns a new uninitialized channel
    */
   constructor(
-    client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
+    client: StreamChat<StreamChatGenerics>,
     type: string,
     id: string | undefined,
-    data: ChannelData<ChannelType>,
+    data: ChannelData<StreamChatGenerics>,
   ) {
     const validTypeRe = /^[\w_-]+$/;
     const validIDRe = /^[\w!_-]+$/;
@@ -119,15 +106,7 @@ export class Channel<
     this.cid = `${type}:${id}`;
     this.listeners = {};
     // perhaps the state variable should be private
-    this.state = new ChannelState<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >(this);
+    this.state = new ChannelState<StreamChatGenerics>(this);
     this.initialized = false;
     this.lastTypingEvent = null;
     this.isTyping = false;
@@ -137,9 +116,9 @@ export class Channel<
   /**
    * getClient - Get the chat client for this channel. If client.disconnect() was called, this function will error
    *
-   * @return {StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>}
+   * @return {StreamChat<StreamChatGenerics>}
    */
-  getClient(): StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType> {
+  getClient(): StreamChat<StreamChatGenerics> {
     if (this.disconnected === true) {
       throw Error(`You can't use a channel after client.disconnect() was called`);
     }
@@ -159,22 +138,23 @@ export class Channel<
   /**
    * sendMessage - Send a message to this channel
    *
-   * @param {Message<AttachmentType, MessageType, UserType>} message The Message object
+   * @param {Message<StreamChatGenerics>} message The Message object
    * @param {boolean} [options.skip_enrich_url] Do not try to enrich the URLs within message
    * @param {boolean} [options.skip_push] Skip sending push notifications
    *
-   * @return {Promise<SendMessageAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The Server Response
+   * @return {Promise<SendMessageAPIResponse<StreamChatGenerics>>} The Server Response
    */
   async sendMessage(
-    message: Message<AttachmentType, MessageType, UserType>,
+    message: Message<StreamChatGenerics>,
     options?: { skip_enrich_url?: boolean; skip_push?: boolean },
   ) {
-    const sendMessageResponse = await this.getClient().post<
-      SendMessageAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this._channelURL() + '/message', {
-      message,
-      ...options,
-    });
+    const sendMessageResponse = await this.getClient().post<SendMessageAPIResponse<StreamChatGenerics>>(
+      this._channelURL() + '/message',
+      {
+        message,
+        ...options,
+      },
+    );
 
     // Reset unreadCount to 0.
     this.state.unreadCount = 0;
@@ -186,7 +166,7 @@ export class Channel<
     uri: string | NodeJS.ReadableStream | Buffer | File,
     name?: string,
     contentType?: string,
-    user?: UserResponse<UserType>,
+    user?: UserResponse<StreamChatGenerics>,
   ) {
     return this.getClient().sendFile(`${this._channelURL()}/file`, uri, name, contentType, user);
   }
@@ -195,7 +175,7 @@ export class Channel<
     uri: string | NodeJS.ReadableStream | File,
     name?: string,
     contentType?: string,
-    user?: UserResponse<UserType>,
+    user?: UserResponse<StreamChatGenerics>,
   ) {
     return this.getClient().sendFile(`${this._channelURL()}/image`, uri, name, contentType, user);
   }
@@ -211,17 +191,13 @@ export class Channel<
   /**
    * sendEvent - Send an event on this channel
    *
-   * @param {Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>} event for example {type: 'message.read'}
+   * @param {Event<StreamChatGenerics>} event for example {type: 'message.read'}
    *
-   * @return {Promise<EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>>} The Server Response
+   * @return {Promise<EventAPIResponse<StreamChatGenerics>>} The Server Response
    */
-  async sendEvent(
-    event: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ) {
+  async sendEvent(event: Event<StreamChatGenerics>) {
     this._checkInitialized();
-    return await this.getClient().post<
-      EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
-    >(this._channelURL() + '/event', {
+    return await this.getClient().post<EventAPIResponse<StreamChatGenerics>>(this._channelURL() + '/event', {
       event,
     });
   }
@@ -229,24 +205,17 @@ export class Channel<
   /**
    * search - Query messages
    *
-   * @param {MessageFilters<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> | string}  query search query or object MongoDB style filters
-   * @param {{client_id?: string; connection_id?: string; query?: string; message_filter_conditions?: MessageFilters<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>}} options Option object, {user_id: 'tommaso'}
+   * @param {MessageFilters<StreamChatGenerics> | string}  query search query or object MongoDB style filters
+   * @param {{client_id?: string; connection_id?: string; query?: string; message_filter_conditions?: MessageFilters<StreamChatGenerics>}} options Option object, {user_id: 'tommaso'}
    *
-   * @return {Promise<SearchAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} search messages response
+   * @return {Promise<SearchAPIResponse<StreamChatGenerics>>} search messages response
    */
   async search(
-    query: MessageFilters<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> | string,
-    options: SearchOptions<MessageType> & {
+    query: MessageFilters<StreamChatGenerics> | string,
+    options: SearchOptions<StreamChatGenerics> & {
       client_id?: string;
       connection_id?: string;
-      message_filter_conditions?: MessageFilters<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >;
+      message_filter_conditions?: MessageFilters<StreamChatGenerics>;
       query?: string;
     } = {},
   ) {
@@ -254,10 +223,10 @@ export class Channel<
       throw Error(`Cannot specify offset with sort or next parameters`);
     }
     // Return a list of channels
-    const payload: SearchPayload<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> = {
-      filter_conditions: { cid: this.cid } as ChannelFilters<ChannelType, CommandType, UserType>,
+    const payload: SearchPayload<StreamChatGenerics> = {
+      filter_conditions: { cid: this.cid } as ChannelFilters<StreamChatGenerics>,
       ...options,
-      sort: options.sort ? normalizeQuerySort<SearchMessageSortBase<MessageType>>(options.sort) : undefined,
+      sort: options.sort ? normalizeQuerySort<SearchMessageSortBase<StreamChatGenerics>>(options.sort) : undefined,
     };
     if (typeof query === 'string') {
       payload.query = query;
@@ -269,9 +238,7 @@ export class Channel<
     // Make sure we wait for the connect promise if there is a pending one
     await this.getClient().wsPromise;
 
-    return await this.getClient().get<
-      SearchAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this.getClient().baseURL + '/search', {
+    return await this.getClient().get<SearchAPIResponse<StreamChatGenerics>>(this.getClient().baseURL + '/search', {
       payload,
     });
   }
@@ -279,51 +246,54 @@ export class Channel<
   /**
    * queryMembers - Query Members
    *
-   * @param {UserFilters<UserType>}  filterConditions object MongoDB style filters
-   * @param {MemberSort<UserType>} [sort] Sort options, for instance [{created_at: -1}].
+   * @param {UserFilters<StreamChatGenerics>}  filterConditions object MongoDB style filters
+   * @param {MemberSort<StreamChatGenerics>} [sort] Sort options, for instance [{created_at: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{name: -1}, {created_at: 1}]
    * @param {{ limit?: number; offset?: number }} [options] Option object, {limit: 10, offset:10}
    *
-   * @return {Promise<ChannelMemberAPIResponse<UserType>>} Query Members response
+   * @return {Promise<ChannelMemberAPIResponse<StreamChatGenerics>>} Query Members response
    */
   async queryMembers(
-    filterConditions: UserFilters<UserType>,
-    sort: MemberSort<UserType> = [],
+    filterConditions: UserFilters<StreamChatGenerics>,
+    sort: MemberSort<StreamChatGenerics> = [],
     options: QueryMembersOptions = {},
   ) {
     let id: string | undefined;
     const type = this.type;
-    let members: string[] | ChannelMemberResponse<UserType>[] | undefined;
+    let members: string[] | ChannelMemberResponse<StreamChatGenerics>[] | undefined;
     if (this.id) {
       id = this.id;
     } else if (this.data?.members && Array.isArray(this.data.members)) {
       members = this.data.members;
     }
     // Return a list of members
-    return await this.getClient().get<ChannelMemberAPIResponse<UserType>>(this.getClient().baseURL + '/members', {
-      payload: {
-        type,
-        id,
-        members,
-        sort: normalizeQuerySort(sort),
-        filter_conditions: filterConditions,
-        ...options,
+    return await this.getClient().get<ChannelMemberAPIResponse<StreamChatGenerics>>(
+      this.getClient().baseURL + '/members',
+      {
+        payload: {
+          type,
+          id,
+          members,
+          sort: normalizeQuerySort(sort),
+          filter_conditions: filterConditions,
+          ...options,
+        },
       },
-    });
+    );
   }
 
   /**
    * sendReaction - Send a reaction about a message
    *
    * @param {string} messageID the message id
-   * @param {Reaction<ReactionType, UserType>} reaction the reaction object for instance {type: 'love'}
+   * @param {Reaction<StreamChatGenerics>} reaction the reaction object for instance {type: 'love'}
    * @param {{ enforce_unique?: boolean, skip_push?: boolean }} [options] Option object, {enforce_unique: true, skip_push: true} to override any existing reaction or skip sending push notifications
    *
-   * @return {Promise<ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The Server Response
+   * @return {Promise<ReactionAPIResponse<StreamChatGenerics>>} The Server Response
    */
   async sendReaction(
     messageID: string,
-    reaction: Reaction<ReactionType, UserType>,
+    reaction: Reaction<StreamChatGenerics>,
     options?: { enforce_unique?: boolean; skip_push?: boolean },
   ) {
     if (!messageID) {
@@ -332,12 +302,13 @@ export class Channel<
     if (!reaction || Object.keys(reaction).length === 0) {
       throw Error(`Reaction object is missing`);
     }
-    return await this.getClient().post<
-      ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this.getClient().baseURL + `/messages/${messageID}/reaction`, {
-      reaction,
-      ...options,
-    });
+    return await this.getClient().post<ReactionAPIResponse<StreamChatGenerics>>(
+      this.getClient().baseURL + `/messages/${messageID}/reaction`,
+      {
+        reaction,
+        ...options,
+      },
+    );
   }
 
   /**
@@ -347,7 +318,7 @@ export class Channel<
    * @param {string} reactionType the type of reaction that should be removed
    * @param {string} [user_id] the id of the user (used only for server side request) default null
    *
-   * @return {Promise<ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The Server Response
+   * @return {Promise<ReactionAPIResponse<StreamChatGenerics>>} The Server Response
    */
   deleteReaction(messageID: string, reactionType: string, user_id?: string) {
     this._checkInitialized();
@@ -358,27 +329,23 @@ export class Channel<
     const url = this.getClient().baseURL + `/messages/${messageID}/reaction/${reactionType}`;
     //provided when server side request
     if (user_id) {
-      return this.getClient().delete<
-        ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-      >(url, { user_id });
+      return this.getClient().delete<ReactionAPIResponse<StreamChatGenerics>>(url, { user_id });
     }
 
-    return this.getClient().delete<
-      ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(url, {});
+    return this.getClient().delete<ReactionAPIResponse<StreamChatGenerics>>(url, {});
   }
 
   /**
    * update - Edit the channel's custom properties
    *
-   * @param {ChannelData<ChannelType>} channelData The object to update the custom properties of this channel with
-   * @param {Message<AttachmentType, MessageType, UserType>} [updateMessage] Optional message object for channel members notification
+   * @param {ChannelData<StreamChatGenerics>} channelData The object to update the custom properties of this channel with
+   * @param {Message<StreamChatGenerics>} [updateMessage] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async update(
-    channelData: Partial<ChannelData<ChannelType>> | Partial<ChannelResponse<ChannelType, CommandType, UserType>> = {},
-    updateMessage?: Message<AttachmentType, MessageType, UserType>,
+    channelData: Partial<ChannelData<StreamChatGenerics>> | Partial<ChannelResponse<StreamChatGenerics>> = {},
+    updateMessage?: Message<StreamChatGenerics>,
     options?: ChannelUpdateOptions,
   ) {
     // Strip out reserved names that will result in API errors.
@@ -408,12 +375,12 @@ export class Channel<
   /**
    * updatePartial - partial update channel properties
    *
-   * @param {PartialUpdateChannel<ChannelType>} partial update request
+   * @param {PartialUpdateChannel<StreamChatGenerics>} partial update request
    *
-   * @return {Promise<PartialUpdateChannelAPIResponse<ChannelType,CommandType, UserType>>}
+   * @return {Promise<PartialUpdateChannelAPIResponse<StreamChatGenerics>>}
    */
-  async updatePartial(update: PartialUpdateChannel<ChannelType>) {
-    return await this.getClient().patch<PartialUpdateChannelAPIResponse<ChannelType, CommandType, UserType>>(
+  async updatePartial(update: PartialUpdateChannel<StreamChatGenerics>) {
+    return await this.getClient().patch<PartialUpdateChannelAPIResponse<StreamChatGenerics>>(
       this._channelURL(),
       update,
     );
@@ -423,12 +390,10 @@ export class Channel<
    * enableSlowMode - enable slow mode
    *
    * @param {number} coolDownInterval the cooldown interval in seconds
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async enableSlowMode(coolDownInterval: number) {
-    const data = await this.getClient().post<
-      UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this._channelURL(), {
+    const data = await this.getClient().post<UpdateChannelAPIResponse<StreamChatGenerics>>(this._channelURL(), {
       cooldown: coolDownInterval,
     });
     this.data = data.channel;
@@ -438,12 +403,10 @@ export class Channel<
   /**
    * disableSlowMode - disable slow mode
    *
-   * @return {Promise<UpdateChannelAPIResponse<ChannelType, AttachmentType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async disableSlowMode() {
-    const data = await this.getClient().post<
-      UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this._channelURL(), {
+    const data = await this.getClient().post<UpdateChannelAPIResponse<StreamChatGenerics>>(this._channelURL(), {
       cooldown: 0,
     });
     this.data = data.channel;
@@ -455,49 +418,45 @@ export class Channel<
    *
    * @param {boolean} [options.hard_delete] Defines if the channel is hard deleted or not
    *
-   * @return {Promise<DeleteChannelAPIResponse<ChannelType, CommandType, UserType>>} The server response
+   * @return {Promise<DeleteChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async delete(options: { hard_delete?: boolean } = {}) {
-    return await this.getClient().delete<DeleteChannelAPIResponse<ChannelType, CommandType, UserType>>(
-      this._channelURL(),
-      { ...options },
-    );
+    return await this.getClient().delete<DeleteChannelAPIResponse<StreamChatGenerics>>(this._channelURL(), {
+      ...options,
+    });
   }
 
   /**
    * truncate - Removes all messages from the channel
-   * @param {TruncateOptions<AttachmentType, MessageType, UserType>} [options] Defines truncation options
-   * @return {Promise<TruncateChannelAPIResponse<ChannelType, CommandType, UserType, MessageType, ReactionType>>} The server response
+   * @param {TruncateOptions<StreamChatGenerics>} [options] Defines truncation options
+   * @return {Promise<TruncateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async truncate(options: TruncateOptions<AttachmentType, MessageType, UserType> = {}) {
-    return await this.getClient().post<
-      TruncateChannelAPIResponse<ChannelType, CommandType, UserType, MessageType, ReactionType>
-    >(this._channelURL() + '/truncate', options);
+  async truncate(options: TruncateOptions<StreamChatGenerics> = {}) {
+    return await this.getClient().post<TruncateChannelAPIResponse<StreamChatGenerics>>(
+      this._channelURL() + '/truncate',
+      options,
+    );
   }
 
   /**
    * acceptInvite - accept invitation to the channel
    *
-   * @param {InviteOptions<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>} [options] The object to update the custom properties of this channel with
+   * @param {InviteOptions<StreamChatGenerics>} [options] The object to update the custom properties of this channel with
    *
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async acceptInvite(
-    options: InviteOptions<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> = {},
-  ) {
+  async acceptInvite(options: InviteOptions<StreamChatGenerics> = {}) {
     return await this._update({ accept_invite: true, ...options });
   }
 
   /**
    * rejectInvite - reject invitation to the channel
    *
-   * @param {InviteOptions<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>} [options] The object to update the custom properties of this channel with
+   * @param {InviteOptions<StreamChatGenerics>} [options] The object to update the custom properties of this channel with
    *
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async rejectInvite(
-    options: InviteOptions<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> = {},
-  ) {
+  async rejectInvite(options: InviteOptions<StreamChatGenerics> = {}) {
     return await this._update({ reject_invite: true, ...options });
   }
 
@@ -505,13 +464,13 @@ export class Channel<
    * addMembers - add members to the channel
    *
    * @param {{user_id: string, channel_role?: Role}[]} members An array of members to add to the channel
-   * @param {Message<AttachmentType, MessageType, UserType>} [message] Optional message object for channel members notification
+   * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async addMembers(
     members: string[] | { user_id: string; channel_role?: Role }[],
-    message?: Message<AttachmentType, MessageType, UserType>,
+    message?: Message<StreamChatGenerics>,
     options: ChannelUpdateOptions = {},
   ) {
     return await this._update({ add_members: members, message, ...options });
@@ -521,15 +480,11 @@ export class Channel<
    * addModerators - add moderators to the channel
    *
    * @param {string[]} members An array of member identifiers
-   * @param {Message<AttachmentType, MessageType, UserType>} [message] Optional message object for channel members notification
+   * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async addModerators(
-    members: string[],
-    message?: Message<AttachmentType, MessageType, UserType>,
-    options: ChannelUpdateOptions = {},
-  ) {
+  async addModerators(members: string[], message?: Message<StreamChatGenerics>, options: ChannelUpdateOptions = {}) {
     return await this._update({ add_moderators: members, message, ...options });
   }
 
@@ -537,13 +492,13 @@ export class Channel<
    * assignRoles - sets member roles in a channel
    *
    * @param {{channel_role: Role, user_id: string}[]} roles List of role assignments
-   * @param {Message<AttachmentType, MessageType, UserType>} [message] Optional message object for channel members notification
+   * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async assignRoles(
     roles: { channel_role: Role; user_id: string }[],
-    message?: Message<AttachmentType, MessageType, UserType>,
+    message?: Message<StreamChatGenerics>,
     options: ChannelUpdateOptions = {},
   ) {
     return await this._update({ assign_roles: roles, message, ...options });
@@ -553,13 +508,13 @@ export class Channel<
    * inviteMembers - invite members to the channel
    *
    * @param {{user_id: string, channel_role?: Role}[]} members An array of members to invite to the channel
-   * @param {Message<AttachmentType, MessageType, UserType>} [message] Optional message object for channel members notification
+   * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
   async inviteMembers(
     members: { user_id: string; channel_role?: Role }[] | string[],
-    message?: Message<AttachmentType, MessageType, UserType>,
+    message?: Message<StreamChatGenerics>,
     options: ChannelUpdateOptions = {},
   ) {
     return await this._update({ invites: members, message, ...options });
@@ -569,15 +524,11 @@ export class Channel<
    * removeMembers - remove members from channel
    *
    * @param {string[]} members An array of member identifiers
-   * @param {Message<AttachmentType, MessageType, UserType>} [message] Optional message object for channel members notification
+   * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async removeMembers(
-    members: string[],
-    message?: Message<AttachmentType, MessageType, UserType>,
-    options: ChannelUpdateOptions = {},
-  ) {
+  async removeMembers(members: string[], message?: Message<StreamChatGenerics>, options: ChannelUpdateOptions = {}) {
     return await this._update({ remove_members: members, message, ...options });
   }
 
@@ -585,28 +536,22 @@ export class Channel<
    * demoteModerators - remove moderator role from channel members
    *
    * @param {string[]} members An array of member identifiers
-   * @param {Message<AttachmentType, MessageType, UserType>} [message] Optional message object for channel members notification
+   * @param {Message<StreamChatGenerics>} [message] Optional message object for channel members notification
    * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async demoteModerators(
-    members: string[],
-    message?: Message<AttachmentType, MessageType, UserType>,
-    options: ChannelUpdateOptions = {},
-  ) {
+  async demoteModerators(members: string[], message?: Message<StreamChatGenerics>, options: ChannelUpdateOptions = {}) {
     return await this._update({ demote_moderators: members, message, ...options });
   }
 
   /**
    * _update - executes channel update request
    * @param payload Object Update Channel payload
-   * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<UpdateChannelAPIResponse<StreamChatGenerics>>} The server response
    * TODO: introduce new type instead of Object in the next major update
    */
   async _update(payload: Object) {
-    const data = await this.getClient().post<
-      UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this._channelURL(), payload);
+    const data = await this.getClient().post<UpdateChannelAPIResponse<StreamChatGenerics>>(this._channelURL(), payload);
     this.data = data.channel;
     return data;
   }
@@ -614,7 +559,7 @@ export class Channel<
   /**
    * mute - mutes the current channel
    * @param {{ user_id?: string, expiration?: string }} opts expiration in minutes or user_id
-   * @return {Promise<MuteChannelAPIResponse<ChannelType, CommandType, UserType>>} The server response
+   * @return {Promise<MuteChannelAPIResponse<StreamChatGenerics>>} The server response
    *
    * example with expiration:
    * await channel.mute({expiration: moment.duration(2, 'weeks')});
@@ -624,7 +569,7 @@ export class Channel<
    *
    */
   async mute(opts: { expiration?: number; user_id?: string } = {}) {
-    return await this.getClient().post<MuteChannelAPIResponse<ChannelType, CommandType, UserType>>(
+    return await this.getClient().post<MuteChannelAPIResponse<StreamChatGenerics>>(
       this.getClient().baseURL + '/moderation/mute/channel',
       { channel_cid: this.cid, ...opts },
     );
@@ -663,14 +608,15 @@ export class Channel<
     if (!messageID) {
       throw Error(`Message id is missing`);
     }
-    return this.getClient().post<
-      SendMessageAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this.getClient().baseURL + `/messages/${messageID}/action`, {
-      message_id: messageID,
-      form_data: formData,
-      id: this.id,
-      type: this.type,
-    });
+    return this.getClient().post<SendMessageAPIResponse<StreamChatGenerics>>(
+      this.getClient().baseURL + `/messages/${messageID}/action`,
+      {
+        message_id: messageID,
+        form_data: formData,
+        id: this.id,
+        type: this.type,
+      },
+    );
   }
 
   /**
@@ -693,7 +639,7 @@ export class Channel<
       await this.sendEvent({
         type: 'typing.start',
         parent_id,
-      } as Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>);
+      } as Event<StreamChatGenerics>);
     }
   }
 
@@ -711,13 +657,13 @@ export class Channel<
     await this.sendEvent({
       type: 'typing.stop',
       parent_id,
-    } as Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>);
+    } as Event<StreamChatGenerics>);
   }
 
   /**
    * lastMessage - return the last message, takes into account that last few messages might not be perfectly sorted
    *
-   * @return {ReturnType<ChannelState<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>['formatMessage']> | undefined} Description
+   * @return {ReturnType<ChannelState<StreamChatGenerics>['formatMessage']> | undefined} Description
    */
   lastMessage() {
     // get last 5 messages, sort, return the latest
@@ -738,19 +684,17 @@ export class Channel<
   /**
    * markRead - Send the mark read event for this user, only works if the `read_events` setting is enabled
    *
-   * @param {MarkReadOptions<UserType>} data
-   * @return {Promise<EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType> | null>} Description
+   * @param {MarkReadOptions<StreamChatGenerics>} data
+   * @return {Promise<EventAPIResponse<StreamChatGenerics> | null>} Description
    */
-  async markRead(data: MarkReadOptions<UserType> = {}) {
+  async markRead(data: MarkReadOptions<StreamChatGenerics> = {}) {
     this._checkInitialized();
 
     if (!this.getConfig()?.read_events) {
       return Promise.resolve(null);
     }
 
-    return await this.getClient().post<
-      EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
-    >(this._channelURL() + '/read', {
+    return await this.getClient().post<EventAPIResponse<StreamChatGenerics>>(this._channelURL() + '/read', {
       ...data,
     });
   }
@@ -773,11 +717,11 @@ export class Channel<
   /**
    * watch - Loads the initial channel state and watches for changes
    *
-   * @param {ChannelQueryOptions<ChannelType, CommandType, UserType>} options additional options for the query endpoint
+   * @param {ChannelQueryOptions<StreamChatGenerics>} options additional options for the query endpoint
    *
-   * @return {Promise<ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
+   * @return {Promise<ChannelAPIResponse<StreamChatGenerics>>} The server response
    */
-  async watch(options?: ChannelQueryOptions<ChannelType, CommandType, UserType>) {
+  async watch(options?: ChannelQueryOptions<StreamChatGenerics>) {
     const defaultOptions = {
       state: true,
       watch: true,
@@ -823,19 +767,20 @@ export class Channel<
    * getReplies - List the message replies for a parent message
    *
    * @param {string} parent_id The message parent id, ie the top of the thread
-   * @param {PaginationOptions & { user?: UserResponse<UserType>; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
+   * @param {PaginationOptions & { user?: UserResponse<StreamChatGenerics>; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
    *
-   * @return {Promise<GetRepliesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} A response with a list of messages
+   * @return {Promise<GetRepliesAPIResponse<StreamChatGenerics>>} A response with a list of messages
    */
   async getReplies(
     parent_id: string,
-    options: PaginationOptions & { user?: UserResponse<UserType>; user_id?: string },
+    options: MessagePaginationOptions & { user?: UserResponse<StreamChatGenerics>; user_id?: string },
   ) {
-    const data = await this.getClient().get<
-      GetRepliesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this.getClient().baseURL + `/messages/${parent_id}/replies`, {
-      ...options,
-    });
+    const data = await this.getClient().get<GetRepliesAPIResponse<StreamChatGenerics>>(
+      this.getClient().baseURL + `/messages/${parent_id}/replies`,
+      {
+        ...options,
+      },
+    );
 
     // add any messages to our thread state
     if (data.messages) {
@@ -848,23 +793,24 @@ export class Channel<
   /**
    * getPinnedMessages - List list pinned messages of the channel
    *
-   * @param {PinnedMessagePaginationOptions & { user?: UserResponse<UserType>; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
+   * @param {PinnedMessagePaginationOptions & { user?: UserResponse<StreamChatGenerics>; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
    * @param {PinnedMessagesSort} sort defines sorting direction of pinned messages
    *
-   * @return {Promise<GetRepliesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} A response with a list of messages
+   * @return {Promise<GetRepliesAPIResponse<StreamChatGenerics>>} A response with a list of messages
    */
   async getPinnedMessages(
-    options: PinnedMessagePaginationOptions & { user?: UserResponse<UserType>; user_id?: string },
+    options: PinnedMessagePaginationOptions & { user?: UserResponse<StreamChatGenerics>; user_id?: string },
     sort: PinnedMessagesSort = [],
   ) {
-    return await this.getClient().get<
-      GetRepliesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this.getClient().baseURL + `/channels/${this.type}/${this.id}/pinned_messages`, {
-      payload: {
-        ...options,
-        sort: normalizeQuerySort(sort),
+    return await this.getClient().get<GetRepliesAPIResponse<StreamChatGenerics>>(
+      this.getClient().baseURL + `/channels/${this.type}/${this.id}/pinned_messages`,
+      {
+        payload: {
+          ...options,
+          sort: normalizeQuerySort(sort),
+        },
       },
-    });
+    );
   }
 
   /**
@@ -873,10 +819,10 @@ export class Channel<
    * @param {string} message_id The message id
    * @param {{ limit?: number; offset?: number }} options The pagination options
    *
-   * @return {Promise<GetReactionsAPIResponse<ReactionType, UserType>>} Server response
+   * @return {Promise<GetReactionsAPIResponse<StreamChatGenerics>>} Server response
    */
   getReactions(message_id: string, options: { limit?: number; offset?: number }) {
-    return this.getClient().get<GetReactionsAPIResponse<ReactionType, UserType>>(
+    return this.getClient().get<GetReactionsAPIResponse<StreamChatGenerics>>(
       this.getClient().baseURL + `/messages/${message_id}/reactions`,
       {
         ...options,
@@ -889,12 +835,10 @@ export class Channel<
    *
    * @param {string[]} messageIds The ids of the messages to retrieve from this channel
    *
-   * @return {Promise<GetMultipleMessagesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} Server response
+   * @return {Promise<GetMultipleMessagesAPIResponse<StreamChatGenerics>>} Server response
    */
   getMessagesById(messageIds: string[]) {
-    return this.getClient().get<
-      GetMultipleMessagesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(this._channelURL() + '/messages', {
+    return this.getClient().get<GetMultipleMessagesAPIResponse<StreamChatGenerics>>(this._channelURL() + '/messages', {
       ids: messageIds.join(','),
     });
   }
@@ -911,11 +855,7 @@ export class Channel<
     }
   }
 
-  _countMessageAsUnread(
-    message:
-      | FormatMessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-      | MessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>,
-  ) {
+  _countMessageAsUnread(message: FormatMessageResponse<StreamChatGenerics> | MessageResponse<StreamChatGenerics>) {
     if (message.shadowed) return false;
     if (message.silent) return false;
     if (message.parent_id && !message.show_in_channel) return false;
@@ -923,6 +863,10 @@ export class Channel<
     if (message.user?.id && this.getClient().userMuteStatus(message.user.id)) return false;
     if (message.type === 'system') return false;
 
+    // Return false if channel doesn't allow read events.
+    if (Array.isArray(this.data?.own_capabilities) && !this.data?.own_capabilities.includes('read-events'))
+      return false;
+
     if (this.muteStatus().muted) return false;
 
     return true;
@@ -974,7 +918,7 @@ export class Channel<
   /**
    * create - Creates a new channel
    *
-   * @return {Promise<ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The Server Response
+   * @return {Promise<ChannelAPIResponse<StreamChatGenerics>>} The Server Response
    */
   create = async () => {
     const options = {
@@ -988,11 +932,11 @@ export class Channel<
   /**
    * query - Query the API, get messages, members or other channel fields
    *
-   * @param {ChannelQueryOptions<ChannelType, CommandType, UserType>} options The query options
+   * @param {ChannelQueryOptions<StreamChatGenerics>} options The query options
    *
-   * @return {Promise<ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} Returns a query response
+   * @return {Promise<ChannelAPIResponse<StreamChatGenerics>>} Returns a query response
    */
-  async query(options: ChannelQueryOptions<ChannelType, CommandType, UserType>) {
+  async query(options: ChannelQueryOptions<StreamChatGenerics>) {
     // Make sure we wait for the connect promise if there is a pending one
     await this.getClient().wsPromise;
 
@@ -1001,9 +945,7 @@ export class Channel<
       queryURL += `/${this.id}`;
     }
 
-    const state = await this.getClient().post<
-      ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
-    >(queryURL + '/query', {
+    const state = await this.getClient().post<ChannelAPIResponse<StreamChatGenerics>>(queryURL + '/query', {
       data: this._data,
       state: true,
       ...options,
@@ -1044,10 +986,10 @@ export class Channel<
    * banUser - Bans a user from a channel
    *
    * @param {string} targetUserID
-   * @param {BanUserOptions<UserType>} options
+   * @param {BanUserOptions<StreamChatGenerics>} options
    * @returns {Promise<APIResponse>}
    */
-  async banUser(targetUserID: string, options: BanUserOptions<UserType>) {
+  async banUser(targetUserID: string, options: BanUserOptions<StreamChatGenerics>) {
     this._checkInitialized();
     return await this.getClient().banUser(targetUserID, {
       ...options,
@@ -1104,10 +1046,10 @@ export class Channel<
    * shadowBan - Shadow bans a user from a channel
    *
    * @param {string} targetUserID
-   * @param {BanUserOptions<UserType>} options
+   * @param {BanUserOptions<StreamChatGenerics>} options
    * @returns {Promise<APIResponse>}
    */
-  async shadowBan(targetUserID: string, options: BanUserOptions<UserType>) {
+  async shadowBan(targetUserID: string, options: BanUserOptions<StreamChatGenerics>) {
     this._checkInitialized();
     return await this.getClient().shadowBan(targetUserID, {
       ...options,
@@ -1137,29 +1079,14 @@ export class Channel<
    * or
    * channel.on(event => {console.log(event.type)})
    *
-   * @param {EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType> | EventTypes} callbackOrString  The event type to listen for (optional)
-   * @param {EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>} [callbackOrNothing] The callback to call
+   * @param {EventHandler<StreamChatGenerics> | EventTypes} callbackOrString  The event type to listen for (optional)
+   * @param {EventHandler<StreamChatGenerics>} [callbackOrNothing] The callback to call
    */
+  on(eventType: EventTypes, callback: EventHandler<StreamChatGenerics>): { unsubscribe: () => void };
+  on(callback: EventHandler<StreamChatGenerics>): { unsubscribe: () => void };
   on(
-    eventType: EventTypes,
-    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ): { unsubscribe: () => void };
-  on(
-    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ): { unsubscribe: () => void };
-  on(
-    callbackOrString:
-      | EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
-      | EventTypes,
-    callbackOrNothing?: EventHandler<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    callbackOrString: EventHandler<StreamChatGenerics> | EventTypes,
+    callbackOrNothing?: EventHandler<StreamChatGenerics>,
   ): { unsubscribe: () => void } {
     const key = callbackOrNothing ? (callbackOrString as string) : 'all';
     const valid = isValidEventType(key);
@@ -1193,26 +1120,11 @@ export class Channel<
    * off - Remove the event handler
    *
    */
+  off(eventType: EventTypes, callback: EventHandler<StreamChatGenerics>): void;
+  off(callback: EventHandler<StreamChatGenerics>): void;
   off(
-    eventType: EventTypes,
-    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ): void;
-  off(
-    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ): void;
-  off(
-    callbackOrString:
-      | EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
-      | EventTypes,
-    callbackOrNothing?: EventHandler<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    callbackOrString: EventHandler<StreamChatGenerics> | EventTypes,
+    callbackOrNothing?: EventHandler<StreamChatGenerics>,
   ): void {
     const key = callbackOrNothing ? (callbackOrString as string) : 'all';
     const valid = isValidEventType(key);
@@ -1232,9 +1144,7 @@ export class Channel<
   }
 
   // eslint-disable-next-line sonarjs/cognitive-complexity
-  _handleChannelEvent(
-    event: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ) {
+  _handleChannelEvent(event: Event<StreamChatGenerics>) {
     const channel = this;
     this._client.logger(
       'info',
@@ -1390,9 +1300,7 @@ export class Channel<
     }
   }
 
-  _callChannelListeners = (
-    event: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
-  ) => {
+  _callChannelListeners = (event: Event<StreamChatGenerics>) => {
     const channel = this;
     // gather and call the listeners
     const listeners = [];
@@ -1432,9 +1340,7 @@ export class Channel<
   }
 
   // eslint-disable-next-line sonarjs/cognitive-complexity
-  _initializeState(
-    state: ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>,
-  ) {
+  _initializeState(state: ChannelAPIResponse<StreamChatGenerics>) {
     const { state: clientState, user, userID } = this.getClient();
 
     // add the Users