stream-chat 9.50.3 → 10.0.0-rc.2

package/dist/types/pagination/paginators/MessagePaginator.d.ts

@@ -0,0 +1,208 @@
+import type { ExecuteQueryReturnValue, Interval, PostQueryReconcileParams } from './BasePaginator';
+import { type MessagePaginatorOptions as BaseMessagePaginatorOptions, type JumpToMessageOptions, MessageIntervalPaginator, type MessageQueryShape } from './MessageIntervalPaginator';
+import type { LocalMessage } from '../../types';
+import { StateStore } from '../../store';
+export type { JumpToMessageOptions, MessageFocusReason, MessageFocusSignal, MessageFocusSignalState, MessagePaginatorFilter, MessagePaginatorSort, MessagePaginatorState, MessageQueryShape, } from './MessageIntervalPaginator';
+export { MessageIntervalPaginator } from './MessageIntervalPaginator';
+/**
+ * Auxiliary (non-pagination) state for the message paginator: whole-collection aggregates that are
+ * independent of the active pagination window (the dual of pagination — values over the entire set,
+ * not a page of it). `lastMessageAt` is effectively `MAX(created_at)` over the channel-relevant
+ * messages and is the source of truth for channel-list ordering
+ * (`channel.messagePaginator.lastMessageAt`): seeded from `ChannelResponse.last_message_at`, then
+ * advanced monotonically as newer messages are ingested.
+ */
+export type MessagePaginatorAggregateState = {
+    /**
+     * The newest channel-relevant message, for display (e.g. a channel/thread list item's last-message
+     * preview or latest-reply avatar). A LIVE reference: it advances to a strictly newer message, is
+     * refreshed in place when that message is edited/soft-deleted/reacted-to, and is recomputed to the
+     * next newest when it is hard-removed. Respects `shouldAdvanceLastMessage` (skips system messages
+     * per `skip_last_msg_update_for_system_msgs`, and thread-only replies). `null` until one is ingested.
+     *
+     * Lives here, NOT derived from pagination `state`, so it stays reactive when a WS message lands in
+     * the head interval while an older window is active — the pagination store only emits when the
+     * active* interval is impacted (see `BasePaginator.ingestItem`), so a `state`-derived latest would
+     * go stale in that case.
+     */
+    lastMessage: LocalMessage | null;
+    /**
+     * Server-provided `ChannelResponse.last_message_at` floor, for channels whose newest message is not
+     * loaded (e.g. surfaced by a channel-list query). Kept SEPARATE from {@link lastMessage} so it can
+     * outrank a stale/absent loaded message for sorting without overwriting the display message. The
+     * sort key {@link MessagePaginator.lastMessageAt} is derived as the max of the two, so the two can
+     * never drift out of sync.
+     */
+    seededLastMessageAt: Date | null;
+};
+export type MessagePaginatorOptions = BaseMessagePaginatorOptions & {
+    /**
+     * Controls whether `jumpToTheFirstUnreadMessage()` should prefer the `unreadStateSnapshot`
+     * state over `channel.state.read[...]`.
+     *
+     * - 'snapshot' (default): retrieve the first unread message id from the unreadStateSnapshot state when jumping to the first unread message
+     * - 'read-state-only': retrieve the last read message id from the channel read state when jumping to the first unread message
+     */
+    unreadReferencePolicy?: 'snapshot' | 'read-state-only';
+};
+export type UnreadSnapshotState = {
+    lastReadAt: Date | null;
+    unreadCount: number;
+    /**
+     * Snapshot of the first unread message id for the user.
+     * This is intentionally decoupled from `channel.state.read[...]` because apps
+     * may mark the channel read immediately on open, while still wanting to render
+     * UI indicators that jump to the previously-unread location.
+     */
+    firstUnreadMessageId: string | null;
+    /**
+     * Snapshot of the last read message id for the user (fallback when first unread
+     * is not known).
+     */
+    lastReadMessageId: string | null;
+};
+/**
+ * External, UI-driven signal: `true` while the user is actively viewing the latest messages of
+ * this collection (app foregrounded AND the newest message on screen). The owning SDK sets it — the
+ * state layer has no viewport. When live, an incoming message is NOT counted as unread (the count /
+ * snapshot bump is skipped), so the "N new" separator/banner never flash for a message the user is
+ * already looking at. Defaults to `false` (assume not viewing until the SDK proves otherwise).
+ */
+export type LiveViewState = {
+    isViewingLive: boolean;
+};
+/**
+ * MessagePaginator extends {@link MessageIntervalPaginator} with the unread/live-view concern:
+ * an independent unread reference snapshot, the UI-driven "viewing the latest messages" signal, and
+ * the "jump to first unread" navigation built on top of them.
+ */
+export declare class MessagePaginator extends MessageIntervalPaginator {
+    private unreadReferencePolicy;
+    /**
+     * Independent unread reference state (not tied to `channel.state.read`).
+     * Consumers may set this right before calling markRead / when opening a channel.
+     */
+    readonly unreadStateSnapshot: StateStore<UnreadSnapshotState>;
+    /**
+     * UI-driven "viewing the latest messages" signal (see {@link LiveViewState}). Set by the SDK via
+     * {@link setViewingLive}; read by the channel to gate the unread bump on `message.new`. Subscribe to
+     * this store for reactivity, or read the current boolean directly via the {@link isViewingLive} getter.
+     */
+    readonly liveViewState: StateStore<LiveViewState>;
+    /**
+     * Auxiliary (non-pagination) state — see {@link MessagePaginatorAggregateState}. A store separate
+     * from `state` so `lastMessageAt` can be advanced from inside a `state.next` updater
+     * (`ingestPage`) without being clobbered, and so consumers subscribe to a quiet signal that only
+     * emits when the aggregate actually changes (not on every scroll/pagination emission). This is
+     * distinct from the base's `intervalViews` interval-projection store.
+     */
+    readonly aggregateState: StateStore<MessagePaginatorAggregateState>;
+    constructor({ unreadReferencePolicy, ...options }: MessagePaginatorOptions);
+    /**
+     * Channel-list sort key: the later of the newest loaded message's `created_at` and the server seed.
+     * **Derived** (never stored) so it cannot drift from {@link lastMessage}. `null` until seeded or a
+     * message is ingested.
+     */
+    get lastMessageAt(): Date | null;
+    /**
+     * The newest channel-relevant message (the monotonic tracked latest), for display. Convenience read
+     * of {@link aggregateState}; subscribe to `aggregateState` for reactivity. `null` until a message is
+     * ingested (a server-only seed advances {@link lastMessageAt} but leaves this `null`).
+     */
+    get lastMessage(): LocalMessage | null;
+    /**
+     * The main channel list's notion of "latest message" for `channel.state.last_message_at`: on top of
+     * the base rule (not shadowed) this excludes thread-only replies (a reply with a `parent_id` that is
+     * not shown in the channel is not part of the channel list) and, when the channel is configured with
+     * `skip_last_msg_update_for_system_msgs`, system messages. Mirrors the legacy
+     * `Channel._trackLastMessage` skip logic.
+     *
+     * These exclusions are specific to the MAIN channel list. A reply list (thread paginator, which has
+     * a `parentMessageId`) is made ENTIRELY of thread replies — there the newest reply is exactly the
+     * "latest message", so the exclusions are skipped and only the base rule applies.
+     */
+    protected shouldAdvanceLastMessage(message: LocalMessage): boolean;
+    /**
+     * Monotonically advance {@link lastMessageAt} to `message.created_at` when it is newer than the
+     * current value and {@link shouldAdvanceLastMessage} permits it. Writes the dedicated
+     * {@link aggregateState} store (not `state`), so it is safe to call from inside a `state.next`
+     * updater (`ingestPage`). Returns `true` when the value moved.
+     *
+     * Called internally on ingest; also public for callers that advance the aggregate without a normal
+     * in-window ingest — e.g. offline pending-message replay, where the sent message has not yet been
+     * ingested via the `message.new` event.
+     */
+    trackLastMessage(message: LocalMessage): boolean;
+    /**
+     * Seed {@link lastMessageAt} from the server-provided `ChannelResponse.last_message_at`, the
+     * authoritative whole-channel aggregate. Monotonic: a no-op when the paginator already advanced
+     * past it (e.g. from ingested messages), so seed order does not matter.
+     */
+    seedLastMessageAt(value: string | Date | null | undefined): void;
+    ingestItem(item: LocalMessage): boolean;
+    ingestPage(params: Parameters<MessageIntervalPaginator['ingestPage']>[0]): Interval | null;
+    removeItem(params: Parameters<MessageIntervalPaginator['removeItem']>[0]): ReturnType<MessageIntervalPaginator['removeItem']>;
+    /**
+     * The still-loaded message with the greatest `created_at` that passes
+     * {@link shouldAdvanceLastMessage} (skips system / thread-only per config), from the newest-loaded
+     * window. Used to recompute the tracked latest after the current one is removed. `null` when nothing
+     * loaded qualifies.
+     *
+     * "Latest" is defined by `created_at` (matching {@link trackLastMessage}), NOT by the paginator's
+     * display order — so this compares timestamps rather than assuming a position, and stays correct
+     * whatever `itemOrder` / `requestSort` are configured to.
+     */
+    private recomputeLastMessage;
+    /**
+     * (Re)seed the unread state snapshot from the current own read state.
+     *
+     * Called after the first-page query, and can be called again by the SDK whenever a channel is
+     * (re)opened from a cached paginator — where no fresh first-page query runs — so the snapshot
+     * reflects the CURRENT read boundary rather than one frozen at the very first open. Without a
+     * re-seed the separator position, unread count and "jump to first unread" target all go stale
+     * across reopens.
+     *
+     * `firstUnreadMessageId` is intentionally reset to `null`: it represents an EXPLICIT mark-unread
+     * (set by `notification.mark_unread`), not a live/computed boundary. Persisting a computed value
+     * here would make the channel look explicitly marked-unread and suppress auto-mark-read.
+     */
+    seedUnreadSnapshot: () => void;
+    /**
+     * Invokes super.postQueryReconcile() and takes an unread state snapshot on the first-page query.
+     * The snapshot has to be taken immediately after the query as the viewed channel is marked read
+     * immediately after opening it. The snapshot can be used to display unread UI indicators.
+     */
+    postQueryReconcile(params: PostQueryReconcileParams<LocalMessage, MessageQueryShape>): ExecuteQueryReturnValue<LocalMessage>;
+    /**
+     * Jumps to the unread reference message.
+     *
+     * IMPORTANT: This intentionally does *not* rely on `channel.state.read[ownUserId]` only,
+     * because apps may mark a channel read immediately after opening it, while still
+     * wanting to keep "jump to unread" UI indicators alive (based on a snapshot).
+     *
+     * Resolution order:
+     * 1) explicit first-unread id from snapshot/read-state (mark-unread) — jump straight to it
+     * 2) last-read timestamp: infer the FIRST UNREAD message from it — using the already-loaded
+     *    window when it straddles the boundary, otherwise a `created_at_around` query — and jump there
+     * 3) last read id from snapshot/read-state (last-resort fallback when no timestamp is available)
+     *
+     * The timestamp inference (2) is preferred over jumping to the last-read id so that the jump lands
+     * ON (and highlights) the first unread message rather than the last read one. The last-read id is
+     * only used as a fallback when we cannot infer an unread boundary. The inference is NOT persisted
+     * back into the snapshot (that is reserved for explicit mark-unread).
+     */
+    jumpToTheFirstUnreadMessage: (options?: JumpToMessageOptions) => Promise<boolean>;
+    setUnreadSnapshot: (next: Partial<UnreadSnapshotState>) => UnreadSnapshotState;
+    /**
+     * Set the UI-driven "viewing the latest messages" signal (see {@link LiveViewState}). Called by
+     * the SDK from its message-list viewability + app-state tracking. No-ops when unchanged.
+     *
+     * Intentionally NOT reset by `clearStateAndCache` — it is an external input owned by the SDK, not
+     * derived pagination state.
+     */
+    /** Current "viewing the latest messages" boolean (convenience read of {@link liveViewState}). */
+    get isViewingLive(): boolean;
+    setViewingLive: (isViewingLive: boolean) => void;
+    clearUnreadSnapshot: () => void;
+    clearStateAndCache(): void;
+}

