stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/channel.d.ts

@@ -3,26 +3,79 @@ import { ChannelState } from './channel_state';
 import { CooldownTimer } from './CooldownTimer';
 import { MessageComposer } from './messageComposer';
 import { MessageReceiptsTracker } from './messageDelivery';
+import { MessagePaginator, PinnedMessagePaginator } from './pagination/paginators';
+import { MessageOperations } from './messageOperations';
 import type { StreamChat } from './client';
-import type { AIState, APIResponse, AscDesc, BanUserOptions, ChannelAPIResponse, ChannelData, ChannelMemberAPIResponse, ChannelMemberResponse, ChannelPushPreference, ChannelQueryOptions, ChannelResponse, ChannelUpdateOptions, CreateDraftResponse, DeleteChannelAPIResponse, DraftMessagePayload, Event, EventAPIResponse, EventHandler, EventTypes, GetDraftResponse, GetMultipleMessagesAPIResponse, GetReactionsAPIResponse, GetRepliesAPIResponse, LiveLocationPayload, LocalMessage, MarkReadOptions, MarkUnreadOptions, MemberFilters, MemberSort, Message, MessageFilters, MessageOptions, MessagePaginationOptions, MessageResponse, MessageSetType, MuteChannelAPIResponse, NewMemberPayload, PartialUpdateChannel, PartialUpdateChannelAPIResponse, PartialUpdateMember, PartialUpdateMemberAPIResponse, PinnedMessagePaginationOptions, PinnedMessagesSort, PollVoteData, QueryChannelAPIResponse, QueryMembersOptions, Reaction, ReactionAPIResponse, SearchAPIResponse, SearchOptions, SendMessageAPIResponse, SendMessageOptions, SendReactionOptions, StaticLocationPayload, TruncateChannelAPIResponse, TruncateOptions, UnBanUserOptions, UpdateChannelAPIResponse, UpdateChannelOptions, UpdateLocationPayload, UserResponse } from './types';
-import type { Role } from './permissions';
+import type { AIState, APIResponse, BanUserOptions, ChannelData, ChannelGetOrCreateRequest, ChannelMemberResponse, ChannelResponse, ChannelStateResponseFields, ChannelUpdateOptions, CreateDraftResponse, DeleteMessageOptions, Event, EventAPIResponse, EventHandler, EventPayload, EventType, GetRepliesAPIResponse, GetRepliesRequest, LocalMessage, MarkReadRequest, MarkUnreadRequest, MessageRequest, MessageResponse, MessageSetType, PinnedMessagePaginationOptions, PinnedMessagesSort, QueryMembersPayload, ReactionAPIResponse, ReactionRequest, SearchPayload, SendMessageOptions, SendReactionRequest, SharedLocation, UnBanUserOptions, UpdateChannelPartialRequest, UpdateLiveLocationRequest, UpdateMessageOptions, UserResponse } from './types';
+import type { RoleName } from './permissions';
+import { StateStore } from './store';
+import type { ChannelMemberRequest as Gen_ChannelMemberRequest, ChannelPushPreferencesResponse as Gen_ChannelPushPreferencesResponse, ChannelStopWatchingRequest as Gen_ChannelStopWatchingRequest, CreateDraftRequest as Gen_CreateDraftRequest, HideChannelRequest as Gen_HideChannelRequest, MuteChannelRequest as Gen_MuteChannelRequest, SendMessageRequest as Gen_SendMessageRequest, ShowChannelRequest as Gen_ShowChannelRequest, UnmuteChannelRequest as Gen_UnmuteChannelRequest, UpdateChannelRequest as Gen_UpdateChannelRequest, WSEvent } from './gen/models';
+import type { ChatApi } from './gen/chat/ChatApi';
+import { ChannelApi } from './gen/chat/ChannelApi';
+export type SendMessageWithStateUpdateParams = {
+    localMessage: LocalMessage;
+    message?: MessageRequest;
+    options?: SendMessageOptions;
+    /**
+     * Per-call override for the send/retry request (advanced).
+     * If set, it takes precedence over channel instance configuration handlers.
+     */
+    sendMessageRequestFn?: CustomSendMessageRequestFn;
+};
+export type RetrySendMessageWithLocalUpdateParams = Omit<SendMessageWithStateUpdateParams, 'message'>;
+export type UpdateMessageWithStateUpdateParams = {
+    localMessage: LocalMessage;
+    options?: UpdateMessageOptions;
+    /**
+     * Per-call override for the update request (advanced).
+     * If set, it takes precedence over channel instance configuration handlers.
+     */
+    updateMessageRequestFn?: CustomUpdateMessageRequestFn;
+};
+export type DeleteMessageWithStateUpdateParams = {
+    localMessage: LocalMessage;
+    options?: DeleteMessageOptions;
+    /**
+     * Per-call override for the delete request (advanced).
+     * If set, it takes precedence over channel instance configuration handlers.
+     */
+    deleteMessageRequestFn?: CustomDeleteMessageRequestFn;
+};
+export type CustomSendMessageRequestFn = (params: Omit<SendMessageWithStateUpdateParams, 'sendMessageRequestFn'>) => Promise<{
+    message: MessageResponse;
+}>;
+export type CustomUpdateMessageRequestFn = (params: Omit<UpdateMessageWithStateUpdateParams, 'updateMessageRequestFn'>) => Promise<{
+    message: MessageResponse;
+}>;
+export type CustomDeleteMessageRequestFn = (params: Omit<DeleteMessageWithStateUpdateParams, 'deleteMessageRequestFn'>) => Promise<{
+    message: MessageResponse;
+}>;
+export type CustomMarkReadRequestFn = (params: {
+    channel: Channel;
+    options?: MarkReadRequest;
+}) => Promise<EventAPIResponse | null>;
+export type ChannelInstanceConfig = {
+    requestHandlers?: {
+        deleteMessageRequest?: CustomDeleteMessageRequestFn;
+        markReadRequest?: CustomMarkReadRequestFn;
+        sendMessageRequest?: CustomSendMessageRequestFn;
+        retrySendMessageRequest?: CustomSendMessageRequestFn;
+        updateMessageRequest?: CustomUpdateMessageRequestFn;
+    };
+};
 /**
- * Channel - The Channel class manages it's own state.
+ * The Channel class manages its own state.
  */
