stream-chat 4.4.3-dev.2 → 5.0.0

package/src/channel.ts

@@ -8,6 +8,7 @@ import {
   ChannelAPIResponse,
   ChannelData,
   ChannelFilters,
+  ChannelUpdateOptions,
   ChannelMemberAPIResponse,
   ChannelMemberResponse,
   ChannelQueryOptions,
@@ -35,16 +36,17 @@ import {
   QueryMembersOptions,
   Reaction,
   ReactionAPIResponse,
+  SearchAPIResponse,
+  SearchMessageSortBase,
   SearchOptions,
   SearchPayload,
-  SearchAPIResponse,
   SendMessageAPIResponse,
   TruncateChannelAPIResponse,
-  UnknownType,
+  TruncateOptions,
+  UR,
   UpdateChannelAPIResponse,
   UserFilters,
   UserResponse,
-  SearchMessageSortBase,
 } from './types';
 import { Role } from './permissions';
 
@@ -52,54 +54,27 @@ import { Role } from './permissions';
  * Channel - The Channel class manages it's own state.
  */
 export class Channel<
-  AttachmentType extends UnknownType = UnknownType,
-  ChannelType extends UnknownType = UnknownType,
+  AttachmentType extends UR = UR,
+  ChannelType extends UR = UR,
   CommandType extends string = LiteralStringForUnion,
-  EventType extends UnknownType = UnknownType,
-  MessageType extends UnknownType = UnknownType,
-  ReactionType extends UnknownType = UnknownType,
-  UserType extends UnknownType = UnknownType
+  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
-  >;
+  _client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
   type: string;
   id: string | undefined;
-  data:
-    | ChannelData<ChannelType>
-    | ChannelResponse<ChannelType, CommandType, UserType>
-    | undefined;
+  data: ChannelData<ChannelType> | ChannelResponse<ChannelType, CommandType, UserType> | undefined;
   _data: ChannelData<ChannelType> | ChannelResponse<ChannelType, CommandType, UserType>;
   cid: string;
   listeners: {
     [key: string]: (
       | string
-      | EventHandler<
-          AttachmentType,
-          ChannelType,
-          CommandType,
-          EventType,
-          MessageType,
-          ReactionType,
-          UserType
-        >
+      | EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
     )[];
   };
-  state: ChannelState<
-    AttachmentType,
-    ChannelType,
-    CommandType,
-    EventType,
-    MessageType,
-    ReactionType,
-    UserType
-  >;
+  state: ChannelState<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
   initialized: boolean;
   lastKeyStroke?: Date;
   lastTypingEvent: Date | null;
@@ -117,15 +92,7 @@ export class Channel<
    * @return {Channel<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>} Returns a new uninitialized channel
    */
   constructor(
-    client: StreamChat<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
     type: string,
     id: string | undefined,
     data: ChannelData<ChannelType>,
@@ -170,15 +137,7 @@ export class Channel<
    *
    * @return {StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>}
    */
-  getClient(): StreamChat<
-    AttachmentType,
-    ChannelType,
-    CommandType,
-    EventType,
-    MessageType,
-    ReactionType,
-    UserType
-  > {
+  getClient(): StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType> {
     if (this.disconnected === true) {
       throw Error(`You can't use a channel after client.disconnect() was called`);
     }
@@ -209,14 +168,7 @@ export class Channel<
     options?: { skip_enrich_url?: boolean; skip_push?: boolean },
   ) {
     const sendMessageResponse = await this.getClient().post<
-      SendMessageAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      SendMessageAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this._channelURL() + '/message', {
       message,
       ...options,
@@ -234,13 +186,7 @@ export class Channel<
     contentType?: string,
     user?: UserResponse<UserType>,
   ) {
-    return this.getClient().sendFile(
-      `${this._channelURL()}/file`,
-      uri,
-      name,
-      contentType,
-      user,
-    );
+    return this.getClient().sendFile(`${this._channelURL()}/file`, uri, name, contentType, user);
   }
 
   sendImage(
@@ -249,13 +195,7 @@ export class Channel<
     contentType?: string,
     user?: UserResponse<UserType>,
   ) {
-    return this.getClient().sendFile(
-      `${this._channelURL()}/image`,
-      uri,
-      name,
-      contentType,
-      user,
-    );
+    return this.getClient().sendFile(`${this._channelURL()}/image`, uri, name, contentType, user);
   }
 
   deleteFile(url: string) {
@@ -274,27 +214,11 @@ export class Channel<
    * @return {Promise<EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>>} The Server Response
    */
   async sendEvent(
-    event: Event<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    event: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ) {
     this._checkInitialized();
     return await this.getClient().post<
-      EventAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        EventType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
     >(this._channelURL() + '/event', {
       event,
     });
@@ -309,16 +233,7 @@ export class Channel<
    * @return {Promise<SearchAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} search messages response
    */
   async search(
-    query:
-      | MessageFilters<
-          AttachmentType,
-          ChannelType,
-          CommandType,
-          MessageType,
-          ReactionType,
-          UserType
-        >
-      | string,
+    query: MessageFilters<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> | string,
     options: SearchOptions<MessageType> & {
       client_id?: string;
       connection_id?: string;
@@ -337,23 +252,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<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> = {
+      filter_conditions: { cid: this.cid } as ChannelFilters<ChannelType, CommandType, UserType>,
       ...options,
-      sort: options.sort
-        ? normalizeQuerySort<SearchMessageSortBase<MessageType>>(options.sort)
-        : undefined,
+      sort: options.sort ? normalizeQuerySort<SearchMessageSortBase<MessageType>>(options.sort) : undefined,
     };
     if (typeof query === 'string') {
       payload.query = query;
@@ -366,14 +268,7 @@ export class Channel<
     await this.getClient().wsPromise;
 
     return await this.getClient().get<
-      SearchAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      SearchAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this.getClient().baseURL + '/search', {
       payload,
     });
@@ -403,19 +298,16 @@ export class Channel<
       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<UserType>>(this.getClient().baseURL + '/members', {
+      payload: {
+        type,
+        id,
+        members,
+        sort: normalizeQuerySort(sort),
+        filter_conditions: filterConditions,
+        ...options,
       },
-    );
+    });
   }
 
   /**
@@ -439,14 +331,7 @@ export class Channel<
       throw Error(`Reaction object is missing`);
     }
     return await this.getClient().post<
-      ReactionAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this.getClient().baseURL + `/messages/${messageID}/reaction`, {
       reaction,
       ...options,
@@ -465,36 +350,19 @@ export class Channel<
   deleteReaction(messageID: string, reactionType: string, user_id?: string) {
     this._checkInitialized();
     if (!reactionType || !messageID) {
-      throw Error(
-        'Deleting a reaction requires specifying both the message and reaction type',
-      );
+      throw Error('Deleting a reaction requires specifying both the message and reaction type');
     }
 
-    const url =
-      this.getClient().baseURL + `/messages/${messageID}/reaction/${reactionType}`;
+    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
-        >
+        ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
       >(url, { user_id });
     }
 
     return this.getClient().delete<
-      ReactionAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      ReactionAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(url, {});
   }
 
@@ -503,15 +371,13 @@ export class Channel<
    *
    * @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 {{ skip_push?: boolean }} [options] Option object, {skip_push: true} to skip sending push notifications
+   * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
    * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
    */
   async update(
-    channelData:
-      | Partial<ChannelData<ChannelType>>
-      | Partial<ChannelResponse<ChannelType, CommandType, UserType>> = {},
+    channelData: Partial<ChannelData<ChannelType>> | Partial<ChannelResponse<ChannelType, CommandType, UserType>> = {},
     updateMessage?: Message<AttachmentType, MessageType, UserType>,
-    options?: { skip_push?: boolean },
+    options?: ChannelUpdateOptions,
   ) {
     // Strip out reserved names that will result in API errors.
     const reserved = [
@@ -545,9 +411,10 @@ export class Channel<
    * @return {Promise<PartialUpdateChannelAPIResponse<ChannelType,CommandType, UserType>>}
    */
   async updatePartial(update: PartialUpdateChannel<ChannelType>) {
-    return await this.getClient().patch<
-      PartialUpdateChannelAPIResponse<ChannelType, CommandType, UserType>
-    >(this._channelURL(), update);
+    return await this.getClient().patch<PartialUpdateChannelAPIResponse<ChannelType, CommandType, UserType>>(
+      this._channelURL(),
+      update,
+    );
   }
 
   /**
@@ -558,14 +425,7 @@ export class Channel<
    */
   async enableSlowMode(coolDownInterval: number) {
     const data = await this.getClient().post<
-      UpdateChannelAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this._channelURL(), {
       cooldown: coolDownInterval,
     });
@@ -580,14 +440,7 @@ export class Channel<
    */
   async disableSlowMode() {
     const data = await this.getClient().post<
-      UpdateChannelAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this._channelURL(), {
       cooldown: 0,
     });
@@ -601,20 +454,21 @@ export class Channel<
    * @return {Promise<DeleteChannelAPIResponse<ChannelType, CommandType, UserType>>} The server response
    */
   async delete() {
-    return await this.getClient().delete<
-      DeleteChannelAPIResponse<ChannelType, CommandType, UserType>
-    >(this._channelURL(), {});
+    return await this.getClient().delete<DeleteChannelAPIResponse<ChannelType, CommandType, UserType>>(
+      this._channelURL(),
+      {},
+    );
   }
 
   /**
    * truncate - Removes all messages from the channel
-   *
-   * @return {Promise<TruncateChannelAPIResponse<ChannelType, CommandType, UserType>>} The server response
+   * @param {TruncateOptions<AttachmentType, MessageType, UserType>} [options] Defines truncation options
+   * @return {Promise<TruncateChannelAPIResponse<ChannelType, CommandType, UserType, MessageType, ReactionType>>} The server response
    */
-  async truncate() {
+  async truncate(options: TruncateOptions<AttachmentType, MessageType, UserType> = {}) {
     return await this.getClient().post<
-      TruncateChannelAPIResponse<ChannelType, CommandType, UserType>
-    >(this._channelURL() + '/truncate', {});
+      TruncateChannelAPIResponse<ChannelType, CommandType, UserType, MessageType, ReactionType>
+    >(this._channelURL() + '/truncate', options);
   }
 
   /**
@@ -625,19 +479,9 @@ export class Channel<
    * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
    */
   async acceptInvite(
-    options: InviteOptions<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      MessageType,
-      ReactionType,
-      UserType
-    > = {},
+    options: InviteOptions<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> = {},
   ) {
-    return await this._update({
-      accept_invite: true,
-      ...options,
-    });
+    return await this._update({ accept_invite: true, ...options });
   }
 
   /**
@@ -648,19 +492,9 @@ export class Channel<
    * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
    */
   async rejectInvite(
-    options: InviteOptions<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      MessageType,
-      ReactionType,
-      UserType
-    > = {},
+    options: InviteOptions<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> = {},
   ) {
-    return await this._update({
-      reject_invite: true,
-      ...options,
-    });
+    return await this._update({ reject_invite: true, ...options });
   }
 
   /**
@@ -668,16 +502,15 @@ export class 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 {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
    * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
    */
   async addMembers(
     members: string[] | { user_id: string; channel_role?: Role }[],
     message?: Message<AttachmentType, MessageType, UserType>,
+    options: ChannelUpdateOptions = {},
   ) {
-    return await this._update({
-      add_members: members,
-      message,
-    });
+    return await this._update({ add_members: members, message, ...options });
   }
 
   /**
@@ -685,16 +518,15 @@ export class Channel<
    *
    * @param {string[]} members An array of member identifiers
    * @param {Message<AttachmentType, MessageType, UserType>} [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
    */
   async addModerators(
     members: string[],
     message?: Message<AttachmentType, MessageType, UserType>,
+    options: ChannelUpdateOptions = {},
   ) {
-    return await this._update({
-      add_moderators: members,
-      message,
-    });
+    return await this._update({ add_moderators: members, message, ...options });
   }
 
   /**
@@ -702,16 +534,15 @@ export class 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 {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
    * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
    */
   async assignRoles(
     roles: { channel_role: Role; user_id: string }[],
     message?: Message<AttachmentType, MessageType, UserType>,
+    options: ChannelUpdateOptions = {},
   ) {
-    return await this._update({
-      assign_roles: roles,
-      message,
-    });
+    return await this._update({ assign_roles: roles, message, ...options });
   }
 
   /**
@@ -719,16 +550,15 @@ export class 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 {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
    * @return {Promise<UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>>} The server response
    */
   async inviteMembers(
     members: { user_id: string; channel_role?: Role }[] | string[],
     message?: Message<AttachmentType, MessageType, UserType>,
+    options: ChannelUpdateOptions = {},
   ) {
-    return await this._update({
-      invites: members,
-      message,
-    });
+    return await this._update({ invites: members, message, ...options });
   }
 
   /**
@@ -736,16 +566,15 @@ export class Channel<
    *
    * @param {string[]} members An array of member identifiers
    * @param {Message<AttachmentType, MessageType, UserType>} [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
    */
   async removeMembers(
     members: string[],
     message?: Message<AttachmentType, MessageType, UserType>,
+    options: ChannelUpdateOptions = {},
   ) {
-    return await this._update({
-      remove_members: members,
-      message,
-    });
+    return await this._update({ remove_members: members, message, ...options });
   }
 
   /**
@@ -753,16 +582,15 @@ export class Channel<
    *
    * @param {string[]} members An array of member identifiers
    * @param {Message<AttachmentType, MessageType, UserType>} [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
    */
   async demoteModerators(
     members: string[],
     message?: Message<AttachmentType, MessageType, UserType>,
+    options: ChannelUpdateOptions = {},
   ) {
-    return await this._update({
-      demote_moderators: members,
-      message,
-    });
+    return await this._update({ demote_moderators: members, message, ...options });
   }
 
   /**
@@ -773,14 +601,7 @@ export class Channel<
    */
   async _update(payload: Object) {
     const data = await this.getClient().post<
-      UpdateChannelAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      UpdateChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this._channelURL(), payload);
     this.data = data.channel;
     return data;
@@ -799,12 +620,10 @@ export class Channel<
    *
    */
   async mute(opts: { expiration?: number; user_id?: string } = {}) {
-    return await this.getClient().post<
-      MuteChannelAPIResponse<ChannelType, CommandType, UserType>
-    >(this.getClient().baseURL + '/moderation/mute/channel', {
-      channel_cid: this.cid,
-      ...opts,
-    });
+    return await this.getClient().post<MuteChannelAPIResponse<ChannelType, CommandType, UserType>>(
+      this.getClient().baseURL + '/moderation/mute/channel',
+      { channel_cid: this.cid, ...opts },
+    );
   }
 
   /**
@@ -816,13 +635,10 @@ export class Channel<
    * await channel.unmute({user_id: userId});
    */
   async unmute(opts: { user_id?: string } = {}) {
-    return await this.getClient().post<APIResponse>(
-      this.getClient().baseURL + '/moderation/unmute/channel',
-      {
-        channel_cid: this.cid,
-        ...opts,
-      },
-    );
+    return await this.getClient().post<APIResponse>(this.getClient().baseURL + '/moderation/unmute/channel', {
+      channel_cid: this.cid,
+      ...opts,
+    });
   }
 
   /**
@@ -844,14 +660,7 @@ export class Channel<
       throw Error(`Message id is missing`);
     }
     return this.getClient().post<
-      SendMessageAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      SendMessageAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this.getClient().baseURL + `/messages/${messageID}/action`, {
       message_id: messageID,
       form_data: formData,
@@ -936,15 +745,7 @@ export class Channel<
     }
 
     return await this.getClient().post<
-      EventAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        EventType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      EventAPIResponse<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
     >(this._channelURL() + '/read', {
       ...data,
     });
@@ -991,14 +792,10 @@ export class Channel<
     this.initialized = true;
     this.data = state.channel;
 
-    this._client.logger(
-      'info',
-      `channel:watch() - started watching channel ${this.cid}`,
-      {
-        tags: ['channel'],
-        channel: this,
-      },
-    );
+    this._client.logger('info', `channel:watch() - started watching channel ${this.cid}`, {
+      tags: ['channel'],
+      channel: this,
+    });
     return state;
   }
 
@@ -1008,19 +805,12 @@ export class Channel<
    * @return {Promise<APIResponse>} The server response
    */
   async stopWatching() {
-    const response = await this.getClient().post<APIResponse>(
-      this._channelURL() + '/stop-watching',
-      {},
-    );
+    const response = await this.getClient().post<APIResponse>(this._channelURL() + '/stop-watching', {});
 
-    this._client.logger(
-      'info',
-      `channel:watch() - stopped watching channel ${this.cid}`,
-      {
-        tags: ['channel'],
-        channel: this,
-      },
-    );
+    this._client.logger('info', `channel:watch() - stopped watching channel ${this.cid}`, {
+      tags: ['channel'],
+      channel: this,
+    });
 
     return response;
   }
@@ -1038,14 +828,7 @@ export class Channel<
     options: PaginationOptions & { user?: UserResponse<UserType>; user_id?: string },
   ) {
     const data = await this.getClient().get<
-      GetRepliesAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      GetRepliesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this.getClient().baseURL + `/messages/${parent_id}/replies`, {
       ...options,
     });
@@ -1084,14 +867,7 @@ export class Channel<
    */
   getMessagesById(messageIds: string[]) {
     return this.getClient().get<
-      GetMultipleMessagesAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      GetMultipleMessagesAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(this._channelURL() + '/messages', {
       ids: messageIds.join(','),
     });
@@ -1111,28 +887,13 @@ export class Channel<
 
   _countMessageAsUnread(
     message:
-      | FormatMessageResponse<
-          AttachmentType,
-          ChannelType,
-          CommandType,
-          MessageType,
-          ReactionType,
-          UserType
-        >
-      | MessageResponse<
-          AttachmentType,
-          ChannelType,
-          CommandType,
-          MessageType,
-          ReactionType,
-          UserType
-        >,
+      | FormatMessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
+      | MessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>,
   ) {
     if (message.shadowed) return false;
     if (message.silent) return false;
     if (message.user?.id === this.getClient().userID) return false;
-    if (message.user?.id && this.getClient().userMuteStatus(message.user.id))
-      return false;
+    if (message.user?.id && this.getClient().userMuteStatus(message.user.id)) return false;
     if (message.type === 'system') return false;
 
     if (this.muteStatus().muted) return false;
@@ -1214,14 +975,7 @@ export class Channel<
     }
 
     const state = await this.getClient().post<
-      ChannelAPIResponse<
-        AttachmentType,
-        ChannelType,
-        CommandType,
-        MessageType,
-        ReactionType,
-        UserType
-      >
+      ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>
     >(queryURL + '/query', {
       data: this._data,
       state: true,
@@ -1361,38 +1115,14 @@ export class Channel<
    */
   on(
     eventType: EventTypes,
-    callback: EventHandler<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ): { unsubscribe: () => void };
   on(
-    callback: EventHandler<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ): { unsubscribe: () => void };
   on(
     callbackOrString:
-      | EventHandler<
-          AttachmentType,
-          ChannelType,
-          CommandType,
-          EventType,
-          MessageType,
-          ReactionType,
-          UserType
-        >
+      | EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
       | EventTypes,
     callbackOrNothing?: EventHandler<
       AttachmentType,
@@ -1413,24 +1143,19 @@ export class Channel<
     if (!(key in this.listeners)) {
       this.listeners[key] = [];
     }
-    this._client.logger(
-      'info',
-      `Attaching listener for ${key} event on channel ${this.cid}`,
-      {
-        tags: ['event', 'channel'],
-        channel: this,
-      },
-    );
+    this._client.logger('info', `Attaching listener for ${key} event on channel ${this.cid}`, {
+      tags: ['event', 'channel'],
+      channel: this,
+    });
 
     this.listeners[key].push(callback);
 
     return {
       unsubscribe: () => {
-        this._client.logger(
-          'info',
-          `Removing listener for ${key} event from channel ${this.cid}`,
-          { tags: ['event', 'channel'], channel: this },
-        );
+        this._client.logger('info', `Removing listener for ${key} event from channel ${this.cid}`, {
+          tags: ['event', 'channel'],
+          channel: this,
+        });
 
         this.listeners[key] = this.listeners[key].filter((el) => el !== callback);
       },
@@ -1443,38 +1168,14 @@ export class Channel<
    */
   off(
     eventType: EventTypes,
-    callback: EventHandler<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ): void;
   off(
-    callback: EventHandler<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    callback: EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ): void;
   off(
     callbackOrString:
-      | EventHandler<
-          AttachmentType,
-          ChannelType,
-          CommandType,
-          EventType,
-          MessageType,
-          ReactionType,
-          UserType
-        >
+      | EventHandler<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>
       | EventTypes,
     callbackOrNothing?: EventHandler<
       AttachmentType,
@@ -1496,25 +1197,16 @@ export class Channel<
       this.listeners[key] = [];
     }
 
-    this._client.logger(
-      'info',
-      `Removing listener for ${key} event from channel ${this.cid}`,
-      { tags: ['event', 'channel'], channel: this },
-    );
+    this._client.logger('info', `Removing listener for ${key} event from channel ${this.cid}`, {
+      tags: ['event', 'channel'],
+      channel: this,
+    });
     this.listeners[key] = this.listeners[key].filter((value) => value !== callback);
   }
 
   // eslint-disable-next-line sonarjs/cognitive-complexity
   _handleChannelEvent(
-    event: Event<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    event: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ) {
     const channel = this;
     this._client.logger(
@@ -1578,8 +1270,7 @@ export class Channel<
         if (event.message) {
           /* if message belongs to current user, always assume timestamp is changed to filter it out and add again to avoid duplication */
           const ownMessage = event.user?.id === this.getClient().user?.id;
-          const isThreadMessage =
-            event.message.parent_id && !event.message.show_in_channel;
+          const isThreadMessage = event.message.parent_id && !event.message.show_in_channel;
 
           if (this.state.isUpToDate || isThreadMessage) {
             channelState.addMessageSorted(event.message, ownMessage);
@@ -1660,15 +1351,7 @@ export class Channel<
   }
 
   _callChannelListeners = (
-    event: Event<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      EventType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    event: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>,
   ) => {
     const channel = this;
     // gather and call the listeners
@@ -1710,14 +1393,7 @@ export class Channel<
 
   // eslint-disable-next-line sonarjs/cognitive-complexity
   _initializeState(
-    state: ChannelAPIResponse<
-      AttachmentType,
-      ChannelType,
-      CommandType,
-      MessageType,
-      ReactionType,
-      UserType
-    >,
+    state: ChannelAPIResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>,
   ) {
     const { state: clientState, user, userID } = this.getClient();
 
@@ -1786,14 +1462,10 @@ export class Channel<
   }
 
   _disconnect() {
-    this._client.logger(
-      'info',
-      `channel:disconnect() - Disconnecting the channel ${this.cid}`,
-      {
-        tags: ['connection', 'channel'],
-        channel: this,
-      },
-    );
+    this._client.logger('info', `channel:disconnect() - Disconnecting the channel ${this.cid}`, {
+      tags: ['connection', 'channel'],
+      channel: this,
+    });
 
     this.disconnected = true;
     this.state.setIsUpToDate(false);