package/dist/types/pagination/paginators/PinnedMessagePaginator.d.ts

@@ -0,0 +1,39 @@
+import type { PaginatorOptions } from './BasePaginator';
+import { MessageIntervalPaginator, type MessageQueryShape } from './MessageIntervalPaginator';
+import type { LocalMessage } from '../../types';
+import type { Channel } from '../../channel';
+import type { ItemIndexApi } from '../ItemIndex';
+export type PinnedMessagePaginatorFilter = {
+    cid: string;
+    pinned: boolean;
+};
+export type PinnedMessagePaginatorOptions = {
+    channel: Channel;
+    id?: string;
+    itemIndex?: ItemIndexApi<LocalMessage>;
+    paginatorOptions?: PaginatorOptions<LocalMessage, MessageQueryShape>;
+};
+/**
+ * Pinned-message list paginator.
+ *
+ * Extends the unread-free {@link MessageIntervalPaginator} base — pinned messages are a subset of
+ * the channel and MUST NOT participate in read/unread or delivery-receipt tracking (that belongs to
+ * the channel and thread message timelines). By extending the base rather than {@link MessagePaginator}
+ * it simply never gets the unread surface.
+ *
+ * Differences from the main list:
+ * - fetches from the `/pinned_messages` endpoint (`channel.getPinnedMessages`) rather than
+ *   `channel.query({ messages })`;
+ * - includes only pinned, non-shadowed messages (`shouldIncludeMessageInInterval`), and filters on
+ *   `{ cid, pinned: true }` so `ingestItem` auto-adds on pin and auto-removes on unpin;
+ * - orders by `pinned_at` ascending (oldest-pinned first), matching the legacy
+ *   `channel.state.pinnedMessages` order.
+ *
+ * Navigation (`jumpToMessage` / `jumpToTheLatestMessage`) is inherited and meaningful — the endpoint
+ * supports `id_around` — but no unread-coupled navigation exists.
+ */
+export declare class PinnedMessagePaginator extends MessageIntervalPaginator {
+    constructor({ channel, id, itemIndex, paginatorOptions, }: PinnedMessagePaginatorOptions);
+    buildMatchFilters: () => PinnedMessagePaginatorFilter;
+    shouldIncludeMessageInInterval(message: LocalMessage): boolean;
+}