-export declare class Channel {
+export declare class Channel extends ChannelApi {
     _client: StreamChat;
-    type: string;
-    id: string | undefined;
-    data: Partial<ChannelData & ChannelResponse> | undefined;
-    _data: Partial<ChannelData & ChannelResponse>;
+    data: Partial<ChannelResponse> | undefined;
+    _data: ChannelData;
     cid: string;
     /**  */
-    listeners: {
-        [key: string]: (string | EventHandler)[];
-    };
+    listeners: Map<EventType, Set<EventHandler>>;
     state: ChannelState;
     /**
-     * This boolean is a vague indication of weather the channel exists on chat backend.
+     * This boolean is a vague indication of whether the channel exists on chat backend.
      *
      * If the value is true, then that means the channel has been initialized by either calling
      * channel.create() or channel.query() or channel.watch().
@@ -32,7 +85,7 @@ export declare class Channel {
      */
     initialized: boolean;
     /**
-     * Indicates weather channel has been initialized by manually populating the state with some messages, members etc.
+     * Indicates whether channel has been initialized by manually populating the state with some messages, members etc.
      * Static state indicates that channel exists on backend, but is not being watched yet.
      */
     offlineMode: boolean;
@@ -40,410 +93,364 @@ export declare class Channel {
     lastTypingEvent: Date | null;
     isTyping: boolean;
     disconnected: boolean;
-    push_preferences?: ChannelPushPreference;
+    push_preferences?: Gen_ChannelPushPreferencesResponse;
+    readonly configState: StateStore<ChannelInstanceConfig>;
     readonly messageComposer: MessageComposer;
     readonly messageReceiptsTracker: MessageReceiptsTracker;
+    readonly messagePaginator: MessagePaginator;
+    readonly pinnedMessagesPaginator: PinnedMessagePaginator;
+    readonly messageOperations: MessageOperations;
     readonly cooldownTimer: CooldownTimer;
     /**
-     * constructor - Create a channel
-     *
-     * @param {StreamChat} client the chat client
-     * @param {string} type  the type of channel
-     * @param {string} [id]  the id of the chat
-     * @param {ChannelData} data any additional custom params
+     * Creates a `Channel` instance bound to the given chat client.
      *
-     * @return {Channel} Returns a new uninitialized channel
+     * @param client - The chat client.
+     * @param type - The type of channel.
+     * @param id - The ID of the chat (optional).
+     * @param data - Any additional custom params.
+     * @returns A new uninitialized channel.
      */
     constructor(client: StreamChat, type: string, id: string | undefined, data: ChannelData);
     /**
-     * getClient - Get the chat client for this channel. If client.disconnect() was called, this function will error
+     * Returns the chat client for this channel. Throws if `client.disconnect()` was called.
      *
-     * @return {StreamChat}
+     * @returns The chat client.
      */
     getClient(): StreamChat;
     /**
-     * getConfig - Get the config for this channel id (cid)
+     * Returns the config for this channel ID (CID).
      *
-     * @return {Record<string, unknown>}
+     * @returns The channel config.
      */
-    getConfig(): import("./types").ChannelConfigWithInfo | undefined;
+    getConfig(): import(".").ChannelConfigWithInfo | undefined;
+    _sendMessage(request: Gen_SendMessageRequest): Promise<import("./types").StreamResponse<import(".").SendMessageResponse>>;
     /**
-     * sendMessage - Send a message to this channel
+     * Sends a message to this channel.
      *
-     * @param {Message} message The Message object
-     * @param {boolean} [options.skip_enrich_url] Do not try to enrich the URLs within message
-     * @param {boolean} [options.skip_push] Skip sending push notifications
-     * @param {boolean} [options.is_pending_message] DEPRECATED, please use `pending` instead.
-     * @param {boolean} [options.pending] Make this message pending
-     * @param {Record<string,string>} [options.pending_message_metadata] Metadata for the pending message
-     * @param {boolean} [options.force_moderation] Apply force moderation for server-side requests
-     *
-     * @return {Promise<SendMessageAPIResponse>} The Server Response
+     * @param request - The send message request payload, including the message body and optional flags
+     *   such as `skip_enrich_url`, `skip_push`, and `keep_channel_hidden`.
+     * @returns The server response.
      */
-    _sendMessage(message: Message, options?: SendMessageOptions): Promise<SendMessageAPIResponse>;
-    sendMessage(message: Message, options?: SendMessageOptions): Promise<SendMessageAPIResponse>;
+    sendMessage(request: Gen_SendMessageRequest): Promise<import("./types").StreamResponse<import(".").SendMessageResponse>>;
     /**
-     * Upload a file to this channel’s file endpoint (multipart). Forwards to the client’s `sendFile` implementation.
-     *
-     * @param uri File source: URL string, `File`, `Buffer`, or readable stream (Node).
-     * @param name File name sent in the multipart body.
-     * @param contentType MIME type; defaults are applied when omitted.
-     * @param user Optional user payload appended to the form as JSON.
-     * @param axiosRequestConfig Optional Axios per-request config, merged after upload defaults (e.g. `onUploadProgress`, `signal` from `AbortController`).
-     * @return Promise resolving to `{ file: string, ... }` with the CDN URL.
+     * Sends a message with optimistic local state update.
      */
-    sendFile(uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse, axiosRequestConfig?: AxiosRequestConfig): Promise<import("./types").SendFileAPIResponse>;
+    sendMessageWithLocalUpdate(params: SendMessageWithStateUpdateParams): Promise<void>;
     /**
-     * Upload an image to this channel’s image endpoint (multipart). Uses the same transport as `sendFile`.
-     *
-     * @param uri Image source: URL string, `File`, or readable stream (Node). For `Buffer` uploads, use `sendFile` toward the channel file endpoint instead.
-     * @param name File name sent in the multipart body.
-     * @param contentType MIME type.
-     * @param user Optional user payload appended to the form as JSON.
-     * @param axiosRequestConfig Optional Axios per-request config, merged after upload defaults (e.g. `onUploadProgress`, `signal`).
-     * @return Promise resolving to `{ file: string, ... }` with the CDN URL.
+     * Retry sending a failed message.
      */
-    sendImage(uri: string | NodeJS.ReadableStream | File, name?: string, contentType?: string, user?: UserResponse, axiosRequestConfig?: AxiosRequestConfig): Promise<import("./types").SendFileAPIResponse>;
-    deleteFile(url: string): Promise<APIResponse>;
-    deleteImage(url: string): Promise<APIResponse>;
+    retrySendMessageWithLocalUpdate(params: Omit<SendMessageWithStateUpdateParams, 'message'>): Promise<void>;
     /**
-     * sendEvent - Send an event on this channel
-     *
-     * @param {Event} event for example {type: 'message.read'}
-     *
-     * @return {Promise<EventAPIResponse>} The Server Response
+     * Updates a message with optimistic local state update.
      */
-    sendEvent(event: Event): Promise<EventAPIResponse>;
+    updateMessageWithLocalUpdate(params: UpdateMessageWithStateUpdateParams): Promise<void>;
     /**
-     * search - Query messages
-     *
-     * @param {MessageFilters | string}  query search query or object MongoDB style filters
-     * @param {{client_id?: string; connection_id?: string; query?: string; message_filter_conditions?: MessageFilters}} options Option object, {user_id: 'tommaso'}
-     *
-     * @return {Promise<SearchAPIResponse>} search messages response
+     * Deletes a message with local state update.
      */
-    search(query: MessageFilters | string, options?: SearchOptions & {
-        client_id?: string;
-        connection_id?: string;
-        message_filter_conditions?: MessageFilters;
-        message_options?: MessageOptions;
-        query?: string;
-    }): Promise<SearchAPIResponse>;
+    deleteMessageWithLocalUpdate(params: DeleteMessageWithStateUpdateParams): Promise<void>;
     /**
-     * queryMembers - Query Members
-     *
-     * @param {MemberFilters}  filterConditions object MongoDB style filters
-     * @param {MemberSort} [sort] Sort options, for instance [{created_at: -1}].
-     * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{name: -1}, {created_at: 1}]
-     * @param {{ limit?: number; offset?: number }} [options] Option object, {limit: 10, offset:10}
-     *
-     * @return {Promise<ChannelMemberAPIResponse>} Query Members response
+     * Adds a reaction with an optimistic local state update: the reaction is applied to the cached
+     * message immediately ({@link applyReactionLocally}), then the request is
+     * fired via {@link Channel.sendReaction} (which owns the offline-DB write + queue). The
+     * server-authoritative counts reconcile on the response; the message is rolled back on failure.
      */
-    queryMembers(filterConditions: MemberFilters, sort?: MemberSort, options?: QueryMembersOptions): Promise<ChannelMemberAPIResponse>;
+    addReactionWithLocalUpdate({ messageId, reaction, options, }: {
+        messageId: string;
+        reaction: ReactionRequest;
+        options?: Pick<SendReactionRequest, 'enforce_unique' | 'skip_push'>;
+    }): Promise<void>;
     /**
-     * updateMemberPartial - Partial update a member
-     *
-     * @param {PartialUpdateMember}  updates
-     * @param {{ user_id?: string }} [options] Option object, {user_id: 'jane'} to optionally specify the user id
-  
-     * @return {Promise<ChannelMemberResponse>} Updated member
+     * Removes the current user's reaction with an optimistic local state update, mirroring
+     * {@link Channel.addReactionWithLocalUpdate}.
      */
-    updateMemberPartial(updates: PartialUpdateMember, options?: {
-        userId?: string;
-    }): Promise<PartialUpdateMemberAPIResponse>;
+    deleteReactionWithLocalUpdate({ messageId, type, }: {
+        messageId: string;
+        type: string;
+    }): Promise<void>;
     /**
-     * @deprecated Use `updateMemberPartial` instead
-     * partialUpdateMember - Partial update a member
-     *
-     * @param {string} user_id member user id
-     * @param {PartialUpdateMember}  updates
+     * Upload a file to this channel’s file endpoint (multipart). Forwards to the client’s `sendFile` implementation.
      *
-     * @return {Promise<ChannelMemberResponse>} Updated member
+     * @param uri - File source: URL string, `File`, `Buffer`, or readable stream (Node).
+     * @param name - File name sent in the multipart body (optional).
+     * @param contentType - MIME type; defaults are applied when omitted (optional).
+     * @param user - User payload appended to the form as JSON (optional).
+     * @param axiosRequestConfig - Axios per-request config, merged after upload defaults, e.g. `onUploadProgress`, `signal` from `AbortController` (optional).
+     * @returns A promise resolving to `{ file: string, ... }` with the CDN URL.
      */
-    partialUpdateMember(user_id: string, updates: PartialUpdateMember): Promise<PartialUpdateMemberAPIResponse>;
+    sendFile(uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string, user?: UserResponse, axiosRequestConfig?: AxiosRequestConfig): Promise<import("./types").SendFileAPIResponse>;
     /**
-     * sendReaction - Sends a reaction to a message. If offline support is enabled, it will make sure
-     * that sending the reaction is queued up if it fails due to bad internet conditions and executed
-     * later.
+     * Upload an image to this channel's image endpoint (multipart). Uses the same transport as `sendFile`.
      *
-     * @param {string} messageID the message id
-     * @param {Reaction} reaction the reaction object for instance {type: 'love'}
-     * @param {{ enforce_unique?: boolean, skip_push?: boolean }} [options] Option object, {enforce_unique: true, skip_push: true} to override any existing reaction or skip sending push notifications
-     *
-     * @return {Promise<ReactionAPIResponse>} The Server Response
+     * @param uri - Image source: URL string, `File`, or readable stream (Node). For `Buffer` uploads, use `sendFile` toward the channel file endpoint instead.
+     * @param name - File name sent in the multipart body (optional).
+     * @param contentType - MIME type (optional).
+     * @param user - User payload appended to the form as JSON (optional).
+     * @param axiosRequestConfig - Axios per-request config, merged after upload defaults, e.g. `onUploadProgress`, `signal` (optional).
+     * @returns A promise resolving to `{ file: string, ... }` with the CDN URL.
      */
-    sendReaction(messageID: string, reaction: Reaction, options?: SendReactionOptions): Promise<ReactionAPIResponse>;
+    sendImage(uri: string | NodeJS.ReadableStream | File, name?: string, contentType?: string, user?: UserResponse, axiosRequestConfig?: AxiosRequestConfig): Promise<import("./types").SendFileAPIResponse>;
+    deleteFile(url: string): Promise<import("./types").StreamResponse<import(".").Response>>;
+    deleteImage(url: string): Promise<import("./types").StreamResponse<import(".").Response>>;
     /**
-     * sendReaction - Send a reaction about a message
+     * Sends an event on this channel.
      *
-     * @param {string} messageID the message id
-     * @param {Reaction} reaction the reaction object for instance {type: 'love'}
-     * @param {{ enforce_unique?: boolean, skip_push?: boolean }} [options] Option object, {enforce_unique: true, skip_push: true} to override any existing reaction or skip sending push notifications
-     *
-     * @return {Promise<ReactionAPIResponse>} The Server Response
+     * @param event - For example `{ type: 'message.read' }`.
+     * @returns The server response.
      */
-    _sendReaction(messageID: string, reaction: Reaction, options?: SendReactionOptions): Promise<ReactionAPIResponse>;
-    deleteReaction(messageID: string, reactionType: string, user_id?: string): Promise<ReactionAPIResponse>;
+    sendEvent(request: {
+        event: Event;
+    }): Promise<import("./types").StreamResponse<import(".").EventResponse>>;
     /**
-     * deleteReaction - Delete a reaction by user and type
-     *
-     * @param {string} messageID the id of the message from which te remove the reaction
-     * @param {string} reactionType the type of reaction that should be removed
-     * @param {string} [user_id] the id of the user (used only for server side request) default null
+     * Queries messages.
      *
-     * @return {Promise<ReactionAPIResponse>} The Server Response
+     * @param request - The search request payload (optional). The inner `payload` accepts
+     *   MongoDB-style filters and additional options such as `user_id`.
+     * @returns The search messages response.
      */
-    _deleteReaction(messageID: string, reactionType: string, user_id?: string): Promise<ReactionAPIResponse>;
+    search(request?: {
+        payload?: SearchPayload;
+    }): Promise<import("./types").StreamResponse<import(".").SearchResponse>>;
     /**
-     * update - Edit the channel's custom properties
+     * Queries members.
      *
-     * @param {ChannelData} channelData The object to update the custom properties of this channel with
-     * @param {Message} [updateMessage] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param request - The query members request payload (optional). The inner `payload` accepts
+     *   MongoDB-style filters, sort directions (e.g. `[{ field: 'created_at', direction: -1 }]`),
+     *   and pagination options (`limit`, `offset`).
+     * @returns The query members response.
      */
-    update(channelData?: Partial<ChannelData & ChannelResponse>, updateMessage?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    queryMembers(request?: {
+        payload?: Partial<QueryMembersPayload>;
+    }): Promise<import("./types").StreamResponse<import(".").MembersResponse>>;
     /**
-     * updatePartial - partial update channel properties
-     *
-     * @param {PartialUpdateChannel} partial update request
+     * Sends a reaction to a message. If offline support is enabled, it will make sure
+     * that sending the reaction is queued up if it fails due to bad internet conditions and executed
+     * later.
      *
-     * @return {Promise<PartialUpdateChannelAPIResponse>}
+     * @param request - The send-reaction request payload, including the target message ID, the
+     *   reaction object (e.g. `{ type: 'love' }`), and optional flags such as `enforce_unique` and
+     *   `skip_push`.
+     * @returns The server response.
      */
-    updatePartial(update: PartialUpdateChannel): Promise<PartialUpdateChannelAPIResponse>;
+    sendReaction(request: Parameters<ChatApi['sendReaction']>[0]): Promise<ReactionAPIResponse>;
+    _sendReaction(request: Parameters<ChatApi['sendReaction']>[0]): Promise<import("./types").StreamResponse<import(".").SendReactionResponse>>;
+    deleteReaction(request: Parameters<ChatApi['deleteReaction']>[0]): Promise<ReactionAPIResponse>;
     /**
-     * enableSlowMode - enable slow mode
+     * Deletes a reaction by user and type.
      *
-     * @param {number} coolDownInterval the cooldown interval in seconds
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param request - The delete reaction request payload identifying the target message and reaction type.
+     * @returns The server response.
      */
-    enableSlowMode(coolDownInterval: number): Promise<UpdateChannelAPIResponse>;
+    _deleteReaction(request: Parameters<ChatApi['deleteReaction']>[0]): Promise<import("./types").StreamResponse<import(".").DeleteReactionResponse>>;
     /**
-     * disableSlowMode - disable slow mode
+     * Edit the channel using the inherited `update()` from `ChannelApi`. Caches the
+     * server-returned channel onto `this.data`.
      *
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param request - Channel update payload, e.g. `{ data: { name: 'foo' }, message }` (optional).
+     * @returns The server response.
      */
-    disableSlowMode(): Promise<UpdateChannelAPIResponse>;
-    sendSharedLocation(location: StaticLocationPayload | LiveLocationPayload, userId?: string): Promise<SendMessageAPIResponse>;
-    stopLiveLocationSharing(payload: UpdateLocationPayload): Promise<void>;
+    update(request?: Gen_UpdateChannelRequest): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * delete - Delete the channel. Messages are permanently removed.
+     * Partial update of channel properties.
      *
-     * @param {boolean} [options.hard_delete] Defines if the channel is hard deleted or not
-     *
-     * @return {Promise<DeleteChannelAPIResponse>} The server response
+     * @param update - The partial update request.
+     * @returns The server response.
      */
-    delete(options?: {
-        hard_delete?: boolean;
-    }): Promise<DeleteChannelAPIResponse>;
+    updatePartial(update: UpdateChannelPartialRequest): Promise<import("./types").StreamResponse<import(".").UpdateChannelPartialResponse>>;
     /**
-     * truncate - Removes all messages from the channel
-     * @param {TruncateOptions} [options] Defines truncation options
-     * @return {Promise<TruncateChannelAPIResponse>} The server response
+     * Enables slow mode.
+     *
+     * @param coolDownInterval - The cooldown interval in seconds.
+     * @returns The server response.
      */
-    truncate(options?: TruncateOptions): Promise<TruncateChannelAPIResponse>;
+    enableSlowMode(coolDownInterval: number): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * acceptInvite - accept invitation to the channel
-     *
-     * @param {UpdateChannelOptions} [options] The object to update the custom properties of this channel with
+     * Disables slow mode.
      *
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @returns The server response.
      */
-    acceptInvite(options?: UpdateChannelOptions): Promise<UpdateChannelAPIResponse>;
+    disableSlowMode(): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
+    sendSharedLocation(location: SharedLocation & {
+        message_id?: string;
+    }): Promise<import("./types").StreamResponse<import(".").SendMessageResponse>>;
+    stopLiveLocationSharing(payload: UpdateLiveLocationRequest): Promise<void>;
     /**
-     * rejectInvite - reject invitation to the channel
+     * Accepts an invitation to the channel.
      *
-     * @param {UpdateChannelOptions} [options] The object to update the custom properties of this channel with
+     * @param options - The object to update the custom properties of this channel with (optional, defaults to `{}`).
+     * @returns The server response.
+     */
+    acceptInvite(options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
+    /**
+     * Rejects an invitation to the channel.
      *
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param options - The object to update the custom properties of this channel with (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    rejectInvite(options?: UpdateChannelOptions): Promise<UpdateChannelAPIResponse>;
+    rejectInvite(options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * addMembers - add members to the channel
+     * Adds members to the channel.
      *
-     * @param {string[] | Array<NewMemberPayload>} members An array of members to add to the channel
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param members - An array of members to add to the channel.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    addMembers(members: string[] | Array<NewMemberPayload>, message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    addMembers(members: string[] | Array<Gen_ChannelMemberRequest>, message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * addFilterTags - add filter tags to the channel
+     * Adds filter tags to the channel.
      *
-     * @param {string[]} tags An array of tags to add to the channel
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param tags - An array of tags to add to the channel.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    addFilterTags(tags: string[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    addFilterTags(tags: string[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * removeFilterTags - remove filter tags from the channel
+     * Removes filter tags from the channel.
      *
-     * @param {string[]} tags An array of tags to remove from the channel
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param tags - An array of tags to remove from the channel.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    removeFilterTags(tags: string[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    removeFilterTags(tags: string[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * addModerators - add moderators to the channel
+     * Adds moderators to the channel.
      *
-     * @param {string[]} members An array of member identifiers
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param members - An array of member identifiers.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    addModerators(members: string[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    addModerators(members: string[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * assignRoles - sets member roles in a channel
+     * Sets member roles in a channel.
      *
-     * @param {{channel_role: Role, user_id: string}[]} roles List of role assignments
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param roles - List of role assignments.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
     assignRoles(roles: {
-        channel_role: Role;
+        channel_role: RoleName;
         user_id: string;
-    }[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    }[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * inviteMembers - invite members to the channel
+     * Invite members to the channel.
      *
-     * @param {string[] | Array<NewMemberPayload>} members An array of members to invite to the channel
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param members - An array of members to invite to the channel.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    inviteMembers(members: string[] | Required<Omit<NewMemberPayload, 'channel_role'>>[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    inviteMembers(members: string[] | Required<Omit<Gen_ChannelMemberRequest, 'channel_role'>>[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * removeMembers - remove members from channel
+     * Removes members from the channel.
      *
-     * @param {string[]} members An array of member identifiers
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param members - An array of member identifiers.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    removeMembers(members: string[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    removeMembers(members: string[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * demoteModerators - remove moderator role from channel members
+     * Removes the moderator role from channel members.
      *
-     * @param {string[]} members An array of member identifiers
-     * @param {Message} [message] Optional message object for channel members notification
-     * @param {ChannelUpdateOptions} [options] Option object, configuration to control the behavior while updating
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
+     * @param members - An array of member identifiers.
+     * @param message - Message object for channel members notification (optional).
+     * @param options - Configuration to control the behavior while updating (optional, defaults to `{}`).
+     * @returns The server response.
      */
-    demoteModerators(members: string[], message?: Message, options?: ChannelUpdateOptions): Promise<UpdateChannelAPIResponse>;
+    demoteModerators(members: string[], message?: MessageRequest, options?: ChannelUpdateOptions): Promise<import("./types").StreamResponse<import(".").UpdateChannelResponse>>;
     /**
-     * _update - executes channel update request
-     * @param payload Object Update Channel payload
-     * @return {Promise<UpdateChannelAPIResponse>} The server response
-     * TODO: introduce new type instead of Object in the next major update
-     */
-    _update(payload: object): Promise<UpdateChannelAPIResponse>;
-    /**
-     * mute - mutes the current channel
-     * @param {{ user_id?: string, expiration?: string }} opts expiration in minutes or user_id
-     * @return {Promise<MuteChannelAPIResponse>} The server response
+     * Mutes the current channel.
      *
-     * example with expiration:
-     * await channel.mute({expiration: moment.duration(2, 'weeks')});
+     * @example
+     * // with expiration
+     * await channel.mute({ expiration: moment.duration(2, 'weeks') });
      *
-     * example server side:
-     * await channel.mute({user_id: userId});
+     * @example
+     * // server side
+     * await channel.mute({ user_id: userId });
      *
+     * @param options - Mute options (optional, defaults to `{}`).
+     * @param options.expiration - Expiration in minutes (optional).
+     * @returns The server response.
      */
-    mute(opts?: {
-        expiration?: number;
-        user_id?: string;
-    }): Promise<MuteChannelAPIResponse>;
+    mute(options?: Gen_MuteChannelRequest): Promise<import("./types").StreamResponse<import(".").MuteChannelResponse>>;
     /**
-     * unmute - mutes the current channel
-     * @param {{ user_id?: string}} opts user_id
-     * @return {Promise<APIResponse>} The server response
+     * Unmutes the current channel.
      *
-     * example server side:
-     * await channel.unmute({user_id: userId});
+     * @example
+     * // server side
+     * await channel.unmute({ user_id: userId });
+     *
+     * @param options - Unmute options (optional, defaults to `{}`).
+     * @param options.user_id - User ID (optional).
+     * @returns The server response.
      */
-    unmute(opts?: {
-        user_id?: string;
-    }): Promise<APIResponse>;
+    unmute(options?: Gen_UnmuteChannelRequest): Promise<import("./types").StreamResponse<import(".").UnmuteResponse>>;
     /**
-     * archive - archives the current channel
-     * @param {{ user_id?: string }} opts user_id if called server side
-     * @return {Promise<ChannelMemberResponse>} The server response
-     *
-     * example:
-     * await channel.archives();
+     * Archives the current channel.
      *
-     * example server side:
-     * await channel.archive({user_id: userId});
+     * @example
+     * await channel.archive();
      *
+     * @returns The server response.
      */
-    archive(opts?: {
-        user_id?: string;
-    }): Promise<ChannelMemberResponse>;
+    archive(): Promise<import("./types").StreamResponse<import(".").UpdateMemberPartialResponse>>;
     /**
-     * unarchive - unarchives the current channel
-     * @param {{ user_id?: string }} opts user_id if called server side
-     * @return {Promise<ChannelMemberResponse>} The server response
+     * Unarchives the current channel.
      *
-     * example:
+     * @example
      * await channel.unarchive();
      *
-     * example server side:
-     * await channel.unarchive({user_id: userId});
-     *
+     * @returns The server response.
      */
-    unarchive(opts?: {
-        user_id?: string;
-    }): Promise<ChannelMemberResponse>;
+    unarchive(): Promise<import("./types").StreamResponse<import(".").UpdateMemberPartialResponse>>;
     /**
-     * pin - pins the current channel
-     * @param {{ user_id?: string }} opts user_id if called server side
-     * @return {Promise<ChannelMemberResponse>} The server response
+     * Pins the current channel.
      *
-     * example:
+     * @example
      * await channel.pin();
      *
-     * example server side:
-     * await channel.pin({user_id: userId});
-     *
+     * @returns The server response.
      */
-    pin(opts?: {
-        user_id?: string;
-    }): Promise<ChannelMemberResponse>;
+    pin(): Promise<import("./types").StreamResponse<import(".").UpdateMemberPartialResponse>>;
     /**
-     * unpin - unpins the current channel
-     * @param {{ user_id?: string }} opts user_id if called server side
-     * @return {Promise<ChannelMemberResponse>} The server response
+     * Unpins the current channel.
      *
-     * example:
+     * @example
      * await channel.unpin();
      *
-     * example server side:
-     * await channel.unpin({user_id: userId});
-     *
+     * @returns The server response.
      */
-    unpin(opts?: {
-        user_id?: string;
-    }): Promise<ChannelMemberResponse>;
+    unpin(): Promise<import("./types").StreamResponse<import(".").UpdateMemberPartialResponse>>;
     /**
-     * muteStatus - returns the mute status for the current channel
-     * @return {{ muted: boolean; createdAt: Date | null; expiresAt: Date | null }} { muted: true | false, createdAt: Date | null, expiresAt: Date | null}
+     * Returns the mute status for the current channel.
+     *
+     * @returns An object of the form `{ muted: true | false, createdAt: Date | null, expiresAt: Date | null }`.
      */
     muteStatus(): {
-        createdAt: Date | null;
+        muted: boolean;
+        createdAt: Date;
         expiresAt: Date | null;
+    } | {
         muted: boolean;
+        createdAt: null;
+        expiresAt: null;
     };
-    sendAction(messageID: string, formData: Record<string, string>): Promise<SendMessageAPIResponse>;
+    sendAction(messageId: string, formData: Record<string, string>): Promise<import("./types").StreamResponse<import(".").MessageActionResponse>>;
     /**
-     * keystroke - First of the typing.start and typing.stop events based on the users keystrokes.
-     * Call this on every keystroke
+     * First of the `typing.start` and `typing.stop` events based on the user's keystrokes.
+     * Call this on every keystroke.
+     *
      * @see {@link https://getstream.io/chat/docs/typing_indicators/?language=js|Docs}
-     * @param {string} [parent_id] set this field to `message.id` to indicate that typing event is happening in a thread
+     *
+     * @param parentId - Set this field to `message.id` to indicate that the typing event is happening in a thread (optional).
+     * @param options - Optional override carrying a `user_id` (optional).
      */
-    keystroke(parent_id?: string, options?: {
+    keystroke(parentId?: string, options?: {
         user_id: string;
     }): Promise<void>;
     /**
@@ -451,8 +458,9 @@ export declare class Channel {
      * Typically used by the server connected to the AI service to notify clients of state changes.
      *
      * @param messageId - The ID of the message associated with the AI state.
-     * @param state - The new state of the AI process (e.g., thinking, generating).
-     * @param options - Optional parameters, such as `ai_message`, to include additional details in the event.
+     * @param state - The new state of the AI process, e.g. thinking, generating.
+     * @param options - Parameters such as `ai_message` to include additional details in the event (optional, defaults to `{}`).
+     * @param options.ai_message - Additional message detail to include in the event (optional).
      */
     updateAIState(messageId: string, state: AIState, options?: {
         ai_message?: string;
@@ -468,43 +476,44 @@ export declare class Channel {
      */
     stopAIResponse(): Promise<void>;
     /**
-     * stopTyping - Sets last typing to null and sends the typing.stop event
+     * Sets last typing to null and sends the `typing.stop` event.
+     *
      * @see {@link https://getstream.io/chat/docs/typing_indicators/?language=js|Docs}
-     * @param {string} [parent_id] set this field to `message.id` to indicate that typing event is happening in a thread
+     *
+     * @param parentId - Set this field to `message.id` to indicate that the typing event is happening in a thread (optional).
+     * @param options - Optional override carrying a `user_id` (optional).
      */
-    stopTyping(parent_id?: string, options?: {
+    stopTyping(parentId?: string, options?: {
         user_id: string;
     }): Promise<void>;
     _isTypingIndicatorsEnabled(): boolean;
     /**
-     * lastMessage - return the last message, takes into account that last few messages might not be perfectly sorted
+     * Run this user's mark-read reporter for this channel. Delegates to
+     * `MessageDeliveryReporter`, which batches the underlying `markRead` request
+     * with the user's read receipts state.
      *
-     * @return {ReturnType<ChannelState['formatMessage']> | undefined} Description
-     */
-    lastMessage(): LocalMessage | undefined;
-    /**
-     * markRead - Send the mark read event for this user, only works if the `read_events` setting is enabled. Syncs the message delivery report candidates local state.
+     * Use the inherited `markRead()` from `ChannelApi` for a direct, unbatched call.
      *
-     * @param {MarkReadOptions} data
-     * @return {Promise<EventAPIResponse | null>} Description
+     * @param data - Mark read options (optional, defaults to `{}`).
      */
-    markRead(data?: MarkReadOptions): Promise<EventAPIResponse | null>;
+    markReadViaReporter(data?: MarkReadRequest): Promise<EventAPIResponse | import("./types").StreamResponse<import(".").MarkReadResponse> | null>;
     /**
-     * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is enabled
+     * Override of the inherited `markRead()` from `ChannelApi` that requires the
+     * channel to be initialized and respects the `read_events` channel config.
      *
-     * @param {MarkReadOptions} data
-     * @return {Promise<EventAPIResponse | null>} Description
+     * @param data - Mark read options (optional, defaults to `{}`).
+     * @returns The server response, or `null` if the request was skipped.
      */
-    markAsReadRequest(data?: MarkReadOptions): Promise<EventAPIResponse | null>;
+    markRead(data?: MarkReadRequest): Promise<import("./types").StreamResponse<import(".").MarkReadResponse>>;
     /**
-     * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is enabled
+     * Marks the channel as unread from `messageId`. Only works when the `read_events` setting is enabled.
      *
-     * @param {MarkUnreadOptions} data
-     * @return {APIResponse} An API response
+     * @param data - Mark unread options.
+     * @returns An API response, or `null` if the request was skipped.
      */
-    markUnread(data: MarkUnreadOptions): Promise<APIResponse | null>;
+    markUnread(data?: MarkUnreadRequest): Promise<import("./types").StreamResponse<import(".").Response>>;
     /**
-     * markReadLocally - Resets this user's unread count locally, without any backend call. Intended for
+     * Resets this user's unread count locally, without any backend call. Intended for
      * channels that have read events disabled (e.g. livestreams) when the client is created with the
      * `isLocalUnreadCountEnabled` option. Dispatches a dedicated, client-only `message.read_locally` event
      * that runs through the same `_handleChannelEvent` read logic as a real `message.read` (minus the
@@ -512,257 +521,223 @@ export declare class Channel {
      * is enabled, the offline DB persists the reset for read-events-disabled channels, so the local
      * count stays consistent across app restarts.
      *
-     * @return {Event | undefined} The dispatched `message.read_locally` event, or `undefined` if there is no connected user.
-     */
-    markReadLocally(): Event | undefined;
+     * @returns The dispatched `message.read_locally` event, or `undefined` if there is no connected user.
+     */
+    markReadLocally(): ({
+        type: "message.read_locally";
+    } & {
+        channel_type: string;
+        cid: string;
+        created_at: Date;
+        channel_id?: string;
+        last_read_message_id?: string;
+        team?: string;
+        user?: UserResponse;
+    } & {
+        received_at?: Date;
+    }) | undefined;
     /**
-     * clean - Cleans the channel state and fires stop typing if needed
+     * Cleans the channel state and fires stop typing if needed.
      */
     clean(): void;
     /**
-     * watch - Loads the initial channel state and watches for changes
+     * Loads the initial channel state and watches for changes.
      *
-     * @param {ChannelQueryOptions} options additional options for the query endpoint
-     *
-     * @return {Promise<QueryChannelAPIResponse>} The server response
+     * @param options - Additional options for the query endpoint (optional).
+     * @returns The server response.
      */
-    watch(options?: ChannelQueryOptions): Promise<QueryChannelAPIResponse>;
+    watch(options?: ChannelGetOrCreateRequest): Promise<import("./types").StreamResponse<import(".").ChannelStateResponse>>;
     /**
-     * stopWatching - Stops watching the channel
+     * Stops watching the channel.
      *
-     * @return {Promise<APIResponse>} The server response
+     * @param request - The stop-watching request payload (optional).
+     * @returns The server response.
      */
-    stopWatching(): Promise<APIResponse>;
+    stopWatching(request?: Gen_ChannelStopWatchingRequest): Promise<import("./types").StreamResponse<import(".").Response>>;
     /**
-     * getReplies - List the message replies for a parent message.
-     *
-     * The recommended way of working with threads is to use the Thread class.
+     * List the message replies for a parent message.
      *
-     * @param {string} parent_id The message parent id, ie the top of the thread
-     * @param {MessagePaginationOptions & { user?: UserResponse; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
+     * The recommended way of working with threads is to use the `Thread` class.
      *
-     * @return {Promise<GetRepliesAPIResponse>} A response with a list of messages
+     * @param request - The get-replies request payload, including the parent message ID, pagination
+     *   params, and optional sort directions for `created_at`.
+     * @returns A response with a list of messages.
      */
-    getReplies(parent_id: string, options: MessagePaginationOptions & {
-        user?: UserResponse;
-        user_id?: string;
-    }, sort?: {
-        created_at: AscDesc;
-    }[]): Promise<GetRepliesAPIResponse>;
+    getReplies(request: GetRepliesRequest): Promise<import("./types").StreamResponse<import(".").GetRepliesResponse>>;
     /**
-     * getPinnedMessages - List list pinned messages of the channel
-     *
-     * @param {PinnedMessagePaginationOptions & { user?: UserResponse; user_id?: string }} options Pagination params, ie {limit:10, id_lte: 10}
-     * @param {PinnedMessagesSort} sort defines sorting direction of pinned messages
+     * List pinned messages of the channel.
      *
-     * @return {Promise<GetRepliesAPIResponse>} A response with a list of messages
+     * @param options - Pagination params, e.g. `{ limit: 10, id_lte: 10 }`.
+     * @param sort - Defines sorting direction of pinned messages (optional, defaults to `[]`).
+     * @returns A response with a list of messages.
      */
-    getPinnedMessages(options: PinnedMessagePaginationOptions & {
-        user?: UserResponse;
-        user_id?: string;
-    }, sort?: PinnedMessagesSort): Promise<GetRepliesAPIResponse>;
+    getPinnedMessages(options: PinnedMessagePaginationOptions, sort?: PinnedMessagesSort): Promise<GetRepliesAPIResponse>;
     /**
-     * getReactions - List the reactions, supports pagination
+     * List the reactions; supports pagination.
      *
-     * @param {string} message_id The message id
-     * @param {{ limit?: number; offset?: number }} options The pagination options
-     *
-     * @return {Promise<GetReactionsAPIResponse>} Server response
+     * @param request - The request payload, including the target message ID and
+     *   pagination options (`limit`, `offset`).
+     * @returns The server response.
      */
-    getReactions(message_id: string, options: {
-        limit?: number;
-        offset?: number;
-    }): Promise<GetReactionsAPIResponse>;
+    getReactions(request: Parameters<ChatApi['getReactions']>[0]): Promise<import("./types").StreamResponse<import(".").GetReactionsResponse>>;
     /**
-     * getMessagesById - Retrieves a list of messages by ID
-     *
-     * @param {string[]} messageIds The ids of the messages to retrieve from this channel
+     * Retrieves a list of messages by ID.
      *
-     * @return {Promise<GetMultipleMessagesAPIResponse>} Server response
+     * @param messageIds - The IDs of the messages to retrieve from this channel.
+     * @returns Server response.
      */
-    getMessagesById(messageIds: string[]): Promise<GetMultipleMessagesAPIResponse>;
+    getMessagesById(messageIds: string[]): Promise<import("./types").StreamResponse<import(".").GetManyMessagesResponse>>;
     /**
-     * lastRead - returns the last time the user marked the channel as read if the user never marked the channel as read, this will return null
-     * @return {Date | null | undefined}
+     * Returns the last time the user marked the channel as read. If the user never marked the channel as read, this will return `null`.
+     *
+     * @returns The last-read `Date`, `null` if never read, or `undefined` if the user is unset.
      */
     lastRead(): Date | null | undefined;
     _countMessageAsUnread(message: LocalMessage | MessageResponse): boolean;
     /**
-     * countUnread - Count of unread messages
-     *
-     * @param {Date | null} [lastRead] lastRead the time that the user read a message, defaults to current user's read state
+     * Count of unread messages.
      *
-     * @return {number} Unread count
+     * @param lastRead - The time that the user read a message (optional, defaults to the current user's read state).
+     * @returns Unread count.
      */
     countUnread(lastRead?: Date | null): number;
     /**
-     * countUnreadMentions - Count the number of unread messages mentioning the current user
+     * Count the number of unread messages mentioning the current user.
      *
-     * @return {number} Unread mentions count
+     * @returns Unread mentions count.
      */
     countUnreadMentions(): number;
     /**
-     * create - Creates a new channel
-     *
-     * @return {Promise<QueryChannelAPIResponse>} The Server Response
+     * Creates a new channel.
      *
+     * @param options - Channel query options (optional).
+     * @returns The server response.
      */
-    create: (options?: ChannelQueryOptions) => Promise<QueryChannelAPIResponse>;
+    create: (options?: ChannelGetOrCreateRequest) => Promise<import("./types").StreamResponse<import(".").ChannelStateResponse>>;
     /**
-     * query - Query the API, get messages, members or other channel fields
+     * Queries the API to load messages, members, or other channel fields.
      *
-     * @param {ChannelQueryOptions} options The query options
-     * @param {MessageSetType} messageSetToAddToIfDoesNotExist It's possible to load disjunct sets of a channel's messages into state, use `current` to load the initial channel state or if you want to extend the currently displayed messages, use `latest` if you want to load/extend the latest messages, `new` is used for loading a specific message and it's surroundings
-     *
-     * @return {Promise<QueryChannelAPIResponse>} Returns a query response
+     * @param options - The query options (optional, defaults to `{}`).
+     * @param messageSetToAddToIfDoesNotExist - It's possible to load disjunct sets of a channel's
+     *   messages into state. Use `current` to load the initial channel state or to extend the
+     *   currently displayed messages; use `latest` to load/extend the latest messages; `new` is
+     *   used for loading a specific message and its surroundings (optional, defaults to `'current'`).
+     * @returns A query response.
      */
-    query(options?: ChannelQueryOptions, messageSetToAddToIfDoesNotExist?: MessageSetType): Promise<QueryChannelAPIResponse>;
+    query(options?: ChannelGetOrCreateRequest, messageSetToAddToIfDoesNotExist?: MessageSetType): Promise<import("./types").StreamResponse<import(".").ChannelStateResponse>>;
     /**
-     * banUser - Bans a user from a channel
+     * Bans a user from a channel.
      *
-     * @param {string} targetUserID
-     * @param {BanUserOptions} options
-     * @returns {Promise<APIResponse>}
+     * @param targetUserId - The user to ban.
+     * @param options - Ban options.
+     * @returns The server response.
      */
-    banUser(targetUserID: string, options: BanUserOptions): Promise<APIResponse>;
+    banUser(targetUserId: string, options: BanUserOptions): Promise<APIResponse>;
     /**
-     * hides the channel from queryChannels for the user until a message is added
-     * If clearHistory is set to true - all messages will be removed for the user
+     * Hides the channel from `queryChannels` for the user until a message is added.
+     * If `clear_history` is set to `true`, all messages will be removed for the user.
      *
-     * @param {string | null} userId
-     * @param {boolean} clearHistory
-     * @returns {Promise<APIResponse>}
+     * @param request - The hide channel request payload (optional). Pass `{ clear_history: true }`
+     *   to clear message history for the user.
+     * @returns The server response.
      */
-    hide(userId?: string | null, clearHistory?: boolean): Promise<APIResponse>;
+    hide(request?: Gen_HideChannelRequest): Promise<import("./types").StreamResponse<import(".").HideChannelResponse>>;
     /**
-     * removes the hidden status for a channel
+     * Removes the hidden status for a channel. Ensures the channel is initialized first.
      *
-     * @param {string | null} userId
-     * @returns {Promise<APIResponse>}
+     * @param request - The show channel request payload (optional).
+     * @returns The server response.
      */
-    show(userId?: string | null): Promise<APIResponse>;
+    show(request?: Gen_ShowChannelRequest): Promise<import("./types").StreamResponse<import(".").ShowChannelResponse>>;
     /**
-     * unbanUser - Removes the bans for a user on a channel
+     * Removes the bans for a user on a channel.
      *
-     * @param {string} targetUserID
-     * @param {UnBanUserOptions} options
-     * @returns {Promise<APIResponse>}
+     * @param targetUserId - The user to unban.
+     * @param options - Unban options (optional).
+     * @returns The server response.
      */
-    unbanUser(targetUserID: string, options?: UnBanUserOptions): Promise<APIResponse>;
+    unbanUser(targetUserId: string, options?: UnBanUserOptions): Promise<APIResponse>;
     /**
-     * shadowBan - Shadow bans a user from a channel
+     * Shadow bans a user from a channel.
      *
-     * @param {string} targetUserID
-     * @param {BanUserOptions} options
-     * @returns {Promise<APIResponse>}
+     * @param targetUserId - The user to shadow ban.
+     * @param options - Ban options.
+     * @returns The server response.
      */
-    shadowBan(targetUserID: string, options: BanUserOptions): Promise<APIResponse>;
+    shadowBan(targetUserId: string, options: BanUserOptions): Promise<APIResponse>;
     /**
-     * removeShadowBan - Removes the shadow ban for a user on a channel
+     * Removes the shadow ban for a user on a channel.
      *
-     * @param {string} targetUserID
-     * @returns {Promise<APIResponse>}
-     */
-    removeShadowBan(targetUserID: string): Promise<APIResponse>;
-    /**
-     * Cast or cancel one or more votes on a poll
-     * @param pollId string The poll id
-     * @param votes PollVoteData[] The votes that will be casted (or canceled in case of an empty array)
-     * @returns {APIResponse & PollVoteResponse} The poll votes
+     * @param targetUserId - The user to remove the shadow ban for.
+     * @returns The server response.
      */
-    vote(messageId: string, pollId: string, vote: PollVoteData): Promise<APIResponse & import("./types").CastVoteAPIResponse>;
-    removeVote(messageId: string, pollId: string, voteId: string): Promise<APIResponse & {
-        vote: import("./types").PollVote;
-    }>;
+    removeShadowBan(targetUserId: string): Promise<APIResponse>;
     /**
-     * createDraft - Creates or updates a draft message in a channel
-     *
-     * @param {DraftMessagePayload} message The draft message to create or update
+     * Casts or cancels one or more votes on a poll.
      *
-     * @return {Promise<CreateDraftResponse>} Response containing the created draft
+     * @param request - The cast-poll-vote request payload, including the target message ID, poll ID,
+     *   and the vote to cast (or an empty payload to cancel).
+     * @returns The poll vote response.
      */
-    _createDraft(message: DraftMessagePayload): Promise<CreateDraftResponse>;
+    vote(request: Parameters<ChatApi['castPollVote']>[0]): Promise<import("./types").StreamResponse<import(".").PollVoteResponse>>;
+    removeVote(request: Parameters<ChatApi['deletePollVote']>[0]): Promise<import("./types").StreamResponse<import(".").PollVoteResponse>>;
+    _createDraft(request: Gen_CreateDraftRequest): Promise<import("./types").StreamResponse<CreateDraftResponse>>;
     /**
-     * createDraft - Creates or updates a draft message in a channel. If offline support is
-     * enabled, it will make sure that creating the draft is queued up if it fails due to
-     * bad internet conditions and executed later.
-     *
-     * @param {DraftMessagePayload} message The draft message to create or update
-     *
-     * @return {Promise<CreateDraftResponse>} Response containing the created draft
+     * Creates or updates a draft message in a channel. If offline support is enabled, the
+     * call is queued so it is replayed on reconnect.
      */
-    createDraft(message: DraftMessagePayload): Promise<CreateDraftResponse>;
+    createDraft(request: Gen_CreateDraftRequest): Promise<import("./types").StreamResponse<CreateDraftResponse>>;
+    _deleteDraft(request?: Parameters<ChannelApi['deleteDraft']>[0]): Promise<import("./types").StreamResponse<import(".").Response>>;
     /**
-     * deleteDraft - Deletes a draft message from a channel or a thread.
-     *
-     * @param {Object} options
-     * @param {string} options.parent_id Optional parent message ID for drafts in threads
-     *
-     * @return {Promise<APIResponse>} API response
+     * Deletes a draft message from a channel or a thread. If offline support is enabled, the
+     * call is queued so it is replayed on reconnect.
      */
-    _deleteDraft({ parent_id }?: {
-        parent_id?: string;
-    }): Promise<APIResponse>;
+    deleteDraft(request?: Parameters<ChannelApi['deleteDraft']>[0]): Promise<import("./types").StreamResponse<import(".").Response>>;
     /**
-     * deleteDraft - Deletes a draft message from a channel or a thread. If offline support is
-     * enabled, it will make sure that deleting the draft is queued up if it fails due to
-     * bad internet conditions and executed later.
+     * Listens to events on this channel.
      *
-     * @param {Object} options
-     * @param {string} options.parent_id Optional parent message ID for drafts in threads
+     * @example
+     * channel.on('message.new', (event) => {
+     *   console.log('my new message', event, channel.state.messages);
+     * });
      *
-     * @return {Promise<APIResponse>} API response
-     */
-    deleteDraft(options?: {
-        parent_id?: string;
-    }): Promise<APIResponse>;
-    /**
-     * getDraft - Retrieves a draft message from a channel
+     * @example
+     * channel.on((event) => {
+     *   console.log(event.type);
+     * });
      *
-     * @param {Object} options
-     * @param {string} options.parent_id Optional parent message ID for drafts in threads
-     *
-     * @return {Promise<GetDraftResponse>} Response containing the draft
+     * @param callbackOrString - The event type to listen for, or the callback when listening to all events.
+     * @param callbackOrNothing - The callback to call when an event type was provided (optional).
+     * @returns An object with an `unsubscribe()` method.
      */
-    getDraft({ parent_id }?: {
-        parent_id?: string;
-    }): Promise<GetDraftResponse>;
-    /**
-     * on - Listen to events on this channel.
-     *
-     * channel.on('message.new', event => {console.log("my new message", event, channel.state.messages)})
-     * or
-     * channel.on(event => {console.log(event.type)})
-     *
-     * @param {EventHandler | EventTypes} callbackOrString  The event type to listen for (optional)
-     * @param {EventHandler} [callbackOrNothing] The callback to call
-     */
-    on(eventType: EventTypes, callback: EventHandler): {
+    on<T extends EventType | string>(eventType: T, callback: EventHandler<T>): {
         unsubscribe: () => void;
     };
     on(callback: EventHandler): {
         unsubscribe: () => void;
     };
     /**
-     * off - Remove the event handler
+     * Removes the event handler.
      *
+     * @param callbackOrString - The event type, or the callback when removing an all-events listener.
+     * @param callbackOrNothing - The callback to remove when an event type was provided (optional).
      */
-    off(eventType: EventTypes, callback: EventHandler): void;
+    off<T extends EventType | string>(eventType: T, callback: EventHandler): void;
     off(callback: EventHandler): void;
+    private _patchReadState;
+    private _upsertReadState;
     _handleChannelEvent(event: Event): void;
-    _callChannelListeners: (event: Event) => void;
+    _callChannelListeners: (event: WSEvent) => void;
     /**
-     * _channelURL - Returns the channel url
+     * Returns the channel url.
      *
-     * @return {string} The channel url
+     * @returns The channel url.
      */
     _channelURL: () => string;
     _checkInitialized(): void;
-    _initializeState(state: ChannelAPIResponse, messageSetToAddToIfDoesNotExist?: MessageSetType): {
-        messageSet: import("./types").MessageSet;
-        filteredMessageIds: string[];
-    };
-    _extendEventWithOwnReactions(event: Event): void;
+    _syncStateFromChannelData(data: Channel['data'], fallbackData?: Channel['data']): void;
+    _initializeState(state: ChannelStateResponseFields): void;
+    _extendEventWithOwnReactions(event: EventPayload<'message.undeleted' | 'message.updated' | 'message.deleted'>): void;
     _hydrateMembers({ members, overrideCurrentState, }: {
         members: ChannelMemberResponse[];
         /**