stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/search/types.d.ts

@@ -9,12 +9,12 @@ export type SearchSourceState<T = any> = {
     offset?: number;
 };
 export type SearchSourceOptions = {
-    /** The number of milliseconds to debounce the search query. The default interval is 300ms. */
+    /** The number of milliseconds to debounce the search query (defaults to `300`). */
     debounceMs?: number;
     pageSize?: number;
-    /** When true, the source can execute queries with an empty search string. Defaults to false. */
+    /** When `true`, the source can execute queries with an empty search string (defaults to `false`). */
     allowEmptySearchString?: boolean;
-    /** When true, previously loaded items are cleared at the start of a new search query. Defaults to true. */
+    /** When `true`, previously loaded items are cleared at the start of a new search query (defaults to `true`). */
     resetOnNewSearchQuery?: boolean;
 };
 export type SearchSourceType = 'channels' | 'users' | 'messages' | (string & {});

package/dist/types/segment.d.ts

@@ -1,34 +0,0 @@
-import type { StreamChat } from './client';
-import type { QuerySegmentTargetsFilter, SegmentData, SegmentResponse, SortParam } from './types';
-type SegmentType = 'user' | 'channel';
-type SegmentUpdatableFields = {
-    description?: string;
-    filter?: {};
-    name?: string;
-};
-export declare class Segment {
-    type: SegmentType;
-    id: string | null;
-    client: StreamChat;
-    data?: SegmentData | SegmentResponse;
-    constructor(client: StreamChat, type: SegmentType, id: string | null, data?: SegmentData);
-    create(): Promise<{
-        segment: SegmentResponse;
-    }>;
-    verifySegmentId(): void;
-    get(): Promise<{
-        segment: SegmentResponse;
-    } & import("./types").APIResponse>;
-    update(data: Partial<SegmentUpdatableFields>): Promise<{
-        segment: SegmentResponse;
-    }>;
-    addTargets(targets: string[]): Promise<import("./types").APIResponse>;
-    removeTargets(targets: string[]): Promise<import("./types").APIResponse>;
-    delete(): Promise<import("./types").APIResponse>;
-    targetExists(targetId: string): Promise<import("./types").APIResponse>;
-    queryTargets(filter?: QuerySegmentTargetsFilter | null, sort?: SortParam[] | null | [], options?: {}): Promise<{
-        targets: import("./types").SegmentTargetsResponse[];
-        next?: string;
-    } & import("./types").APIResponse>;
-}
-export {};

package/dist/types/signing.d.ts

@@ -1,42 +1,64 @@
 import jwt from 'jsonwebtoken';
-import type { Event, UR } from './types';
+import type { UR } from './types';
+import type { WSEvent } from './gen/models';
 /**
- * Creates the JWT token that can be used for a UserSession
- * @method JWTUserToken
- * @memberof signing
- * @private
- * @param {Secret} apiSecret - API Secret key
- * @param {string} userId - The user_id key in the JWT payload
- * @param {UR} [extraData] - Extra that should be part of the JWT token
- * @param {SignOptions} [jwtOptions] - Options that can be past to jwt.sign
- * @return {string} JWT Token
+ * Creates the JWT token that can be used for a user session.
+ *
+ * @param apiSecret - API secret key.
+ * @param userId - The `user_id` key in the JWT payload.
+ * @param extraData - Extra data that should be part of the JWT token (optional, defaults to `{}`).
+ * @param jwtOptions - Options that can be passed to `jwt.sign` (optional, defaults to `{}`).
+ * @returns The signed JWT token.
  */
 export declare function JWTUserToken(apiSecret: jwt.Secret, userId: string, extraData?: UR, jwtOptions?: jwt.SignOptions): string;
+/**
+ * Creates the JWT token that can be used for a server-side session.
+ *
+ * @param apiSecret - API secret key.
+ * @param jwtOptions - Options that can be passed to `jwt.sign` (optional, defaults to `{}`).
+ * @returns The signed JWT token.
+ */
 export declare function JWTServerToken(apiSecret: jwt.Secret, jwtOptions?: jwt.SignOptions): string;
