stream-chat-angular 5.12.5 → 6.0.0-beta.1

package/esm2022/lib/channel.service.mjs

@@ -0,0 +1,1381 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, ReplaySubject, } from 'rxjs';
+import { distinctUntilChanged, filter, first, map, shareReplay, take, } from 'rxjs/operators';
+import { ChannelManager, promoteChannel, } from 'stream-chat';
+import { getMessageTranslation } from './get-message-translation';
+import { createMessagePreview } from './message-preview';
+import { getReadBy } from './read-by';
+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;
+        /**
+         * @internal
+         */
+        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.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.shouldSetActiveChannel = true;
+        this.isStateRecoveryInProgress$ = new BehaviorSubject(false);
+        this.channelQueryStateSubject = new BehaviorSubject(undefined);
+        this.areReadEventsPaused = false;
+        this.markReadThrottleTime = 1050;
+        this.channelManagerSubscriptions = [];
+        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.shouldRecoverState$ = combineLatest([
+            this.channels$,
+            this.channelQueryState$,
+            this.isStateRecoveryInProgress$,
+        ]).pipe(map(([channels, queryState, isStateRecoveryInProgress]) => {
+            return ((!channels || channels.length === 0) &&
+                queryState?.state === 'error' &&
+                !isStateRecoveryInProgress);
+        }), distinctUntilChanged());
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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) {
+        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);
+    }
+    /**
+     * Deselects the currently active (if any) channel
+     */
+    deselectActiveChannel() {
+        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;
+    }
+    /**
+     * 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 queryConfig the filter, sort and options for the query
+     * @param options behavior customization for the channel list and WebSocket event handling
+     * @returns the list of channels found by the query
+     */
+    init(queryConfig, options) {
+        this.channelQueryConfig = {
+            filters: queryConfig.filters,
+            sort: queryConfig.sort ?? { last_message_at: -1 },
+            options: {
+                limit: 25,
+                state: true,
+                presence: true,
+                watch: true,
+                message_limit: this.messagePageSize,
+                ...queryConfig.options,
+            },
+        };
+        return this._init({
+            ...options,
+            messagePageSize: queryConfig.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 behavior customization for the channel list and WebSocket event handling
+     * @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.messagePageSize = options?.messagePageSize ?? this.messagePageSize;
+        this.shouldSetActiveChannel =
+            options?.shouldSetActiveChannel ?? this.shouldSetActiveChannel;
+        const eventHandlerOverrides = options?.eventHandlerOverrides;
+        const managerOptions = { ...options };
+        delete managerOptions?.eventHandlerOverrides;
+        delete managerOptions?.shouldSetActiveChannel;
+        this.customChannelQuery = query;
+        this.createChannelManager({
+            eventHandlerOverrides,
+            options: managerOptions,
+        });
+        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.channelQueryStateSubject.next(undefined);
+        this.clientEventsSubscription?.unsubscribe();
+        this.dismissErrorNotification?.();
+        this.dismissErrorNotification = undefined;
+        this.channelQueryConfig = undefined;
+        this.destroyChannelManager();
+        this.isStateRecoveryInProgress$.next(false);
+    }
+    /**
+     * 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('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
+     */
+    async sendMessage(text, attachments = [], mentionedUsers = [], parentId = undefined, quotedMessageId = undefined, customData = undefined) {
+        let input = {
+            text,
+            attachments,
+            mentionedUsers,
+            parentId,
+            quotedMessageId,
+            customData,
+        };
+        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);
+        const channel = this.activeChannelSubject.getValue();
+        preview.readBy = [];
+        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,
+            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,
+        };
+        delete messageToUpdate.i18n;
+        if (this.beforeUpdateMessage) {
+            messageToUpdate = await this.beforeUpdateMessage(messageToUpdate);
+        }
+        if (messageToUpdate.readBy) {
+            delete messageToUpdate.readBy;
+        }
+        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) {
+        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.channelManager) {
+            throw new Error('Channel service not initialized');
+        }
+        if (!this.channels.find((c) => c.cid === channel.cid)) {
+            this.channelManager?.setChannels(promoteChannel({
+                channels: this.channels,
+                channelToMove: channel,
+                sort: this.channelQueryConfig?.sort ?? [],
+            }));
+        }
+    }
+    /**
+     *
+     * @param cid
+     */
+    removeChannel(cid) {
+        if (!this.channelManager) {
+            throw new Error('Channel service not initialized');
+        }
+        const remainingChannels = this.channels.filter((c) => c.cid !== cid);
+        this.channelManager?.setChannels(remainingChannels);
+    }
+    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,
+                ...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,
+                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;
+        }
+    }
+    /**
+     * Reloads all channels and messages. Useful if state is empty due to an error.
+     *
+     * The SDK will automatically call this after `connection.recovered` event. In other cases it's up to integrators to recover state.
+     *
+     * Use the `shouldRecoverState$` to know if state recover is necessary.
+     * @returns when recovery is completed
+     */
+    async recoverState() {
+        if (this.isStateRecoveryInProgress$.getValue()) {
+            return;
+        }
+        this.isStateRecoveryInProgress$.next(true);
+        try {
+            await this.queryChannels('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);
+                }
+            }
+        }
+        finally {
+            this.isStateRecoveryInProgress$.next(false);
+        }
+    }
+    handleNotification(clientEvent) {
+        switch (clientEvent.eventType) {
+            case 'connection.recovered': {
+                void this.recoverState().catch((error) => this.chatClientService.chatClient.logger('warn', `Failed to recover state after connection recovery: ${error}`));
+                break;
+            }
+            case 'user.updated': {
+                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;
+            }
+        }
+    }
+    watchForActiveChannelEvents(channel) {
+        this.activeChannelSubscriptions.push(channel.on('message.new', (event) => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            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) => {
+            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.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.handleTypingStartEvent(e)));
+        this.activeChannelSubscriptions.push(
+        // client._startCleaning can emit typing.stop events
+        // since client._startCleaning runs outside Angular, we need to reenter Angular here
+        channel.on('typing.stop', (e) => this.ngZone.run(() => this.handleTypingStopEvent(e))));
+        this.activeChannelSubscriptions.push(channel.on('capabilities.changed', (_) => {
+            this.activeChannelSubject.next(this.activeChannelSubject.getValue());
+        }));
+        this.activeChannelSubscriptions.push(channel.on('channel.updated', (_) => {
+            this.activeChannelSubject.next(this.activeChannelSubject.getValue());
+        }));
+        this.activeChannelSubscriptions.push(channel.on('channel.truncated', (_) => {
+            this.activeChannelSubject.next(this.activeChannelSubject.getValue());
+            this.activeChannelMessagesSubject.next([]);
+            void this.setAsActiveParentMessage(undefined);
+        }));
+    }
+    /**
+     * 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) {
+        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) {
+        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 !!message.readBy;
+    }
+    isFormatMessageResponse(message) {
+        return message.created_at instanceof Date;
+    }
+    stopWatchForActiveChannelEvents(channel) {
+        if (!channel) {
+            return;
+        }
+        this.activeChannelSubscriptions.forEach((s) => s.unsubscribe());
+        this.activeChannelSubscriptions = [];
+    }
+    async queryChannels(queryType) {
+        if (!this.channelManager) {
+            throw new Error('Query channels called before initializing ChannelService');
+        }
+        try {
+            this.channelQueryStateSubject.next({ state: 'in-progress' });
+            if (this.customChannelQuery) {
+                const result = await this.customChannelQuery(queryType);
+                const currentChannels = this.channels;
+                const filteredChannels = result.channels.filter((channel, index) => !currentChannels.slice(0, index).find((c) => c.cid === channel.cid));
+                this.channelManager.setChannels(filteredChannels);
+                this.hasMoreChannelsSubject.next(result.hasMorePage);
+            }
+            else {
+                if (queryType === 'first-page' || queryType === 'recover-state') {
+                    if (!this.channelQueryConfig) {
+                        throw new Error('Channel query config not initialized');
+                    }
+                    await this.channelManager.queryChannels({ ...this.channelQueryConfig.filters }, this.channelQueryConfig.sort, this.channelQueryConfig.options);
+                }
+                else {
+                    await this.channelManager.loadNext();
+                }
+            }
+            if (this.channelManagerSubscriptions.length === 0) {
+                this.channelManagerSubscriptions.push(this.channelManager.state.subscribeWithSelector((s) => ({ channels: s.channels }), ({ channels }) => {
+                    const activeChannel = this.activeChannel;
+                    if (!this.isStateRecoveryInProgress$.getValue() &&
+                        activeChannel &&
+                        !channels.find((c) => c.cid === activeChannel.cid)) {
+                        this.deselectActiveChannel();
+                    }
+                    this.channelsSubject.next(channels);
+                }));
+                if (!this.customChannelQuery) {
+                    this.channelManagerSubscriptions.push(this.channelManager.state.subscribeWithSelector((s) => ({ hasNext: s.pagination?.hasNext ?? true }), ({ hasNext }) => this.hasMoreChannelsSubject.next(hasNext)));
+                }
+            }
+            if (queryType === 'recover-state') {
+                await this.maybeRestoreActiveChannelAfterRecovery();
+            }
+            const activeChannel = this.activeChannelSubject.getValue();
+            const shouldSetActiveChannel = queryType === 'next-page' ? false : this.shouldSetActiveChannel;
+            if (this.channels.length > 0 &&
+                !activeChannel &&
+                shouldSetActiveChannel) {
+                this.setAsActiveChannel(this.channels[0]);
+            }
+            this.channelQueryStateSubject.next({ state: 'success' });
+            this.dismissErrorNotification?.();
+            return this.channels;
+        }
+        catch (error) {
+            this.channelQueryStateSubject.next({
+                state: 'error',
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                error,
+            });
+            if (queryType === 'recover-state') {
+                this.deselectActiveChannel();
+                this.channelManager.setChannels([]);
+            }
+            if (queryType !== 'next-page') {
+                this.dismissErrorNotification =
+                    this.notificationService.addPermanentNotification('streamChat.Error loading channels', 'error');
+            }
+            throw error;
+        }
+    }
+    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;
+    }
+    _init(options) {
+        this.messagePageSize = options.messagePageSize;
+        this.shouldSetActiveChannel =
+            options?.shouldSetActiveChannel ?? this.shouldSetActiveChannel;
+        const eventHandlerOverrides = options?.eventHandlerOverrides;
+        const managerOptions = { ...options };
+        delete managerOptions?.eventHandlerOverrides;
+        delete managerOptions?.shouldSetActiveChannel;
+        this.createChannelManager({
+            eventHandlerOverrides,
+            options: managerOptions,
+        });
+        this.clientEventsSubscription = this.chatClientService.events$.subscribe((notification) => void this.handleNotification(notification));
+        return this.queryChannels('first-page');
+    }
+    createChannelManager({ eventHandlerOverrides, options, }) {
+        this.channelManager = new ChannelManager({
+            client: this.chatClientService.chatClient,
+            options: {
+                ...options,
+                allowNotLoadedChannelPromotionForEvent: {
+                    'message.new': false,
+                    'channel.visible': true,
+                    'notification.added_to_channel': true,
+                    'notification.message_new': true,
+                    ...options?.allowNotLoadedChannelPromotionForEvent,
+                },
+            },
+            eventHandlerOverrides,
+        });
+        this.channelManager.registerSubscriptions();
+    }
+    destroyChannelManager() {
+        this.channelManager?.unregisterSubscriptions();
+        this.channelManager = undefined;
+        this.channelManagerSubscriptions.forEach((unsubscribe) => unsubscribe());
+        this.channelManagerSubscriptions = [];
+        this.channelsSubject.next(undefined);
+        this.hasMoreChannelsSubject.next(true);
+    }
+    async maybeRestoreActiveChannelAfterRecovery() {
+        const previousActiveChannel = this.activeChannelSubject.getValue();
+        if (!previousActiveChannel) {
+            return;
+        }
+        try {
+            if (!this.channels.find((c) => c.cid === previousActiveChannel?.cid)) {
+                await previousActiveChannel.watch();
+                // 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(previousActiveChannel);
+                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.channelManager?.setChannels(promoteChannel({
+                    channels: this.channels,
+                    channelToMove: previousActiveChannel,
+                    sort: this.channelQueryConfig?.sort ?? [],
+                }));
+            }
+        }
+        catch (error) {
+            this.chatClientService.chatClient.logger('warn', 'Unable to refetch active channel after state recover', error);
+            this.deselectActiveChannel();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", 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.0.0", ngImport: i0, type: ChannelService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", 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 {\n  distinctUntilChanged,\n  filter,\n  first,\n  map,\n  shareReplay,\n  take,\n} from 'rxjs/operators';\nimport {\n  Attachment,\n  Channel,\n  ChannelManager,\n  ChannelManagerEventHandlerOverrides,\n  ChannelManagerOptions,\n  Event,\n  FormatMessageResponse,\n  MemberFilters,\n  Message,\n  MessageResponse,\n  promoteChannel,\n  ReactionResponse,\n  Unsubscribe,\n  UpdatedMessage,\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  ChannelQueryConfig,\n  ChannelQueryConfigInput,\n  ChannelQueryResult,\n  ChannelQueryState,\n  ChannelQueryType,\n  ChannelServiceOptions,\n  DefaultStreamChatGenerics,\n  MessageInput,\n  MessageReactionType,\n  StreamMessage,\n} from './types';\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  T extends DefaultStreamChatGenerics = DefaultStreamChatGenerics,\n> {\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  channels$: Observable<Channel<T>[] | undefined>;\n  /**\n   * The result of the latest channel query request.\n   */\n  channelQueryState$: Observable<ChannelQueryState | undefined>;\n  /**\n   * Emits `true` when the state needs to be recovered after an error\n   *\n   * You can recover it by calling the `recoverState` method\n   */\n  shouldRecoverState$: Observable<boolean>;\n  /**\n   * Emits the currently active channel.\n   *\n   * The active channel will always be marked as read when a new message is received\n   */\n  activeChannel$: Observable<Channel<T> | undefined>;\n  /**\n   * Emits the list of currently loaded messages of the active channel.\n   */\n  activeChannelMessages$: Observable<StreamMessage<T>[]>;\n  /**\n   * Emits the list of pinned messages of the active channel.\n   */\n  activeChannelPinnedMessages$: Observable<StreamMessage<T>[]>;\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<T>[]>;\n  /**\n   * Emits the currently selected parent message. If no message is selected, it emits undefined.\n   */\n  activeParentMessage$: Observable<StreamMessage<T> | undefined>;\n  /**\n   * Emits the currently selected message to quote\n   */\n  messageToQuote$: Observable<StreamMessage<T> | 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<T>[]>;\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<T>[]>;\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<T> | 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   * 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<T>,\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<T>,\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<T>) => Promise<void>;\n  /**\n   * You can override the default image delete request - override this if you use your own CDN\n   */\n  customImageDeleteRequest?: (\n    url: string,\n    channel: Channel<T>,\n  ) => 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<T>,\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<T>,\n  ) => MessageInput<T> | Promise<MessageInput<T>>;\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<T>,\n  ) => StreamMessage<T> | Promise<StreamMessage<T>>;\n  /**\n   * @internal\n   */\n  static readonly MAX_MESSAGE_REACTIONS_TO_FETCH = 1200;\n  /**\n   * @internal\n   */\n  isMessageLoadingInProgress = false;\n  /**\n   * @internal\n   */\n  messagePageSize = 25;\n  private channelsSubject = new BehaviorSubject<Channel<T>[] | undefined>(\n    undefined,\n  );\n  private activeChannelSubject = new BehaviorSubject<Channel<T> | undefined>(\n    undefined,\n  );\n  private activeChannelMessagesSubject = new BehaviorSubject<\n    (StreamMessage<T> | MessageResponse<T> | FormatMessageResponse<T>)[]\n  >([]);\n  private activeChannelPinnedMessagesSubject = new BehaviorSubject<\n    StreamMessage[]\n  >([]);\n  private hasMoreChannelsSubject = new ReplaySubject<boolean>(1);\n  private activeChannelSubscriptions: { unsubscribe: () => void }[] = [];\n  private activeParentMessageIdSubject = new BehaviorSubject<\n    string | undefined\n  >(undefined);\n  private activeThreadMessagesSubject = new BehaviorSubject<\n    (StreamMessage<T> | MessageResponse<T> | FormatMessageResponse<T>)[]\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<T> | undefined\n  >(undefined);\n  private usersTypingInChannelSubject = new BehaviorSubject<UserResponse<T>[]>(\n    [],\n  );\n  private usersTypingInThreadSubject = new BehaviorSubject<UserResponse<T>[]>(\n    [],\n  );\n  private _shouldMarkActiveChannelAsRead = true;\n  private shouldSetActiveChannel = true;\n  private clientEventsSubscription: Subscription | undefined;\n  private isStateRecoveryInProgress$ = new BehaviorSubject(false);\n  private channelQueryStateSubject = new BehaviorSubject<\n    ChannelQueryState | undefined\n  >(undefined);\n  private customChannelQuery?: (\n    queryType: ChannelQueryType,\n  ) => Promise<ChannelQueryResult<T>>;\n  private channelManager?: ChannelManager<T>;\n  private channelQueryConfig?: ChannelQueryConfig<T>;\n  private dismissErrorNotification?: () => void;\n  private areReadEventsPaused = false;\n  private markReadThrottleTime = 1050;\n  private markReadTimeout?: ReturnType<typeof setTimeout>;\n  private scheduledMarkReadRequest?: () => void;\n  private channelManagerSubscriptions: Unsubscribe[] = [];\n\n  constructor(\n    private chatClientService: ChatClientService<T>,\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<T> | 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.shouldRecoverState$ = combineLatest([\n      this.channels$,\n      this.channelQueryState$,\n      this.isStateRecoveryInProgress$,\n    ]).pipe(\n      map(([channels, queryState, isStateRecoveryInProgress]) => {\n        return (\n          (!channels || channels.length === 0) &&\n          queryState?.state === 'error' &&\n          !isStateRecoveryInProgress\n        );\n      }),\n      distinctUntilChanged(),\n    );\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   * 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<T>) {\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  }\n\n  /**\n   * Deselects the currently active (if any) channel\n   */\n  deselectActiveChannel() {\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  }\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<T> | 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 queryConfig the filter, sort and options for the query\n   * @param options behavior customization for the channel list and WebSocket event handling\n   * @returns the list of channels found by the query\n   */\n  init(\n    queryConfig: ChannelQueryConfigInput<T>,\n    options?: ChannelServiceOptions<T>,\n  ) {\n    this.channelQueryConfig = {\n      filters: queryConfig.filters,\n      sort: queryConfig.sort ?? { last_message_at: -1 },\n      options: {\n        limit: 25,\n        state: true,\n        presence: true,\n        watch: true,\n        message_limit: this.messagePageSize,\n        ...queryConfig.options,\n      },\n    };\n\n    return this._init({\n      ...options,\n      messagePageSize:\n        queryConfig.options?.message_limit ?? this.messagePageSize,\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 behavior customization for the channel list and WebSocket event handling\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<T>>,\n    options: ChannelServiceOptions<T> & { messagePageSize: number } = {\n      shouldSetActiveChannel: true,\n      messagePageSize: this.messagePageSize,\n    },\n  ) {\n    this.messagePageSize = options?.messagePageSize ?? this.messagePageSize;\n\n    this.shouldSetActiveChannel =\n      options?.shouldSetActiveChannel ?? this.shouldSetActiveChannel;\n    const eventHandlerOverrides = options?.eventHandlerOverrides;\n    const managerOptions = { ...options };\n    delete managerOptions?.eventHandlerOverrides;\n    delete managerOptions?.shouldSetActiveChannel;\n\n    this.customChannelQuery = query;\n    this.createChannelManager({\n      eventHandlerOverrides,\n      options: managerOptions,\n    });\n\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.channelQueryStateSubject.next(undefined);\n    this.clientEventsSubscription?.unsubscribe();\n    this.dismissErrorNotification?.();\n    this.dismissErrorNotification = undefined;\n    this.channelQueryConfig = undefined;\n    this.destroyChannelManager();\n    this.isStateRecoveryInProgress$.next(false);\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('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?: T['reactionType'],\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   */\n  async sendMessage(\n    text: string,\n    attachments: Attachment<T>[] = [],\n    mentionedUsers: UserResponse<T>[] = [],\n    parentId: string | undefined = undefined,\n    quotedMessageId: string | undefined = undefined,\n    customData: undefined | Partial<T['messageType']> = undefined,\n  ) {\n    let input: MessageInput<T> = {\n      text,\n      attachments,\n      mentionedUsers,\n      parentId,\n      quotedMessageId,\n      customData,\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    );\n    const channel = this.activeChannelSubject.getValue()!;\n    preview.readBy = [];\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<T>),\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<T>) {\n    let messageToUpdate = {\n      ...message,\n    };\n    delete messageToUpdate.i18n;\n    if (this.beforeUpdateMessage) {\n      messageToUpdate = await this.beforeUpdateMessage(\n        messageToUpdate as StreamMessage,\n      );\n    }\n    if (messageToUpdate.readBy) {\n      delete (messageToUpdate as Omit<StreamMessage<T>, 'readBy'>).readBy;\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 UpdatedMessage<T>,\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<T>); // 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) {\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<T>) {\n    if (!this.channelManager) {\n      throw new Error('Channel service not initialized');\n    }\n    if (!this.channels.find((c) => c.cid === channel.cid)) {\n      this.channelManager?.setChannels(\n        promoteChannel({\n          channels: this.channels,\n          channelToMove: channel,\n          sort: this.channelQueryConfig?.sort ?? [],\n        }),\n      );\n    }\n  }\n\n  /**\n   *\n   * @param cid\n   */\n  removeChannel(cid: string) {\n    if (!this.channelManager) {\n      throw new Error('Channel service not initialized');\n    }\n    const remainingChannels = this.channels.filter((c) => c.cid !== cid);\n\n    this.channelManager?.setChannels(remainingChannels);\n  }\n\n  private async sendMessageRequest(\n    preview: MessageResponse<T> | StreamMessage<T>,\n    customData?: Partial<T['messageType']>,\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        ...customData,\n      } as Message<T>); // 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<T>[];\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<T>),\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<T>[];\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(parentMessage, 'state');\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<DefaultStreamChatGenerics>) {\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<DefaultStreamChatGenerics>) {\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  /**\n   * Reloads all channels and messages. Useful if state is empty due to an error.\n   *\n   * The SDK will automatically call this after `connection.recovered` event. In other cases it's up to integrators to recover state.\n   *\n   * Use the `shouldRecoverState$` to know if state recover is necessary.\n   * @returns when recovery is completed\n   */\n  async recoverState() {\n    if (this.isStateRecoveryInProgress$.getValue()) {\n      return;\n    }\n    this.isStateRecoveryInProgress$.next(true);\n    try {\n      await this.queryChannels('recover-state');\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<T>[];\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    } finally {\n      this.isStateRecoveryInProgress$.next(false);\n    }\n  }\n\n  private handleNotification(clientEvent: ClientEvent<T>) {\n    switch (clientEvent.eventType) {\n      case 'connection.recovered': {\n        void this.recoverState().catch((error) =>\n          this.chatClientService.chatClient.logger(\n            'warn',\n            `Failed to recover state after connection recovery: ${error}`,\n          ),\n        );\n        break;\n      }\n      case 'user.updated': {\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.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,\n          ]);\n        }\n        break;\n      }\n    }\n  }\n\n  private watchForActiveChannelEvents(channel: Channel<T>) {\n    this.activeChannelSubscriptions.push(\n      channel.on('message.new', (event) => {\n        // eslint-disable-next-line @typescript-eslint/no-unused-expressions\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([...channel.state.messages]);\n        this.activeChannel$.pipe(first()).subscribe((c) => {\n          if (c) {\n            this.markRead(c);\n          }\n        });\n        this.updateLatestMessages(event);\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        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    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.activeChannelLastReadMessageId = e.last_read_message_id;\n          this.activeChannelUnreadCount = e.unread_messages;\n          this.activeChannelSubject.next(this.activeChannel);\n        }),\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('typing.start', (e) => this.handleTypingStartEvent(e)),\n    );\n    this.activeChannelSubscriptions.push(\n      // client._startCleaning can emit typing.stop events\n      // since client._startCleaning runs outside Angular, we need to reenter Angular here\n      channel.on('typing.stop', (e) =>\n        this.ngZone.run(() => this.handleTypingStopEvent(e)),\n      ),\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('capabilities.changed', (_) => {\n        this.activeChannelSubject.next(this.activeChannelSubject.getValue());\n      }),\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('channel.updated', (_) => {\n        this.activeChannelSubject.next(this.activeChannelSubject.getValue());\n      }),\n    );\n    this.activeChannelSubscriptions.push(\n      channel.on('channel.truncated', (_) => {\n        this.activeChannelSubject.next(this.activeChannelSubject.getValue());\n        this.activeChannelMessagesSubject.next([]);\n        void this.setAsActiveParentMessage(undefined);\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<T>[] = [];\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<T>) {\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<T>[] = isThreadReply\n      ? channel.state.threads[event?.message?.parent_id || '']\n      : channel.state.messages;\n    if (!messages) {\n      return;\n    }\n    const messageIndex = messages.findIndex((m) => m.id === event?.message?.id);\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,\n      ]);\n    }\n  }\n\n  private messageReactionEventReceived(e: Event<T>) {\n    const isThreadMessage = e.message && e.message.parent_id;\n    let messages!: StreamMessage[];\n    (isThreadMessage ? this.activeThreadMessages$ : this.activeChannelMessages$)\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  private formatMessage(message: MessageResponse<T>) {\n    const m = message as unknown as FormatMessageResponse<T>;\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 !!message.readBy;\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<T> | undefined) {\n    if (!channel) {\n      return;\n    }\n    this.activeChannelSubscriptions.forEach((s) => s.unsubscribe());\n    this.activeChannelSubscriptions = [];\n  }\n\n  private async queryChannels(queryType: ChannelQueryType) {\n    if (!this.channelManager) {\n      throw new Error(\n        'Query channels called before initializing ChannelService',\n      );\n    }\n    try {\n      this.channelQueryStateSubject.next({ state: 'in-progress' });\n\n      if (this.customChannelQuery) {\n        const result = await this.customChannelQuery(queryType);\n        const currentChannels = this.channels;\n        const filteredChannels = result.channels.filter(\n          (channel, index) =>\n            !currentChannels.slice(0, index).find((c) => c.cid === channel.cid),\n        );\n        this.channelManager.setChannels(filteredChannels);\n        this.hasMoreChannelsSubject.next(result.hasMorePage);\n      } else {\n        if (queryType === 'first-page' || queryType === 'recover-state') {\n          if (!this.channelQueryConfig) {\n            throw new Error('Channel query config not initialized');\n          }\n          await this.channelManager.queryChannels(\n            { ...this.channelQueryConfig.filters },\n            this.channelQueryConfig.sort,\n            this.channelQueryConfig.options,\n          );\n        } else {\n          await this.channelManager.loadNext();\n        }\n      }\n\n      if (this.channelManagerSubscriptions.length === 0) {\n        this.channelManagerSubscriptions.push(\n          this.channelManager.state.subscribeWithSelector(\n            (s) => ({ channels: s.channels }),\n            ({ channels }) => {\n              const activeChannel = this.activeChannel;\n              if (\n                !this.isStateRecoveryInProgress$.getValue() &&\n                activeChannel &&\n                !channels.find((c) => c.cid === activeChannel.cid)\n              ) {\n                this.deselectActiveChannel();\n              }\n              this.channelsSubject.next(channels);\n            },\n          ),\n        );\n        if (!this.customChannelQuery) {\n          this.channelManagerSubscriptions.push(\n            this.channelManager.state.subscribeWithSelector(\n              (s) => ({ hasNext: s.pagination?.hasNext ?? true }),\n              ({ hasNext }) => this.hasMoreChannelsSubject.next(hasNext),\n            ),\n          );\n        }\n      }\n\n      if (queryType === 'recover-state') {\n        await this.maybeRestoreActiveChannelAfterRecovery();\n      }\n\n      const activeChannel = this.activeChannelSubject.getValue();\n      const shouldSetActiveChannel =\n        queryType === 'next-page' ? false : this.shouldSetActiveChannel;\n      if (\n        this.channels.length > 0 &&\n        !activeChannel &&\n        shouldSetActiveChannel\n      ) {\n        this.setAsActiveChannel(this.channels[0]);\n      }\n\n      this.channelQueryStateSubject.next({ state: 'success' });\n      this.dismissErrorNotification?.();\n      return this.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      if (queryType === 'recover-state') {\n        this.deselectActiveChannel();\n        this.channelManager.setChannels([]);\n      }\n      if (queryType !== 'next-page') {\n        this.dismissErrorNotification =\n          this.notificationService.addPermanentNotification(\n            'streamChat.Error loading channels',\n            'error',\n          );\n      }\n      throw error;\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<T> | MessageResponse<T> | FormatMessageResponse<T>,\n    channel?: Channel<T>,\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.quoted_message.translation = getMessageTranslation(\n          message.quoted_message,\n          channel,\n          this.chatClientService.chatClient.user,\n        );\n      }\n      if (this.isFormatMessageResponse(message)) {\n        message.readBy = isThreadMessage\n          ? []\n          : channel\n            ? getReadBy(message, channel)\n            : [];\n        message.translation = getMessageTranslation(\n          message,\n          channel,\n          this.chatClientService.chatClient.user,\n        );\n\n        return message;\n      } else {\n        message = this.formatMessage(message);\n        message.readBy = isThreadMessage\n          ? []\n          : channel\n            ? getReadBy(message, channel)\n            : [];\n        message.translation = getMessageTranslation(\n          message,\n          channel,\n          this.chatClientService.chatClient.user,\n        );\n        return message;\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<T>) {\n    channel.state.messages.forEach((m) => {\n      m.readBy = getReadBy(m, channel);\n      m.translation = getMessageTranslation(\n        m,\n        channel,\n        this.chatClientService.chatClient.user,\n      );\n      if (m.quoted_message) {\n        m.quoted_message.translation = 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,\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<T>, 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<T>) {\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 _init(\n    options: ChannelServiceOptions<T> & { messagePageSize: number },\n  ) {\n    this.messagePageSize = options.messagePageSize;\n\n    this.shouldSetActiveChannel =\n      options?.shouldSetActiveChannel ?? this.shouldSetActiveChannel;\n    const eventHandlerOverrides = options?.eventHandlerOverrides;\n    const managerOptions = { ...options };\n    delete managerOptions?.eventHandlerOverrides;\n    delete managerOptions?.shouldSetActiveChannel;\n\n    this.createChannelManager({\n      eventHandlerOverrides,\n      options: managerOptions,\n    });\n\n    this.clientEventsSubscription = this.chatClientService.events$.subscribe(\n      (notification) => void this.handleNotification(notification),\n    );\n    return this.queryChannels('first-page');\n  }\n\n  private createChannelManager({\n    eventHandlerOverrides,\n    options,\n  }: {\n    eventHandlerOverrides?: ChannelManagerEventHandlerOverrides<T>;\n    options?: ChannelManagerOptions;\n  }) {\n    this.channelManager = new ChannelManager({\n      client: this.chatClientService.chatClient,\n      options: {\n        ...options,\n        allowNotLoadedChannelPromotionForEvent: {\n          'message.new': false,\n          'channel.visible': true,\n          'notification.added_to_channel': true,\n          'notification.message_new': true,\n          ...options?.allowNotLoadedChannelPromotionForEvent,\n        },\n      },\n      eventHandlerOverrides,\n    });\n    this.channelManager.registerSubscriptions();\n  }\n\n  private destroyChannelManager() {\n    this.channelManager?.unregisterSubscriptions();\n    this.channelManager = undefined;\n    this.channelManagerSubscriptions.forEach((unsubscribe) => unsubscribe());\n    this.channelManagerSubscriptions = [];\n    this.channelsSubject.next(undefined);\n    this.hasMoreChannelsSubject.next(true);\n  }\n\n  private async maybeRestoreActiveChannelAfterRecovery() {\n    const previousActiveChannel = this.activeChannelSubject.getValue();\n    if (!previousActiveChannel) {\n      return;\n    }\n    try {\n      if (!this.channels.find((c) => c.cid === previousActiveChannel?.cid)) {\n        await previousActiveChannel.watch();\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(previousActiveChannel);\n        let messages!: StreamMessage<T>[];\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        this.channelManager?.setChannels(\n          promoteChannel({\n            channels: this.channels,\n            channelToMove: previousActiveChannel,\n            sort: this.channelQueryConfig?.sort ?? [],\n          }),\n        );\n      }\n    } catch (error) {\n      this.chatClientService.chatClient.logger(\n        'warn',\n        'Unable to refetch active channel after state recover',\n        error as Record<string, unknown>,\n      );\n      this.deselectActiveChannel();\n    }\n  }\n}\n"]}