stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/utils/FixedSizeQueueCache.d.ts

@@ -1,6 +1,7 @@
 /**
  * A cache that stores a fixed number of values in a queue.
  * The most recently added or retrieved value is kept at the front of the queue.
+ *
  * @template K - The type of the keys.
  * @template T - The type of the values.
  */
@@ -13,19 +14,24 @@ export declare class FixedSizeQueueCache<K, T> {
         dispose: (key: K, value: T) => void;
     });
     /**
-     * Adds a new or moves the existing reference to the front of the queue
-     * @param key
-     * @param value
+     * Adds a new entry or moves the existing reference to the front of the queue.
+     *
+     * @param key - The cache key.
+     * @param value - The value to associate with `key`.
      */
     add(key: K, value: T): void;
     /**
-     * Retrieves the value by key.
-     * @param key
+     * Retrieves the value by key without changing its position in the queue.
+     *
+     * @param key - The cache key.
+     * @returns The value, or `undefined` when the key is not cached.
      */
     peek(key: K): T | undefined;
     /**
      * Retrieves the value and moves it to the front of the queue.
-     * @param key
+     *
+     * @param key - The cache key.
+     * @returns The value, or `undefined` when the key is not cached.
      */
     get(key: K): T | undefined;
     /**

package/dist/types/utils/WithSubscriptions.d.ts

@@ -1,7 +1,8 @@
 import type { Unsubscribe } from '../store';
 /**
- * @private
  * Class to use as a template for subscribable entities.
+ *
+ * @internal
  */
 export declare abstract class WithSubscriptions {
     private unsubscribeFunctions;

package/dist/types/utils/concurrency.d.ts

@@ -3,9 +3,9 @@
  * should never run simultaneously: if marked with the same tag, functions
  * will run one after another.
  *
- * @param tag Async functions with the same tag will run serially. Async functions
+ * @param tag - Async functions with the same tag will run serially. Async functions
  * with different tags can run in parallel.
- * @param cb Async function to run.
+ * @param cb - Async function to run.
  * @returns Promise that resolves when async functions returns.
  */
 export declare const withoutConcurrency: <T>(tag: string | symbol, cb: () => Promise<T>) => Promise<T>;
@@ -18,9 +18,9 @@ export declare const withoutConcurrency: <T>(tag: string | symbol, cb: () => Pro
  * If an async function is already running and was canceled, it will be notified
  * via an abort signal passed as an argument.
  *
- * @param tag Async functions with the same tag will run serially and are canceled
+ * @param tag - Async functions with the same tag will run serially and are canceled
  * when a new action with the same tag is scheduled.
- * @param cb Async function to run. Receives AbortSignal as the only argument.
+ * @param cb - Async function to run. Receives AbortSignal as the only argument.
  * @returns Promise that resolves when async functions returns. If the function didn't
  * start and was canceled, will resolve with 'canceled'. If the function started to run,
  * it's up to the function to decide how to react to cancelation.

package/dist/types/utils/mergeWith/mergeWith.d.ts

@@ -6,9 +6,9 @@
  * (objValue, srcValue, key, object, source, stack).
  *
  * @category Object
- * @param object The destination object.
- * @param source A single source object or an array of objects to be merged into the .
- * @param customizer The function to customize assigned values.
+ * @param object - The destination object.
+ * @param source - A single source object or an array of objects to be merged into the .
+ * @param customizer - The function to customize assigned values.
  * @returns Returns `object`.
  * @example
  *

package/dist/types/utils/mergeWith/mergeWithCore.d.ts

@@ -17,11 +17,15 @@ export interface DiffNode {
     oldValue?: unknown;
 }
 export declare const isClassInstance: (value: unknown) => boolean;
+type PairMemo = WeakMap<object, WeakSet<object>>;
 /**
- * Performs a deep comparison between two values to determine if they are equivalent.
- * This is similar to Lodash's isEqual implementation but simplified.
+ * Deep semantic equality with cycle safety and symbol-key support.
+ * Keeps your existing semantics:
+ *  - Dates/RegExps compared by value
+ *  - "Class instances" are treated atomically (unequal unless ===)
+ *  - NaN equals NaN; -0 equals 0 (same as ===)
  */
-export declare const isEqual: (value1: unknown, value2: unknown, compareStack?: Set<[unknown, unknown]>, objectStack1?: WeakSet<object>, objectStack2?: WeakSet<object>) => boolean;
+export declare const isEqual: (value1: unknown, value2: unknown, pairMemo?: PairMemo) => boolean;
 /**
  * Generates a diff between original and modified objects.
  * This is used after the merge operation to track what has changed.
@@ -38,3 +42,4 @@ export declare function createMergeCore<T extends object>(options?: {
     diff: DiffNode | null;
 };
 export declare function cleanupDiffTree(diffNode: DiffNode): DiffNode | null;
+export {};

package/dist/types/utils/retryable.d.ts

@@ -0,0 +1,34 @@
+type FunctionToRetry<T = any> = (...functionArguments: any[]) => PromiseLike<T>;
+declare enum RetryErrorType {
+    ABORT = 0,
+    ATTEMPT_LIMIT_REACHED = 1
+}
+export declare class RetryError extends Error {
+    name: string;
+    private static errorMap;
+    constructor({ type }: {
+        type: RetryErrorType;
+    });
+}
+export declare const sleep: (duration: number) => Promise<unknown>;
+export type RunWithRetryOptions<T extends FunctionToRetry> = {
+    retryAttempts?: number;
+    delayBetweenRetries?: number | ((attempt: number) => number);
+    isRetryable?: (error: unknown) => boolean;
+    didValueChange?: (...functionArguments: Parameters<T>) => Promise<boolean> | boolean;
+};
+/**
+ * Function which wraps asynchronous functions with retry mechanism which'll keep executing said
+ * function pre-defined number of times until it resolves, rejects or the retry mechanism runs out of available attempts.
+ *
+ * #### Available options:
+ *  - `didValueChange` - check function with initial argument value to check against new values, return `true` to abort next attempt
+ *
+ *  - `isRetryable` - error evaluation function which determines whether to retry the execution
+ *
+ *  - `delayBetweenRetries` - accepts either fixed numeric value or function which provides retry attempt as the argument, expects number as return value
+ *
+ *  - `retryAttempts` - number of attempts to try out before rejecting the promise
+ */
+export declare const runWithRetry: <T extends FunctionToRetry>(f: T, { retryAttempts, delayBetweenRetries, isRetryable, didValueChange, }?: RunWithRetryOptions<T>) => (...functionArguments: Parameters<T>) => Promise<NonNullable<Awaited<ReturnType<T>>>>;
+export {};

package/dist/types/utils/throttling/throttle.d.ts

@@ -0,0 +1,36 @@
+export type ThrottledCallback = (...args: unknown[]) => unknown;
+export type ThrottleOptions = {
+    /** Call on the leading edge (default: true). */
+    leading?: boolean;
+    /** Call once at the end of the window with the latest args (default: false). */
+    trailing?: boolean;
+};
+export type Throttled<T extends unknown[]> = {
+    /**
+     * The throttled function — call it as often as you like; it invokes `fn` at most once per window
+     * (leading and/or trailing per options).
+     */
+    throttledFn: (...args: T) => void;
+    /** Clear a pending trailing invocation WITHOUT firing it. */
+    cancelTimer: () => void;
+    /**
+     * Fire a pending trailing invocation immediately (with the latest stored args), clearing the timer.
+     * No-op when nothing is pending. Use to bypass the throttle delay for updates that must land now.
+     */
+    flush: () => void;
+};
+/**
+ * Throttle a function so it runs at most once per `timeout` ms.
+ *
+ * - `leading`: fire immediately when the window opens
+ * - `trailing`: remember the latest args/this and fire once when the window closes
+ *
+ * defaults: `{ leading: true, trailing: false }`
+ *
+ * Copied verbatim from the Feeds client (`packages/feeds-client/src/utils/throttling/throttle.ts`)
+ * and extended with a `flush()` method (the Feeds version only exposes `cancelTimer()`).
+ *
+ * notes:
+ * - make one throttled instance and reuse it; re-creating it resets internal state
+ */
+export declare const throttle: <T extends unknown[]>(fn: (...args: T) => void, timeout?: number, { leading, trailing }?: ThrottleOptions) => Throttled<T>;

package/dist/types/utils.d.ts

@@ -1,15 +1,14 @@
 import FormData from 'form-data';
-import type { AscDesc, ChannelFilters, ChannelQueryOptions, ChannelSort, ChannelSortBase, LocalMessage, LocalMessageBase, Logger, Message, MessagePaginationOptions, MessageResponse, MessageResponseBase, MessageSet, OwnUserResponse, PromoteChannelParams, ReactionGroupResponse, UpdatedMessage, UserResponse } from './types';
+import type { LocalMessage, MessageRequest, MessageResponse, OwnUserResponse, ReactionGroupResponse, ReactionResponse, UpdatedMessage, UserResponse } from './types';
 import type { StreamChat } from './client';
 import type { Channel } from './channel';
 import type { AxiosRequestConfig } from 'axios';
 /**
- * logChatPromiseExecution - utility function for logging the execution of a promise..
- *  use this when you want to run the promise and handle errors by logging a warning
- *
- * @param {Promise<T>} promise The promise you want to run and log
- * @param {string} name    A descriptive name of what the promise does for log output
+ * Logs the execution of a promise. Use this when you want to run the promise and handle errors by
+ * logging a warning.
  *
+ * @param promise - The promise you want to run and log.
+ * @param name - A descriptive name of what the promise does for log output.
  */
 export declare function logChatPromiseExecution<T>(promise: Promise<T>, name: string): void;
 export declare const sleep: (m: number) => Promise<void>;
@@ -34,14 +33,10 @@ export declare const channelTracksReadLocally: (channel?: Channel) => boolean;
  */
 export declare const userHasReadReceipts: (client: StreamChat) => boolean;
 export declare function addFileToFormData(uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string): FormData;
-export declare function normalizeQuerySort<T extends Record<string, AscDesc | undefined>>(sort: T | T[]): {
-    direction: AscDesc;
-    field: keyof T;
-}[];
 /**
  * retryInterval - A retry interval which increases acc to number of failures
  *
- * @return {number} Duration to wait in milliseconds
+ * @returns Duration to wait in milliseconds
  */
 export declare function retryInterval(numberOfFailures: number): number;
 export declare function randomId(): string;
@@ -59,115 +54,122 @@ export declare function addConnectionEventListeners(cb: (e: Event) => void): voi
 export declare function removeConnectionEventListeners(cb: (e: Event) => void): void;
 export declare const axiosParamsSerializer: AxiosRequestConfig['paramsSerializer'];
 /**
- * Takes the message object, parses the dates, sets `__html`
- * and sets the status to `received` if missing; returns a new LocalMessage object.
+ * Takes the message object, adds SDK-specific fields (status, error),
+ * and returns a new LocalMessage object.
  *
- * @param {LocalMessage} message `LocalMessage` object
+ * @param message - message object
  */
-export declare function formatMessage(message: MessageResponse | MessageResponseBase | LocalMessage): LocalMessage;
+export declare function formatMessage(message: MessageResponse | LocalMessage): LocalMessage;
 /**
- * @private
+ * Computes the current user's `own_reactions` after applying a single reaction change, off a
+ * `current` base. A WS reaction/edit event carries `own_reactions: []` (or stale), so consumers
+ * must recompute from the copy they already hold rather than trusting the event — this is the
+ * shared core used by both the message paginator (`reflectReaction`) and the thread's parent
+ * message (which is not held in any paginator, so it needs the same logic directly).
  *
- * Takes a LocalMessage, parses the dates back to strings,
- * and converts the message back to a MessageResponse.
+ * - `removed`: drop the current user's reaction of this type.
+ * - `enforceUnique`: replace any existing own reaction with the incoming one (used by
+ *   `reaction.updated`, where a user's reaction supersedes their previous one).
+ * - otherwise: add the reaction, de-duped by type.
  *
- * @param {MessageResponse} message `MessageResponse` object
+ * A reaction by another user never changes the current user's `own_reactions`.
+ */
+export declare function computeOwnReactions({ current, enforceUnique, reaction, removed, userId, }: {
+    current: ReactionResponse[];
+    reaction: ReactionResponse;
+    enforceUnique?: boolean;
+    removed?: boolean;
+    userId?: string;
+}): ReactionResponse[];
+/**
+ * Returns a copy of `message` with `reaction` folded into its `reaction_groups` /
+ * `latest_reactions`. Does not touch `own_reactions` — the reaction entry points
+ * ({@link MessageIntervalPaginator.reflectReaction} / `Thread.applyParentReactionLocally`) own that
+ * via {@link computeOwnReactions}. Shared so both the paginator and the (paginator-less) thread
+ * parent compute counts identically.
+ */
+export declare function messageWithReactionAdded(message: LocalMessage, reaction: ReactionResponse, enforceUnique: boolean): LocalMessage;
+/**
+ * Returns a copy of `message` with the current user's reaction of `reaction.type` backed out of its
+ * `reaction_groups` / `latest_reactions`. Does not touch `own_reactions`.
  */
-export declare function unformatMessage(message: LocalMessage): MessageResponse;
-export declare const localMessageToNewMessagePayload: (localMessage: LocalMessage) => Message;
+export declare function messageWithReactionRemoved(message: LocalMessage, reaction: ReactionResponse): LocalMessage;
+export declare const localMessageToNewMessagePayload: (localMessage: LocalMessage) => MessageRequest;
 export declare const toUpdatedMessagePayload: (message: LocalMessage | Partial<MessageResponse>) => UpdatedMessage;
 export declare const toDeletedMessage: ({ message, deletedAt, hardDelete, }: {
-    message: LocalMessage | LocalMessageBase;
+    message: LocalMessage;
     deletedAt: LocalMessage["deleted_at"];
     hardDelete: boolean;
 }) => {
     attachments: never[];
-    cid: string | undefined;
+    cid: string;
     created_at: Date;
-    deleted_at: Date | null;
+    deleted_at: Date | undefined;
     id: string;
     latest_reactions: never[];
     mentioned_users: never[];
     own_reactions: never[];
     parent_id: string | undefined;
-    reply_count: number | undefined;
+    reply_count: number;
     status: string;
     thread_participants: UserResponse[] | undefined;
     type: "deleted";
     updated_at: Date;
-    user: UserResponse | null | undefined;
+    user: UserResponse;
 } | {
     attachments: never[];
     type: string;
-    deleted_at: Date | null;
-    text?: string | undefined;
-    user_id?: string | undefined;
-    command?: string | undefined;
-    mentioned_groups?: import("./types").UserGroupResponse[] | undefined;
-    mentioned_users?: UserResponse[] | undefined;
-    latest_reactions?: import("./types").ReactionResponse[] | undefined;
-    own_reactions?: import("./types").ReactionResponse[] | null | undefined;
-    reaction_counts?: {
-        [key: string]: number;
-    } | null | undefined;
-    reply_count?: number | undefined;
-    i18n?: (import("./types").RequireAtLeastOne<Record<`${import("./types").TranslationLanguages}_text`, string>> & {
-        language: import("./types").TranslationLanguages;
-    }) | undefined;
-    html?: string | undefined;
-    user?: (UserResponse | null) | undefined;
-    id: string;
-    mml?: string | undefined;
-    parent_id?: string | undefined;
-    pin_expires?: string | null | undefined;
-    pinned?: boolean | undefined;
-    poll_id?: string | undefined;
-    quoted_message_id?: string | undefined;
-    restricted_visibility?: string[] | undefined;
-    show_in_channel?: boolean | undefined;
-    silent?: boolean | undefined;
-    args?: string | undefined;
-    before_message_send_failed?: boolean | undefined;
-    channel?: import("./types").ChannelResponse | undefined;
-    cid?: string | undefined;
-    command_info?: {
-        name?: string;
-    } | undefined;
-    deleted_reply_count?: number | undefined;
-    member?: import("./types").ChannelMemberResponse | undefined;
-    mentioned_channel?: boolean | undefined;
-    mentioned_here?: boolean | undefined;
-    mentioned_group_ids?: string[] | undefined;
-    mentioned_roles?: string[] | undefined;
-    message_text_updated_at?: string | undefined;
-    moderation?: import("./types").ModerationResponse | undefined;
-    moderation_details?: import("./types").ModerationDetailsResponse | undefined;
-    pinned_by?: (UserResponse | null) | undefined;
-    poll?: import("./types").PollResponse | undefined;
-    reaction_groups?: {
-        [key: string]: ReactionGroupResponse;
-    } | null | undefined;
-    reaction_scores?: {
-        [key: string]: number;
-    } | null | undefined;
-    reminder?: import("./types").ReminderResponseBase | undefined;
-    shadowed?: boolean | undefined;
-    shared_location?: import("./types").SharedLocationResponse | undefined;
-    thread_participants?: UserResponse[] | undefined;
-    deleted_for_me?: boolean | undefined;
+    deleted_at: Date | undefined;
+    cid: string;
     created_at: Date;
-    pinned_at: Date | null;
-    status: string;
+    deleted_reply_count: number;
+    html: string;
+    id: string;
+    mentioned_channel: boolean;
+    mentioned_here: boolean;
+    pinned: boolean;
+    reply_count: number;
+    shadowed: boolean;
+    silent: boolean;
+    text: string;
     updated_at: Date;
-    error?: import("./types").ErrorFromResponse<import("./types").APIErrorResponse> | null;
-    quoted_message?: LocalMessageBase | null;
-};
-export declare const deleteUserMessages: ({ messages, user, hardDelete, deletedAt, }: {
-    messages: Array<LocalMessage>;
+    latest_reactions: Array<ReactionResponse>;
+    mentioned_users: Array<UserResponse>;
+    own_reactions: Array<ReactionResponse>;
+    restricted_visibility: Array<string>;
+    custom: import("./custom_types").CustomMessageData;
+    reaction_counts: Record<string, number>;
+    reaction_scores: Record<string, number>;
     user: UserResponse;
-    hardDelete: boolean;
-    deletedAt: LocalMessage["deleted_at"];
-}) => void;
+    command?: string;
+    deleted_for_me?: boolean;
+    message_text_updated_at?: Date;
+    mml?: string;
+    parent_id?: string;
+    pin_expires?: Date;
+    pinned_at?: Date;
+    poll_id?: string;
+    quoted_message_id?: string;
+    show_in_channel?: boolean;
+    mentioned_group_ids?: Array<string>;
+    mentioned_groups?: Array<import(".").UserGroupResponse>;
+    mentioned_roles?: Array<string>;
+    thread_participants?: Array<UserResponse>;
+    draft?: import(".").DraftResponse;
+    i18n?: Record<string, string>;
+    image_labels?: Record<string, Array<string>>;
+    member?: import(".").ChannelMemberResponse;
+    moderation?: import(".").ModerationV2Response;
+    pinned_by?: UserResponse;
+    poll?: import(".").PollResponseData;
+    quoted_message?: MessageResponse;
+    reaction_groups?: Record<string, ReactionGroupResponse>;
+    reminder?: import(".").ReminderResponseData;
+    shared_location?: import(".").SharedLocationResponseData;
+    status: string;
+    error?: import("./types").StreamAPIError;
+    user_id?: string;
+};
 export declare const findIndexInSortedArray: <T, L>({ needle, sortedArray, selectKey, selectValueToCompare, sortDirection, }: {
     needle: T;
     sortedArray: readonly T[];
@@ -202,7 +204,6 @@ export declare const findIndexInSortedArray: <T, L>({ needle, sortedArray, selec
      */
     sortDirection?: "ascending" | "descending";
 }) => number;
-export declare function addToMessageList<T extends LocalMessage>(messages: readonly T[], newMessage: T, timestampChanged?: boolean, sortBy?: 'pinned_at' | 'created_at', addIfDoesNotExist?: boolean): T[];
 export interface DebouncedFunc<T extends (...args: any[]) => any> {
     /**
      * Call the original function, but applying the debounce rules.
@@ -231,113 +232,18 @@ export declare const debounce: <T extends (...args: any[]) => any>(fn: T, timeou
     leading?: boolean;
     trailing?: boolean;
 }) => DebouncedFunc<T>;
-export declare const throttle: <T extends (...args: any[]) => any>(fn: T, timeout?: number, { leading, trailing }?: {
-    leading?: boolean;
-    trailing?: boolean;
-}) => (...args: Parameters<T>) => void;
+export { throttle } from './utils/throttling/throttle';
+export type { Throttled, ThrottleOptions, ThrottledCallback, } from './utils/throttling/throttle';
 export declare const uniqBy: <T>(array: T[] | unknown, iteratee: ((item: T) => unknown) | keyof T) => T[];
-type MessagePaginationUpdatedParams = {
-    parentSet: MessageSet;
-    requestedPageSize: number;
-    returnedPage: MessageResponse[];
-    filteredReturnedPage: MessageResponse[];
-    logger?: Logger;
-    messagePaginationOptions?: MessagePaginationOptions;
-};
-export declare function binarySearchByDateEqualOrNearestGreater(array: {
-    created_at?: string;
-}[], targetDate: Date): number;
-export declare const messageSetPagination: (params: MessagePaginationUpdatedParams) => {
-    hasNext: boolean;
-    hasPrev: boolean;
-};
-type GetChannelParams = {
-    client: StreamChat;
-    channel?: Channel;
-    id?: string;
-    members?: string[];
-    options?: ChannelQueryOptions;
-    type?: string;
-};
-/**
- * Calls channel.watch() if it was not already recently called. Waits for watch promise to resolve even if it was invoked previously.
- * If the channel is not passed as a property, it will get it either by its channel.cid or by its members list and do the same.
- * @param client
- * @param members
- * @param options
- * @param type
- * @param id
- * @param channel
- */
-export declare const getAndWatchChannel: ({ channel, client, id, members, options, type, }: GetChannelParams) => Promise<Channel>;
 /**
  * Generates a temporary channel.cid for channels created without ID, as they need to be referenced
  * by an identifier until the back-end generates the final ID. The cid is generated by its member IDs
  * which are sorted and can be recreated the same every time given the same arguments.
- * @param channelType
- * @param members
+ *
+ * @param channelType - The channel type.
+ * @param members - The member ids used to build the temporary cid.
  */
 export declare const generateChannelTempCid: (channelType: string, members: string[]) => string | undefined;
-/**
- * Checks if a channel is pinned or not. Will return true only if channel.state.membership.pinned_at exists.
- * @param channel
- */
-export declare const isChannelPinned: (channel: Channel) => boolean;
-/**
- * Checks if a channel is archived or not. Will return true only if channel.state.membership.archived_at exists.
- * @param channel
- */
-export declare const isChannelArchived: (channel: Channel) => boolean;
-/**
- * A utility that tells us whether we should consider archived channels or not based
- * on filters. Will return true only if filters.archived exists and is a boolean value.
- * @param filters
- */
-export declare const shouldConsiderArchivedChannels: (filters: ChannelFilters) => boolean;
-/**
- * Extracts the value of the sort parameter at a given index, for a targeted key. Can
- * handle both array and object versions of sort. Will return null if the index/key
- * combination does not exist.
- * @param atIndex - the index at which we'll examine the sort value, if it's an array one
- * @param sort - the sort value - both array and object notations are accepted
- * @param targetKey - the target key which needs to exist for the sort at a certain index
- */
-export declare const extractSortValue: ({ atIndex, sort, targetKey, }: {
-    atIndex: number;
-    targetKey: keyof ChannelSortBase;
-    sort?: ChannelSort;
-}) => AscDesc | null;
-/**
- * Returns true only if `{ pinned_at: -1 }` or `{ pinned_at: 1 }` option is first within the `sort` array.
- */
-export declare const shouldConsiderPinnedChannels: (sort: ChannelSort) => boolean;
-/**
- * Checks whether the sort value of type object contains a pinned_at value or if
- * an array sort value type has the first value be an object containing pinned_at.
- * @param sort
- */
-export declare const findPinnedAtSortOrder: ({ sort }: {
-    sort: ChannelSort;
-}) => AscDesc | null;
-/**
- * Finds the index of the last consecutively pinned channel, starting from the start of the
- * array. Will not consider any pinned channels after the contiguous subsequence at the
- * start of the array.
- * @param channels
- */
-export declare const findLastPinnedChannelIndex: ({ channels }: {
-    channels: Channel[];
-}) => number | null;
-/**
- * A utility used to move a channel towards the beginning of a list of channels (promote it to a higher position). It
- * considers pinned channels in the process if needed and makes sure to only update the list reference if the list
- * should actually change. It will try to move the channel as high as it can within the list.
- * @param channels - the list of channels we want to modify
- * @param channelToMove - the channel we want to promote
- * @param channelToMoveIndexWithinChannels - optionally, the index of the channel we want to move if we know it (will skip a manual check)
- * @param sort - the sort value used to check for pinned channels
- */
-export declare const promoteChannel: ({ channels, channelToMove, channelToMoveIndexWithinChannels, sort, }: PromoteChannelParams) => Channel[];
 export declare const isDate: (value: unknown) => value is Date;
 export declare const isLocalMessage: (message: unknown) => message is LocalMessage;
 export declare const runDetached: <T>(callback: Promise<void | T>, options?: {
@@ -347,4 +253,4 @@ export declare const runDetached: <T>(callback: Promise<void | T>, options?: {
 }) => void;
 export declare const isBlockedMessage: (message: LocalMessage) => boolean;
 export declare const isBouncedMessage: (message: LocalMessage) => boolean;
-export {};
+export declare const getEnv: (envKey: keyof NodeJS.ProcessEnv) => string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-chat",
-  "version": "9.50.3",
+  "version": "10.0.0-rc.2",
   "description": "JS SDK for the Stream Chat API",
   "homepage": "https://getstream.io/chat/",
   "author": {
@@ -50,6 +50,7 @@
     "/src"
   ],
   "dependencies": {
+    "@stream-io/logger": "^2.0.0",
     "@types/jsonwebtoken": "^9.0.8",
     "@types/ws": "^8.18.1",
     "axios": "^1.16.1",
@@ -75,6 +76,8 @@
     "esbuild": "^0.28.0",
     "eslint": "^9.39.4",
     "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^63.0.7",
+    "eslint-plugin-unused-imports": "^4.4.1",
     "globals": "^17.6.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.5",
@@ -90,7 +93,7 @@
     "start": "concurrently 'tsc --watch' './scripts/bundle.mjs --watch'",
     "types": "tsc --noEmit",
     "lint": "yarn run prettier && yarn run eslint",
-    "lint-fix": "yarn run prettier-fix && yarn run eslint-fix",
+    "lint-fix": "yarn run eslint-fix; yarn run prettier-fix",
     "prettier": "prettier '**/*.{json,js,mjs,ts,yml,md}' --check",
     "prettier-fix": "yarn run prettier --write",
     "eslint": "eslint --max-warnings 0",
@@ -104,7 +107,8 @@
     "fix-staged": "lint-staged --config .lintstagedrc.fix.json --concurrent 1",
     "semantic-release": "semantic-release",
     "postinstall": "node -e \"require('fs').existsSync('scripts/install-husky.mjs') && import('./scripts/install-husky.mjs')\"",
-    "prepare": "yarn run build"
+    "prepare": "yarn run build",
+    "generate-client": "./scripts/generate-client.sh"
   },
   "engines": {
     "node": ">=18"