+/**
+ * Decodes a JWT token and returns the embedded `user_id`.
+ *
+ * @param token - The JWT token to decode.
+ * @returns The `user_id` extracted from the token's payload, or an empty string when the token is malformed.
+ */
 export declare function UserFromToken(token: string): string;
 /**
+ * Generates a development token for the given user.
+ *
+ * Development tokens are unsigned and must only be used in environments where token validation is disabled.
  *
- * @param {string} userId the id of the user
- * @return {string}
+ * @param userId - The ID of the user.
+ * @returns The development token.
  */
 export declare function DevToken(userId: string): string;
 /**
- * Constant-time HMAC-SHA256 verification of `signature` against the
- * digest of `body` using `secret` as the key. The signature is always
- * computed over the **uncompressed** JSON bytes, so callers that
- * decoded a gzipped or base64-wrapped payload must pass the inflated
- * bytes here.
- *
- * The legacy `client.verifyWebhook` helper wraps this function, so
- * callers that have already migrated to `verifyAndParseWebhook`,
- * `parseSqs`, or `parseSns` rarely need to invoke this
- * directly.
+ * Constant-time HMAC-SHA256 verification of `signature` against the digest of `body` using `secret`
+ * as the key. The signature is always computed over the **uncompressed** JSON bytes, so callers that
+ * decoded a gzipped or base64-wrapped payload must pass the inflated bytes here.
+ *
+ * The legacy `client.verifyWebhook` helper wraps this function, so callers that have already
+ * migrated to {@link verifyAndParseWebhook}, {@link parseSqs}, or {@link parseSns} rarely need to
+ * invoke this directly.
+ *
+ * @param body - The uncompressed payload bytes that Stream signed.
+ * @param signature - The HMAC-SHA256 signature delivered alongside the payload.
+ * @param secret - Your app's API secret used as the HMAC key.
+ * @returns `true` when the signature matches the digest of `body`, otherwise `false`.
  */
 export declare function verifySignature(body: string | Buffer, signature: string, secret: string): boolean;
 /**
- * @deprecated Use {@link verifySignature} - same logic, parameters
- * reordered to match the cross-SDK contract
- * (`verifySignature(body, signature, secret)`).
+ * Verifies an HMAC-SHA256 signature with the legacy parameter order.
+ *
+ * @param body - The uncompressed payload bytes that Stream signed.
+ * @param secret - Your app's API secret used as the HMAC key.
+ * @param signature - The HMAC-SHA256 signature delivered alongside the payload.
+ * @returns `true` when the signature matches the digest of `body`, otherwise `false`.
+ * @deprecated Use {@link verifySignature} instead — same logic, parameters reordered to match the
+ *   cross-SDK contract (`verifySignature(body, signature, secret)`).
  */
 export declare function CheckSignature(body: string | Buffer, secret: string, signature: string): boolean;
 /**
@@ -65,60 +87,78 @@ export declare class InvalidWebhookError extends Error {
     constructor(message?: string);
 }
 /**
- * Returns `body` as a `Buffer`, gzip-decompressed when its first two
- * bytes match the gzip magic (`1f 8b`, per RFC 1952). When the body is
- * plain JSON (no compression, or middleware already decompressed), the
- * bytes are returned unchanged.
- *
- * Magic-byte detection (rather than relying on a header) keeps the
- * same handler correct when middleware - Express, Next.js, AWS Lambda
- * - auto-decompresses the request before your code sees it.
+ * Returns `body` as a `Buffer`, gzip-decompressed when its first two bytes match the gzip magic
+ * (`1f 8b`, per RFC 1952). When the body is plain JSON (no compression, or middleware already
+ * decompressed), the bytes are returned unchanged.
+ *
+ * Magic-byte detection (rather than relying on a header) keeps the same handler correct when
+ * middleware — Express, Next.js, AWS Lambda — auto-decompresses the request before your code sees it.
+ *
+ * @param rawBody - The raw HTTP request body, either as a string or a `Buffer`.
+ * @returns The uncompressed payload bytes.
+ * @throws {@link InvalidWebhookError} when the gzip envelope is malformed.
  */
 export declare function gunzipPayload(rawBody: string | Buffer): Buffer;
 /**
- * Reverses the SQS firehose envelope: the message `Body` is
- * base64-decoded, then the result is gzip-decompressed when it begins
- * with the gzip magic. Returns the raw JSON `Buffer` Stream signed.
+ * Reverses the SQS firehose envelope: the message `Body` is base64-decoded, then the result is
+ * gzip-decompressed when it begins with the gzip magic. Returns the raw JSON `Buffer` Stream signed.
  *
- * SQS bodies are always base64-encoded so they remain valid UTF-8 over
- * the queue. The same call works whether or not Stream is currently
- * compressing payloads for this app.
+ * SQS bodies are always base64-encoded so they remain valid UTF-8 over the queue. The same call
+ * works whether or not Stream is currently compressing payloads for this app.
+ *
+ * @param body - The base64-encoded SQS message body.
+ * @returns The decoded (and decompressed, when gzipped) payload bytes.
+ * @throws {@link InvalidWebhookError} when the body is not canonical base64 or the gzip envelope is malformed.
  */
 export declare function decodeSqsPayload(body: string): Buffer;
 /**
- * Reverses an SNS HTTP notification envelope. When `notificationBody`
- * is a JSON envelope (`{"Type":"Notification","Message":"..."}`), the
- * inner `Message` field is extracted and run through the SQS pipeline
- * (base64-decode, then gzip-if-magic). When the input is not a JSON
- * envelope it is treated as the already-extracted `Message` string,
- * so call sites that pre-unwrap continue to work.
+ * Reverses an SNS HTTP notification envelope. When `notificationBody` is a JSON envelope
+ * (`{"Type":"Notification","MessageRequest":"..."}`), the inner `MessageRequest` field is extracted and run
+ * through the SQS pipeline (base64-decode, then gzip-if-magic). When the input is not a JSON
+ * envelope it is treated as the already-extracted `MessageRequest` string, so call sites that pre-unwrap
+ * continue to work.
+ *
+ * @param notificationBody - The raw SNS notification body, or a pre-extracted `MessageRequest` string.
+ * @returns The decoded (and decompressed, when gzipped) payload bytes.
+ * @throws {@link InvalidWebhookError} when the body is not canonical base64 or the gzip envelope is malformed.
  */
 export declare function decodeSnsPayload(notificationBody: string): Buffer;
 /**
- * Parse a JSON-encoded webhook event into a typed {@link Event}. New
- * event types Stream introduces still parse successfully - the runtime
- * shape is the JSON Stream sent and the `type` field stays preserved.
+ * Parses a JSON-encoded webhook event into a typed {@link WSEvent}. New event types Stream
+ * introduces still parse successfully — the runtime shape is the JSON Stream sent and the `type`
+ * field stays preserved.
+ *
+ * @param payload - The raw event payload bytes or string.
+ * @returns The parsed WebSocket event.
+ * @throws {@link InvalidWebhookError} when the payload is not valid JSON.
  */