package/dist/types/pagination/paginators/ReminderPaginator.d.ts

@@ -0,0 +1,19 @@
+import { BasePaginator } from './BasePaginator';
+import type { PaginationQueryParams, PaginationQueryReturnValue, PaginatorOptions } from './BasePaginator';
+import type { QueryRemindersOptions, ReminderFilters, ReminderResponseData, ReminderSort } from '../../types';
+import type { StreamChat } from '../../client';
+export declare class ReminderPaginator extends BasePaginator<ReminderResponseData, QueryRemindersOptions> {
+    private client;
+    protected _filters: ReminderFilters | undefined;
+    protected _sort: ReminderSort | undefined;
+    get filters(): ReminderFilters | undefined;
+    get sort(): ReminderSort | undefined;
+    set filters(filters: ReminderFilters | undefined);
+    set sort(sort: ReminderSort | undefined);
+    constructor(client: StreamChat, options?: PaginatorOptions<ReminderResponseData, QueryRemindersOptions>);
+    getItemId(item: ReminderResponseData): string;
+    private buildSortComparator;
+    protected getNextQueryShape({ direction, }: Required<Pick<PaginationQueryParams<QueryRemindersOptions>, 'direction'>>): QueryRemindersOptions;
+    query: ({ queryShape, }: PaginationQueryParams<QueryRemindersOptions>) => Promise<PaginationQueryReturnValue<ReminderResponseData>>;
+    filterQueryResults: (items: ReminderResponseData[]) => ReminderResponseData[];
+}

