stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/client_state.d.ts

@@ -1,12 +1,12 @@
-import type { UserResponse } from './types';
+import type { OwnUserResponse, UserResponse } from './types';
 import type { StreamChat } from './client';
 /**
- * ClientState - A container class for the client state.
+ * Container class for the client state.
  */
 export declare class ClientState {
     private client;
     users: {
-        [key: string]: UserResponse;
+        [key: string]: UserResponse | OwnUserResponse;
     };
     userChannelReferences: {
         [key: string]: {
@@ -17,7 +17,7 @@ export declare class ClientState {
         client: StreamChat;
     });
     updateUsers(users: UserResponse[]): void;
-    updateUser(user?: UserResponse): void;
+    updateUser(user?: UserResponse | OwnUserResponse): void;
     updateUserReference(user: UserResponse, channelID: string): void;
     deleteAllChannelReference(channelID: string): void;
 }

package/dist/types/configuration/InstanceConfigurationService.d.ts

@@ -0,0 +1,26 @@
+/**
+ * InstanceConfigurationService is a singleton class that is used to store the configuration for the instances of classes exposed by the SKD such as:
+ * - StreamChat
+ * - Channel
+ * - Thread
+ * - MessageComposer
+ *
+ * Every existing and future instance configuration of the above classes will be setup using the following pattern:
+ * - StreamChat: StreamChat.setClientSetupFunction(setupFunction)
+ * - Channel: StreamChat.setChannelSetupFunction(setupFunction)
+ * - Thread: StreamChat.setThreadSetupFunction(setupFunction)
+ * - MessageComposer: StreamChat.setMessageComposerSetupFunction(setupFunction)
+ *
+ * The setupFunction is a function that is used to set up the instance configuration.
+ */
+import { StateStore } from '../store';
+import type { ChannelSetupState, MessageComposerSetupState, SetInstanceConfigurationFunctions, StreamChatSetupState, ThreadSetupState } from './types';
+export declare class InstanceConfigurationService {
+    private static instance;
+    private setupStates;
+    setSetupFunctions(setupFunctions: SetInstanceConfigurationFunctions): void;
+    get Channel(): StateStore<ChannelSetupState>;
+    get MessageComposer(): StateStore<MessageComposerSetupState>;
+    get StreamChat(): StateStore<StreamChatSetupState>;
+    get Thread(): StateStore<ThreadSetupState>;
+}

package/dist/types/configuration/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/types/configuration/types.d.ts

@@ -0,0 +1,53 @@
+import type { StreamChat } from '../client';
+import type { MessageComposer } from '../messageComposer';
+import type { Channel } from '../channel';
+import type { Thread } from '../thread';
+import type { StateStore } from '../store';
+export type MessageComposerTearDownFunction = () => void;
+export type MessageComposerSetupFunction = ({ composer, }: {
+    composer: MessageComposer;
+}) => void | MessageComposerTearDownFunction;
+export type MessageComposerSetupState = {
+    /**
+     * Each `MessageComposer` runs this function each time its signature changes or
+     * whenever you run `MessageComposer.registerSubscriptions`. Function returned
+     * from `applyModifications` will be used as a cleanup function - it will be stored
+     * and ran before new modification is applied. Cleaning up only the
+     * modified parts is the general way to go but if your setup gets a bit
+     * complicated, feel free to restore the whole composer with `MessageComposer.restore`.
+     */
+    setupFunction: MessageComposerSetupFunction | null;
+};
+export type StreamChatTearDownFunction = () => void;
+export type StreamChatSetupFunction = ({ client, }: {
+    client: StreamChat;
+}) => void | StreamChatTearDownFunction;
+export type StreamChatSetupState = {
+    setupFunction: StreamChatSetupFunction | null;
+};
+export type ChannelTearDownFunction = () => void;
+export type ChannelSetupFunction = ({ channel, }: {
+    channel: Channel;
+}) => void | ChannelTearDownFunction;
+export type ChannelSetupState = {
+    setupFunction: ChannelSetupFunction | null;
+};
+export type ThreadTearDownFunction = () => void;
+export type ThreadSetupFunction = ({ thread, }: {
+    thread: Thread;
+}) => void | ThreadTearDownFunction;
+export type ThreadSetupState = {
+    setupFunction: ThreadSetupFunction | null;
+};
+export type SetInstanceConfigurationServiceStates = {
+    Channel: StateStore<ChannelSetupState>;
+    MessageComposer: StateStore<MessageComposerSetupState>;
+    StreamChat: StateStore<StreamChatSetupState>;
+    Thread: StateStore<ThreadSetupState>;
+};
+export type SetupFnOf<T> = T extends StateStore<infer S> ? S extends {
+    setupFunction?: infer F;
+} ? F : never : never;
+export type SetInstanceConfigurationFunctions = {
+    [K in keyof SetInstanceConfigurationServiceStates]?: SetupFnOf<SetInstanceConfigurationServiceStates[K]>;
+};

package/dist/types/connection.d.ts

@@ -1,16 +1,17 @@
 import WebSocket from 'isomorphic-ws';
-import type { ConnectAPIResponse, ConnectionOpen, LogLevel, UR } from './types';
+import type { ConnectAPIResponse, ConnectionOpen } from './types';
 import type { StreamChat } from './client';
 /**
- * StableWSConnection - A WS connection that reconnects upon failure.
+ * A WS connection that reconnects upon failure.
+ *
  * - the browser will sometimes report that you're online or offline
  * - the WS connection can break and fail (there is a 30s health check)
  * - sometimes your WS connection will seem to work while the user is in fact offline
- * - to speed up online/offline detection you can use the window.addEventListener('offline');
+ * - to speed up online/offline detection you can use the `window.addEventListener('offline')`
  *
  * There are 4 ways in which a connection can become unhealthy:
- * - websocket.onerror is called
- * - websocket.onclose is called
+ * - WebSocket.onerror is called
+ * - WebSocket.onclose is called
  * - the health check fails and no event is received for ~40 seconds
  * - the browser indicates the connection is now offline
  *
@@ -45,71 +46,79 @@ export declare class StableWSConnection {
     constructor({ client }: {
         client: StreamChat;
     });
-    _log(msg: string, extra?: UR, level?: LogLevel): void;
     setClient(client: StreamChat): void;
     /**
-     * connect - Connect to the WS URL
-     * the default 15s timeout allows between 2~3 tries
-     * @return {ConnectAPIResponse<ChannelType, CommandType, UserType>} Promise that completes once the first health check message is received
+     * Connects to the WS URL. The default 15s timeout allows between 2 and 3 tries.
+     *
+     * @param timeout - Connect timeout in milliseconds (optional, defaults to `15000`).
+     * @returns A promise that resolves once the first health check message is received.
      */
-    connect(timeout?: number): Promise<void | ConnectionOpen>;
+    connect(timeout?: number): Promise<void | ({
+        type: "health.check";
+    } & import(".").HealthCheckEvent)>;
     /**
      * _waitForHealthy polls the promise connection to see if its resolved until it times out
      * the default 15s timeout allows between 2~3 tries
-     * @param timeout duration(ms)
+     *
+     * @param timeout - duration (ms)
      */
-    _waitForHealthy(timeout?: number): Promise<void | ConnectionOpen>;
+    _waitForHealthy(timeout?: number): Promise<void | ({
+        type: "health.check";
+    } & import(".").HealthCheckEvent)>;
     /**
-     * Builds and returns the url for websocket.
+     * Builds and returns the URL for the WebSocket connection.
+     *
      * @private
      * @returns url string
      */
     _buildUrl: () => string;
     /**
-     * disconnect - Disconnect the connection and doesn't recover...
+     * Disconnects the connection without attempting to recover.
      *
+     * @param timeout - Optional timeout in milliseconds to wait for the close frame from the server.
      */
     disconnect(timeout?: number): Promise<void>;
     /**
-     * _connect - Connect to the WS endpoint
+     * Connects to the WS endpoint.
      *
-     * @return {ConnectAPIResponse<ChannelType, CommandType, UserType>} Promise that completes once the first health check message is received
+     * @returns A promise that resolves once the first health check message is received.
      */
-    _connect(): Promise<ConnectionOpen | undefined>;
+    _connect(): Promise<({
+        type: "health.check";
+    } & import(".").HealthCheckEvent) | undefined>;
     /**
-     * _reconnect - Retry the connection to WS endpoint
+     * Retries the connection to the WS endpoint.
      *
-     * @param {{ interval?: number; refreshToken?: boolean }} options Following options are available
-     *
-     * - `interval`	{int}			number of ms that function should wait before reconnecting
-     * - `refreshToken` {boolean}	reload/refresh user token be refreshed before attempting reconnection.
+     * @param options - Reconnect options.
+     * @param options.interval - Number of milliseconds to wait before reconnecting.
+     * @param options.refreshToken - Reload/refresh the user token before attempting to reconnect.
      */
     _reconnect(options?: {
         interval?: number;
         refreshToken?: boolean;
     }): Promise<void>;
     /**
-     * onlineStatusChanged - this function is called when the browser connects or disconnects from the internet.
-     *
-     * @param {Event} event Event with type online or offline
+     * Called when the browser connects or disconnects from the internet.
      *
+     * @param event - The DOM event whose `type` is `'online'` or `'offline'`.
      */
     onlineStatusChanged: (event: Event) => void;
-    onopen: (wsID: number) => void;
-    onmessage: (wsID: number, event: WebSocket.MessageEvent) => void;
-    onclose: (wsID: number, event: WebSocket.CloseEvent) => void;
-    onerror: (wsID: number, event: WebSocket.ErrorEvent) => void;
+    onopen: (wsId: number) => void;
+    onmessage: (wsId: number, event: WebSocket.MessageEvent) => void;
+    onclose: (wsId: number, event: WebSocket.CloseEvent) => void;
+    onerror: (wsId: number, event: WebSocket.ErrorEvent) => void;
     /**
-     * _setHealth - Sets the connection to healthy or unhealthy.
-     * Broadcasts an event in case the connection status changed.
-     *
-     * @param {boolean} healthy boolean indicating if the connection is healthy or not
+     * Sets the connection to healthy or unhealthy. Broadcasts an event if the connection status changed.
      *
+     * @param healthy - Whether the connection is healthy.
      */
     _setHealth: (healthy: boolean) => void;
     /**
-     * _errorFromWSEvent - Creates an error object for the WS event
+     * Creates an error object for the WS event.
      *
+     * @param event - The raw WebSocket close / data / error event.
+     * @param isWSFailure - Whether the underlying cause is a WebSocket failure (optional, defaults to `true`).
+     * @returns A normalized error describing the WS failure.
      */
     _errorFromWSEvent: (event: WebSocket.CloseEvent | WebSocket.Data | WebSocket.ErrorEvent, isWSFailure?: boolean) => Error & {
         code?: string | number;
@@ -117,22 +126,21 @@ export declare class StableWSConnection {
         StatusCode?: string | number;
     };
     /**
-     * _destroyCurrentWSConnection - Removes the current WS connection
-     *
+     * Removes the current WS connection.
      */
     _destroyCurrentWSConnection(): void;
     /**
-     * _setupPromise - sets up the this.connectOpen promise
+     * Sets up the `this.connectionOpen` promise.
      */
     _setupConnectionPromise: () => void;
     /**
-     * Schedules a next health check ping for websocket.
+     * Schedules the next health check ping for the WebSocket connection.
      */
     scheduleNextPing: () => void;
     /**
-     * scheduleConnectionCheck - schedules a check for time difference between last received event and now.
-     * If the difference is more than 35 seconds, it means our health check logic has failed and websocket needs
-     * to be reconnected.
+     * Schedules a check for the time difference between the last received event and now. If the
+     * difference is more than 35 seconds, it means our health check logic has failed and the
+     * WebSocket needs to be reconnected.
      */
     scheduleConnectionCheck: () => void;
 }

package/dist/types/connection_fallback.d.ts

@@ -1,6 +1,6 @@
 import type { AxiosRequestConfig, CancelTokenSource } from 'axios';
 import type { StreamChat } from './client';
-import type { ConnectionOpen, LogLevel, UR } from './types';
+import type { UR } from './types';
 export declare enum ConnectionState {
     Closed = "CLOSED",
     Connected = "CONNECTED",
@@ -17,7 +17,6 @@ export declare class WSConnectionFallback {
     constructor({ client }: {
         client: StreamChat;
     });
-    _log(msg: string, extra?: UR, level?: LogLevel): void;
     _setState(state: ConnectionState): void;
     /** @private */
     _onlineStatusChanged: (event: {
@@ -29,9 +28,12 @@ export declare class WSConnectionFallback {
     _poll: () => Promise<void>;
     /**
      * connect try to open a longpoll request
-     * @param reconnect should be false for first call and true for subsequent calls to keep the connection alive and call recoverState
+     *
+     * @param reconnect - should be false for first call and true for subsequent calls to keep the connection alive and call recoverState
      */
-    connect: (reconnect?: boolean) => Promise<ConnectionOpen | undefined>;
+    connect: (reconnect?: boolean) => Promise<({
+        type: "health.check";
+    } & import(".").HealthCheckEvent) | undefined>;
     /**
      * isHealthy checks if there is a connectionID and connection is in Connected state
      */

package/dist/types/constants.d.ts

@@ -1,9 +1,5 @@
 export declare const DEFAULT_QUERY_CHANNELS_MESSAGE_LIST_PAGE_SIZE = 25;
 export declare const DEFAULT_QUERY_CHANNEL_MESSAGE_LIST_PAGE_SIZE = 100;
-export declare const DEFAULT_MESSAGE_SET_PAGINATION: Readonly<{
-    hasNext: false;
-    hasPrev: false;
-}>;
 export declare const DEFAULT_UPLOAD_SIZE_LIMIT_BYTES: number;
 export declare const API_MAX_FILES_ALLOWED_PER_MESSAGE = 10;
 export declare const MAX_CHANNEL_MEMBER_COUNT_IN_CHANNEL_QUERY = 100;

package/dist/types/custom_types.d.ts

@@ -1,4 +1,6 @@
 export interface CustomAttachmentData {
+    mime_type?: string;
+    file_size?: number;
 }
 export interface CustomChannelData {
 }

package/dist/types/entityStore/EntityStore.d.ts

@@ -0,0 +1,111 @@
+import type { Unsubscribe } from '../store';
+/**
+ * A batch of entity-store changes delivered to a subscriber in a single notification.
+ *
+ * `changedIds` are the ids the subscriber watches whose canonical object changed reference this
+ * flush (an upsert, or a removal — a removal makes `store.get(id)` return `undefined`).
+ */
+export type EntityStoreChangeBatch = {
+    changedIds: ReadonlySet<string>;
+};
+/**
+ * Anything that observes entities held in an {@link EntityStore}.
+ *
+ * A subscriber watches a *set* of entity ids (a paginator watches all ids in its
+ * intervals; a thread watches its single parent id). It is notified at most once
+ * per store transaction with the subset of its watched ids that changed.
+ */
+export type EntityStoreSubscriber = {
+    onEntitiesChanged: (batch: EntityStoreChangeBatch) => void;
+    /**
+     * Optional: emit any throttled/pending state notification immediately. Called by
+     * {@link EntityStore.flushSubscribers} after an optimistic (local-user) write so the change
+     * renders without throttle delay. A paginator implements this by flushing its throttled window
+     * publish.
+     */
+    flushState?: () => void;
+};
+export type EntityStoreOptions<T> = {
+    /** Extracts the canonical id an entity is stored and addressed under. */
+    getEntityId: (entity: T) => string;
+};
+/**
+ * A client-global, normalized store for domain entities addressed by id.
+ *
+ * The store holds exactly **one** canonical `T` per id and lets any number of entities
+ * (paginators, threads, ad-hoc consumers) subscribe to individual ids. Every mutation of a
+ * stored entity becomes a single `upsert`, and the store fans the change out to exactly the
+ * subscribers holding that id — replacing the manual copy-to-copy fan-out that keeping N
+ * per-consumer copies in sync required.
+ *
+ * The store is entity-agnostic: it learns how to extract an id from a `T` via the `getEntityId`
+ * function passed to its constructor. The client holds one as `client.messageStore`, an
+ * `EntityStore<LocalMessage>`, for message content.
+ *
+ * ## Design
+ *
+ * - **Content:** `byId` (`Map<id, T>`) is the single source of truth. Objects are immutable
+ *   snapshots: `upsert` *replaces*, never mutates in place, so the reference-equality
+ *   short-circuit (mirroring {@link StateStore.next}) and every downstream selector keep working.
+ * - **Subscription registry / refcount:** `subscribers` (`Map<id, Set<subscriber>>`) is both the
+ *   per-id notification list and the reference count — when the last subscriber of an id unlinks,
+ *   the canonical copy is garbage-collected.
+ * - **Batching:** `transaction` coalesces a bulk write (e.g. a page of N entities) so each affected
+ *   subscriber is notified **once** with the full changed-id set, instead of N times.
+ * - **Signal-then-pull:** subscribers receive the set of changed ids and pull the new content via
+ *   `get`; the store never pushes objects.
+ *
+ * This is deliberately a hand-rolled per-id registry rather than a {@link StateStore}: a single
+ * `StateStore` would run every subscriber's selector on every change (O(all subscribers) per emit),
+ * and a store-per-entity would allocate a full `StateStore` per id with no cross-id batching. The
+ * `Map<id, Set>` gives O(subscribers-of-changed-id) fan-out — the same idiom as `PollManager`'s
+ * cache.
+ *
+ * @template T The domain entity type held by the store.
+ */
+export declare class EntityStore<T> {
+    private byId;
+    private subscribers;
+    private readonly getEntityId;
+    private transactionDepth;
+    private pendingChanged;
+    constructor({ getEntityId }: EntityStoreOptions<T>);
+    get(id: string | undefined): T | undefined;
+    has(id: string): boolean;
+    /**
+     * Replaces the canonical copy of `entity` and notifies every subscriber watching its id —
+     * except `subscriber`, the one that performed the write, which is expected to re-render itself
+     * (the paginator that performed the write already emits its own window inline, so it must not be
+     * notified a second time through the subscription).
+     */
+    upsert(entity: T, subscriber?: EntityStoreSubscriber): void;
+    /** Registers `subscriber` for `id` (notification target + refcount). */
+    link(id: string, subscriber: EntityStoreSubscriber): void;
+    /** Drops `subscriber` from `id`; GCs the canonical copy when none remain. */
+    unlink(id: string, subscriber: EntityStoreSubscriber): void;
+    /**
+     * Sugar for atomic / ad-hoc consumers that watch a single id (e.g. a thread watching its parent
+     * message). Fires `handler` immediately with the current value (mirroring
+     * {@link StateStore.subscribe}) and on every subsequent change.
+     */
+    subscribe(id: string, handler: (entity: T | undefined) => void): Unsubscribe;
+    /**
+     * Runs `fn`, coalescing all notifications produced by writes inside it into a single flush on
+     * exit. Re-entrant: nested transactions flush only when the outermost exits.
+     */
+    transaction<R>(fn: () => R): R;
+    /**
+     * Immediately flushes any throttled/pending state publish on the subscribers of `id` (via
+     * {@link EntityStoreSubscriber.flushState}). Called after an optimistic (local-user) write to
+     * `id` so it renders without the throttle delay. Only that id's own subscribers are flushed — the
+     * write touched no other id — and flushing a subscriber with nothing pending is a no-op.
+     */
+    flushSubscribers(id: string): void;
+    /**
+     * Records `id` as changed for every subscriber watching it, except `subscriber` — the one that
+     * wrote it and is resposible for updating itself (see {@link EntityStore.upsert}).
+     */
+    private markDirty;
+    private autoFlush;
+    private flush;
+}

package/dist/types/entityStore/StoreBackedItemIndex.d.ts

@@ -0,0 +1,60 @@
+import type { ItemIndexApi } from '../pagination/ItemIndex';
+import { EntityStore, type EntityStoreSubscriber } from './EntityStore';
+export type StoreBackedItemIndexOptions<T> = {
+    getEntityId: (item: T) => string;
+    /**
+     * The entity that owns this index; used as the store subscriber, which also holds its refcount.
+     * Optional: an index over a private store (see `store`) has no one to fan out to, so an
+     * owner-less index just uses an internal no-op subscriber to hold its refcount. Message paginators pass themselves so
+     * cross-collection updates reach them; single-home collections (channels, reminders, …) omit it.
+     */
+    owner?: EntityStoreSubscriber;
+    /**
+     * The shared, client-global store that holds the canonical content. Optional: when omitted the
+     * index provisions a **private** {@link EntityStore} of its own, so it behaves exactly like a
+     * plain, per-instance index — same code path, no shared content, no fan-out. This is the mode used
+     * by single-home collections and by detached paginators (e.g. built without a client, in tests).
+     */
+    store?: EntityStore<T>;
+};
+/**
+ * An {@link ItemIndexApi} implementation that keeps entity **content** in an {@link EntityStore}
+ * while keeping **membership** local.
+ *
+ * A consumer sees the same minimal CRUD surface ({@link ItemIndexApi}), but:
+ *
+ * - `get`/`has`/`values`/`entries` are scoped to *this* index's membership (`memberIds`), so
+ *   `getItem(id)` still means "does THIS index hold the id" — even though the canonical object
+ *   lives in the (possibly shared) store. This is what keeps e.g. reaction routing
+ *   (`threadPaginator.getItem(id) ? thread : channel`) correct and keeps the `.values()` scans
+ *   from ever walking other channels' entities.
+ * - `setOne` writes content once into the store and links the owner as a subscriber (drives both
+ *   notification fan-out and refcount GC). The write passes the owner as the `subscriber` to skip, so
+ *   the owner is not notified of its own write (it re-emits its window inline); other subscribers of
+ *   the same id ARE notified and re-project.
+ * - `remove`/`clear` unlink the owner rather than hard-deleting content, so an entity still held by
+ *   another index (e.g. a `show_in_channel` reply in both the channel list and its thread) survives;
+ *   the store GCs it only when the last subscriber unlinks.
+ *
+ * When no shared store is supplied the index holds a private store — every id it links has exactly
+ * one subscriber (its own owner), so no fan-out ever fires and removal GCs immediately, matching a plain
+ * per-instance index.
+ *
+ * @template T The domain item type held by the index; collocated with the {@link EntityStore}'s.
+ */
+export declare class StoreBackedItemIndex<T> implements ItemIndexApi<T> {
+    private memberIds;
+    private readonly store;
+    private readonly owner;
+    private readonly getEntityId;
+    constructor({ store, owner, getEntityId }: StoreBackedItemIndexOptions<T>);
+    setMany(items: T[]): void;
+    setOne(item: T): void;
+    get(id: string): T | undefined;
+    has(id: string): boolean;
+    remove(id: string): void;
+    clear(): void;
+    entries(): [string, T][];
+    values(): T[];
+    batch<R>(fn: () => R): R;
+}

package/dist/types/entityStore/applyReactionLocally.d.ts

@@ -0,0 +1,26 @@
+import type { StreamChat } from '../client';
+import type { ReactionRequest } from '../types';
+/**
+ * Applies a reaction to the single canonical copy of a message in the client-global
+ * {@link EntityStore} (`client.messageStore`), addressed purely by id — NOT through any paginator's
+ * membership. It reads the
+ * current message POJO (`store.get`), produces a new POJO with the reaction folded into its
+ * `reaction_groups` / `latest_reactions` (shared count helpers) and `own_reactions`
+ * ({@link computeOwnReactions}), and writes it back (`store.upsert`). The store then notifies every
+ * collection currently holding that id — the main-list / thread-reply paginators, a thread's
+ * subscribed parent, any future consumer — and each re-projects. The message stays a plain object;
+ * the store's per-id registry is the reactivity.
+ *
+ * Because it is keyed by id rather than by a paginator's `getItem`, it reaches a message held by ANY
+ * collection, including the thread parent that lives in no paginator — with no per-home wiring.
+ *
+ * Writes memory (synchronous) + the offline DB (fire-and-forget), and returns an `undo()` reversing
+ * both on the current state (inverse deltas, concurrency-safe), or `undefined` when the user isn't
+ * connected or the message isn't in the store.
+ */
+export declare const applyReactionLocally: (client: StreamChat, { enforceUnique, messageId, reaction, removed, }: {
+    messageId: string;
+    reaction: ReactionRequest;
+    enforceUnique?: boolean;
+    removed?: boolean;
+}) => (() => void) | undefined;

package/dist/types/entityStore/index.d.ts

@@ -0,0 +1,2 @@
+export * from './applyReactionLocally';
+export * from './EntityStore';

package/dist/types/errors.d.ts

@@ -1,5 +1,5 @@
 import type { AxiosResponse } from 'axios';
-import type { APIErrorResponse } from './types';
+import type { APIError as Gen_APIError } from './types';
 export declare const APIErrorCodes: Record<string, {
     name: string;
     retryable: boolean;
@@ -11,6 +11,14 @@ export type APIError = Error & {
 };
 export declare function isAPIError(error: Error): error is APIError;
 export declare function isErrorRetryable(error: APIError): boolean;
+/**
+ * Whether an error is EPHEMERAL — a transient failure worth queueing/retrying rather than a
+ * definitive rejection. True when the server never responded (connection/network/offline error - no
+ * `response`, i.e an axios network error or an `OfflineError`) and when the server responded with a
+ * retryable code (see {@link APIErrorCodes}); false only when the server responded with a
+ * non-retryable code (InputError 4, DoesNotExist 16, NotAllowed 17, …).
+ */
+export declare function isEphemeral(error: Error): boolean;
 export declare function isConnectionIDError(error: APIError): boolean;
 export declare function isWSFailure(err: APIError): boolean;
-export declare function isErrorResponse(res: AxiosResponse<unknown>): res is AxiosResponse<APIErrorResponse>;
+export declare function isErrorResponse(res: AxiosResponse<unknown>): res is AxiosResponse<Gen_APIError>;

package/dist/types/gen/chat/ChannelApi.d.ts

@@ -0,0 +1,45 @@
+import type { ChatApi, StreamResponse } from '../../gen-imports';
+import type { ChannelGetOrCreateRequest, ChannelStateResponse, ChannelStopWatchingRequest, CreateDraftRequest, CreateDraftResponse, DeleteChannelResponse, EventResponse, GetDraftResponse, GetManyMessagesResponse, HideChannelRequest, HideChannelResponse, MarkReadRequest, MarkReadResponse, MarkUnreadRequest, Response, SendEventRequest, SendMessageRequest, SendMessageResponse, ShowChannelRequest, ShowChannelResponse, TruncateChannelRequest, TruncateChannelResponse, UpdateChannelPartialRequest, UpdateChannelPartialResponse, UpdateChannelRequest, UpdateChannelResponse, UpdateMemberPartialRequest, UpdateMemberPartialResponse, UploadChannelFileRequest, UploadChannelFileResponse, UploadChannelRequest, UploadChannelResponse } from '../models';
+export declare class ChannelApi {
+    protected chatApi: ChatApi;
+    readonly type: string;
+    id: string | undefined;
+    constructor(chatApi: ChatApi, type: string, id: string | undefined);
+    delete(request?: {
+        hard_delete?: boolean;
+    }): Promise<StreamResponse<DeleteChannelResponse>>;
+    updateChannelPartial(request?: UpdateChannelPartialRequest): Promise<StreamResponse<UpdateChannelPartialResponse>>;
+    update(request?: UpdateChannelRequest): Promise<StreamResponse<UpdateChannelResponse>>;
+    deleteDraft(request?: {
+        parent_id?: string;
+    }): Promise<StreamResponse<Response>>;
+    getDraft(request?: {
+        parent_id?: string;
+    }): Promise<StreamResponse<GetDraftResponse>>;
+    createDraft(request: CreateDraftRequest): Promise<StreamResponse<CreateDraftResponse>>;
+    sendEvent(request: SendEventRequest): Promise<StreamResponse<EventResponse>>;
+    deleteChannelFile(request?: {
+        url?: string;
+    }): Promise<StreamResponse<Response>>;
+    uploadChannelFile(request?: UploadChannelFileRequest): Promise<StreamResponse<UploadChannelFileResponse>>;
+    hide(request?: HideChannelRequest): Promise<StreamResponse<HideChannelResponse>>;
+    deleteChannelImage(request?: {
+        url?: string;
+    }): Promise<StreamResponse<Response>>;
+    uploadChannelImage(request?: UploadChannelRequest): Promise<StreamResponse<UploadChannelResponse>>;
+    updateMemberPartial(request?: UpdateMemberPartialRequest): Promise<StreamResponse<UpdateMemberPartialResponse>>;
+    sendMessage(request: SendMessageRequest): Promise<StreamResponse<SendMessageResponse>>;
+    getManyMessages(request: {
+        ids: Array<string>;
+    }): Promise<StreamResponse<GetManyMessagesResponse>>;
+    getOrCreate(request?: ChannelGetOrCreateRequest & {
+        connection_id?: string;
+    }): Promise<StreamResponse<ChannelStateResponse>>;
+    markRead(request?: MarkReadRequest): Promise<StreamResponse<MarkReadResponse>>;
+    show(request?: ShowChannelRequest): Promise<StreamResponse<ShowChannelResponse>>;
+    stopWatching(request?: ChannelStopWatchingRequest & {
+        connection_id?: string;
+    }): Promise<StreamResponse<Response>>;
+    truncate(request?: TruncateChannelRequest): Promise<StreamResponse<TruncateChannelResponse>>;
+    markUnread(request?: MarkUnreadRequest): Promise<StreamResponse<Response>>;
+}