-export declare function parseEvent(payload: Buffer | string): Event;
+export declare function parseEvent(payload: Buffer | string): WSEvent;
 /**
- * Decompress (when gzipped), verify the HMAC `signature`, and return
- * the parsed {@link Event}.
- *
- * @param rawBody Raw HTTP request body bytes Stream signed
- * @param signature Value of the `X-Signature` header
- * @param secret Your app's API secret
- * @throws {InvalidWebhookError} When the signature does not match or
- *   the gzip envelope is malformed.
+ * Decompress (when gzipped), verify the HMAC `signature`, and return the parsed {@link WSEvent}.
+ *
+ * @param rawBody - Raw HTTP request body bytes Stream signed.
+ * @param signature - Value of the `X-Signature` header.
+ * @param secret - Your app's API secret.
+ * @returns The parsed WebSocket event.
+ * @throws {@link InvalidWebhookError} when the signature does not match or the gzip envelope is malformed.
  */
-export declare function verifyAndParseWebhook(rawBody: string | Buffer, signature: string, secret: string): Event;
+export declare function verifyAndParseWebhook(rawBody: string | Buffer, signature: string, secret: string): WSEvent;
 /**
- * Decode the SQS message `Body` (base64, then gzip-if-magic) and return
- * the parsed {@link Event}. Stream does not attach an application-level HMAC
- * to SQS deliveries — use {@link verifyAndParseWebhook} for HTTP webhooks.
+ * Decodes the SQS message `Body` (base64, then gzip-if-magic) and returns the parsed {@link WSEvent}.
+ * Stream does not attach an application-level HMAC to SQS deliveries — use
+ * {@link verifyAndParseWebhook} for HTTP webhooks.
+ *
+ * @param messageBody - The base64-encoded SQS message body.
+ * @returns The parsed WebSocket event.
+ * @throws {@link InvalidWebhookError} when the body is malformed.
  */