package/dist/types/pagination/paginators/UserGroupPaginator.d.ts

@@ -0,0 +1,24 @@
+import { BasePaginator } from './BasePaginator';
+import type { PaginationQueryParams, PaginationQueryReturnValue, PaginatorOptions, PaginatorState } from './BasePaginator';
+import type { ListUserGroupsOptions, UserGroupResponse } from '../../types';
+import type { StreamChat } from '../../client';
+/**
+ * Paginates user-group listing through `/usergroups`.
+ *
+ * This entity only supports forward (tailward) cursor pagination via
+ * `created_at_gt` and `id_gt`. Backward (headward) pagination is not available
+ * because the API does not expose a backward cursor, so the headward cursor is
+ * initialized as exhausted (`null`).
+ */
+export declare class UserGroupPaginator extends BasePaginator<UserGroupResponse, ListUserGroupsOptions> {
+    private client;
+    protected _teamId: string | undefined;
+    constructor(client: StreamChat, options?: PaginatorOptions<UserGroupResponse, ListUserGroupsOptions>);
+    get initialState(): PaginatorState<UserGroupResponse>;
+    get teamId(): string | undefined;
+    set teamId(teamId: string | undefined);
+    private buildNextCursor;
+    protected getNextQueryShape(): ListUserGroupsOptions;
+    query: ({ direction, queryShape, }: PaginationQueryParams<ListUserGroupsOptions>) => Promise<PaginationQueryReturnValue<UserGroupResponse>>;
+    filterQueryResults: (items: UserGroupResponse[]) => UserGroupResponse[];
+}

package/dist/types/pagination/paginators/index.d.ts

@@ -0,0 +1,7 @@
+export * from './BasePaginator';
+export * from './ChannelPaginator';
+export { MessageIntervalPaginator } from './MessageIntervalPaginator';
+export * from './MessagePaginator';
+export * from './PinnedMessagePaginator';
+export * from './ReminderPaginator';
+export * from './UserGroupPaginator';

package/dist/types/pagination/paginators/stateThrottling.d.ts

@@ -0,0 +1,2 @@
+export declare const isStateThrottlingEnabled: () => boolean;
+export declare const setStateThrottlingEnabled: (value: boolean) => void;

package/dist/types/pagination/sortCompiler.d.ts

