stream-chat-angular 6.4.1 → 7.0.0

package/esm2022/lib/channel.service.mjs

@@ -0,0 +1,1575 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, ReplaySubject, } from 'rxjs';
+import { filter, first, map, shareReplay, take } from 'rxjs/operators';
+import { getMessageTranslation } from './get-message-translation';
+import { createMessagePreview } from './message-preview';
+import { getReadBy } from './read-by';
+import { ChannelQuery } from './channel-query';
+import * as i0 from "@angular/core";
+import * as i1 from "./chat-client.service";
+import * as i2 from "./notification.service";
+/**
+ * The `ChannelService` provides data and interaction for the channel list and message list.
+ */
+export class ChannelService {
+    /**
+     * @internal
+     */
+    static { this.MAX_MESSAGE_REACTIONS_TO_FETCH = 1200; }
+    constructor(chatClientService, ngZone, notificationService) {
+        this.chatClientService = chatClientService;
+        this.ngZone = ngZone;
+        this.notificationService = notificationService;
+        /**
+         * @internal
+         */
+        this.isMessageLoadingInProgress = false;
+        this.messagePageSize = 25;
+        this.channelsSubject = new BehaviorSubject(undefined);
+        this.activeChannelSubject = new BehaviorSubject(undefined);
+        this.activeChannelMessagesSubject = new BehaviorSubject([]);
+        this.activeChannelPinnedMessagesSubject = new BehaviorSubject([]);
+        this.hasMoreChannelsSubject = new ReplaySubject(1);
+        this.activeChannelSubscriptions = [];
+        this.channelSubscriptions = {};
+        this.activeParentMessageIdSubject = new BehaviorSubject(undefined);
+        this.activeThreadMessagesSubject = new BehaviorSubject([]);
+        this.jumpToMessageSubject = new BehaviorSubject({ id: undefined, parentId: undefined });
+        this.latestMessageDateByUserByChannelsSubject = new BehaviorSubject({});
+        this.attachmentMaxSizeFallbackInMB = 100;
+        this.messageToQuoteSubject = new BehaviorSubject(undefined);
+        this.usersTypingInChannelSubject = new BehaviorSubject([]);
+        this.usersTypingInThreadSubject = new BehaviorSubject([]);
+        this._shouldMarkActiveChannelAsRead = true;
+        this.isStateRecoveryInProgress = false;
+        this.channelQueryStateSubject = new BehaviorSubject(undefined);
+        this.channelSwitchStateSubject = new BehaviorSubject('end');
+        this.channelListSetter = (channels, shouldStopWatchingRemovedChannels = true) => {
+            const currentChannels = this.channelsSubject.getValue() || [];
+            const deletedChannels = currentChannels.filter((c) => !channels?.find((channel) => channel.cid === c.cid));
+            for (let i = 0; i < channels.length; i++) {
+                const channel = channels[i];
+                if (!this.channelSubscriptions[channel.cid]) {
+                    this.watchForChannelEvents(channel);
+                }
+                if (deletedChannels.includes(channel)) {
+                    if (shouldStopWatchingRemovedChannels) {
+                        if (this.channelSubscriptions[channel.cid]) {
+                            this.channelSubscriptions[channel.cid]();
+                            delete this.channelSubscriptions.cid;
+                        }
+                        void this.chatClientService.chatClient.activeChannels[channel.cid]
+                            ?.stopWatching()
+                            .catch((err) => this.chatClientService.chatClient.logger('warn', 'Failed to unwatch channel', err));
+                    }
+                }
+            }
+            const nextChannels = channels;
+            this.channelsSubject.next(nextChannels);
+            if (!nextChannels.find((c) => c.cid === this.activeChannelSubject.getValue()?.cid)) {
+                if (nextChannels.length > 0) {
+                    this.setAsActiveChannel(nextChannels[0]);
+                }
+                else {
+                    this.activeChannelSubject.next(undefined);
+                }
+            }
+        };
+        this.messageListSetter = (messages) => {
+            this.activeChannelMessagesSubject.next(messages);
+        };
+        this.threadListSetter = (messages) => {
+            this.activeThreadMessagesSubject.next(messages);
+        };
+        this.parentMessageSetter = (message) => {
+            this.activeParentMessageIdSubject.next(message?.id);
+        };
+        this.areReadEventsPaused = false;
+        this.markReadThrottleTime = 1050;
+        this.channels$ = this.channelsSubject.asObservable().pipe(shareReplay(1));
+        this.activeChannel$ = this.activeChannelSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.activeChannelMessages$ = this.activeChannelMessagesSubject.pipe(map((messages) => {
+            const channel = this.activeChannelSubject.getValue();
+            return messages.map((message) => this.transformToStreamMessage(message, channel));
+        }), shareReplay(1));
+        this.bouncedMessage$ = new BehaviorSubject(undefined);
+        this.hasMoreChannels$ = this.hasMoreChannelsSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.activeParentMessageId$ = this.activeParentMessageIdSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.activeThreadMessages$ = this.activeThreadMessagesSubject.pipe(map((messages) => {
+            const channel = this.activeChannelSubject.getValue();
+            return messages.map((message) => this.transformToStreamMessage(message, channel));
+        }), shareReplay(1));
+        this.activeParentMessage$ = combineLatest([
+            this.activeChannelMessages$,
+            this.activeParentMessageId$,
+        ]).pipe(map(([messages, parentMessageId]) => {
+            if (!parentMessageId) {
+                return undefined;
+            }
+            else {
+                const message = messages.find((m) => m.id === parentMessageId);
+                if (!message) {
+                    void this.setAsActiveParentMessage(undefined);
+                    return undefined;
+                }
+                else {
+                    return message;
+                }
+            }
+        }), shareReplay(1));
+        this.messageToQuote$ = this.messageToQuoteSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.jumpToMessage$ = this.jumpToMessageSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.usersTypingInChannel$ = this.usersTypingInChannelSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.usersTypingInThread$ = this.usersTypingInThreadSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.latestMessageDateByUserByChannels$ =
+            this.latestMessageDateByUserByChannelsSubject
+                .asObservable()
+                .pipe(shareReplay(1));
+        this.activeChannelPinnedMessages$ = this.activeChannelPinnedMessagesSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.channelQueryState$ = this.channelQueryStateSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.channelSwitchState$ = this.channelSwitchStateSubject
+            .asObservable()
+            .pipe(shareReplay(1));
+    }
+    /**
+     * If set to false, read events won't be sent as new messages are received. If set to true active channel (if any) will immediately be marked as read.
+     */
+    get shouldMarkActiveChannelAsRead() {
+        return this._shouldMarkActiveChannelAsRead;
+    }
+    /**
+     * If set to false, read events won't be sent as new messages are received. If set to true active channel (if any) will immediately be marked as read.
+     */
+    set shouldMarkActiveChannelAsRead(shouldMarkActiveChannelAsRead) {
+        if (!this._shouldMarkActiveChannelAsRead && shouldMarkActiveChannelAsRead) {
+            const activeChannel = this.activeChannelSubject.getValue();
+            if (activeChannel && this.canSendReadEvents) {
+                void activeChannel.markRead();
+            }
+        }
+        this._shouldMarkActiveChannelAsRead = shouldMarkActiveChannelAsRead;
+    }
+    /**
+     * By default the SDK uses an offset based pagination, you can change/extend this by providing your own custom paginator method.
+     *
+     * The method will be called with the result of the latest channel query.
+     *
+     * You can return either an offset, or a filter using the [`$lte`/`$gte` operator](/chat/docs/javascript/query_syntax_operators/). If you return a filter, it will be merged with the filter provided for the `init` method.
+     */
+    set customPaginator(paginator) {
+        this._customPaginator = paginator;
+        if (this.channelQuery && 'customPaginator' in this.channelQuery) {
+            this.channelQuery.customPaginator = this._customPaginator;
+        }
+    }
+    /**
+     * Sets the given `channel` as active and marks it as read.
+     * If the channel wasn't previously part of the channel, it will be added to the beginning of the list.
+     * @param channel
+     */
+    setAsActiveChannel(channel) {
+        this.channelSwitchStateSubject.next('start');
+        const prevActiveChannel = this.activeChannelSubject.getValue();
+        if (prevActiveChannel?.cid === channel.cid) {
+            return;
+        }
+        this.stopWatchForActiveChannelEvents(prevActiveChannel);
+        this.flushMarkReadQueue();
+        this.areReadEventsPaused = false;
+        this.isMessageLoadingInProgress = false;
+        const readState = channel.state.read[this.chatClientService.chatClient.user?.id || ''];
+        this.activeChannelLastReadMessageId = readState?.last_read_message_id;
+        if (channel.state.latestMessages[channel.state.latestMessages.length - 1]
+            ?.id === this.activeChannelLastReadMessageId) {
+            this.activeChannelLastReadMessageId = undefined;
+        }
+        this.activeChannelUnreadCount = readState?.unread_messages || 0;
+        this.watchForActiveChannelEvents(channel);
+        this.addChannel(channel);
+        this.activeChannelSubject.next(channel);
+        const channelStateLength = channel.state.latestMessages.length;
+        if (channelStateLength > 2 * this.messagePageSize) {
+            channel.state.latestMessages = channel.state.latestMessages.slice(channelStateLength - 2 * this.messagePageSize);
+        }
+        this.setChannelState(channel);
+        this.channelSwitchStateSubject.next('end');
+    }
+    /**
+     * Deselects the currently active (if any) channel
+     */
+    deselectActiveChannel() {
+        this.channelSwitchStateSubject.next('start');
+        const activeChannel = this.activeChannelSubject.getValue();
+        if (!activeChannel) {
+            return;
+        }
+        this.stopWatchForActiveChannelEvents(activeChannel);
+        this.flushMarkReadQueue();
+        this.activeChannelMessagesSubject.next([]);
+        this.activeChannelSubject.next(undefined);
+        this.activeParentMessageIdSubject.next(undefined);
+        this.activeThreadMessagesSubject.next([]);
+        this.latestMessageDateByUserByChannelsSubject.next({});
+        this.selectMessageToQuote(undefined);
+        this.jumpToMessageSubject.next({ id: undefined, parentId: undefined });
+        this.activeChannelPinnedMessagesSubject.next([]);
+        this.usersTypingInChannelSubject.next([]);
+        this.usersTypingInThreadSubject.next([]);
+        this.activeChannelLastReadMessageId = undefined;
+        this.activeChannelUnreadCount = undefined;
+        this.areReadEventsPaused = false;
+        this.isMessageLoadingInProgress = false;
+        this.channelSwitchStateSubject.next('end');
+    }
+    /**
+     * Sets the given `message` as an active parent message. If `undefined` is provided, it will deleselect the current parent message.
+     * @param message
+     * @param loadMessagesForm
+     */
+    async setAsActiveParentMessage(message, loadMessagesForm = 'request') {
+        const messageToQuote = this.messageToQuoteSubject.getValue();
+        if (messageToQuote && !!messageToQuote.parent_id) {
+            this.messageToQuoteSubject.next(undefined);
+        }
+        if (!message) {
+            this.activeParentMessageIdSubject.next(undefined);
+            this.activeThreadMessagesSubject.next([]);
+            const messageToJumpTo = this.jumpToMessageSubject.getValue();
+            if (messageToJumpTo && !!messageToJumpTo.parentId) {
+                this.jumpToMessageSubject.next({ id: undefined, parentId: undefined });
+            }
+        }
+        else {
+            this.activeParentMessageIdSubject.next(message.id);
+            const activeChannel = this.activeChannelSubject.getValue();
+            if (loadMessagesForm === 'request') {
+                const result = await activeChannel?.getReplies(message.id, {
+                    limit: this.messagePageSize,
+                });
+                this.activeThreadMessagesSubject.next(result?.messages || []);
+            }
+            else {
+                this.activeThreadMessagesSubject.next(activeChannel?.state.threads[message.id] || []);
+            }
+        }
+    }
+    /**
+     * Loads the next page of messages of the active channel. The page size can be set in the [query option](/chat/docs/javascript/query_channels/#query-options) object.
+     * @param direction
+     */
+    loadMoreMessages(direction = 'older') {
+        const activeChnannel = this.activeChannelSubject.getValue();
+        const messages = this.activeChannelMessagesSubject.getValue();
+        const lastMessageId = messages[direction === 'older' ? 0 : messages.length - 1]?.id;
+        if (direction === 'newer' &&
+            activeChnannel?.state?.latestMessages === activeChnannel?.state?.messages) {
+            // If we are on latest message set, activeChannelMessages$ will be refreshed by WS events, no need for a request
+            return false;
+        }
+        return activeChnannel
+            ?.query({
+            messages: {
+                limit: this.messagePageSize,
+                [direction === 'older' ? 'id_lt' : 'id_gt']: lastMessageId,
+            },
+            members: { limit: 0 },
+            watchers: { limit: 0 },
+        })
+            .then((res) => {
+            if (activeChnannel?.data?.id ===
+                this.activeChannelSubject.getValue()?.data?.id) {
+                this.activeChannelMessagesSubject.next([
+                    ...activeChnannel.state.messages,
+                ]);
+            }
+            return res;
+        });
+    }
+    /**
+     * Loads the next page of messages of the active thread. The page size can be set in the [query option](/chat/docs/javascript/query_channels/#query-options) object.
+     * @param direction
+     */
+    loadMoreThreadReplies(direction = 'older') {
+        if (direction === 'newer') {
+            // Thread replies aren't broke into different message sets, activeThreadMessages$ will be refreshed by WS events, no need for a request
+            return false;
+        }
+        const activeChnannel = this.activeChannelSubject.getValue();
+        const parentMessageId = this.activeParentMessageIdSubject.getValue();
+        if (!parentMessageId || !activeChnannel) {
+            return false;
+        }
+        const threadMessages = this.activeThreadMessagesSubject.getValue();
+        const lastMessageId = threadMessages[direction === 'older' ? 0 : threadMessages.length - 1]?.id;
+        return activeChnannel
+            .getReplies(parentMessageId, {
+            limit: this.messagePageSize,
+            [direction === 'older' ? 'id_lt' : 'id_gt']: lastMessageId,
+        })
+            .then(() => {
+            this.activeThreadMessagesSubject.next(activeChnannel?.state.threads[parentMessageId] || []);
+        });
+    }
+    /**
+     * Queries the channels with the given filters, sorts and options. More info about [channel querying](/chat/docs/javascript/query_channels/) can be found in the platform documentation. By default the first channel in the list will be set as active channel and will be marked as read.
+     * @param filters
+     * @param sort
+     * @param options
+     * @param shouldSetActiveChannel Decides if the first channel in the result should be made as an active channel or not.
+     * @returns the list of channels found by the query
+     */
+    init(filters, sort, options, shouldSetActiveChannel = true) {
+        this.channelQuery = new ChannelQuery(this.chatClientService, this, filters, sort || { last_message_at: -1 }, {
+            limit: 25,
+            state: true,
+            presence: true,
+            watch: true,
+            message_limit: this.messagePageSize,
+            ...options,
+        });
+        this.channelQuery.customPaginator = this._customPaginator;
+        return this._init({
+            shouldSetActiveChannel,
+            messagePageSize: options?.message_limit ?? this.messagePageSize,
+        });
+    }
+    /**
+     * Queries the channels with the given query function. More info about [channel querying](/chat/docs/javascript/query_channels/) can be found in the platform documentation.
+     * @param query
+     * @param options
+     * @param options.shouldSetActiveChannel The `shouldSetActiveChannel` specifies if the first channel in the result should be selected as the active channel or not. Default is `true`.
+     * @param options.messagePageSize How many messages should we load? The default is 25
+     * @returns the channels that were loaded
+     */
+    initWithCustomQuery(query, options = {
+        shouldSetActiveChannel: true,
+        messagePageSize: this.messagePageSize,
+    }) {
+        this.channelQuery = query;
+        return this._init(options);
+    }
+    /**
+     * Resets the `activeChannel$`, `channels$` and `activeChannelMessages$` Observables. Useful when disconnecting a chat user, use in combination with [`disconnectUser`](/chat/docs/sdk/angular/services/ChatClientService/#disconnectuser/).
+     */
+    reset() {
+        this.deselectActiveChannel();
+        this.channelsSubject.next(undefined);
+        this.channelQueryStateSubject.next(undefined);
+        this.clientEventsSubscription?.unsubscribe();
+        this.dismissErrorNotification?.();
+        this.dismissErrorNotification = undefined;
+        Object.keys(this.channelSubscriptions).forEach((cid) => {
+            this.channelSubscriptions[cid]();
+        });
+        this.channelSubscriptions = {};
+    }
+    /**
+     * Loads the next page of channels. The page size can be set in the [query option](/chat/docs/javascript/query_channels/#query-options) object.
+     */
+    async loadMoreChannels() {
+        await this.queryChannels(false, 'next-page');
+    }
+    /**
+     * Adds a reaction to a message.
+     * @param messageId The id of the message to add the reaction to
+     * @param reactionType The type of the reaction
+     * @param customData
+     */
+    async addReaction(messageId, reactionType, customData) {
+        await this.activeChannelSubject.getValue()?.sendReaction(messageId, {
+            type: reactionType,
+            ...customData,
+        });
+    }
+    /**
+     * Removes a reaction from a message.
+     * @param messageId The id of the message to remove the reaction from
+     * @param reactionType Thr type of reaction to remove
+     */
+    async removeReaction(messageId, reactionType) {
+        await this.activeChannelSubject
+            .getValue()
+            ?.deleteReaction(messageId, reactionType);
+    }
+    /**
+     * Sends a message to the active channel. The message is immediately added to the message list, if an error occurs and the message can't be sent, the error is indicated in `state` of the message.
+     * @param text The text of the message
+     * @param attachments The attachments
+     * @param mentionedUsers Mentioned users
+     * @param parentId Id of the parent message (if sending a thread reply)
+     * @param quotedMessageId Id of the message to quote (if sending a quote reply)
+     * @param customData
+     * @param pollId Id of the poll (if sending a poll message)
+     */
+    async sendMessage(text, attachments = [], mentionedUsers = [], parentId = undefined, quotedMessageId = undefined, customData = undefined, pollId = undefined) {
+        let input = {
+            text,
+            attachments,
+            mentionedUsers,
+            parentId,
+            quotedMessageId,
+            customData,
+            pollId,
+        };
+        if (this.beforeSendMessage) {
+            input = await this.beforeSendMessage(input);
+        }
+        const preview = createMessagePreview(this.chatClientService.chatClient.user, input.text, input.attachments, input.mentionedUsers, input.parentId, input.quotedMessageId, input.customData, input.pollId);
+        const channel = this.activeChannelSubject.getValue();
+        channel.state.addMessageSorted(preview, true);
+        const response = await this.sendMessageRequest(preview, input.customData);
+        return response;
+    }
+    /**
+     * Resends the given message to the active channel
+     * @param message The message to resend
+     */
+    async resendMessage(message) {
+        const channel = this.activeChannelSubject.getValue();
+        channel.state.addMessageSorted({
+            ...message,
+            // @ts-expect-error stream-chat doesn't know about this property
+            errorStatusCode: undefined,
+            status: 'sending',
+        }, true);
+        return this.sendMessageRequest(message, undefined, true);
+    }
+    /**
+     * Updates the message in the active channel
+     * @param message Mesage to be updated
+     */
+    async updateMessage(message) {
+        let messageToUpdate = {
+            ...message,
+        };
+        if (messageToUpdate.quoted_message) {
+            messageToUpdate.quoted_message = {
+                ...messageToUpdate.quoted_message,
+            };
+        }
+        delete messageToUpdate.i18n;
+        if (this.beforeUpdateMessage) {
+            messageToUpdate = await this.beforeUpdateMessage(messageToUpdate);
+        }
+        if (messageToUpdate.readBy) {
+            // @ts-expect-error this is only a run time proparty for the SDK
+            delete messageToUpdate.readBy;
+        }
+        if (messageToUpdate.translation) {
+            delete messageToUpdate.translation;
+        }
+        if (messageToUpdate.quoted_message?.translation) {
+            delete messageToUpdate.quoted_message.translation;
+        }
+        if (message.moderation_details) {
+            return this.resendMessage(message);
+        }
+        const response = await this.chatClientService.chatClient.updateMessage(messageToUpdate);
+        const channel = this.channelsSubject
+            .getValue()
+            ?.find((c) => c.cid === message.cid);
+        if (response.message.type === 'error' &&
+            response.message.moderation_details) {
+            this.notificationService.addTemporaryNotification('streamChat.This message did not meet our content guidelines');
+            return message;
+        }
+        return this.transformToStreamMessage(response.message, channel);
+    }
+    /**
+     * Deletes the message from the active channel
+     * @param message Message to be deleted
+     * @param isLocalDelete set this `true` if you want to delete a message that's only part of the local state, not yet saved on the backend
+     */
+    async deleteMessage(message, isLocalDelete = false) {
+        if (isLocalDelete && this.activeChannel) {
+            const result = this.activeChannel.state.removeMessage({
+                id: message.id,
+                parent_id: message.parent_id,
+            });
+            if (result) {
+                message.parent_id
+                    ? this.activeThreadMessagesSubject.next(this.activeChannel.state.threads[message.parent_id])
+                    : this.activeChannelMessagesSubject.next(this.activeChannel.state.messages);
+            }
+            return;
+        }
+        if (this.messageDeleteConfirmationHandler) {
+            const result = await this.messageDeleteConfirmationHandler(message);
+            if (result) {
+                await this.chatClientService.chatClient.deleteMessage(message.id);
+            }
+        }
+        else {
+            await this.chatClientService.chatClient.deleteMessage(message.id);
+        }
+    }
+    /**
+     * Uploads files to the channel. If you want to know more about [file uploads](/chat/docs/javascript/file_uploads/) check out the platform documentation.
+     * @param uploads the attachments to upload (output of the [`AttachmentService`](/chat/docs/sdk/angular/services/AttachmentService/))
+     * @returns the result of file upload requests
+     */
+    async uploadAttachments(uploads) {
+        const result = [];
+        const channel = this.activeChannelSubject.getValue();
+        const uploadResults = await Promise.allSettled(uploads.map((upload) => upload.type === 'image'
+            ? this.customImageUploadRequest
+                ? this.customImageUploadRequest(upload.file, channel)
+                : channel.sendImage(upload.file, upload.file.name, upload.file.type)
+            : this.customFileUploadRequest
+                ? this.customFileUploadRequest(upload.file, channel)
+                : channel.sendFile(upload.file, upload.file.name, upload.file.type)));
+        uploadResults.forEach((uploadResult, i) => {
+            const file = uploads[i].file;
+            const type = uploads[i].type;
+            if (uploadResult.status === 'fulfilled') {
+                result.push({
+                    file,
+                    type,
+                    state: 'success',
+                    url: uploadResult.value.file,
+                    /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any */
+                    thumb_url: uploadResult.value.thumb_url,
+                });
+            }
+            else {
+                let reason = 'unknown';
+                let extraData;
+                /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */
+                const message = 
+                /* eslint-disable-next-line @typescript-eslint/no-unsafe-member-access */
+                uploadResult.reason.response?.data?.message;
+                /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */
+                const code = 
+                /* eslint-disable-next-line @typescript-eslint/no-unsafe-member-access */
+                uploadResult.reason.response?.data?.code;
+                if (code === 22 ||
+                    (code === 4 && message?.toLowerCase()?.includes('bytes'))) {
+                    reason = 'file-size';
+                    extraData = {
+                        param: /\d+MB|\d+\s?bytes/.exec(message || '')?.[0] ||
+                            `${this.attachmentMaxSizeFallbackInMB}MB`,
+                    };
+                    if (extraData.param.includes('bytes')) {
+                        const limitInBytes = +(/\d+/.exec(extraData.param)?.[0] ||
+                            this.attachmentMaxSizeFallbackInMB * 1024 * 1024);
+                        extraData.param = `${limitInBytes / (1024 * 1024)}MB`;
+                    }
+                }
+                else if (code === 4 &&
+                    message?.toLowerCase()?.includes('file extension')) {
+                    reason = 'file-extension';
+                    extraData = { param: /\.\w+/.exec(message)?.[0] || '' };
+                }
+                result.push({
+                    file,
+                    type,
+                    state: 'error',
+                    errorReason: reason,
+                    errorExtraInfo: extraData ? [extraData] : undefined,
+                });
+            }
+        });
+        return result;
+    }
+    /**
+     * Deletes an uploaded file by URL. If you want to know more about [file uploads](/chat/docs/javascript/file_uploads/) check out the platform documentation
+     * @param attachmentUpload Attachment to be deleted (output of the [`AttachmentService`](/chat/docs/sdk/angular/services/AttachmentService/))
+     */
+    async deleteAttachment(attachmentUpload) {
+        const channel = this.activeChannelSubject.getValue();
+        await (attachmentUpload.type === 'image'
+            ? this.customImageDeleteRequest
+                ? this.customImageDeleteRequest(attachmentUpload.url, channel)
+                : channel.deleteImage(attachmentUpload.url)
+            : this.customFileDeleteRequest
+                ? this.customFileDeleteRequest(attachmentUpload.url, channel)
+                : channel.deleteFile(attachmentUpload.url));
+    }
+    /**
+     * Returns the autocomplete options for current channel members. If the channel has less than 100 members, it returns the channel members, otherwise sends a [search request](/chat/docs/javascript/query_members/#pagination-and-ordering) with the given search term.
+     * @param searchTerm Text to search for in the names of members
+     * @returns The list of members matching the search filter
+     */
+    async autocompleteMembers(searchTerm) {
+        const activeChannel = this.activeChannelSubject.getValue();
+        if (!activeChannel) {
+            return [];
+        }
+        if (Object.keys(activeChannel.state.members).length < 100) {
+            return Object.values(activeChannel.state.members).filter((m) => m.user?.id !== this.chatClientService.chatClient.userID);
+        }
+        else {
+            if (!searchTerm) {
+                return [];
+            }
+            const result = await activeChannel.queryMembers({
+                name: { $autocomplete: searchTerm },
+            }); // TODO: find out why we need typecast here
+            return result.members.filter((m) => m.user_id !== this.chatClientService.chatClient?.user?.id);
+        }
+    }
+    /**
+     * [Runs a message action](https://getstream.io/chat/docs/rest/#messages-runmessageaction) in the current channel. Updates the message list based on the action result (if no message is returned, the message will be removed from the message list).
+     * @param messageId
+     * @param formData
+     * @param parentMessageId
+     */
+    async sendAction(messageId, formData, parentMessageId) {
+        const channel = this.activeChannelSubject.getValue();
+        const response = await channel.sendAction(messageId, formData);
+        if (response?.message) {
+            channel.state.addMessageSorted({
+                ...response.message,
+                status: 'received',
+            });
+            const isThreadReply = !!response.message.parent_id;
+            isThreadReply
+                ? this.activeThreadMessagesSubject.next([
+                    ...channel.state.threads[response.message.parent_id],
+                ])
+                : this.activeChannelMessagesSubject.next([...channel.state.messages]);
+        }
+        else {
+            channel.state.removeMessage({
+                id: messageId,
+                parent_id: parentMessageId,
+            });
+            if (parentMessageId) {
+                this.activeThreadMessagesSubject.next(channel.state.threads[this.activeParentMessageIdSubject.getValue()]);
+            }
+            else {
+                this.activeChannelMessagesSubject.next([...channel.state.messages]);
+            }
+        }
+    }
+    /**
+     * Selects or deselects the current message to quote reply to
+     * @param message The message to select, if called with `undefined`, it deselects the message
+     */
+    selectMessageToQuote(message) {
+        if (message && !this.isStreamMessage(message)) {
+            message = this.transformToStreamMessage(message);
+        }
+        this.messageToQuoteSubject.next(message);
+    }
+    /**
+     * Add a new channel to the channel list
+     * The channel will be added to the beginning of the channel list
+     * @param channel
+     */
+    addChannel(channel) {
+        if (!this.channels.find((c) => c.cid === channel.cid)) {
+            this.channelsSubject.next([channel, ...this.channels]);
+            this.watchForChannelEvents(channel);
+        }
+    }
+    /**
+     *
+     * @param cid
+     * @param shouldStopWatching
+     */
+    removeChannel(cid, shouldStopWatching = true) {
+        const remainingChannels = this.channels.filter((c) => c.cid !== cid);
+        if (shouldStopWatching) {
+            if (this.channelSubscriptions[cid]) {
+                this.channelSubscriptions[cid]();
+                delete this.channelSubscriptions.cid;
+            }
+            void this.chatClientService.chatClient.activeChannels[cid]
+                ?.stopWatching()
+                .catch((err) => this.chatClientService.chatClient.logger('warn', 'Failed to unwatch channel', err));
+        }
+        if (remainingChannels.length < this.channels.length) {
+            this.channelsSubject.next(remainingChannels);
+            if (cid === this.activeChannelSubject.getValue()?.cid) {
+                if (remainingChannels.length > 0) {
+                    this.setAsActiveChannel(remainingChannels[0]);
+                }
+                else {
+                    this.activeChannelSubject.next(undefined);
+                }
+            }
+        }
+    }
+    async sendMessageRequest(preview, customData, isResend = false) {
+        const channel = this.activeChannelSubject.getValue();
+        const isThreadReply = !!preview.parent_id;
+        isThreadReply
+            ? this.activeThreadMessagesSubject.next([
+                ...channel.state.threads[preview.parent_id],
+            ])
+            : this.activeChannelMessagesSubject.next([...channel.state.messages]);
+        try {
+            const response = await channel.sendMessage({
+                id: preview.id,
+                text: preview.text,
+                attachments: preview.attachments,
+                mentioned_users: preview.mentioned_users?.map((u) => u.id),
+                parent_id: preview.parent_id,
+                quoted_message_id: preview.quoted_message_id,
+                poll_id: preview.poll_id,
+                ...customData,
+            }); // TODO: find out why we need typecast here
+            channel.state.addMessageSorted({
+                ...response.message,
+                status: 'received',
+            }, true);
+            isThreadReply
+                ? this.activeThreadMessagesSubject.next([
+                    ...channel.state.threads[preview.parent_id],
+                ])
+                : this.activeChannelMessagesSubject.next([...channel.state.messages]);
+            let messages;
+            (isThreadReply ? this.activeThreadMessages$ : this.activeChannelMessages$)
+                .pipe(take(1))
+                .subscribe((m) => (messages = m));
+            const newMessage = messages[messages.length - 1];
+            return newMessage;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            const stringError = JSON.stringify(error);
+            const parsedError = stringError ? JSON.parse(stringError) : {};
+            let isAlreadyExists = false;
+            if (isResend) {
+                if (parsedError.status === 400 &&
+                    parsedError.code === 4 &&
+                    parsedError?.response?.data?.message?.includes('already exists')) {
+                    isAlreadyExists = true;
+                }
+            }
+            channel.state.addMessageSorted({
+                ...preview,
+                // @ts-expect-error stream-chat doesn't know about this property
+                errorStatusCode: isAlreadyExists
+                    ? undefined
+                    : parsedError.status || undefined,
+                status: isAlreadyExists ? 'received' : 'failed',
+            }, true);
+            isThreadReply
+                ? this.activeThreadMessagesSubject.next([
+                    ...channel.state.threads[preview.parent_id],
+                ])
+                : this.activeChannelMessagesSubject.next([...channel.state.messages]);
+            let messages;
+            (isThreadReply ? this.activeThreadMessages$ : this.activeChannelMessages$)
+                .pipe(take(1))
+                .subscribe((m) => (messages = m));
+            const newMessage = messages[messages.length - 1];
+            return newMessage;
+        }
+    }
+    /**
+     * Jumps to the selected message inside the message list, if the message is not yet loaded, it'll load the message (and it's surroundings) from the API.
+     * @param messageId The ID of the message to be loaded, 'latest' means jump to the latest messages
+     * @param parentMessageId The ID of the parent message if we want to load a thread message
+     */
+    async jumpToMessage(messageId, parentMessageId) {
+        this.isMessageLoadingInProgress = true;
+        const activeChannel = this.activeChannelSubject.getValue();
+        try {
+            await activeChannel?.state.loadMessageIntoState(messageId, parentMessageId);
+            const messages = activeChannel?.state.messages || [];
+            this.activeChannelMessagesSubject.next([...messages]);
+            if (parentMessageId) {
+                const parentMessage = messages.find((m) => m.id === parentMessageId);
+                void this.setAsActiveParentMessage(parentMessage, 'state');
+            }
+            this.jumpToMessageSubject.next({
+                id: messageId,
+                parentId: parentMessageId,
+            });
+        }
+        catch (error) {
+            this.notificationService.addTemporaryNotification('streamChat.Message not found');
+            throw error;
+        }
+        finally {
+            this.isMessageLoadingInProgress = false;
+        }
+    }
+    /**
+     * Clears the currently selected message to jump
+     */
+    clearMessageJump() {
+        this.jumpToMessageSubject.next({ id: undefined, parentId: undefined });
+    }
+    /**
+     * Pins the given message in the channel
+     * @param message
+     */
+    async pinMessage(message) {
+        try {
+            await this.chatClientService.chatClient?.pinMessage(message);
+            this.notificationService.addTemporaryNotification('streamChat.Message pinned', 'success');
+        }
+        catch (error) {
+            this.notificationService.addTemporaryNotification('streamChat.Error pinning message');
+            throw error;
+        }
+    }
+    /**
+     * Removes the given message from pinned messages
+     * @param message
+     */
+    async unpinMessage(message) {
+        try {
+            await this.chatClientService.chatClient?.unpinMessage(message);
+            this.notificationService.addTemporaryNotification('streamChat.Message unpinned', 'success');
+        }
+        catch (error) {
+            this.notificationService.addTemporaryNotification('streamChat.Error removing message pin');
+            throw error;
+        }
+    }
+    handleNotification(clientEvent) {
+        switch (clientEvent.eventType) {
+            case 'connection.recovered': {
+                void this.ngZone.run(async () => {
+                    if (this.isStateRecoveryInProgress) {
+                        return;
+                    }
+                    this.isStateRecoveryInProgress = true;
+                    try {
+                        // If channel list is not inited, we set the active channel
+                        const shoulSetActiveChannel = this.shouldSetActiveChannel &&
+                            !this.activeChannelSubject.getValue();
+                        await this.queryChannels(shoulSetActiveChannel || false, 'recover-state');
+                        if (this.activeChannelSubject.getValue()) {
+                            // Thread messages are not refetched so active thread gets deselected to avoid displaying stale messages
+                            void this.setAsActiveParentMessage(undefined);
+                            // Update and reselect message to quote
+                            const messageToQuote = this.messageToQuoteSubject.getValue();
+                            this.setChannelState(this.activeChannelSubject.getValue());
+                            let messages;
+                            this.activeChannelMessages$
+                                .pipe(take(1))
+                                .subscribe((m) => (messages = m));
+                            const updatedMessageToQuote = messages.find((m) => m.id === messageToQuote?.id);
+                            if (updatedMessageToQuote) {
+                                this.selectMessageToQuote(updatedMessageToQuote);
+                            }
+                        }
+                        this.isStateRecoveryInProgress = false;
+                    }
+                    catch {
+                        this.isStateRecoveryInProgress = false;
+                    }
+                });
+                break;
+            }
+            case 'notification.message_new': {
+                this.ngZone.run(() => {
+                    if (this.customNewMessageNotificationHandler) {
+                        this.customNewMessageNotificationHandler(clientEvent, this.channelListSetter);
+                    }
+                    else {
+                        this.handleNewMessageNotification(clientEvent);
+                    }
+                });
+                break;
+            }
+            case 'notification.added_to_channel': {
+                this.ngZone.run(() => {
+                    if (this.customAddedToChannelNotificationHandler) {
+                        this.customAddedToChannelNotificationHandler(clientEvent, this.channelListSetter);
+                    }
+                    else {
+                        this.handleAddedToChannelNotification(clientEvent);
+                    }
+                });
+                break;
+            }
+            case 'notification.removed_from_channel': {
+                this.ngZone.run(() => {
+                    if (this.customRemovedFromChannelNotificationHandler) {
+                        this.customRemovedFromChannelNotificationHandler(clientEvent, this.channelListSetter);
+                    }
+                    else {
+                        this.handleRemovedFromChannelNotification(clientEvent);
+                    }
+                });
+                break;
+            }
+            case 'user.updated': {
+                this.ngZone.run(() => {
+                    const updatedChannels = this.channelsSubject.getValue()?.map((c) => {
+                        if (this.chatClientService.chatClient.activeChannels[c.cid]) {
+                            return this.chatClientService.chatClient.activeChannels[c.cid];
+                        }
+                        else {
+                            return c;
+                        }
+                    });
+                    this.channelsSubject.next(updatedChannels);
+                    const activeChannel = this.activeChannelSubject.getValue();
+                    if (activeChannel) {
+                        this.activeChannelSubject.next(this.chatClientService.chatClient.activeChannels[activeChannel.cid] || activeChannel);
+                        this.activeChannelMessagesSubject.next(activeChannel.state.messages.map((m) => {
+                            m.readBy = getReadBy(m, activeChannel);
+                            return { ...m };
+                        }));
+                        const activeParentMessage = this.activeParentMessageIdSubject.getValue();
+                        if (activeParentMessage) {
+                            const messages = activeChannel.state.threads[activeParentMessage];
+                            this.activeThreadMessagesSubject.next([...messages]);
+                        }
+                        this.activeChannelPinnedMessagesSubject.next([
+                            ...activeChannel.state.pinnedMessages,
+                        ]);
+                    }
+                });
+                break;
+            }
+        }
+    }
+    handleRemovedFromChannelNotification(clientEvent) {
+        const channelIdToBeRemoved = clientEvent.event.channel.cid;
+        this.removeChannel(channelIdToBeRemoved, true);
+    }
+    handleNewMessageNotification(clientEvent) {
+        if (clientEvent.event.channel) {
+            void this.addChannelFromNotification(clientEvent.event.channel);
+        }
+    }
+    handleAddedToChannelNotification(clientEvent) {
+        if (clientEvent.event.channel) {
+            void this.addChannelFromNotification(clientEvent.event.channel);
+        }
+    }
+    async addChannelFromNotification(channelResponse) {
+        const newChannel = this.chatClientService.chatClient.channel(channelResponse.type, channelResponse.id);
+        let currentChannels = this.channelsSubject.getValue() || [];
+        if (currentChannels.find((c) => c.cid === newChannel.cid)) {
+            return;
+        }
+        await newChannel.watch().catch((err) => {
+            this.chatClientService.chatClient.logger('error', 'Failed to add channel to channel list because watch request failed', err);
+        });
+        currentChannels = this.channelsSubject.getValue() || [];
+        if (currentChannels.find((c) => c.cid === newChannel.cid)) {
+            return;
+        }
+        this.watchForChannelEvents(newChannel);
+        this.channelsSubject.next([newChannel, ...currentChannels]);
+    }
+    watchForActiveChannelEvents(channel) {
+        this.activeChannelSubscriptions.push(channel.on('message.new', (event) => {
+            this.ngZone.run(() => {
+                event.message && event.message.parent_id
+                    ? event.message.parent_id ===
+                        this.activeParentMessageIdSubject.getValue()
+                        ? this.activeThreadMessagesSubject.next([
+                            ...channel.state.threads[event.message.parent_id],
+                        ])
+                        : null
+                    : this.activeChannelMessagesSubject.next([
+                        ...channel.state.messages,
+                    ]);
+                this.activeChannel$.pipe(first()).subscribe((c) => {
+                    if (c) {
+                        this.markRead(c);
+                    }
+                });
+                this.updateLatestMessages(event);
+            });
+        }));
+        this.activeChannelSubscriptions.push(channel.on('message.updated', (event) => this.messageUpdated(event)));
+        this.activeChannelSubscriptions.push(channel.on('message.deleted', (event) => this.messageUpdated(event)));
+        this.activeChannelSubscriptions.push(channel.on('reaction.new', (e) => this.messageReactionEventReceived(e)));
+        this.activeChannelSubscriptions.push(channel.on('reaction.deleted', (e) => this.messageReactionEventReceived(e)));
+        this.activeChannelSubscriptions.push(channel.on('reaction.updated', (e) => this.messageReactionEventReceived(e)));
+        this.activeChannelSubscriptions.push(channel.on('message.read', (e) => {
+            this.ngZone.run(() => {
+                let latestMessage;
+                let messages;
+                this.activeChannelMessages$.pipe(first()).subscribe((m) => {
+                    messages = m;
+                    latestMessage = messages[messages.length - 1];
+                });
+                if (!latestMessage || !e.user) {
+                    return;
+                }
+                if (latestMessage.readBy) {
+                    latestMessage.readBy.splice(0, latestMessage.readBy.length);
+                }
+                else {
+                    latestMessage.readBy = [];
+                }
+                latestMessage.readBy.push(...getReadBy(latestMessage, channel));
+                messages[messages.length - 1] = { ...latestMessage };
+                this.activeChannelMessagesSubject.next([...messages]);
+            });
+        }));
+        this.activeChannelSubscriptions.push(this.chatClientService.events$
+            .pipe(filter((e) => e.eventType === 'notification.mark_unread' &&
+            e.event.channel_id === channel.id), map((e) => e.event))
+            .subscribe((e) => {
+            this.ngZone.run(() => {
+                this.activeChannelLastReadMessageId = e.last_read_message_id;
+                this.activeChannelUnreadCount = e.unread_messages;
+                this.activeChannelSubject.next(this.activeChannel);
+            });
+        }));
+        this.activeChannelSubscriptions.push(channel.on('typing.start', (e) => this.ngZone.run(() => this.handleTypingStartEvent(e))));
+        this.activeChannelSubscriptions.push(channel.on('typing.stop', (e) => this.ngZone.run(() => this.handleTypingStopEvent(e))));
+    }
+    /**
+     * Call this method if user started typing in the active channel
+     * @param parentId The id of the parent message, if user is typing in a thread
+     */
+    async typingStarted(parentId) {
+        const activeChannel = this.activeChannelSubject.getValue();
+        await activeChannel?.keystroke(parentId);
+    }
+    /**
+     * Call this method if user stopped typing in the active channel
+     * @param parentId The id of the parent message, if user were typing in a thread
+     */
+    async typingStopped(parentId) {
+        const activeChannel = this.activeChannelSubject.getValue();
+        await activeChannel?.stopTyping(parentId);
+    }
+    /**
+     * The current list of channels
+     */
+    get channels() {
+        return this.channelsSubject.getValue() || [];
+    }
+    /**
+     * The current active channel
+     */
+    get activeChannel() {
+        return this.activeChannelSubject.getValue() || undefined;
+    }
+    /**
+     * The current active channel messages
+     */
+    get activeChannelMessages() {
+        return this.activeChannelMessagesSubject.getValue() || [];
+    }
+    /**
+     * The current thread replies
+     */
+    get activeChannelThreadReplies() {
+        return this.activeThreadMessagesSubject.getValue() || [];
+    }
+    /**
+     * Get the last 1200 reactions of a message in the current active channel. If you need to fetch more reactions please use the [following endpoint](/chat/docs/javascript/send_reaction/#paginating-reactions).
+     * @deprecated use [`messageReactionsService.queryReactions()`](/chat/docs/sdk/angular/services/MessageReactionsService/#queryreactions) instead
+     * @param messageId
+     * @returns all reactions of a message
+     */
+    async getMessageReactions(messageId) {
+        const reactions = [];
+        const limit = 300;
+        let offset = 0;
+        const reactionsLimit = ChannelService.MAX_MESSAGE_REACTIONS_TO_FETCH;
+        let lastPageSize = limit;
+        while (lastPageSize === limit && reactions.length < reactionsLimit) {
+            try {
+                const response = await this.activeChannel?.getReactions(messageId, {
+                    offset,
+                    limit,
+                });
+                lastPageSize = response?.reactions?.length || 0;
+                if (lastPageSize > 0) {
+                    reactions.push(...response.reactions);
+                }
+                offset += lastPageSize;
+            }
+            catch (e) {
+                this.notificationService.addTemporaryNotification('streamChat.Error loading reactions');
+                throw e;
+            }
+        }
+        return reactions;
+    }
+    /**
+     * Marks the channel from the given message as unread
+     * @param messageId
+     * @returns the result of the request
+     */
+    async markMessageUnread(messageId) {
+        if (!this.activeChannel) {
+            return;
+        }
+        try {
+            const response = await this.activeChannel.markUnread({
+                message_id: messageId,
+            });
+            this.areReadEventsPaused = true;
+            return response;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            const error = JSON.parse(JSON.stringify(e));
+            const data = error?.response?.data;
+            if (data &&
+                data.code === 4 &&
+                data.StatusCode === 400 &&
+                data.message?.includes('it is older than last')) {
+                const count = /\d+ channel messages/
+                    .exec(data.message)?.[0]
+                    .match(/\d+/)?.[0];
+                if (count) {
+                    this.notificationService.addTemporaryNotification('streamChat.Error, only the first {{count}} message can be marked as unread', undefined, undefined, { count });
+                    throw e;
+                }
+            }
+            this.notificationService.addTemporaryNotification('streamChat.Error marking message as unread');
+            throw e;
+        }
+    }
+    messageUpdated(event) {
+        this.ngZone.run(() => {
+            const isThreadReply = event.message && event.message.parent_id;
+            const channel = this.activeChannelSubject.getValue();
+            if (!channel) {
+                return;
+            }
+            // Get messages from state as message order could change, and message could've been deleted
+            const messages = isThreadReply
+                ? channel.state.threads[event?.message?.parent_id || '']
+                : channel.state.messages;
+            if (!messages) {
+                return;
+            }
+            const messageIndex = messages.findIndex((m) => m.id === event?.message?.id);
+            if (messageIndex !== -1 || event.type === 'message.deleted') {
+                isThreadReply
+                    ? this.activeThreadMessagesSubject.next([...messages])
+                    : this.activeChannelMessagesSubject.next([...messages]);
+                this.activeChannelPinnedMessagesSubject.next([
+                    ...channel.state.pinnedMessages,
+                ]);
+            }
+        });
+    }
+    messageReactionEventReceived(e) {
+        this.ngZone.run(() => {
+            const isThreadMessage = e.message && e.message.parent_id;
+            let messages;
+            (isThreadMessage
+                ? this.activeThreadMessages$
+                : this.activeChannelMessages$)
+                .pipe(first())
+                .subscribe((m) => (messages = m));
+            const messageIndex = messages.findIndex((m) => m.id === e?.message?.id);
+            if (messageIndex === -1) {
+                return;
+            }
+            const message = messages[messageIndex];
+            message.reaction_counts = { ...e.message?.reaction_counts };
+            message.reaction_scores = { ...e.message?.reaction_scores };
+            message.latest_reactions = [...(e.message?.latest_reactions || [])];
+            message.own_reactions = [...(e.message?.own_reactions || [])];
+            message.reaction_groups = { ...e.message?.reaction_groups };
+            messages[messageIndex] = { ...message };
+            isThreadMessage
+                ? this.activeThreadMessagesSubject.next([...messages])
+                : this.activeChannelMessagesSubject.next([...messages]);
+        });
+    }
+    formatMessage(message) {
+        const m = message;
+        m.pinned_at = message.pinned_at ? new Date(message.pinned_at) : null;
+        m.created_at = message.created_at
+            ? new Date(message.created_at)
+            : new Date();
+        m.updated_at = message.updated_at
+            ? new Date(message.updated_at)
+            : new Date();
+        message.status = message.status || 'received';
+        return m;
+    }
+    isStreamMessage(message) {
+        return 'readBy' in message;
+    }
+    isFormatMessageResponse(message) {
+        return message.created_at instanceof Date;
+    }
+    stopWatchForActiveChannelEvents(channel) {
+        if (!channel) {
+            return;
+        }
+        this.activeChannelSubscriptions.forEach((s) => s.unsubscribe());
+        this.activeChannelSubscriptions = [];
+    }
+    async queryChannels(shouldSetActiveChannel, queryType) {
+        if (!this.channelQuery) {
+            throw new Error('Query channels called before initializing ChannelQuery instance');
+        }
+        try {
+            this.channelQueryStateSubject.next({ state: 'in-progress' });
+            const { channels, hasMorePage } = await ('query' in this.channelQuery
+                ? this.channelQuery.query(queryType)
+                : this.channelQuery(queryType));
+            const filteredChannels = channels.filter((channel, index) => !channels.slice(0, index).find((c) => c.cid === channel.cid));
+            filteredChannels.forEach((c) => {
+                if (!this.channelSubscriptions[c.cid]) {
+                    this.watchForChannelEvents(c);
+                }
+            });
+            this.channelsSubject.next(filteredChannels);
+            const currentActiveChannel = this.activeChannelSubject.getValue();
+            if (currentActiveChannel &&
+                !filteredChannels.find((c) => c.cid === currentActiveChannel?.cid)) {
+                this.deselectActiveChannel();
+            }
+            else if (filteredChannels.length > 0 &&
+                !currentActiveChannel &&
+                shouldSetActiveChannel) {
+                this.setAsActiveChannel(filteredChannels[0]);
+            }
+            this.hasMoreChannelsSubject.next(hasMorePage);
+            this.channelQueryStateSubject.next({ state: 'success' });
+            this.dismissErrorNotification?.();
+            return channels;
+        }
+        catch (error) {
+            this.channelQueryStateSubject.next({
+                state: 'error',
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                error,
+            });
+            throw error;
+        }
+    }
+    watchForChannelEvents(channel) {
+        if (this.channelSubscriptions[channel.cid]) {
+            this.channelSubscriptions[channel.cid]();
+        }
+        const unsubscribe = channel.on((event) => {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+            const type = event.type;
+            switch (type) {
+                case 'message.new': {
+                    this.ngZone.run(() => {
+                        if (this.customNewMessageHandler) {
+                            this.customNewMessageHandler(event, channel, this.channelListSetter, this.messageListSetter, this.threadListSetter, this.parentMessageSetter);
+                        }
+                        else {
+                            this.handleNewMessage(event, channel);
+                        }
+                    });
+                    break;
+                }
+                case 'channel.hidden': {
+                    this.ngZone.run(() => {
+                        if (this.customChannelHiddenHandler) {
+                            this.customChannelHiddenHandler(event, channel, this.channelListSetter, this.messageListSetter, this.threadListSetter, this.parentMessageSetter);
+                        }
+                        else {
+                            this.handleChannelHidden(event);
+                        }
+                    });
+                    break;
+                }
+                case 'channel.deleted': {
+                    this.ngZone.run(() => {
+                        if (this.customChannelDeletedHandler) {
+                            this.customChannelDeletedHandler(event, channel, this.channelListSetter, this.messageListSetter, this.threadListSetter, this.parentMessageSetter);
+                        }
+                        else {
+                            this.handleChannelDeleted(event);
+                        }
+                    });
+                    break;
+                }
+                case 'channel.visible': {
+                    this.ngZone.run(() => {
+                        if (this.customChannelVisibleHandler) {
+                            this.customChannelVisibleHandler(event, channel, this.channelListSetter, this.messageListSetter, this.threadListSetter, this.parentMessageSetter);
+                        }
+                        else {
+                            this.handleChannelVisible(event, channel);
+                        }
+                    });
+                    break;
+                }
+                case 'channel.updated': {
+                    this.ngZone.run(() => {
+                        if (this.customChannelUpdatedHandler) {
+                            this.customChannelUpdatedHandler(event, channel, this.channelListSetter, this.messageListSetter, this.threadListSetter, this.parentMessageSetter);
+                        }
+                        else {
+                            this.handleChannelUpdate(event);
+                        }
+                    });
+                    break;
+                }
+                case 'channel.truncated': {
+                    this.ngZone.run(() => {
+                        if (this.customChannelTruncatedHandler) {
+                            this.customChannelTruncatedHandler(event, channel, this.channelListSetter, this.messageListSetter, this.threadListSetter, this.parentMessageSetter);
+                        }
+                        else {
+                            this.handleChannelTruncate(event);
+                        }
+                    });
+                    break;
+                }
+                case 'capabilities.changed': {
+                    this.ngZone.run(() => {
+                        const cid = event.cid;
+                        if (cid) {
+                            const currentChannels = this.channelsSubject.getValue();
+                            const index = currentChannels?.findIndex((c) => c.cid === cid);
+                            if (index !== -1 && index !== undefined) {
+                                this.channelsSubject.next([...currentChannels]);
+                                if (cid === this.activeChannelSubject.getValue()?.cid) {
+                                    this.activeChannelSubject.next(this.activeChannelSubject.getValue());
+                                }
+                            }
+                        }
+                    });
+                    break;
+                }
+            }
+        });
+        this.channelSubscriptions[channel.cid] = unsubscribe.unsubscribe;
+    }
+    handleNewMessage(_, channel) {
+        const channelIndex = this.channels.findIndex((c) => c.cid === channel.cid);
+        this.channels.splice(channelIndex, 1);
+        this.channelsSubject.next([channel, ...this.channels]);
+    }
+    handleChannelHidden(event) {
+        this.removeChannel(event.channel.cid, false);
+    }
+    handleChannelDeleted(event) {
+        this.removeChannel(event.channel.cid, false);
+    }
+    handleChannelVisible(event, channel) {
+        if (!this.channels.find((c) => c.cid === event.cid)) {
+            this.ngZone.run(() => this.channelsSubject.next([...this.channels, channel]));
+        }
+    }
+    handleChannelUpdate(event) {
+        const channelIndex = this.channels.findIndex((c) => c.cid === event.channel.cid);
+        if (channelIndex !== -1) {
+            const channel = this.channels[channelIndex];
+            const notIncludedProperies = {
+                hidden: channel.data?.hidden || false,
+                own_capabilities: channel.data?.own_capabilities || [],
+            };
+            channel.data = {
+                ...event.channel,
+                ...notIncludedProperies,
+            };
+            this.channelsSubject.next([...this.channels]);
+            if (event.channel?.cid === this.activeChannelSubject.getValue()?.cid) {
+                this.activeChannelSubject.next(channel);
+            }
+        }
+    }
+    handleChannelTruncate(event) {
+        const channelIndex = this.channels.findIndex((c) => c.cid === event.channel.cid);
+        if (channelIndex !== -1) {
+            this.channels[channelIndex].state.messages = [];
+            this.channelsSubject.next([...this.channels]);
+            if (event.channel?.cid === this.activeChannelSubject.getValue()?.cid) {
+                const channel = this.activeChannelSubject.getValue();
+                channel.state.messages = [];
+                this.activeChannelSubject.next(channel);
+                this.activeChannelMessagesSubject.next([]);
+                this.activeParentMessageIdSubject.next(undefined);
+                this.activeThreadMessagesSubject.next([]);
+            }
+        }
+    }
+    get canSendReadEvents() {
+        const channel = this.activeChannelSubject.getValue();
+        if (!channel) {
+            return false;
+        }
+        const capabilites = channel.data?.own_capabilities;
+        return capabilites.indexOf('read-events') !== -1;
+    }
+    transformToStreamMessage(message, channel) {
+        const isThreadMessage = !!message.parent_id;
+        if (this.isStreamMessage(message) &&
+            this.isFormatMessageResponse(message)) {
+            if (message.quoted_message) {
+                message.quoted_message.translation = getMessageTranslation(message.quoted_message, channel, this.chatClientService.chatClient.user);
+            }
+            message.translation = getMessageTranslation(message, channel, this.chatClientService.chatClient.user);
+            return message;
+        }
+        else {
+            if (message.quoted_message) {
+                message.quoted_message.translation =
+                    getMessageTranslation(message.quoted_message, channel, this.chatClientService.chatClient.user);
+            }
+            if (this.isFormatMessageResponse(message)) {
+                message.readBy = isThreadMessage
+                    ? []
+                    : channel
+                        ? getReadBy(message, channel)
+                        : [];
+                message.translation = getMessageTranslation(message, channel, this.chatClientService.chatClient.user);
+                return message;
+            }
+            else {
+                message = this.formatMessage(message);
+                message.readBy = isThreadMessage
+                    ? []
+                    : channel
+                        ? getReadBy(message, channel)
+                        : [];
+                message.translation = getMessageTranslation(message, channel, this.chatClientService.chatClient.user);
+                return message;
+            }
+        }
+    }
+    handleTypingStartEvent(event) {
+        if (event.user?.id === this.chatClientService.chatClient.user?.id) {
+            return;
+        }
+        const isTypingInThread = !!event.parent_id;
+        if (isTypingInThread &&
+            event.parent_id !== this.activeParentMessageIdSubject.getValue()) {
+            return;
+        }
+        const subject = isTypingInThread
+            ? this.usersTypingInThreadSubject
+            : this.usersTypingInChannelSubject;
+        const users = subject.getValue();
+        const user = event.user;
+        if (user && !users.find((u) => u.id === user.id)) {
+            users.push(user);
+            subject.next([...users]);
+        }
+    }
+    handleTypingStopEvent(event) {
+        const usersTypingInChannel = this.usersTypingInChannelSubject.getValue();
+        const usersTypingInThread = this.usersTypingInThreadSubject.getValue();
+        const user = event.user;
+        if (user && usersTypingInChannel.find((u) => u.id === user.id)) {
+            usersTypingInChannel.splice(usersTypingInChannel.findIndex((u) => u.id === user.id), 1);
+            this.usersTypingInChannelSubject.next([...usersTypingInChannel]);
+            return;
+        }
+        if (user && usersTypingInThread.find((u) => u.id === user.id)) {
+            usersTypingInThread.splice(usersTypingInThread.findIndex((u) => u.id === user.id), 1);
+            this.usersTypingInThreadSubject.next([...usersTypingInThread]);
+            return;
+        }
+    }
+    updateLatestMessages(event) {
+        if (event.message?.user?.id !== this.chatClientService?.chatClient.user?.id) {
+            return;
+        }
+        const latestMessages = this.latestMessageDateByUserByChannelsSubject.getValue();
+        if (!event.message?.created_at) {
+            return;
+        }
+        const channelId = event?.message?.cid;
+        if (!channelId) {
+            return;
+        }
+        const messageDate = new Date(event.message.created_at);
+        if (!latestMessages[channelId] ||
+            latestMessages[channelId]?.getTime() < messageDate.getTime()) {
+            latestMessages[channelId] = messageDate;
+            this.latestMessageDateByUserByChannelsSubject.next({
+                ...latestMessages,
+            });
+        }
+    }
+    setChannelState(channel) {
+        channel.state.messages.forEach((m) => {
+            m.readBy = getReadBy(m, channel);
+            m.translation = getMessageTranslation(m, channel, this.chatClientService.chatClient.user);
+            if (m.quoted_message) {
+                m.quoted_message.translation =
+                    getMessageTranslation(m.quoted_message, channel, this.chatClientService.chatClient.user);
+            }
+        });
+        this.markRead(channel);
+        this.activeChannelMessagesSubject.next([...channel.state.messages]);
+        this.activeChannelPinnedMessagesSubject.next([
+            ...channel.state.pinnedMessages,
+        ]);
+        this.activeParentMessageIdSubject.next(undefined);
+        this.activeThreadMessagesSubject.next([]);
+        this.messageToQuoteSubject.next(undefined);
+        this.usersTypingInChannelSubject.next([]);
+        this.usersTypingInThreadSubject.next([]);
+    }
+    markRead(channel, isThrottled = true) {
+        if (this.canSendReadEvents &&
+            this.shouldMarkActiveChannelAsRead &&
+            !this.areReadEventsPaused) {
+            if (isThrottled) {
+                this.markReadThrottled(channel);
+            }
+            else {
+                void channel.markRead();
+            }
+        }
+    }
+    markReadThrottled(channel) {
+        if (!this.markReadTimeout) {
+            this.markRead(channel, false);
+            this.markReadTimeout = setTimeout(() => {
+                this.flushMarkReadQueue();
+            }, this.markReadThrottleTime);
+        }
+        else {
+            clearTimeout(this.markReadTimeout);
+            this.scheduledMarkReadRequest = () => this.markRead(channel, false);
+            this.markReadTimeout = setTimeout(() => {
+                this.flushMarkReadQueue();
+            }, this.markReadThrottleTime);
+        }
+    }
+    flushMarkReadQueue() {
+        this.scheduledMarkReadRequest?.();
+        this.scheduledMarkReadRequest = undefined;
+        clearTimeout(this.markReadTimeout);
+        this.markReadTimeout = undefined;
+    }
+    async _init(settings) {
+        this.shouldSetActiveChannel = settings.shouldSetActiveChannel;
+        this.messagePageSize = settings.messagePageSize;
+        this.clientEventsSubscription = this.chatClientService.events$.subscribe((notification) => void this.handleNotification(notification));
+        try {
+            const result = await this.queryChannels(this.shouldSetActiveChannel, 'first-page');
+            return result;
+        }
+        catch (error) {
+            this.dismissErrorNotification =
+                this.notificationService.addPermanentNotification('streamChat.Error loading channels', 'error');
+            throw error;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChannelService, deps: [{ token: i1.ChatClientService }, { token: i0.NgZone }, { token: i2.NotificationService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChannelService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChannelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ChatClientService }, { type: i0.NgZone }, { type: i2.NotificationService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"channel.service.js","sourceRoot":"","sources":["../../../../projects/stream-chat-angular/src/lib/channel.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  Observable,\n  ReplaySubject,\n  Subscription,\n} from 'rxjs';\nimport { filter, first, map, shareReplay, take } from 'rxjs/operators';\nimport {\n  Attachment,\n  Channel,\n  ChannelFilters,\n  ChannelOptions,\n  ChannelResponse,\n  ChannelSort,\n  CustomMessageData,\n  CustomReactionData,\n  Event,\n  EventTypes,\n  FormatMessageResponse,\n  LocalMessage,\n  MemberFilters,\n  Message,\n  MessageResponse,\n  ReactionResponse,\n  UserResponse,\n} from 'stream-chat';\nimport { ChatClientService, ClientEvent } from './chat-client.service';\nimport { getMessageTranslation } from './get-message-translation';\nimport { createMessagePreview } from './message-preview';\nimport { NotificationService } from './notification.service';\nimport { getReadBy } from './read-by';\nimport {\n  AttachmentUpload,\n  AttachmentUploadErrorReason,\n  ChannelQueryResult,\n  ChannelQueryState,\n  ChannelQueryType,\n  MessageInput,\n  MessageReactionType,\n  NextPageConfiguration,\n  StreamMessage,\n} from './types';\nimport { ChannelQuery } from './channel-query';\n\n/**\n * The `ChannelService` provides data and interaction for the channel list and message list.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ChannelService {\n  /**\n   * Emits `false` if there are no more pages of channels that can be loaded.\n   */\n  hasMoreChannels$: Observable<boolean>;\n  /**\n   * Emits the currently loaded and [watched](/chat/docs/javascript/watch_channel/) channel list.\n   *\n   * :::important\n   * If you want to subscribe to channel events, you need to manually reenter Angular's change detection zone, our [Change detection guide](/chat/docs/sdk/angular/concepts/change-detection/) explains this in detail.\n   * :::\n   */\n  channels$: Observable<Channel[] | undefined>;\n  /**\n   * The result of the latest channel query request.\n   */\n  channelQueryState$: Observable<ChannelQueryState | undefined>;\n  /**\n   * Emits the currently active channel.\n   *\n   * :::important\n   * If you want to subscribe to channel events, you need to manually reenter Angular's change detection zone, our [Change detection guide](/chat/docs/sdk/angular/concepts/change-detection/) explains this in detail.\n   * :::\n   *\n   * The active channel will always be marked as read when a new message is received\n   */\n  activeChannel$: Observable<Channel | undefined>;\n  /**\n   * Emits the list of currently loaded messages of the active channel.\n   */\n  activeChannelMessages$: Observable<StreamMessage[]>;\n  /**\n   * Emits the list of pinned messages of the active channel.\n   */\n  activeChannelPinnedMessages$: Observable<StreamMessage[]>;\n  /**\n   * Emits the id of the currently selected parent message. If no message is selected, it emits undefined.\n   */\n  activeParentMessageId$: Observable<string | undefined>;\n  /**\n   * Emits the list of currently loaded thread replies belonging to the selected parent message. If there is no currently active thread it emits an empty array.\n   */\n  activeThreadMessages$: Observable<StreamMessage[]>;\n  /**\n   * Emits the currently selected parent message. If no message is selected, it emits undefined.\n   */\n  activeParentMessage$: Observable<StreamMessage | undefined>;\n  /**\n   * Emits the currently selected message to quote\n   */\n  messageToQuote$: Observable<StreamMessage | undefined>;\n  /**\n   * Emits the ID of the message the message list should jump to (can be a channel message or thread message)\n   */\n  jumpToMessage$: Observable<{ id?: string; parentId?: string }>;\n  /**\n   * Emits the list of users that are currently typing in the channel (current user is not included)\n   */\n  usersTypingInChannel$: Observable<UserResponse[]>;\n  /**\n   * Emits the list of users that are currently typing in the active thread (current user is not included)\n   */\n  usersTypingInThread$: Observable<UserResponse[]>;\n  /**\n   * Emits a map that contains the date of the latest message sent by the current user by channels (this is used to detect if slow mode countdown should be started)\n   */\n  latestMessageDateByUserByChannels$: Observable<{ [key: string]: Date }>;\n  /**\n   * If you're using [semantic filters for moderation](/moderation/docs/) you can set up rules for bouncing messages.\n   *\n   * If a message is bounced, it will be emitted via this `Observable`. The built-in [`MessageBouncePrompt` component](/chat/docs/sdk/angular/components/MessageBouncePromptComponent/) will display the bounce option to the user if a bounced message is clicked.\n   */\n  bouncedMessage$: BehaviorSubject<StreamMessage | undefined>;\n  /**\n   * The last read message id of the active channel, it's used by the message list component to display unread UI, and jump to latest read message\n   *\n   * This property isn't always updated, please use `channel.read` to display up-to-date read information\n   */\n  activeChannelLastReadMessageId?: string;\n  /**\n   * The unread count of the active channel, it's used by the message list component to display unread UI\n   *\n   * This property isn't always updated, please use `channel.read` to display up-to-date read information\n   */\n  activeChannelUnreadCount?: number;\n  /**\n   * Custom event handler to call if a new message received from a channel that is not being watched, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/)\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customNewMessageNotificationHandler?: (\n    clientEvent: ClientEvent,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void\n  ) => void;\n  /**\n   * Custom event handler to call when the user is added to a channel, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customAddedToChannelNotificationHandler?: (\n    clientEvent: ClientEvent,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void\n  ) => void;\n  /**\n   * Custom event handler to call when the user is removed from a channel, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customRemovedFromChannelNotificationHandler?: (\n    clientEvent: ClientEvent,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void\n  ) => void;\n  /**\n   * Custom event handler to call when a channel is deleted, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customChannelDeletedHandler?: (\n    event: Event,\n    channel: Channel,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void,\n    messageListSetter: (messages: StreamMessage[]) => void,\n    threadListSetter: (messages: StreamMessage[]) => void,\n    parentMessageSetter: (message: StreamMessage | undefined) => void\n  ) => void;\n  /**\n   * Custom event handler to call when a channel is updated, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customChannelUpdatedHandler?: (\n    event: Event,\n    channel: Channel,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void,\n    messageListSetter: (messages: StreamMessage[]) => void,\n    threadListSetter: (messages: StreamMessage[]) => void,\n    parentMessageSetter: (message: StreamMessage | undefined) => void\n  ) => void;\n  /**\n   * Custom event handler to call when a channel is truncated, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customChannelTruncatedHandler?: (\n    event: Event,\n    channel: Channel,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void,\n    messageListSetter: (messages: StreamMessage[]) => void,\n    threadListSetter: (messages: StreamMessage[]) => void,\n    parentMessageSetter: (message: StreamMessage | undefined) => void\n  ) => void;\n  /**\n   * Custom event handler to call when a channel becomes hidden, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customChannelHiddenHandler?: (\n    event: Event,\n    channel: Channel,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void,\n    messageListSetter: (messages: StreamMessage[]) => void,\n    threadListSetter: (messages: StreamMessage[]) => void,\n    parentMessageSetter: (message: StreamMessage | undefined) => void\n  ) => void;\n  /**\n   * Custom event handler to call when a channel becomes visible, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customChannelVisibleHandler?: (\n    event: Event,\n    channel: Channel,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void,\n    messageListSetter: (messages: StreamMessage[]) => void,\n    threadListSetter: (messages: StreamMessage[]) => void,\n    parentMessageSetter: (message: StreamMessage | undefined) => void\n  ) => void;\n  /**\n   * Custom event handler to call if a new message received from a channel that is being watched, provide an event handler if you want to override the [default channel list ordering](/chat/docs/sdk/angular/services/ChannelService/#channels/).\n   *\n   * If you're adding a new channel, make sure that it's a [watched](/chat/docs/javascript/watch_channel/) channel.\n   */\n  customNewMessageHandler?: (\n    event: Event,\n    channel: Channel,\n    channelListSetter: (\n      channels: Channel[],\n      shouldStopWatchingRemovedChannels?: boolean\n    ) => void,\n    messageListSetter: (messages: StreamMessage[]) => void,\n    threadListSetter: (messages: StreamMessage[]) => void,\n    parentMessageSetter: (message: StreamMessage | undefined) => void\n  ) => void;\n  /**\n   * You can override the default file upload request - you can use this to upload files to your own CDN\n   */\n  customFileUploadRequest?: (\n    file: File,\n    channel: Channel\n  ) => Promise<{ file: string }>;\n  /**\n   * You can override the default image upload request - you can use this to upload images to your own CDN\n   */\n  customImageUploadRequest?: (\n    file: File,\n    channel: Channel\n  ) => Promise<{ file: string }>;\n  /**\n   * You can override the default file delete request - override this if you use your own CDN\n   */\n  customFileDeleteRequest?: (url: string, channel: Channel) => Promise<void>;\n  /**\n   * You can override the default image delete request - override this if you use your own CDN\n   */\n  customImageDeleteRequest?: (url: string, channel: Channel) => Promise<void>;\n  /**\n   * The provided method will be called before deleting a message. If the returned Promise resolves to `true` to deletion will go ahead. If `false` is returned, the message won't be deleted.\n   */\n  messageDeleteConfirmationHandler?: (\n    message: StreamMessage\n  ) => Promise<boolean>;\n  /**\n   * The provided method will be called before a new message is sent to Stream's API. You can use this hook to tranfrom or enrich the message being sent.\n   */\n  beforeSendMessage?: (\n    input: MessageInput\n  ) => MessageInput | Promise<MessageInput>;\n  /**\n   * The provided method will be called before a message is sent to Stream's API for update. You can use this hook to tranfrom or enrich the message being updated.\n   */\n  beforeUpdateMessage?: (\n    message: StreamMessage\n  ) => StreamMessage | Promise<StreamMessage>;\n  /**\n   * Since switching channels changes the state of multiple obserables, this observable can be used to check if all observables are updated.\n   * - `end` means all observables are in stable state\n   * - `start` means all observables are in unstable state\n   */\n  channelSwitchState$: Observable<'start' | 'end'>;\n  /**\n   * @internal\n   */\n  static readonly MAX_MESSAGE_REACTIONS_TO_FETCH = 1200;\n  /**\n   * @internal\n   */\n  isMessageLoadingInProgress = false;\n  messagePageSize = 25;\n  private channelsSubject = new BehaviorSubject<Channel[] | undefined>(\n    undefined\n  );\n  private activeChannelSubject = new BehaviorSubject<Channel | undefined>(\n    undefined\n  );\n  private activeChannelMessagesSubject = new BehaviorSubject<\n    (StreamMessage | MessageResponse | FormatMessageResponse)[]\n  >([]);\n  private activeChannelPinnedMessagesSubject = new BehaviorSubject<\n    StreamMessage[]\n  >([]);\n  private hasMoreChannelsSubject = new ReplaySubject<boolean>(1);\n  private activeChannelSubscriptions: { unsubscribe: () => void }[] = [];\n  private channelSubscriptions: { [key: string]: () => void } = {};\n  private activeParentMessageIdSubject = new BehaviorSubject<\n    string | undefined\n  >(undefined);\n  private activeThreadMessagesSubject = new BehaviorSubject<\n    (StreamMessage | MessageResponse | FormatMessageResponse)[]\n  >([]);\n  private jumpToMessageSubject = new BehaviorSubject<{\n    id?: string;\n    parentId?: string;\n  }>({ id: undefined, parentId: undefined });\n  private latestMessageDateByUserByChannelsSubject = new BehaviorSubject<{\n    [key: string]: Date;\n  }>({});\n  private readonly attachmentMaxSizeFallbackInMB = 100;\n  private messageToQuoteSubject = new BehaviorSubject<\n    StreamMessage | undefined\n  >(undefined);\n  private usersTypingInChannelSubject = new BehaviorSubject<UserResponse[]>([]);\n  private usersTypingInThreadSubject = new BehaviorSubject<UserResponse[]>([]);\n  private _shouldMarkActiveChannelAsRead = true;\n  private shouldSetActiveChannel: boolean | undefined;\n  private clientEventsSubscription: Subscription | undefined;\n  private isStateRecoveryInProgress = false;\n  private channelQueryStateSubject = new BehaviorSubject<\n    ChannelQueryState | undefined\n  >(undefined);\n  private channelSwitchStateSubject = new BehaviorSubject<'start' | 'end'>(\n    'end'\n  );\n  private channelQuery?:\n    | ChannelQuery\n    | ((queryType: ChannelQueryType) => Promise<ChannelQueryResult>);\n  private _customPaginator:\n    | ((channelQueryResult: Channel[]) => NextPageConfiguration)\n    | undefined;\n\n  private channelListSetter = (\n    channels: Channel[],\n    shouldStopWatchingRemovedChannels = true\n  ) => {\n    const currentChannels = this.channelsSubject.getValue() || [];\n    const deletedChannels = currentChannels.filter(\n      (c) => !channels?.find((channel) => channel.cid === c.cid)\n    );\n\n    for (let i = 0; i < channels.length; i++) {\n      const channel = channels[i];\n      if (!this.channelSubscriptions[channel.cid]) {\n        this.watchForChannelEvents(channel);\n      }\n      if (deletedChannels.includes(channel)) {\n        if (shouldStopWatchingRemovedChannels) {\n          if (this.channelSubscriptions[channel.cid]) {\n            this.channelSubscriptions[channel.cid]();\n            delete this.channelSubscriptions.cid;\n          }\n          void this.chatClientService.chatClient.activeChannels[channel.cid]\n            ?.stopWatching()\n            .catch((err) =>\n              this.chatClientService.chatClient.logger(\n                'warn',\n                'Failed to unwatch channel',\n                err as Record<string, unknown>\n              )\n            );\n        }\n      }\n    }\n    const nextChannels = channels;\n    this.channelsSubject.next(nextChannels);\n    if (\n      !nextChannels.find(\n        (c) => c.cid === this.activeChannelSubject.getValue()?.cid\n      )\n    ) {\n      if (nextChannels.length > 0) {\n        this.setAsActiveChannel(nextChannels[0]);\n      } else {\n        this.activeChannelSubject.next(undefined);\n      }\n    }\n  };\n\n  private messageListSetter = (messages: StreamMessage[]) => {\n    this.activeChannelMessagesSubject.next(messages);\n  };\n\n  private threadListSetter = (messages: StreamMessage[]) => {\n    this.activeThreadMessagesSubject.next(messages);\n  };\n\n  private parentMessageSetter = (message: StreamMessage | undefined) => {\n    this.activeParentMessageIdSubject.next(message?.id);\n  };\n  private dismissErrorNotification?: () => void;\n  private areReadEventsPaused = false;\n  private markReadThrottleTime = 1050;\n  private markReadTimeout?: ReturnType<typeof setTimeout>;\n  private scheduledMarkReadRequest?: () => void;\n\n  constructor(\n    private chatClientService: ChatClientService,\n    private ngZone: NgZone,\n    private notificationService: NotificationService\n  ) {\n    this.channels$ = this.channelsSubject.asObservable().pipe(shareReplay(1));\n    this.activeChannel$ = this.activeChannelSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.activeChannelMessages$ = this.activeChannelMessagesSubject.pipe(\n      map((messages) => {\n        const channel = this.activeChannelSubject.getValue()!;\n        return messages.map((message) =>\n          this.transformToStreamMessage(message, channel)\n        );\n      }),\n      shareReplay(1)\n    );\n    this.bouncedMessage$ = new BehaviorSubject<StreamMessage | undefined>(\n      undefined\n    );\n    this.hasMoreChannels$ = this.hasMoreChannelsSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.activeParentMessageId$ = this.activeParentMessageIdSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.activeThreadMessages$ = this.activeThreadMessagesSubject.pipe(\n      map((messages) => {\n        const channel = this.activeChannelSubject.getValue()!;\n        return messages.map((message) =>\n          this.transformToStreamMessage(message, channel)\n        );\n      }),\n      shareReplay(1)\n    );\n    this.activeParentMessage$ = combineLatest([\n      this.activeChannelMessages$,\n      this.activeParentMessageId$,\n    ]).pipe(\n      map(\n        ([messages, parentMessageId]: [\n          StreamMessage[],\n          string | undefined\n        ]) => {\n          if (!parentMessageId) {\n            return undefined;\n          } else {\n            const message = messages.find((m) => m.id === parentMessageId);\n            if (!message) {\n              void this.setAsActiveParentMessage(undefined);\n              return undefined;\n            } else {\n              return message;\n            }\n          }\n        }\n      ),\n      shareReplay(1)\n    );\n    this.messageToQuote$ = this.messageToQuoteSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.jumpToMessage$ = this.jumpToMessageSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n\n    this.usersTypingInChannel$ = this.usersTypingInChannelSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.usersTypingInThread$ = this.usersTypingInThreadSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.latestMessageDateByUserByChannels$ =\n      this.latestMessageDateByUserByChannelsSubject\n        .asObservable()\n        .pipe(shareReplay(1));\n    this.activeChannelPinnedMessages$ = this.activeChannelPinnedMessagesSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.channelQueryState$ = this.channelQueryStateSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n    this.channelSwitchState$ = this.channelSwitchStateSubject\n      .asObservable()\n      .pipe(shareReplay(1));\n  }\n\n  /**\n   * If set to false, read events won't be sent as new messages are received. If set to true active channel (if any) will immediately be marked as read.\n   */\n  get shouldMarkActiveChannelAsRead() {\n    return this._shouldMarkActiveChannelAsRead;\n  }\n\n  /**\n   * If set to false, read events won't be sent as new messages are received. If set to true active channel (if any) will immediately be marked as read.\n   */\n  set shouldMarkActiveChannelAsRead(shouldMarkActiveChannelAsRead: boolean) {\n    if (!this._shouldMarkActiveChannelAsRead && shouldMarkActiveChannelAsRead) {\n      const activeChannel = this.activeChannelSubject.getValue();\n      if (activeChannel && this.canSendReadEvents) {\n        void activeChannel.markRead();\n      }\n    }\n    this._shouldMarkActiveChannelAsRead = shouldMarkActiveChannelAsRead;\n  }\n\n  /**\n   * By default the SDK uses an offset based pagination, you can change/extend this by providing your own custom paginator method.\n   *\n   * The method will be called with the result of the latest channel query.\n   *\n   * You can return either an offset, or a filter using the [`$lte`/`$gte` operator](/chat/docs/javascript/query_syntax_operators/). If you return a filter, it will be merged with the filter provided for the `init` method.\n   */\n  set customPaginator(\n    paginator:\n      | ((channelQueryResult: Channel[]) => NextPageConfiguration)\n      | undefined\n  ) {\n    this._customPaginator = paginator;\n    if (this.channelQuery && 'customPaginator' in this.channelQuery) {\n      this.channelQuery.customPaginator = this._customPaginator;\n    }\n  }\n\n  /**\n   * Sets the given `channel` as active and marks it as read.\n   * If the channel wasn't previously part of the channel, it will be added to the beginning of the list.\n   * @param channel\n   */\n  setAsActiveChannel(channel: Channel) {\n    this.channelSwitchStateSubject.next('start');\n    const prevActiveChannel = this.activeChannelSubject.getValue();\n    if (prevActiveChannel?.cid === channel.cid) {\n      return;\n    }\n    this.stopWatchForActiveChannelEvents(prevActiveChannel);\n    this.flushMarkReadQueue();\n    this.areReadEventsPaused = false;\n    this.isMessageLoadingInProgress = false;\n    const readState =\n      channel.state.read[this.chatClientService.chatClient.user?.id || ''];\n    this.activeChannelLastReadMessageId = readState?.last_read_message_id;\n    if (\n      channel.state.latestMessages[channel.state.latestMessages.length - 1]\n        ?.id === this.activeChannelLastReadMessageId\n    ) {\n      this.activeChannelLastReadMessageId = undefined;\n    }\n    this.activeChannelUnreadCount = readState?.unread_messages || 0;\n    this.watchForActiveChannelEvents(channel);\n    this.addChannel(channel);\n    this.activeChannelSubject.next(channel);\n    const channelStateLength = channel.state.latestMessages.length;\n    if (channelStateLength > 2 * this.messagePageSize) {\n      channel.state.latestMessages = channel.state.latestMessages.slice(\n        channelStateLength - 2 * this.messagePageSize\n      );\n    }\n    this.setChannelState(channel);\n    this.channelSwitchStateSubject.next('end');\n  }\n\n  /**\n   * Deselects the currently active (if any) channel\n   */\n  deselectActiveChannel() {\n    this.channelSwitchStateSubject.next('start');\n    const activeChannel = this.activeChannelSubject.getValue();\n    if (!activeChannel) {\n      return;\n    }\n    this.stopWatchForActiveChannelEvents(activeChannel);\n    this.flushMarkReadQueue();\n    this.activeChannelMessagesSubject.next([]);\n    this.activeChannelSubject.next(undefined);\n    this.activeParentMessageIdSubject.next(undefined);\n    this.activeThreadMessagesSubject.next([]);\n    this.latestMessageDateByUserByChannelsSubject.next({});\n    this.selectMessageToQuote(undefined);\n    this.jumpToMessageSubject.next({ id: undefined, parentId: undefined });\n    this.activeChannelPinnedMessagesSubject.next([]);\n    this.usersTypingInChannelSubject.next([]);\n    this.usersTypingInThreadSubject.next([]);\n    this.activeChannelLastReadMessageId = undefined;\n    this.activeChannelUnreadCount = undefined;\n    this.areReadEventsPaused = false;\n    this.isMessageLoadingInProgress = false;\n    this.channelSwitchStateSubject.next('end');\n  }\n\n  /**\n   * Sets the given `message` as an active parent message. If `undefined` is provided, it will deleselect the current parent message.\n   * @param message\n   * @param loadMessagesForm\n   */\n  async setAsActiveParentMessage(\n    message: StreamMessage | undefined,\n    loadMessagesForm: 'request' | 'state' = 'request'\n  ) {\n    const messageToQuote = this.messageToQuoteSubject.getValue();\n    if (messageToQuote && !!messageToQuote.parent_id) {\n      this.messageToQuoteSubject.next(undefined);\n    }\n    if (!message) {\n      this.activeParentMessageIdSubject.next(undefined);\n      this.activeThreadMessagesSubject.next([]);\n      const messageToJumpTo = this.jumpToMessageSubject.getValue();\n      if (messageToJumpTo && !!messageToJumpTo.parentId) {\n        this.jumpToMessageSubject.next({ id: undefined, parentId: undefined });\n      }\n    } else {\n      this.activeParentMessageIdSubject.next(message.id);\n      const activeChannel = this.activeChannelSubject.getValue();\n      if (loadMessagesForm === 'request') {\n        const result = await activeChannel?.getReplies(message.id, {\n          limit: this.messagePageSize,\n        });\n        this.activeThreadMessagesSubject.next(result?.messages || []);\n      } else {\n        this.activeThreadMessagesSubject.next(\n          activeChannel?.state.threads[message.id] || []\n        );\n      }\n    }\n  }\n\n  /**\n   * Loads the next page of messages of the active channel. The page size can be set in the [query option](/chat/docs/javascript/query_channels/#query-options) object.\n   * @param direction\n   */\n  loadMoreMessages(direction: 'older' | 'newer' = 'older') {\n    const activeChnannel = this.activeChannelSubject.getValue();\n    const messages = this.activeChannelMessagesSubject.getValue();\n    const lastMessageId =\n      messages[direction === 'older' ? 0 : messages.length - 1]?.id;\n    if (\n      direction === 'newer' &&\n      activeChnannel?.state?.latestMessages === activeChnannel?.state?.messages\n    ) {\n      // If we are on latest message set, activeChannelMessages$ will be refreshed by WS events, no need for a request\n      return false;\n    }\n    return activeChnannel\n      ?.query({\n        messages: {\n          limit: this.messagePageSize,\n          [direction === 'older' ? 'id_lt' : 'id_gt']: lastMessageId,\n        },\n        members: { limit: 0 },\n        watchers: { limit: 0 },\n      })\n      .then((res) => {\n        if (\n          activeChnannel?.data?.id ===\n          this.activeChannelSubject.getValue()?.data?.id\n        ) {\n          this.activeChannelMessagesSubject.next([\n            ...activeChnannel.state.messages,\n          ]);\n        }\n\n        return res;\n      });\n  }\n\n  /**\n   * Loads the next page of messages of the active thread. The page size can be set in the [query option](/chat/docs/javascript/query_channels/#query-options) object.\n   * @param direction\n   */\n  loadMoreThreadReplies(direction: 'older' | 'newer' = 'older') {\n    if (direction === 'newer') {\n      // Thread replies aren't broke into different message sets, activeThreadMessages$ will be refreshed by WS events, no need for a request\n      return false;\n    }\n    const activeChnannel = this.activeChannelSubject.getValue();\n    const parentMessageId = this.activeParentMessageIdSubject.getValue();\n    if (!parentMessageId || !activeChnannel) {\n      return false;\n    }\n    const threadMessages = this.activeThreadMessagesSubject.getValue();\n    const lastMessageId =\n      threadMessages[direction === 'older' ? 0 : threadMessages.length - 1]?.id;\n    return activeChnannel\n      .getReplies(parentMessageId, {\n        limit: this.messagePageSize,\n        [direction === 'older' ? 'id_lt' : 'id_gt']: lastMessageId,\n      })\n      .then(() => {\n        this.activeThreadMessagesSubject.next(\n          activeChnannel?.state.threads[parentMessageId] || []\n        );\n      });\n  }\n\n  /**\n   * Queries the channels with the given filters, sorts and options. More info about [channel querying](/chat/docs/javascript/query_channels/) can be found in the platform documentation. By default the first channel in the list will be set as active channel and will be marked as read.\n   * @param filters\n   * @param sort\n   * @param options\n   * @param shouldSetActiveChannel Decides if the first channel in the result should be made as an active channel or not.\n   * @returns the list of channels found by the query\n   */\n  init(\n    filters: ChannelFilters,\n    sort?: ChannelSort,\n    options?: ChannelOptions,\n    shouldSetActiveChannel: boolean = true\n  ) {\n    this.channelQuery = new ChannelQuery(\n      this.chatClientService,\n      this,\n      filters,\n      sort || { last_message_at: -1 },\n      {\n        limit: 25,\n        state: true,\n        presence: true,\n        watch: true,\n        message_limit: this.messagePageSize,\n        ...options,\n      }\n    );\n    this.channelQuery.customPaginator = this._customPaginator;\n\n    return this._init({\n      shouldSetActiveChannel,\n      messagePageSize: options?.message_limit ?? this.messagePageSize,\n    });\n  }\n\n  /**\n   * Queries the channels with the given query function. More info about [channel querying](/chat/docs/javascript/query_channels/) can be found in the platform documentation.\n   * @param query\n   * @param options\n   * @param options.shouldSetActiveChannel The `shouldSetActiveChannel` specifies if the first channel in the result should be selected as the active channel or not. Default is `true`.\n   * @param options.messagePageSize How many messages should we load? The default is 25\n   * @returns the channels that were loaded\n   */\n  initWithCustomQuery(\n    query: (queryType: ChannelQueryType) => Promise<ChannelQueryResult>,\n    options: { shouldSetActiveChannel: boolean; messagePageSize: number } = {\n      shouldSetActiveChannel: true,\n      messagePageSize: this.messagePageSize,\n    }\n  ) {\n    this.channelQuery = query;\n    return this._init(options);\n  }\n\n  /**\n   * Resets the `activeChannel$`, `channels$` and `activeChannelMessages$` Observables. Useful when disconnecting a chat user, use in combination with [`disconnectUser`](/chat/docs/sdk/angular/services/ChatClientService/#disconnectuser/).\n   */\n  reset() {\n    this.deselectActiveChannel();\n    this.channelsSubject.next(undefined);\n    this.channelQueryStateSubject.next(undefined);\n    this.clientEventsSubscription?.unsubscribe();\n    this.dismissErrorNotification?.();\n    this.dismissErrorNotification = undefined;\n    Object.keys(this.channelSubscriptions).forEach((cid) => {\n      this.channelSubscriptions[cid]();\n    });\n    this.channelSubscriptions = {};\n  }\n\n  /**\n   * Loads the next page of channels. The page size can be set in the [query option](/chat/docs/javascript/query_channels/#query-options) object.\n   */\n  async loadMoreChannels() {\n    await this.queryChannels(false, 'next-page');\n  }\n\n  /**\n   * Adds a reaction to a message.\n   * @param messageId The id of the message to add the reaction to\n   * @param reactionType The type of the reaction\n   * @param customData\n   */\n  async addReaction(\n    messageId: string,\n    reactionType: MessageReactionType,\n    customData?: CustomReactionData\n  ) {\n    await this.activeChannelSubject.getValue()?.sendReaction(messageId, {\n      type: reactionType,\n      ...customData,\n    });\n  }\n\n  /**\n   * Removes a reaction from a message.\n   * @param messageId The id of the message to remove the reaction from\n   * @param reactionType Thr type of reaction to remove\n   */\n  async removeReaction(messageId: string, reactionType: MessageReactionType) {\n    await this.activeChannelSubject\n      .getValue()\n      ?.deleteReaction(messageId, reactionType);\n  }\n\n  /**\n   * Sends a message to the active channel. The message is immediately added to the message list, if an error occurs and the message can't be sent, the error is indicated in `state` of the message.\n   * @param text The text of the message\n   * @param attachments The attachments\n   * @param mentionedUsers Mentioned users\n   * @param parentId Id of the parent message (if sending a thread reply)\n   * @param quotedMessageId Id of the message to quote (if sending a quote reply)\n   * @param customData\n   * @param pollId Id of the poll (if sending a poll message)\n   */\n  async sendMessage(\n    text: string,\n    attachments: Attachment[] = [],\n    mentionedUsers: UserResponse[] = [],\n    parentId: string | undefined = undefined,\n    quotedMessageId: string | undefined = undefined,\n    customData: undefined | CustomMessageData = undefined,\n    pollId: string | undefined = undefined\n  ) {\n    let input: MessageInput = {\n      text,\n      attachments,\n      mentionedUsers,\n      parentId,\n      quotedMessageId,\n      customData,\n      pollId,\n    };\n    if (this.beforeSendMessage) {\n      input = await this.beforeSendMessage(input);\n    }\n    const preview = createMessagePreview(\n      this.chatClientService.chatClient.user!,\n      input.text,\n      input.attachments,\n      input.mentionedUsers,\n      input.parentId,\n      input.quotedMessageId,\n      input.customData,\n      input.pollId\n    );\n    const channel = this.activeChannelSubject.getValue()!;\n    channel.state.addMessageSorted(preview, true);\n    const response = await this.sendMessageRequest(preview, input.customData);\n    return response;\n  }\n\n  /**\n   * Resends the given message to the active channel\n   * @param message The message to resend\n   */\n  async resendMessage(message: StreamMessage) {\n    const channel = this.activeChannelSubject.getValue()!;\n    channel.state.addMessageSorted(\n      {\n        ...(message as unknown as MessageResponse),\n        // @ts-expect-error stream-chat doesn't know about this property\n        errorStatusCode: undefined,\n        status: 'sending',\n      },\n      true\n    );\n    return this.sendMessageRequest(message, undefined, true);\n  }\n\n  /**\n   * Updates the message in the active channel\n   * @param message Mesage to be updated\n   */\n  async updateMessage(message: StreamMessage) {\n    let messageToUpdate: StreamMessage = {\n      ...message,\n    };\n    if (messageToUpdate.quoted_message) {\n      messageToUpdate.quoted_message = {\n        ...messageToUpdate.quoted_message,\n      };\n    }\n    delete messageToUpdate.i18n;\n    if (this.beforeUpdateMessage) {\n      messageToUpdate = await this.beforeUpdateMessage(messageToUpdate);\n    }\n    if (messageToUpdate.readBy) {\n      // @ts-expect-error this is only a run time proparty for the SDK\n      delete messageToUpdate.readBy;\n    }\n    if (messageToUpdate.translation) {\n      delete messageToUpdate.translation;\n    }\n    if (messageToUpdate.quoted_message?.translation) {\n      delete messageToUpdate.quoted_message.translation;\n    }\n    if (message.moderation_details) {\n      return this.resendMessage(message);\n    }\n    const response = await this.chatClientService.chatClient.updateMessage(\n      messageToUpdate as unknown as LocalMessage\n    );\n\n    const channel = this.channelsSubject\n      .getValue()\n      ?.find((c) => c.cid === message.cid);\n\n    if (\n      response.message.type === 'error' &&\n      response.message.moderation_details\n    ) {\n      this.notificationService.addTemporaryNotification(\n        'streamChat.This message did not meet our content guidelines'\n      );\n      return message;\n    }\n\n    return this.transformToStreamMessage(response.message, channel);\n  }\n\n  /**\n   * Deletes the message from the active channel\n   * @param message Message to be deleted\n   * @param isLocalDelete set this `true` if you want to delete a message that's only part of the local state, not yet saved on the backend\n   */\n  async deleteMessage(message: StreamMessage, isLocalDelete = false) {\n    if (isLocalDelete && this.activeChannel) {\n      const result = this.activeChannel.state.removeMessage({\n        id: message.id,\n        parent_id: message.parent_id,\n      });\n      if (result) {\n        message.parent_id\n          ? this.activeThreadMessagesSubject.next(\n              this.activeChannel.state.threads[message.parent_id]\n            )\n          : this.activeChannelMessagesSubject.next(\n              this.activeChannel.state.messages\n            );\n      }\n      return;\n    }\n    if (this.messageDeleteConfirmationHandler) {\n      const result = await this.messageDeleteConfirmationHandler(message);\n      if (result) {\n        await this.chatClientService.chatClient.deleteMessage(message.id);\n      }\n    } else {\n      await this.chatClientService.chatClient.deleteMessage(message.id);\n    }\n  }\n\n  /**\n   * Uploads files to the channel. If you want to know more about [file uploads](/chat/docs/javascript/file_uploads/) check out the platform documentation.\n   * @param uploads the attachments to upload (output of the [`AttachmentService`](/chat/docs/sdk/angular/services/AttachmentService/))\n   * @returns the result of file upload requests\n   */\n  async uploadAttachments(\n    uploads: AttachmentUpload[]\n  ): Promise<AttachmentUpload[]> {\n    const result: AttachmentUpload[] = [];\n    const channel = this.activeChannelSubject.getValue()!;\n    const uploadResults = await Promise.allSettled(\n      uploads.map((upload) =>\n        upload.type === 'image'\n          ? this.customImageUploadRequest\n            ? this.customImageUploadRequest(upload.file, channel)\n            : channel.sendImage(upload.file, upload.file.name, upload.file.type)\n          : this.customFileUploadRequest\n          ? this.customFileUploadRequest(upload.file, channel)\n          : channel.sendFile(upload.file, upload.file.name, upload.file.type)\n      )\n    );\n    uploadResults.forEach((uploadResult, i) => {\n      const file = uploads[i].file;\n      const type = uploads[i].type;\n      if (uploadResult.status === 'fulfilled') {\n        result.push({\n          file,\n          type,\n          state: 'success',\n          url: uploadResult.value.file,\n          /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any */\n          thumb_url: (uploadResult.value as any).thumb_url,\n        });\n      } else {\n        let reason: AttachmentUploadErrorReason = 'unknown';\n        let extraData: { param: string } | undefined;\n        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */\n        const message: string | undefined =\n          /* eslint-disable-next-line @typescript-eslint/no-unsafe-member-access */\n          uploadResult.reason.response?.data?.message;\n        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */\n        const code: number | undefined =\n          /* eslint-disable-next-line @typescript-eslint/no-unsafe-member-access */\n          uploadResult.reason.response?.data?.code;\n        if (\n          code === 22 ||\n          (code === 4 && message?.toLowerCase()?.includes('bytes'))\n        ) {\n          reason = 'file-size';\n          extraData = {\n            param:\n              /\\d+MB|\\d+\\s?bytes/.exec(message || '')?.[0] ||\n              `${this.attachmentMaxSizeFallbackInMB}MB`,\n          };\n          if (extraData.param.includes('bytes')) {\n            const limitInBytes = +(\n              /\\d+/.exec(extraData.param)?.[0] ||\n              this.attachmentMaxSizeFallbackInMB * 1024 * 1024\n            );\n            extraData.param = `${limitInBytes / (1024 * 1024)}MB`;\n          }\n        } else if (\n          code === 4 &&\n          message?.toLowerCase()?.includes('file extension')\n        ) {\n          reason = 'file-extension';\n          extraData = { param: /\\.\\w+/.exec(message)?.[0] || '' };\n        }\n        result.push({\n          file,\n          type,\n          state: 'error',\n          errorReason: reason,\n          errorExtraInfo: extraData ? [extraData] : undefined,\n        });\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * Deletes an uploaded file by URL. If you want to know more about [file uploads](/chat/docs/javascript/file_uploads/) check out the platform documentation\n   * @param attachmentUpload Attachment to be deleted (output of the [`AttachmentService`](/chat/docs/sdk/angular/services/AttachmentService/))\n   */\n  async deleteAttachment(attachmentUpload: AttachmentUpload) {\n    const channel = this.activeChannelSubject.getValue()!;\n    await (attachmentUpload.type === 'image'\n      ? this.customImageDeleteRequest\n        ? this.customImageDeleteRequest(attachmentUpload.url!, channel)\n        : channel.deleteImage(attachmentUpload.url!)\n      : this.customFileDeleteRequest\n      ? this.customFileDeleteRequest(attachmentUpload.url!, channel)\n      : channel.deleteFile(attachmentUpload.url!));\n  }\n\n  /**\n   * Returns the autocomplete options for current channel members. If the channel has less than 100 members, it returns the channel members, otherwise sends a [search request](/chat/docs/javascript/query_members/#pagination-and-ordering) with the given search term.\n   * @param searchTerm Text to search for in the names of members\n   * @returns The list of members matching the search filter\n   */\n  async autocompleteMembers(searchTerm: string) {\n    const activeChannel = this.activeChannelSubject.getValue();\n    if (!activeChannel) {\n      return [];\n    }\n    if (Object.keys(activeChannel.state.members).length < 100) {\n      return Object.values(activeChannel.state.members).filter(\n        (m) => m.user?.id !== this.chatClientService.chatClient.userID!\n      );\n    } else {\n      if (!searchTerm) {\n        return [];\n      }\n      const result = await activeChannel.queryMembers({\n        name: { $autocomplete: searchTerm },\n      } as MemberFilters); // TODO: find out why we need typecast here\n\n      return result.members.filter(\n        (m) => m.user_id !== this.chatClientService.chatClient?.user?.id\n      );\n    }\n  }\n\n  /**\n   * [Runs a message action](https://getstream.io/chat/docs/rest/#messages-runmessageaction) in the current channel. Updates the message list based on the action result (if no message is returned, the message will be removed from the message list).\n   * @param messageId\n   * @param formData\n   * @param parentMessageId\n   */\n  async sendAction(\n    messageId: string,\n    formData: Record<string, string>,\n    parentMessageId?: string\n  ) {\n    const channel = this.activeChannelSubject.getValue()!;\n    const response = await channel.sendAction(messageId, formData);\n    if (response?.message) {\n      channel.state.addMessageSorted({\n        ...response.message,\n        status: 'received',\n      });\n      const isThreadReply = !!response.message.parent_id;\n      isThreadReply\n        ? this.activeThreadMessagesSubject.next([\n            ...channel.state.threads[response.message.parent_id!],\n          ])\n        : this.activeChannelMessagesSubject.next([...channel.state.messages]);\n    } else {\n      channel.state.removeMessage({\n        id: messageId,\n        parent_id: parentMessageId,\n      });\n      if (parentMessageId) {\n        this.activeThreadMessagesSubject.next(\n          channel.state.threads[this.activeParentMessageIdSubject.getValue()!]\n        );\n      } else {\n        this.activeChannelMessagesSubject.next([...channel.state.messages]);\n      }\n    }\n  }\n\n  /**\n   * Selects or deselects the current message to quote reply to\n   * @param message The message to select, if called with `undefined`, it deselects the message\n   */\n  selectMessageToQuote(message: StreamMessage | undefined | MessageResponse) {\n    if (message && !this.isStreamMessage(message)) {\n      message = this.transformToStreamMessage(message);\n    }\n    this.messageToQuoteSubject.next(message);\n  }\n\n  /**\n   * Add a new channel to the channel list\n   * The channel will be added to the beginning of the channel list\n   * @param channel\n   */\n  addChannel(channel: Channel) {\n    if (!this.channels.find((c) => c.cid === channel.cid)) {\n      this.channelsSubject.next([channel, ...this.channels]);\n      this.watchForChannelEvents(channel);\n    }\n  }\n\n  /**\n   *\n   * @param cid\n   * @param shouldStopWatching\n   */\n  removeChannel(cid: string, shouldStopWatching = true) {\n    const remainingChannels = this.channels.filter((c) => c.cid !== cid);\n\n    if (shouldStopWatching) {\n      if (this.channelSubscriptions[cid]) {\n        this.channelSubscriptions[cid]();\n        delete this.channelSubscriptions.cid;\n      }\n      void this.chatClientService.chatClient.activeChannels[cid]\n        ?.stopWatching()\n        .catch((err) =>\n          this.chatClientService.chatClient.logger(\n            'warn',\n            'Failed to unwatch channel',\n            err as Record<string, unknown>\n          )\n        );\n    }\n\n    if (remainingChannels.length < this.channels.length) {\n      this.channelsSubject.next(remainingChannels);\n      if (cid === this.activeChannelSubject.getValue()?.cid) {\n        if (remainingChannels.length > 0) {\n          this.setAsActiveChannel(remainingChannels[0]);\n        } else {\n          this.activeChannelSubject.next(undefined);\n        }\n      }\n    }\n  }\n\n  private async sendMessageRequest(\n    preview: MessageResponse | StreamMessage,\n    customData?: CustomMessageData,\n    isResend = false\n  ) {\n    const channel = this.activeChannelSubject.getValue()!;\n    const isThreadReply = !!preview.parent_id;\n    isThreadReply\n      ? this.activeThreadMessagesSubject.next([\n          ...channel.state.threads[preview.parent_id!],\n        ])\n      : this.activeChannelMessagesSubject.next([...channel.state.messages]);\n    try {\n      const response = await channel.sendMessage({\n        id: preview.id,\n        text: preview.text,\n        attachments: preview.attachments,\n        mentioned_users: preview.mentioned_users?.map((u) => u.id),\n        parent_id: preview.parent_id,\n        quoted_message_id: preview.quoted_message_id,\n        poll_id: preview.poll_id,\n        ...customData,\n      } as Message); // TODO: find out why we need typecast here\n      channel.state.addMessageSorted(\n        {\n          ...response.message,\n          status: 'received',\n        },\n        true\n      );\n      isThreadReply\n        ? this.activeThreadMessagesSubject.next([\n            ...channel.state.threads[preview.parent_id!],\n          ])\n        : this.activeChannelMessagesSubject.next([...channel.state.messages]);\n      let messages!: StreamMessage[];\n      (isThreadReply ? this.activeThreadMessages$ : this.activeChannelMessages$)\n        .pipe(take(1))\n        .subscribe((m) => (messages = m));\n      const newMessage = messages[messages.length - 1];\n      return newMessage;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      const stringError = JSON.stringify(error);\n      const parsedError: {\n        status?: number;\n        code?: number;\n        response?: { data?: { message?: string } };\n      } = stringError ? (JSON.parse(stringError) as { status?: number }) : {};\n\n      let isAlreadyExists = false;\n      if (isResend) {\n        if (\n          parsedError.status === 400 &&\n          parsedError.code === 4 &&\n          parsedError?.response?.data?.message?.includes('already exists')\n        ) {\n          isAlreadyExists = true;\n        }\n      }\n\n      channel.state.addMessageSorted(\n        {\n          ...(preview as MessageResponse),\n          // @ts-expect-error stream-chat doesn't know about this property\n          errorStatusCode: isAlreadyExists\n            ? undefined\n            : parsedError.status || undefined,\n          status: isAlreadyExists ? 'received' : 'failed',\n        },\n        true\n      );\n      isThreadReply\n        ? this.activeThreadMessagesSubject.next([\n            ...channel.state.threads[preview.parent_id!],\n          ])\n        : this.activeChannelMessagesSubject.next([...channel.state.messages]);\n      let messages!: StreamMessage[];\n      (isThreadReply ? this.activeThreadMessages$ : this.activeChannelMessages$)\n        .pipe(take(1))\n        .subscribe((m) => (messages = m));\n      const newMessage = messages[messages.length - 1];\n      return newMessage;\n    }\n  }\n\n  /**\n   * Jumps to the selected message inside the message list, if the message is not yet loaded, it'll load the message (and it's surroundings) from the API.\n   * @param messageId The ID of the message to be loaded, 'latest' means jump to the latest messages\n   * @param parentMessageId The ID of the parent message if we want to load a thread message\n   */\n  async jumpToMessage(messageId: string, parentMessageId?: string) {\n    this.isMessageLoadingInProgress = true;\n    const activeChannel = this.activeChannelSubject.getValue();\n    try {\n      await activeChannel?.state.loadMessageIntoState(\n        messageId,\n        parentMessageId\n      );\n      const messages = activeChannel?.state.messages || [];\n      this.activeChannelMessagesSubject.next([...messages]);\n      if (parentMessageId) {\n        const parentMessage = messages.find((m) => m.id === parentMessageId);\n        void this.setAsActiveParentMessage(\n          parentMessage as StreamMessage,\n          'state'\n        );\n      }\n      this.jumpToMessageSubject.next({\n        id: messageId,\n        parentId: parentMessageId,\n      });\n    } catch (error) {\n      this.notificationService.addTemporaryNotification(\n        'streamChat.Message not found'\n      );\n      throw error;\n    } finally {\n      this.isMessageLoadingInProgress = false;\n    }\n  }\n\n  /**\n   * Clears the currently selected message to jump\n   */\n  clearMessageJump() {\n    this.jumpToMessageSubject.next({ id: undefined, parentId: undefined });\n  }\n\n  /**\n   * Pins the given message in the channel\n   * @param message\n   */\n  async pinMessage(message: StreamMessage) {\n    try {\n      await this.chatClientService.chatClient?.pinMessage(message);\n      this.notificationService.addTemporaryNotification(\n        'streamChat.Message pinned',\n        'success'\n      );\n    } catch (error) {\n      this.notificationService.addTemporaryNotification(\n        'streamChat.Error pinning message'\n      );\n      throw error;\n    }\n  }\n\n  /**\n   * Removes the given message from pinned messages\n   * @param message\n   */\n  async unpinMessage(message: StreamMessage) {\n    try {\n      await this.chatClientService.chatClient?.unpinMessage(message);\n      this.notificationService.addTemporaryNotification(\n        'streamChat.Message unpinned',\n        'success'\n      );\n    } catch (error) {\n      this.notificationService.addTemporaryNotification(\n        'streamChat.Error removing message pin'\n      );\n      throw error;\n    }\n  }\n\n  private handleNotification(clientEvent: ClientEvent) {\n    switch (clientEvent.eventType) {\n      case 'connection.recovered': {\n        void this.ngZone.run(async () => {\n          if (this.isStateRecoveryInProgress) {\n            return;\n          }\n          this.isStateRecoveryInProgress = true;\n          try {\n            // If channel list is not inited, we set the active channel\n            const shoulSetActiveChannel =\n              this.shouldSetActiveChannel &&\n              !this.activeChannelSubject.getValue();\n            await this.queryChannels(\n              shoulSetActiveChannel || false,\n              'recover-state'\n            );\n            if (this.activeChannelSubject.getValue()) {\n              // Thread messages are not refetched so active thread gets deselected to avoid displaying stale messages\n              void this.setAsActiveParentMessage(undefined);\n              // Update and reselect message to quote\n              const messageToQuote = this.messageToQuoteSubject.getValue();\n              this.setChannelState(this.activeChannelSubject.getValue()!);\n              let messages!: StreamMessage[];\n              this.activeChannelMessages$\n                .pipe(take(1))\n                .subscribe((m) => (messages = m));\n              const updatedMessageToQuote = messages.find(\n                (m) => m.id === messageToQuote?.id\n              );\n              if (updatedMessageToQuote) {\n                this.selectMessageToQuote(updatedMessageToQuote);\n              }\n            }\n            this.isStateRecoveryInProgress = false;\n          } catch {\n            this.isStateRecoveryInProgress = false;\n          }\n        });\n        break;\n      }\n      case 'notification.message_new': {\n        this.ngZone.run(() => {\n          if (this.customNewMessageNotificationHandler) {\n            this.customNewMessageNotificationHandler(\n              clientEvent,\n              this.channelListSetter\n            );\n          } else {\n            this.handleNewMessageNotification(clientEvent);\n          }\n        });\n        break;\n      }\n      case 'notification.added_to_channel': {\n        this.ngZone.run(() => {\n          if (this.customAddedToChannelNotificationHandler) {\n            this.customAddedToChannelNotificationHandler(\n              clientEvent,\n              this.channelListSetter\n            );\n          } else {\n            this.handleAddedToChannelNotification(clientEvent);\n          }\n        });\n        break;\n      }\n      case 'notification.removed_from_channel': {\n        this.ngZone.run(() => {\n          if (this.customRemovedFromChannelNotificationHandler) {\n            this.customRemovedFromChannelNotificationHandler(\n              clientEvent,\n              this.channelListSetter\n            );\n          } else {\n            this.handleRemovedFromChannelNotification(clientEvent);\n          }\n        });\n        break;\n      }\n      case 'user.updated': {\n        this.ngZone.run(() => {\n          const updatedChannels = this.channelsSubject.getValue()?.map((c) => {\n            if (this.chatClientService.chatClient.activeChannels[c.cid]) {\n              return this.chatClientService.chatClient.activeChannels[c.cid];\n            } else {\n              return c;\n            }\n          });\n          this.channelsSubject.next(updatedChannels);\n          const activeChannel = this.activeChannelSubject.getValue();\n          if (activeChannel) {\n            this.activeChannelSubject.next(\n              this.chatClientService.chatClient.activeChannels[\n                activeChannel.cid\n              ] || activeChannel\n            );\n            this.activeChannelMessagesSubject.next(\n              activeChannel.state.messages.map((m) => {\n                (m as StreamMessage).readBy = getReadBy(m, activeChannel);\n                return { ...m };\n              })\n            );\n            const activeParentMessage =\n              this.activeParentMessageIdSubject.getValue();\n            if (activeParentMessage) {\n              const messages = activeChannel.state.threads[activeParentMessage];\n              this.activeThreadMessagesSubject.next([...messages]);\n            }\n            this.activeChannelPinnedMessagesSubject.next([\n              ...(activeChannel.state.pinnedMessages as StreamMessage[]),\n            ]);\n          }\n        });\n        break;\n      }\n    }\n  }\n\n  private handleRemovedFromChannelNotification(clientEvent: ClientEvent) {\n    const channelIdToBeRemoved = clientEvent.event.channel!.cid;\n    this.removeChannel(channelIdToBeRemoved, true);\n  }\n\n  private handleNewMessageNotification(clientEvent: ClientEvent) {\n    if (clientEvent.event.channel) {\n      void this.addChannelFromNotification(clientEvent.event.channel);\n    }\n  }\n\n  private handleAddedToChannelNotification(clientEvent: ClientEvent) {\n    if (clientEvent.event.channel) {\n      void this.addChannelFromNotification(clientEvent.event.channel);\n    }\n  }\n\n  private async addChannelFromNotification(channelResponse: ChannelResponse) {\n    const newChannel = this.chatClientService.chatClient.channel(\n      channelResponse.type,\n      channelResponse.id\n    );\n    let currentChannels = this.channelsSubject.getValue() || [];\n    if (currentChannels.find((c) => c.cid === newChannel.cid)) {\n      return;\n    }\n    await newChannel.watch().catch((err) => {\n      this.chatClientService.chatClient.logger(\n        'error',\n        'Failed to add channel to channel list because watch request failed',\n        err as Record<string, unknown>\n      );\n    });\n    currentChannels = this.channelsSubject.getValue() || [];\n    if (currentChannels.find((c) => c.cid === newChannel.cid)) {\n      return;\n    }\n    this.watchForChannelEvents(newChannel);\n    this.channelsSubject.next([newChannel, ...currentChannels]);\n  }\n\n  private watchForActiveChannelEvents(channel: Channel) {\n    this.activeChannelSubscriptions.push(\n      channel.on('message.new', (event) => {\n        this.ngZone.run(() => {\n          event.message && event.message.parent_id\n            ? event.message.parent_id ===\n              this.activeParentMessageIdSubject.getValue()\n              ? this.activeThreadMessagesSubject.next([\n                  ...channel.state.threads[event.message.parent_id],\n                ])\n              : null\n            : this.activeChannelMessagesSubject.next([\n                ...channel.state.messages,\n              ]);\n          this.activeChannel$.pipe(first()).subscribe((c) => {\n            if (c) {\n              this.markRead(c);\n            }\n          });\n          this.updateLatestMessages(event);\n        });\n      })\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('message.updated', (event) => this.messageUpdated(event))\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('message.deleted', (event) => this.messageUpdated(event))\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('reaction.new', (e) => this.messageReactionEventReceived(e))\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('reaction.deleted', (e) =>\n        this.messageReactionEventReceived(e)\n      )\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('reaction.updated', (e) =>\n        this.messageReactionEventReceived(e)\n      )\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('message.read', (e) => {\n        this.ngZone.run(() => {\n          let latestMessage!: StreamMessage;\n          let messages!: StreamMessage[];\n          this.activeChannelMessages$.pipe(first()).subscribe((m) => {\n            messages = m;\n            latestMessage = messages[messages.length - 1];\n          });\n          if (!latestMessage || !e.user) {\n            return;\n          }\n          if (latestMessage.readBy) {\n            latestMessage.readBy.splice(0, latestMessage.readBy.length);\n          } else {\n            latestMessage.readBy = [];\n          }\n          latestMessage.readBy.push(...getReadBy(latestMessage, channel));\n          messages[messages.length - 1] = { ...latestMessage };\n\n          this.activeChannelMessagesSubject.next([...messages]);\n        });\n      })\n    );\n    this.activeChannelSubscriptions.push(\n      this.chatClientService.events$\n        .pipe(\n          filter(\n            (e) =>\n              e.eventType === 'notification.mark_unread' &&\n              e.event.channel_id === channel.id\n          ),\n          map((e) => e.event)\n        )\n        .subscribe((e) => {\n          this.ngZone.run(() => {\n            this.activeChannelLastReadMessageId = e.last_read_message_id;\n            this.activeChannelUnreadCount = e.unread_messages;\n            this.activeChannelSubject.next(this.activeChannel);\n          });\n        })\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('typing.start', (e) =>\n        this.ngZone.run(() => this.handleTypingStartEvent(e))\n      )\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('typing.stop', (e) =>\n        this.ngZone.run(() => this.handleTypingStopEvent(e))\n      )\n    );\n  }\n\n  /**\n   * Call this method if user started typing in the active channel\n   * @param parentId The id of the parent message, if user is typing in a thread\n   */\n  async typingStarted(parentId?: string) {\n    const activeChannel = this.activeChannelSubject.getValue();\n    await activeChannel?.keystroke(parentId);\n  }\n\n  /**\n   * Call this method if user stopped typing in the active channel\n   * @param parentId The id of the parent message, if user were typing in a thread\n   */\n  async typingStopped(parentId?: string) {\n    const activeChannel = this.activeChannelSubject.getValue();\n    await activeChannel?.stopTyping(parentId);\n  }\n\n  /**\n   * The current list of channels\n   */\n  get channels() {\n    return this.channelsSubject.getValue() || [];\n  }\n\n  /**\n   * The current active channel\n   */\n  get activeChannel() {\n    return this.activeChannelSubject.getValue() || undefined;\n  }\n\n  /**\n   * The current active channel messages\n   */\n  get activeChannelMessages() {\n    return this.activeChannelMessagesSubject.getValue() || [];\n  }\n\n  /**\n   * The current thread replies\n   */\n  get activeChannelThreadReplies() {\n    return this.activeThreadMessagesSubject.getValue() || [];\n  }\n\n  /**\n   * Get the last 1200 reactions of a message in the current active channel. If you need to fetch more reactions please use the [following endpoint](/chat/docs/javascript/send_reaction/#paginating-reactions).\n   * @deprecated use [`messageReactionsService.queryReactions()`](/chat/docs/sdk/angular/services/MessageReactionsService/#queryreactions) instead\n   * @param messageId\n   * @returns all reactions of a message\n   */\n  async getMessageReactions(messageId: string) {\n    const reactions: ReactionResponse[] = [];\n    const limit = 300;\n    let offset = 0;\n    const reactionsLimit = ChannelService.MAX_MESSAGE_REACTIONS_TO_FETCH;\n    let lastPageSize = limit;\n\n    while (lastPageSize === limit && reactions.length < reactionsLimit) {\n      try {\n        const response = await this.activeChannel?.getReactions(messageId, {\n          offset,\n          limit,\n        });\n        lastPageSize = response?.reactions?.length || 0;\n        if (lastPageSize > 0) {\n          reactions.push(...response!.reactions);\n        }\n        offset += lastPageSize;\n      } catch (e) {\n        this.notificationService.addTemporaryNotification(\n          'streamChat.Error loading reactions'\n        );\n        throw e;\n      }\n    }\n    return reactions;\n  }\n\n  /**\n   * Marks the channel from the given message as unread\n   * @param messageId\n   * @returns the result of the request\n   */\n  async markMessageUnread(messageId: string) {\n    if (!this.activeChannel) {\n      return;\n    }\n\n    try {\n      const response = await this.activeChannel.markUnread({\n        message_id: messageId,\n      });\n      this.areReadEventsPaused = true;\n      return response;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      const error: {\n        response?: {\n          data?: { code?: number; message?: string; StatusCode?: number };\n        };\n      } = JSON.parse(JSON.stringify(e)) as {\n        response?: {\n          data?: { code?: number; message?: string; StatusCode?: number };\n        };\n      };\n      const data = error?.response?.data;\n      if (\n        data &&\n        data.code === 4 &&\n        data.StatusCode === 400 &&\n        data.message?.includes('it is older than last')\n      ) {\n        const count = /\\d+ channel messages/\n          .exec(data.message)?.[0]\n          .match(/\\d+/)?.[0];\n        if (count) {\n          this.notificationService.addTemporaryNotification(\n            'streamChat.Error, only the first {{count}} message can be marked as unread',\n            undefined,\n            undefined,\n            { count }\n          );\n          throw e;\n        }\n      }\n      this.notificationService.addTemporaryNotification(\n        'streamChat.Error marking message as unread'\n      );\n      throw e;\n    }\n  }\n\n  private messageUpdated(event: Event) {\n    this.ngZone.run(() => {\n      const isThreadReply = event.message && event.message.parent_id;\n      const channel = this.activeChannelSubject.getValue();\n      if (!channel) {\n        return;\n      }\n      // Get messages from state as message order could change, and message could've been deleted\n      const messages: FormatMessageResponse[] = isThreadReply\n        ? channel.state.threads[event?.message?.parent_id || '']\n        : channel.state.messages;\n      if (!messages) {\n        return;\n      }\n      const messageIndex = messages.findIndex(\n        (m) => m.id === event?.message?.id\n      );\n      if (messageIndex !== -1 || event.type === 'message.deleted') {\n        isThreadReply\n          ? this.activeThreadMessagesSubject.next([...messages])\n          : this.activeChannelMessagesSubject.next([...messages]);\n        this.activeChannelPinnedMessagesSubject.next([\n          ...(channel.state.pinnedMessages as StreamMessage[]),\n        ]);\n      }\n    });\n  }\n\n  private messageReactionEventReceived(e: Event) {\n    this.ngZone.run(() => {\n      const isThreadMessage = e.message && e.message.parent_id;\n      let messages!: StreamMessage[];\n      (isThreadMessage\n        ? this.activeThreadMessages$\n        : this.activeChannelMessages$\n      )\n        .pipe(first())\n        .subscribe((m) => (messages = m));\n      const messageIndex = messages.findIndex((m) => m.id === e?.message?.id);\n      if (messageIndex === -1) {\n        return;\n      }\n      const message = messages[messageIndex];\n      message.reaction_counts = { ...e.message?.reaction_counts };\n      message.reaction_scores = { ...e.message?.reaction_scores };\n      message.latest_reactions = [...(e.message?.latest_reactions || [])];\n      message.own_reactions = [...(e.message?.own_reactions || [])];\n      message.reaction_groups = { ...e.message?.reaction_groups };\n\n      messages[messageIndex] = { ...message };\n      isThreadMessage\n        ? this.activeThreadMessagesSubject.next([...messages])\n        : this.activeChannelMessagesSubject.next([...messages]);\n    });\n  }\n\n  private formatMessage(message: MessageResponse) {\n    const m = message as unknown as FormatMessageResponse;\n    m.pinned_at = message.pinned_at ? new Date(message.pinned_at) : null;\n    m.created_at = message.created_at\n      ? new Date(message.created_at)\n      : new Date();\n    m.updated_at = message.updated_at\n      ? new Date(message.updated_at)\n      : new Date();\n    message.status = message.status || 'received';\n\n    return m;\n  }\n\n  private isStreamMessage(\n    message: StreamMessage | FormatMessageResponse | MessageResponse\n  ): message is StreamMessage {\n    return 'readBy' in message;\n  }\n\n  private isFormatMessageResponse(\n    message: StreamMessage | FormatMessageResponse | MessageResponse\n  ): message is FormatMessageResponse {\n    return message.created_at instanceof Date;\n  }\n\n  private stopWatchForActiveChannelEvents(channel: Channel | undefined) {\n    if (!channel) {\n      return;\n    }\n    this.activeChannelSubscriptions.forEach((s) => s.unsubscribe());\n    this.activeChannelSubscriptions = [];\n  }\n\n  private async queryChannels(\n    shouldSetActiveChannel: boolean,\n    queryType: ChannelQueryType\n  ) {\n    if (!this.channelQuery) {\n      throw new Error(\n        'Query channels called before initializing ChannelQuery instance'\n      );\n    }\n    try {\n      this.channelQueryStateSubject.next({ state: 'in-progress' });\n\n      const { channels, hasMorePage } = await ('query' in this.channelQuery\n        ? this.channelQuery.query(queryType)\n        : this.channelQuery(queryType));\n      const filteredChannels = channels.filter(\n        (channel, index) =>\n          !channels.slice(0, index).find((c) => c.cid === channel.cid)\n      );\n      filteredChannels.forEach((c) => {\n        if (!this.channelSubscriptions[c.cid]) {\n          this.watchForChannelEvents(c);\n        }\n      });\n\n      this.channelsSubject.next(filteredChannels);\n      const currentActiveChannel = this.activeChannelSubject.getValue();\n      if (\n        currentActiveChannel &&\n        !filteredChannels.find((c) => c.cid === currentActiveChannel?.cid)\n      ) {\n        this.deselectActiveChannel();\n      } else if (\n        filteredChannels.length > 0 &&\n        !currentActiveChannel &&\n        shouldSetActiveChannel\n      ) {\n        this.setAsActiveChannel(filteredChannels[0]);\n      }\n      this.hasMoreChannelsSubject.next(hasMorePage);\n      this.channelQueryStateSubject.next({ state: 'success' });\n      this.dismissErrorNotification?.();\n      return channels;\n    } catch (error) {\n      this.channelQueryStateSubject.next({\n        state: 'error',\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        error,\n      });\n      throw error;\n    }\n  }\n\n  private watchForChannelEvents(channel: Channel) {\n    if (this.channelSubscriptions[channel.cid]) {\n      this.channelSubscriptions[channel.cid]();\n    }\n    const unsubscribe = channel.on((event: Event) => {\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n      const type = event.type as EventTypes | 'capabilities.changed';\n      switch (type) {\n        case 'message.new': {\n          this.ngZone.run(() => {\n            if (this.customNewMessageHandler) {\n              this.customNewMessageHandler(\n                event,\n                channel,\n                this.channelListSetter,\n                this.messageListSetter,\n                this.threadListSetter,\n                this.parentMessageSetter\n              );\n            } else {\n              this.handleNewMessage(event, channel);\n            }\n          });\n          break;\n        }\n        case 'channel.hidden': {\n          this.ngZone.run(() => {\n            if (this.customChannelHiddenHandler) {\n              this.customChannelHiddenHandler(\n                event,\n                channel,\n                this.channelListSetter,\n                this.messageListSetter,\n                this.threadListSetter,\n                this.parentMessageSetter\n              );\n            } else {\n              this.handleChannelHidden(event);\n            }\n          });\n          break;\n        }\n        case 'channel.deleted': {\n          this.ngZone.run(() => {\n            if (this.customChannelDeletedHandler) {\n              this.customChannelDeletedHandler(\n                event,\n                channel,\n                this.channelListSetter,\n                this.messageListSetter,\n                this.threadListSetter,\n                this.parentMessageSetter\n              );\n            } else {\n              this.handleChannelDeleted(event);\n            }\n          });\n          break;\n        }\n        case 'channel.visible': {\n          this.ngZone.run(() => {\n            if (this.customChannelVisibleHandler) {\n              this.customChannelVisibleHandler(\n                event,\n                channel,\n                this.channelListSetter,\n                this.messageListSetter,\n                this.threadListSetter,\n                this.parentMessageSetter\n              );\n            } else {\n              this.handleChannelVisible(event, channel);\n            }\n          });\n          break;\n        }\n        case 'channel.updated': {\n          this.ngZone.run(() => {\n            if (this.customChannelUpdatedHandler) {\n              this.customChannelUpdatedHandler(\n                event,\n                channel,\n                this.channelListSetter,\n                this.messageListSetter,\n                this.threadListSetter,\n                this.parentMessageSetter\n              );\n            } else {\n              this.handleChannelUpdate(event);\n            }\n          });\n          break;\n        }\n        case 'channel.truncated': {\n          this.ngZone.run(() => {\n            if (this.customChannelTruncatedHandler) {\n              this.customChannelTruncatedHandler(\n                event,\n                channel,\n                this.channelListSetter,\n                this.messageListSetter,\n                this.threadListSetter,\n                this.parentMessageSetter\n              );\n            } else {\n              this.handleChannelTruncate(event);\n            }\n          });\n          break;\n        }\n        case 'capabilities.changed': {\n          this.ngZone.run(() => {\n            const cid = event.cid;\n            if (cid) {\n              const currentChannels = this.channelsSubject.getValue();\n              const index = currentChannels?.findIndex((c) => c.cid === cid);\n              if (index !== -1 && index !== undefined) {\n                this.channelsSubject.next([...currentChannels!]);\n                if (cid === this.activeChannelSubject.getValue()?.cid) {\n                  this.activeChannelSubject.next(\n                    this.activeChannelSubject.getValue()\n                  );\n                }\n              }\n            }\n          });\n          break;\n        }\n      }\n    });\n    this.channelSubscriptions[channel.cid] = unsubscribe.unsubscribe;\n  }\n\n  private handleNewMessage(_: Event, channel: Channel) {\n    const channelIndex = this.channels.findIndex((c) => c.cid === channel.cid);\n    this.channels.splice(channelIndex, 1);\n    this.channelsSubject.next([channel, ...this.channels]);\n  }\n\n  private handleChannelHidden(event: Event) {\n    this.removeChannel(event.channel!.cid, false);\n  }\n\n  private handleChannelDeleted(event: Event) {\n    this.removeChannel(event.channel!.cid, false);\n  }\n\n  private handleChannelVisible(event: Event, channel: Channel) {\n    if (!this.channels.find((c) => c.cid === event.cid)) {\n      this.ngZone.run(() =>\n        this.channelsSubject.next([...this.channels, channel])\n      );\n    }\n  }\n\n  private handleChannelUpdate(event: Event) {\n    const channelIndex = this.channels.findIndex(\n      (c) => c.cid === event.channel!.cid\n    );\n    if (channelIndex !== -1) {\n      const channel = this.channels[channelIndex];\n      const notIncludedProperies = {\n        hidden: channel.data?.hidden || false,\n        own_capabilities: channel.data?.own_capabilities || [],\n      };\n      channel.data = {\n        ...event.channel!,\n        ...notIncludedProperies,\n      };\n      this.channelsSubject.next([...this.channels]);\n      if (event.channel?.cid === this.activeChannelSubject.getValue()?.cid) {\n        this.activeChannelSubject.next(channel);\n      }\n    }\n  }\n\n  private handleChannelTruncate(event: Event) {\n    const channelIndex = this.channels.findIndex(\n      (c) => c.cid === event.channel!.cid\n    );\n    if (channelIndex !== -1) {\n      this.channels[channelIndex].state.messages = [];\n      this.channelsSubject.next([...this.channels]);\n      if (event.channel?.cid === this.activeChannelSubject.getValue()?.cid) {\n        const channel = this.activeChannelSubject.getValue()!;\n        channel.state.messages = [];\n        this.activeChannelSubject.next(channel);\n        this.activeChannelMessagesSubject.next([]);\n        this.activeParentMessageIdSubject.next(undefined);\n        this.activeThreadMessagesSubject.next([]);\n      }\n    }\n  }\n\n  private get canSendReadEvents() {\n    const channel = this.activeChannelSubject.getValue();\n    if (!channel) {\n      return false;\n    }\n    const capabilites = channel.data?.own_capabilities as string[];\n    return capabilites.indexOf('read-events') !== -1;\n  }\n\n  private transformToStreamMessage(\n    message: StreamMessage | MessageResponse | FormatMessageResponse,\n    channel?: Channel\n  ) {\n    const isThreadMessage = !!message.parent_id;\n    if (\n      this.isStreamMessage(message) &&\n      this.isFormatMessageResponse(message)\n    ) {\n      if (message.quoted_message) {\n        message.quoted_message.translation = getMessageTranslation(\n          message.quoted_message,\n          channel,\n          this.chatClientService.chatClient.user\n        );\n      }\n      message.translation = getMessageTranslation(\n        message,\n        channel,\n        this.chatClientService.chatClient.user\n      );\n      return message;\n    } else {\n      if (message.quoted_message) {\n        (message as StreamMessage).quoted_message!.translation =\n          getMessageTranslation(\n            message.quoted_message,\n            channel,\n            this.chatClientService.chatClient.user\n          );\n      }\n      if (this.isFormatMessageResponse(message)) {\n        (message as StreamMessage).readBy = isThreadMessage\n          ? []\n          : channel\n          ? getReadBy(message, channel)\n          : [];\n        (message as StreamMessage).translation = getMessageTranslation(\n          message,\n          channel,\n          this.chatClientService.chatClient.user\n        );\n\n        return message as StreamMessage;\n      } else {\n        message = this.formatMessage(message);\n        (message as StreamMessage).readBy = isThreadMessage\n          ? []\n          : channel\n          ? getReadBy(message, channel)\n          : [];\n        (message as StreamMessage).translation = getMessageTranslation(\n          message,\n          channel,\n          this.chatClientService.chatClient.user\n        );\n        return message as StreamMessage;\n      }\n    }\n  }\n\n  private handleTypingStartEvent(event: Event) {\n    if (event.user?.id === this.chatClientService.chatClient.user?.id) {\n      return;\n    }\n    const isTypingInThread = !!event.parent_id;\n    if (\n      isTypingInThread &&\n      event.parent_id !== this.activeParentMessageIdSubject.getValue()\n    ) {\n      return;\n    }\n    const subject = isTypingInThread\n      ? this.usersTypingInThreadSubject\n      : this.usersTypingInChannelSubject;\n    const users: UserResponse[] = subject.getValue();\n    const user = event.user;\n    if (user && !users.find((u) => u.id === user.id)) {\n      users.push(user);\n      subject.next([...users]);\n    }\n  }\n\n  private handleTypingStopEvent(event: Event) {\n    const usersTypingInChannel = this.usersTypingInChannelSubject.getValue();\n    const usersTypingInThread = this.usersTypingInThreadSubject.getValue();\n    const user = event.user;\n    if (user && usersTypingInChannel.find((u) => u.id === user.id)) {\n      usersTypingInChannel.splice(\n        usersTypingInChannel.findIndex((u) => u.id === user.id),\n        1\n      );\n      this.usersTypingInChannelSubject.next([...usersTypingInChannel]);\n      return;\n    }\n    if (user && usersTypingInThread.find((u) => u.id === user.id)) {\n      usersTypingInThread.splice(\n        usersTypingInThread.findIndex((u) => u.id === user.id),\n        1\n      );\n      this.usersTypingInThreadSubject.next([...usersTypingInThread]);\n      return;\n    }\n  }\n\n  private updateLatestMessages(event: Event) {\n    if (\n      event.message?.user?.id !== this.chatClientService?.chatClient.user?.id\n    ) {\n      return;\n    }\n    const latestMessages =\n      this.latestMessageDateByUserByChannelsSubject.getValue();\n    if (!event.message?.created_at) {\n      return;\n    }\n    const channelId = event?.message?.cid;\n    if (!channelId) {\n      return;\n    }\n    const messageDate = new Date(event.message.created_at);\n    if (\n      !latestMessages[channelId] ||\n      latestMessages[channelId]?.getTime() < messageDate.getTime()\n    ) {\n      latestMessages[channelId] = messageDate;\n      this.latestMessageDateByUserByChannelsSubject.next({\n        ...latestMessages,\n      });\n    }\n  }\n\n  private setChannelState(channel: Channel) {\n    channel.state.messages.forEach((m) => {\n      (m as StreamMessage).readBy = getReadBy(m, channel);\n      (m as StreamMessage).translation = getMessageTranslation(\n        m,\n        channel,\n        this.chatClientService.chatClient.user\n      );\n      if (m.quoted_message) {\n        (m as StreamMessage).quoted_message!.translation =\n          getMessageTranslation(\n            m.quoted_message,\n            channel,\n            this.chatClientService.chatClient.user\n          );\n      }\n    });\n    this.markRead(channel);\n    this.activeChannelMessagesSubject.next([...channel.state.messages]);\n    this.activeChannelPinnedMessagesSubject.next([\n      ...(channel.state.pinnedMessages as StreamMessage[]),\n    ]);\n    this.activeParentMessageIdSubject.next(undefined);\n    this.activeThreadMessagesSubject.next([]);\n    this.messageToQuoteSubject.next(undefined);\n    this.usersTypingInChannelSubject.next([]);\n    this.usersTypingInThreadSubject.next([]);\n  }\n\n  private markRead(channel: Channel, isThrottled = true) {\n    if (\n      this.canSendReadEvents &&\n      this.shouldMarkActiveChannelAsRead &&\n      !this.areReadEventsPaused\n    ) {\n      if (isThrottled) {\n        this.markReadThrottled(channel);\n      } else {\n        void channel.markRead();\n      }\n    }\n  }\n\n  private markReadThrottled(channel: Channel) {\n    if (!this.markReadTimeout) {\n      this.markRead(channel, false);\n      this.markReadTimeout = setTimeout(() => {\n        this.flushMarkReadQueue();\n      }, this.markReadThrottleTime);\n    } else {\n      clearTimeout(this.markReadTimeout);\n      this.scheduledMarkReadRequest = () => this.markRead(channel, false);\n      this.markReadTimeout = setTimeout(() => {\n        this.flushMarkReadQueue();\n      }, this.markReadThrottleTime);\n    }\n  }\n\n  private flushMarkReadQueue() {\n    this.scheduledMarkReadRequest?.();\n    this.scheduledMarkReadRequest = undefined;\n    clearTimeout(this.markReadTimeout);\n    this.markReadTimeout = undefined;\n  }\n\n  private async _init(settings: {\n    shouldSetActiveChannel: boolean;\n    messagePageSize: number;\n  }) {\n    this.shouldSetActiveChannel = settings.shouldSetActiveChannel;\n    this.messagePageSize = settings.messagePageSize;\n    this.clientEventsSubscription = this.chatClientService.events$.subscribe(\n      (notification) => void this.handleNotification(notification)\n    );\n    try {\n      const result = await this.queryChannels(\n        this.shouldSetActiveChannel,\n        'first-page'\n      );\n      return result;\n    } catch (error) {\n      this.dismissErrorNotification =\n        this.notificationService.addPermanentNotification(\n          'streamChat.Error loading channels',\n          'error'\n        );\n      throw error;\n    }\n  }\n}\n"]}