-export declare function parseSqs(messageBody: string): Event;
+export declare function parseSqs(messageBody: string): WSEvent;
 /**
- * Decode an SNS notification (unwrap the JSON envelope when needed; same
- * inner format as SQS). No application-level HMAC verification.
+ * Decodes an SNS notification (unwraps the JSON envelope when needed; same inner format as SQS).
+ * No application-level HMAC verification.
+ *
+ * @param notificationBody - The raw SNS notification body, or a pre-extracted `MessageRequest` string.
+ * @returns The parsed WebSocket event.
+ * @throws {@link InvalidWebhookError} when the body is malformed.
  */
-export declare function parseSns(notificationBody: string): Event;
+export declare function parseSns(notificationBody: string): WSEvent;

package/dist/types/store.d.ts

@@ -12,6 +12,7 @@ export declare class StateStore<T extends Record<string, unknown>> {
     constructor(value: T);
     /**
      * Allows merging two stores only if their keys differ otherwise there's no way to ensure the data type stability.
+     *
      * @experimental
      * This method is experimental and may change in future versions.
      */

package/dist/types/thread.d.ts

@@ -1,18 +1,12 @@
 import { StateStore } from './store';
-import type { AscDesc, LocalMessage, MessagePaginationOptions, MessageResponse, ThreadResponse, UserResponse } from './types';
-import type { Channel } from './channel';
+import type { DraftResponse, EventAPIResponse, LocalMessage, MarkReadRequest, MessageResponse, ReactionRequest, SendReactionRequest, ThreadStateResponse, UserResponse } from './types';
+import type { Channel, DeleteMessageWithStateUpdateParams, SendMessageWithStateUpdateParams, UpdateMessageWithStateUpdateParams } from './channel';
 import type { StreamChat } from './client';
 import type { CustomThreadData } from './custom_types';
 import { MessageComposer } from './messageComposer';
+import { MessageOperations } from './messageOperations';
 import { WithSubscriptions } from './utils/WithSubscriptions';
-type QueryRepliesOptions = {
-    sort?: {
-        created_at: AscDesc;
-    }[];
-} & MessagePaginationOptions & {
-    user?: UserResponse;
-    user_id?: string;
-};
+import { MessagePaginator } from './pagination';
 export type ThreadState = {
     /**
      * Determines if the thread is currently opened and on-screen. When the thread is active,
@@ -25,25 +19,17 @@ export type ThreadState = {
     deletedAt: Date | null;
     isLoading: boolean;
     isStateStale: boolean;
-    pagination: ThreadRepliesPagination;
     /**
      * Thread is identified by and has a one-to-one relation with its parent message.
      * We use parent message id as a thread id.
      */
     parentMessage: LocalMessage;
-    participants: ThreadResponse['thread_participants'];
+    participants: ThreadStateResponse['thread_participants'];
     read: ThreadReadState;
-    replies: Array<LocalMessage>;
     replyCount: number;
     title: string;
     updatedAt: Date | null;
 };
-export type ThreadRepliesPagination = {
-    isLoadingNext: boolean;
-    isLoadingPrev: boolean;
-    nextCursor: string | null;
-    prevCursor: string | null;
-};
 export type ThreadUserReadState = {
     lastReadAt: Date;
     unreadMessageCount: number;
@@ -52,16 +38,30 @@ export type ThreadUserReadState = {
     firstUnreadMessageId?: string;
 };
 export type ThreadReadState = Record<string, ThreadUserReadState | undefined>;
-export declare const THREAD_RESPONSE_RESERVED_KEYS: Record<keyof ThreadResponse, true>;
+export type CustomThreadMarkReadRequestFn = (params: {
+    thread: Thread;
+    options?: MarkReadRequest;
+}) => Promise<EventAPIResponse | null> | void;
+export type ThreadInstanceConfig = {
+    requestHandlers?: {
+        markReadRequest?: CustomThreadMarkReadRequestFn;
+    };
+};
 export declare class Thread extends WithSubscriptions {
+    readonly configState: StateStore<ThreadInstanceConfig>;
     readonly state: StateStore<ThreadState>;
     readonly id: string;
     readonly messageComposer: MessageComposer;
+    readonly messagePaginator: MessagePaginator;
+    readonly messageOperations: MessageOperations;
     private client;
     private failedRepliesMap;
-    constructor({ client, threadData, }: {
+    constructor({ client, threadData, channel, parentMessage, draft, }: {
         client: StreamChat;
-        threadData: ThreadResponse;
+        threadData?: ThreadStateResponse;
+        channel?: Channel;
+        parentMessage?: MessageResponse | LocalMessage;
+        draft?: DraftResponse;
     });
     get channel(): Channel;
     get hasStaleState(): boolean;
@@ -80,11 +80,13 @@ export declare class Thread extends WithSubscriptions {
     private subscribeRepliesRead;
     private subscribeMessageDeleted;
     private subscribeMessageUpdated;
+    private subscribeUserMessagesDeleted;
+    private subscribeParentMessageFromStore;
     unregisterSubscriptions: () => symbol;
     deleteReplyLocally: ({ message }: {
         message: MessageResponse;
     }) => void;
-    upsertReplyLocally: ({ message, timestampChanged, }: {
+    upsertReplyLocally: ({ message, }: {
         message: MessageResponse | LocalMessage;
         timestampChanged?: boolean;
     }) => void;
@@ -92,17 +94,51 @@ export declare class Thread extends WithSubscriptions {
         message: MessageResponse;
     }) => void;
     updateParentMessageOrReplyLocally: (message: MessageResponse) => void;
+    /**
+     * Sends a message with optimistic local state update.
+     */
+    sendMessageWithLocalUpdate({ localMessage, message, options, sendMessageRequestFn, }: SendMessageWithStateUpdateParams): Promise<void>;
+    /**
+     * Retry sending a failed message.
+     */
+    retrySendMessageWithLocalUpdate(params: Omit<SendMessageWithStateUpdateParams, 'message'>): Promise<void>;
+    /**
+     * Updates a message with optimistic local state update.
+     *
+     * The update flows through `messagePaginator`, which is the sole reply source.
+     */
+    updateMessageWithLocalUpdate(params: UpdateMessageWithStateUpdateParams): Promise<void>;
+    /**
+     * Deletes a message with local state update.
+     */
+    deleteMessageWithLocalUpdate(params: DeleteMessageWithStateUpdateParams): Promise<void>;
+    /**
+     * Adds a reaction to a reply with an optimistic local state update, mirroring
+     * {@link Channel.addReactionWithLocalUpdate}. The optimistic message is applied to THIS thread's
+     * paginator (so pure replies get optimism the channel paginator can't give); the request routes
+     * through the parent channel since reactions are channel-level.
+     */
+    addReactionWithLocalUpdate({ messageId, reaction, options, }: {
+        messageId: string;
+        reaction: ReactionRequest;
+        options?: Pick<SendReactionRequest, 'enforce_unique' | 'skip_push'>;
+    }): Promise<void>;
+    /**
+     * Removes the current user's reaction from a reply with an optimistic local state update,
+     * mirroring {@link Thread.addReactionWithLocalUpdate}.
+     */
+    deleteReactionWithLocalUpdate({ messageId, type, }: {
+        messageId: string;
+        type: string;
+    }): Promise<void>;
+    markRead: ({ force }?: {
+        force?: boolean;
+    }) => Promise<EventAPIResponse | import("./types").StreamResponse<import(".").MarkReadResponse> | null>;
+    private throttledMarkRead;
+    /**
+     * @deprecated Use `thread.markRead` instead.
+     */
     markAsRead: ({ force }?: {
         force?: boolean;
-    }) => Promise<import("./types").EventAPIResponse | null>;
-    private throttledMarkAsRead;
-    queryReplies: ({ limit, sort, ...otherOptions }?: QueryRepliesOptions) => Promise<import("./types").GetRepliesAPIResponse>;
-    loadNextPage: ({ limit }?: {
-        limit?: number;
-    }) => Promise<void>;
-    loadPrevPage: ({ limit }?: {
-        limit?: number;
-    }) => Promise<void>;
-    private loadPage;
+    }) => Promise<EventAPIResponse | import("./types").StreamResponse<import(".").MarkReadResponse> | null>;
 }
-export {};

package/dist/types/thread_manager.d.ts

@@ -1,7 +1,7 @@
 import { StateStore } from './store';
 import type { StreamChat } from './client';
 import type { Thread } from './thread';
-import type { QueryThreadsOptions } from './types';
+import type { QueryThreadsRequest } from './types';
 import { WithSubscriptions } from './utils/WithSubscriptions';
 export declare const THREAD_MANAGER_INITIAL_STATE: {
     active: boolean;
@@ -65,9 +65,9 @@ export declare class ThreadManager extends WithSubscriptions {
     reload: ({ force }?: {
         force?: boolean | undefined;
     }) => Promise<void>;
-    queryThreads: (options?: QueryThreadsOptions) => Promise<{
+    queryThreads: (options?: QueryThreadsRequest) => Promise<{
         threads: Thread[];
         next: string | undefined;
     }>;
-    loadNextPage: (options?: Omit<QueryThreadsOptions, "next">) => Promise<void>;
+    loadNextPage: (options?: Omit<QueryThreadsRequest, "next">) => Promise<void>;
 }

package/dist/types/token_manager.d.ts

@@ -1,5 +1,9 @@
 import type jwt from 'jsonwebtoken';
-import type { TokenOrProvider, UserResponse } from './types';
+import type { TokenOrProvider } from './types';
+export type TokenManagerMinimalUser = {
+    id: string;
+    anon?: boolean;
+};
 /**
  * TokenManager
  *
@@ -11,27 +15,28 @@ export declare class TokenManager {
     secret?: jwt.Secret;
     token?: string;
     tokenProvider?: TokenOrProvider;
-    user?: UserResponse;
+    user?: TokenManagerMinimalUser;
     /**
-     * Constructor
+     * Initializes the token manager, optionally with a server-side API secret used to mint tokens
+     * locally.
      *
-     * @param {Secret} secret
+     * @param secret - Optional API secret. When provided, the manager will sign server tokens locally.
      */
     constructor(secret?: jwt.Secret);
     /**
-     * Set the static string token or token provider.
-     * Token provider should return a token string or a promise which resolves to string token.
+     * Sets the static string token or token provider. A token provider should return a token string
+     * or a promise that resolves to a token string.
      *
-     * @param {TokenOrProvider} tokenOrProvider
-     * @param {UserResponse} user
+     * @param tokenOrProvider - A token string or an async provider that returns one.
+     * @param user - The user the token belongs to.
      */
-    setTokenOrProvider: (tokenOrProvider: TokenOrProvider, user: UserResponse) => Promise<void>;
+    setTokenOrProvider: (tokenOrProvider: TokenOrProvider, user: TokenManagerMinimalUser) => Promise<void>;
     /**
      * Resets the token manager.
      * Useful for client disconnection or switching user.
      */
     reset: () => void;
-    validateToken: (tokenOrProvider: TokenOrProvider, user: UserResponse) => void;
+    validateToken: (tokenOrProvider: TokenOrProvider, user: TokenManagerMinimalUser) => void;
     tokenReady: () => Promise<string> | null;
     loadToken: () => Promise<string>;
     getToken: () => string | undefined;