@@ -0,0 +1,49 @@
+import type { SortParamRequest } from '../types';
+import type { Comparator, PathResolver } from './types.normalization';
+export type ItemLocation = {
+    currentIndex: number;
+    insertionIndex: number;
+};
+/**
+ * Generic binary-search + plateau lookup over an abstract sorted array.
+ *
+ * The array is represented by:
+ *  - its length
+ *  - a getter `getItemAt(index)` that returns the item (or undefined)
+ *
+ * It returns:
+ *  - current: actual index of the item in the array
+ *  - expected: lower-bound position where the item belongs according to compare function
+ */
+export declare function binarySearch<T>({ needle, length, getItemAt, itemIdentityEquals, compare, plateauScan, }: {
+    /** Target item in the searched array */
+    needle: T;
+    length: number;
+    /** Retrieves the item from an array. The array could be just an array of reference by id to an index.
+     * Therefore, we do not access the array directly but allow to determine, how the item is constructed.
+     */
+    getItemAt: (index: number) => T | undefined;
+    /** Used to determine identity, not equality based on sort / comparator rules */
+    itemIdentityEquals: (item1: T, item2: T) => boolean;
+    /** Used to determine equality from the sort order point of view. */
+    compare: Comparator<T>;
+    plateauScan?: boolean;
+}): ItemLocation;
+/**
+ * Negative number (< 0) → a comes before b
+ *
+ * Zero (0) → leave a and b unchanged relative to each other
+ * (but they can still move relative to others — sort in JS is not guaranteed stable in older engines, though modern V8/Node/Chrome/Firefox make it stable)
+ *
+ * Positive number (> 0) → a comes after b
+ *
+ * @param params - Comparator configuration.
+ * @param params.sort - The sort specification defining fields and directions.
+ * @param params.resolvePathValue - Resolver used to read a field value from an item.
+ * @param params.tiebreaker - Comparator applied when all sort terms are equal.
+ */
+export declare function makeComparator<T>({ sort, resolvePathValue, tiebreaker, }: {
+    sort: SortParamRequest[];
+    resolvePathValue?: PathResolver<T>;
+    tiebreaker?: Comparator<T>;
+}): Comparator<T>;

package/dist/types/pagination/types.normalization.d.ts

@@ -0,0 +1,11 @@
+export type PathResolver<DataSource> = (item: DataSource, field: string) => unknown;
+export declare enum ComparisonResult {
+    A_PRECEDES_B = -1,
+    A_IS_EQUAL_TO_B = 0,
+    A_COMES_AFTER_B = 1
+}
+export type Comparator<T> = (left: T, right: T) => ComparisonResult;
+export type FieldToDataResolver<DataSource> = {
+    matchesField: (field: string) => boolean;
+    resolve: PathResolver<DataSource>;
+};

package/dist/types/pagination/utility.normalization.d.ts

@@ -0,0 +1,18 @@
+export declare function asArray(v: any): any[];
+export declare function isISODateString(x: any): x is string;
+export declare function toEpochMillis(x: any): number | null;
+export declare function toNumberLike(x: any): number | null;
+export declare function normalizeComparedValues(a: any, b: any): {
+    kind: string;
+    a: any;
+    b: any;
+};
+export declare function normKey(x: unknown): string;
+export declare function compare(a: any, b: any): number;
+export declare function arraysEqualAsSets(aList: unknown[], bList: unknown[]): boolean;
+export declare function normalizeString(s: string): string;
+export declare function normalizeStringAccentInsensitive(s: string): string;
+export declare function tokenize(s: string): string[];
+export declare function resolveDotPathValue(obj: any, path: string): unknown[];
+export declare function isIterableButNotString(v: unknown): v is Iterable<unknown>;
+export declare function toIterableArray(v: unknown): unknown[];

package/dist/types/pagination/utility.queryChannel.d.ts

@@ -0,0 +1,26 @@
+import type { ChannelGetOrCreateRequest } from '../types';
+import type { StreamChat } from '../client';
+import type { Channel } from '../channel';
+type GetChannelParams = {
+    client: StreamChat;
+    channel?: Channel;
+    id?: string;
+    members?: string[];
+    options?: ChannelGetOrCreateRequest;
+    type?: string;
+};
+/**
+ * Watches a channel, coalescing concurrent invocations for the same CID.
+ * If a watch is already in flight, this call waits for it to settle instead of
+ * issuing another network request.
+ *
+ * @param params - The channel query parameters.
+ * @param params.client - The chat client instance.
+ * @param params.members - Member user ids used to construct or identify the channel.
+ * @param params.options - Options forwarded to the underlying channel watch request.
+ * @param params.type - The channel type.
+ * @param params.id - The channel id.
+ * @param params.channel - An existing channel to watch (skips construction from type/id/members).
+ */
+export declare const getChannel: ({ channel, client, id, members, options, type, }: GetChannelParams) => Promise<Channel>;
+export {};

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

@@ -0,0 +1,13 @@
+/**
+ * Partition-point ("lower bound") binary search over the index range `[0, length)`.
+ *
+ * `predicate` must be **monotonic** over the range — `false` for a (possibly empty) prefix, then
+ * `true` for the remaining suffix. Returns the first index at which `predicate(index)` holds, or
+ * `length` if it never does. O(log length).
+ *
+ * Unlike `binarySearch`, this locates a *boundary* defined by a predicate rather than a specific
+ * item by identity — e.g. "first message at/after a timestamp" over a chronologically sorted array.
+ */
+export declare function lowerBound(length: number, predicate: (index: number) => boolean): number;
+export declare function locateOnPlateauAlternating<T>(items: readonly T[], needle: T, compare: (left: T, right: T) => number, getItemId: (x: T) => string, insertionIndex: number): number;
+export declare function locateOnPlateauScanOneSide<T>(items: readonly T[], needle: T, compare: (left: T, right: T) => number, getItemId: (x: T) => string, insertionIndex: number): number;

package/dist/types/permissions.d.ts

@@ -17,7 +17,7 @@ export declare class Permission {
 }
 export declare const AllowAll: Permission;
 export declare const DenyAll: Permission;
-export type Role = 'admin' | 'user' | 'guest' | 'anonymous' | 'channel_member' | 'channel_moderator' | (string & {});
+export type RoleName = 'admin' | 'user' | 'guest' | 'anonymous' | 'channel_member' | 'channel_moderator' | (string & {});
 export declare const BuiltinRoles: {
     Admin: string;
     Anonymous: string;

package/dist/types/poll.d.ts

@@ -1,7 +1,8 @@
 import { StateStore } from './store';
 import type { StreamChat } from './client';
-import type { Event, PartialPollUpdate, PollAnswer, PollData, PollEnrichData, PollOptionData, PollResponse, PollVote, QueryVotesFilters, QueryVotesOptions, VoteSort } from './types';
-export declare const isVoteAnswer: (vote: PollVote | PollAnswer) => vote is PollAnswer;
+import type { EventPayload, PartialPollUpdate, PollEnrichData, PollOptionData, PollResponse_old, PollVoteResponseData, QueryVotesFilters, QueryVotesOptions, RequireLiteral, UpdatePollRequest, VoteSort } from './types';
+import type { PollResponseData as Gen_PollResponseData } from './gen/models';
+export declare const isVoteAnswer: (vote: any | undefined) => vote is RequireLiteral<PollVoteResponseData, "answer_text" | "is_answer">;
 export type PollAnswersQueryParams = {
     filter?: QueryVotesFilters;
     options?: QueryVotesOptions;
@@ -15,15 +16,15 @@ export type PollOptionVotesQueryParams = {
     sort?: VoteSort;
 };
 type OptionId = string;
-export type PollState = Omit<PollResponse, 'own_votes' | 'id'> & {
+export type PollState = Omit<PollResponse_old, 'own_votes' | 'id'> & {
     lastActivityAt: Date;
     maxVotedOptionIds: OptionId[];
-    ownVotesByOptionId: Record<OptionId, PollVote>;
-    ownAnswer?: PollAnswer;
+    ownVotesByOptionId: Record<OptionId, PollVoteResponseData>;
+    ownAnswer?: PollVoteResponseData;
 };
 type PollInitOptions = {
     client: StreamChat;
-    poll: PollResponse;
+    poll: Gen_PollResponseData;
 };
 export declare class Poll {
     readonly state: StateStore<PollState>;
@@ -34,31 +35,27 @@ export declare class Poll {
     private upsertOfflineDb;
     reinitializeState: (poll: PollInitOptions["poll"]) => void;
     get data(): PollState;
-    handlePollUpdated: (event: Event) => void;
-    handlePollClosed: (event: Event) => void;
-    handleVoteCasted: (event: Event) => void;
-    handleVoteChanged: (event: Event) => void;
-    handleVoteRemoved: (event: Event) => void;
-    query: (id: string) => Promise<PollResponse>;
-    update: (data: Exclude<PollData, "id">) => Promise<import("./types").APIResponse & import("./types").UpdatePollAPIResponse>;
-    partialUpdate: (partialPollObject: PartialPollUpdate) => Promise<import("./types").APIResponse & import("./types").UpdatePollAPIResponse>;
-    close: () => Promise<import("./types").APIResponse & import("./types").UpdatePollAPIResponse>;
-    delete: () => Promise<import("./types").APIResponse>;
-    createOption: (option: PollOptionData) => Promise<import("./types").APIResponse & import("./types").CreatePollOptionAPIResponse>;
-    updateOption: (option: PollOptionData) => Promise<import("./types").APIResponse & import("./types").CreatePollOptionAPIResponse>;
-    deleteOption: (optionId: string) => Promise<import("./types").APIResponse>;
-    castVote: (optionId: string, messageId: string) => Promise<(import("./types").APIResponse & import("./types").CastVoteAPIResponse) | undefined>;
-    removeVote: (voteId: string, messageId: string) => Promise<import("./types").APIResponse & {
-        vote: PollVote;
-    }>;
-    addAnswer: (answerText: string, messageId: string) => Promise<import("./types").APIResponse & import("./types").CastVoteAPIResponse>;
-    removeAnswer: (answerId: string, messageId: string) => Promise<import("./types").APIResponse & {
-        vote: PollVote;
-    }>;
-    queryAnswers: (params: PollAnswersQueryParams) => Promise<import("./types").APIResponse & import("./types").PollAnswersAPIResponse>;
-    queryOptionVotes: (params: PollOptionVotesQueryParams) => Promise<import("./types").APIResponse & import("./types").PollVotesAPIResponse>;
+    handlePollUpdated: (event: EventPayload<"poll.updated">) => void;
+    handlePollClosed: (event: EventPayload<"poll.closed">) => void;
+    handleVoteCasted: (event: EventPayload<"poll.vote_casted">) => void;
+    handleVoteChanged: (event: EventPayload<"poll.vote_changed">) => void;
+    handleVoteRemoved: (event: EventPayload<"poll.vote_removed">) => void;
+    query: (id: string) => Promise<Gen_PollResponseData>;
+    update: (data: Exclude<UpdatePollRequest, "id">) => Promise<import("./types").StreamResponse<import(".").PollResponse>>;
+    partialUpdate: (partialPollObject: PartialPollUpdate) => Promise<import("./types").StreamResponse<import(".").PollResponse>>;
+    close: () => Promise<import("./types").StreamResponse<import(".").PollResponse>>;
+    delete: () => Promise<import("./types").StreamResponse<import(".").Response>>;
+    createOption: (option: PollOptionData) => Promise<import("./types").StreamResponse<import(".").PollOptionResponse>>;
+    updateOption: (option: PollOptionData) => Promise<import("./types").StreamResponse<import(".").PollOptionResponse>>;
+    deleteOption: (option_id: string) => Promise<import("./types").StreamResponse<import(".").Response>>;
+    castVote: (optionId: string, messageId: string) => Promise<import("./types").StreamResponse<import(".").PollVoteResponse> | undefined>;
+    removeVote: (voteId: string, messageId: string) => Promise<import("./types").StreamResponse<import(".").PollVoteResponse>>;
+    addAnswer: (answerText: string, messageId: string) => Promise<import("./types").StreamResponse<import(".").PollVoteResponse>>;
+    removeAnswer: (answerId: string, messageId: string) => Promise<import("./types").StreamResponse<import(".").PollVoteResponse>>;
+    queryAnswers: (params: PollAnswersQueryParams) => Promise<import("./types").StreamResponse<import(".").PollVotesResponse>>;
+    queryOptionVotes: (params: PollOptionVotesQueryParams) => Promise<import("./types").StreamResponse<import(".").PollVotesResponse>>;
 }
-export declare function extractPollData(pollResponse: PollResponse): PollData;
-export declare function mapPollStateToResponse(poll: Poll): PollResponse;
-export declare function extractPollEnrichedData(pollResponse: PollResponse): Omit<PollEnrichData, 'own_votes' | 'latest_answers'>;
+export declare function extractPollData(pollResponse: Gen_PollResponseData): UpdatePollRequest;
+export declare function mapPollStateToResponse(poll: Poll): PollResponse_old;
+export declare function extractPollEnrichedData(pollResponse: Gen_PollResponseData): Omit<PollEnrichData, 'own_votes' | 'latest_answers'>;
 export {};

package/dist/types/poll_manager.d.ts

@@ -1,5 +1,5 @@
 import type { StreamChat } from './client';
-import type { CreatePollData, LocalMessage, MessageResponse, PollSort, QueryPollsFilters, QueryPollsOptions } from './types';
+import type { CreatePollRequest, LocalMessage, MessageResponse, PollSort, QueryPollsFilters, QueryPollsOptions } from './types';
 import { Poll } from './poll';
 import { WithSubscriptions } from './utils/WithSubscriptions';
 export declare class PollManager extends WithSubscriptions {
@@ -11,7 +11,7 @@ export declare class PollManager extends WithSubscriptions {
     get data(): Map<string, Poll>;
     fromState: (id: string) => Poll | undefined;
     registerSubscriptions: () => void;
-    createPoll: (poll: CreatePollData) => Promise<Poll | undefined>;
+    createPoll: (poll: CreatePollRequest) => Promise<Poll | undefined>;
     getPoll: (id: string) => Promise<Poll | undefined>;
     queryPolls: (filter: QueryPollsFilters, sort?: PollSort, options?: QueryPollsOptions) => Promise<{
         polls: (Poll | undefined)[];

package/dist/types/reminders/Reminder.d.ts

@@ -1,12 +1,9 @@
 import { ReminderTimer } from './ReminderTimer';
 import { StateStore } from '../store';
 import type { ReminderTimerConfig } from './ReminderTimer';
-import type { MessageResponse, ReminderResponseBase, UserResponse } from '../types';
+import type { MessageResponse, ReminderResponseData, UserResponse } from '../types';
 export declare const timeLeftMs: (remindAt: number) => number;
-export type ReminderResponseBaseOrResponse = ReminderResponseBase & {
-    user?: UserResponse;
-    message?: MessageResponse;
-};
+export type ReminderResponseBaseOrResponse = ReminderResponseData;
 export type ReminderState = {
     channel_cid: string;
     created_at: Date;

package/dist/types/reminders/ReminderManager.d.ts

@@ -4,17 +4,10 @@ import { ReminderPaginator } from '../pagination';
 import { WithSubscriptions } from '../utils/WithSubscriptions';
 import type { ReminderResponseBaseOrResponse } from './Reminder';
 import type { StreamChat } from '../client';
-import type { CreateReminderOptions, Event, EventTypes, LocalMessage, MessageResponse, ReminderResponse } from '../types';
+import type { CreateReminderOptions, Event, EventPayload, LocalMessage, MessageResponse } from '../types';
 export declare const DEFAULT_REMINDER_MANAGER_CONFIG: ReminderManagerConfig;
 type MessageId = string;
-export type ReminderEvent = {
-    cid: string;
-    created_at: string;
-    message_id: MessageId;
-    reminder: ReminderResponse;
-    type: EventTypes;
-    user_id: string;
-};
+export type ReminderEvent = EventPayload<`reminder.${string}` | 'notification.reminder_due'>;
 export type ReminderManagerState = {
     reminders: Map<MessageId, Reminder>;
 };

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

@@ -1,5 +1,5 @@
 import { BaseSearchSource } from './BaseSearchSource';
-import type { ChannelFilters, ChannelOptions, ChannelSort, MessageFilters, MessageResponse, SearchMessageSort } from '../types';
+import type { ChannelFilters, ChannelOptions, ChannelSort, MessageFilters, MessageResponse, SearchMessageSort, SearchPayload } from '../types';
 import type { StreamChat } from '../client';
 import type { SearchSourceOptions } from './types';
 import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
@@ -29,13 +29,13 @@ export type MessageSearchSourceFilterBuilderOptions<TContexts extends MessageSea
 export declare class MessageSearchSource<TContexts extends MessageSearchSourceContexts = {}> extends BaseSearchSource<MessageResponse> {
     readonly type = "messages";
     private client;
-    messageSearchChannelFilters: ChannelFilters | undefined;
+    messageSearchChannelFilters: SearchPayload['filter_conditions'] | undefined;
     messageSearchFilters: MessageFilters | undefined;
     messageSearchSort: SearchMessageSort | undefined;
     channelQueryFilters: ChannelFilters | undefined;
     channelQuerySort: ChannelSort | undefined;
     channelQueryOptions: Omit<ChannelOptions, 'limit' | 'offset'> | undefined;
-    messageSearchChannelFilterBuilder: FilterBuilder<ChannelFilters, MergeContext<BuiltInContexts['messageSearchChannel'], TContexts['messageSearchChannelContext']>>;
+    messageSearchChannelFilterBuilder: FilterBuilder<SearchPayload['filter_conditions'], MergeContext<BuiltInContexts['messageSearchChannel'], TContexts['messageSearchChannelContext']>>;
     messageSearchFilterBuilder: FilterBuilder<MessageFilters, MergeContext<BuiltInContexts['messageSearch'], TContexts['messageSearchContext']>>;
     channelQueryFilterBuilder: FilterBuilder<ChannelFilters, MergeContext<BuiltInContexts['channelQuery'], TContexts['channelQueryContext']>>;
     constructor(client: StreamChat, options?: SearchSourceOptions, filterBuilderOptions?: MessageSearchSourceFilterBuilderOptions<TContexts>);
@@ -43,7 +43,7 @@ export declare class MessageSearchSource<TContexts extends MessageSearchSourceCo
         items: never[];
         next?: undefined;
     } | {
-        items: MessageResponse[];
+        items: import("..").SearchResultMessage[];
         next: string | undefined;
     }>;
     protected filterQueryResults(items: MessageResponse[]): MessageResponse[];

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

@@ -16,7 +16,7 @@ export declare class UserSearchSource<TFilterContext extends CustomContext = Cus
     filterBuilder: FilterBuilder<UserFilters, UserSearchSourceFilterBuilderContext<TFilterContext>>;
     constructor(client: StreamChat, options?: SearchSourceOptions, filterBuilderOptions?: FilterBuilderOptions<UserFilters, UserSearchSourceFilterBuilderContext<TFilterContext>>);
     protected query(searchQuery: string): Promise<{
-        items: UserResponse[];
+        items: import("..").FullUserResponse[];
     }>;
     protected filterQueryResults(items: UserResponse[]): UserResponse[];
 }