@stream-io/feeds-client 0.1.0

package/dist/src/Feed.d.ts

@@ -0,0 +1,109 @@
+import { ActivityRequest, FeedResponse, GetOrCreateFeedRequest, GetOrCreateFeedResponse, QueryFollowsRequest, WSEvent, ActivityResponse, CommentResponse, SingleFollowRequest } from './gen/models';
+import { StateStore } from './common/StateStore';
+import { EventDispatcher } from './common/EventDispatcher';
+import { FeedApi } from './gen/feeds/FeedApi';
+import { FeedsClient } from './FeedsClient';
+import { StreamResponse } from './gen-imports';
+import type { ActivityIdOrCommentId, GetCommentsRepliesRequest, GetCommentsRequest, LoadingStates, PagerResponseWithLoadingStates } from './types';
+export type FeedState = Omit<Partial<GetOrCreateFeedResponse & FeedResponse>, 'feed' | 'duration'> & {
+    /**
+     * True when loading state using `getOrCreate`
+     */
+    is_loading: boolean;
+    /**
+     * True when loading activities using `getOrCreate` or `getNextPage`
+     */
+    is_loading_activities: boolean;
+    comments_by_entity_id: Record<ActivityIdOrCommentId, {
+        pagination?: PagerResponseWithLoadingStates & {
+            sort?: string;
+        };
+        /**
+         * Id of the "store" where the actual parent is stored in the comments array.
+         *
+         * Example:
+         * ```
+         * // top-level comment:
+         * const comment1 = {
+         *   id: 'comment-1',
+         *   object_id: 'activity-1',
+         * }
+         * // child comment:
+         * const comment2 = {
+         *   id: 'comment-2',
+         *   object_id: 'activity-1',
+         *   parent_id: 'comment-1',
+         * }
+         * ```
+         * When these comments are loaded, they're stored in the state like this:
+         * ```
+         * {
+         *   comments_by_entity_id: {
+         *     'activity-1': {
+         *       comments: [comment1],
+         *       parent_id: undefined,
+         *     },
+         *     'comment-1': {
+         *       comments: [comment2],
+         *       parent_id: 'activity-1', // parent store where "comment-1" is located in "comments" array
+         *     }
+         *   }
+         * }
+         * ```
+         */
+        parent_id?: ActivityIdOrCommentId;
+        comments?: CommentResponse[];
+    } | undefined>;
+    followers_pagination?: LoadingStates & {
+        sort?: string;
+    };
+    following_pagination?: LoadingStates & {
+        sort?: string;
+    };
+};
+export declare class Feed extends FeedApi {
+    readonly state: StateStore<FeedState>;
+    private static readonly noop;
+    private readonly eventHandlers;
+    protected eventDispatcher: EventDispatcher<WSEvent['type'], WSEvent>;
+    constructor(client: FeedsClient, groupId: 'user' | 'timeline' | (string & {}), id: string, data?: FeedResponse);
+    private readonly client;
+    get fid(): string;
+    get currentState(): FeedState;
+    private handleCommentReactionEvent;
+    getOrCreate(request?: GetOrCreateFeedRequest): Promise<StreamResponse<GetOrCreateFeedResponse>>;
+    private handleBookmarkAdded;
+    private handleBookmarkDeleted;
+    private handleBookmarkUpdated;
+    /**
+     * Returns index of the provided comment object.
+     */
+    private getCommentIndex;
+    private getActivityIndex;
+    private updateActivityInState;
+    private loadNextPageComments;
+    loadNextPageActivityComments(activity: ActivityResponse, request?: Partial<Omit<GetCommentsRequest, 'object_id' | 'object_type' | 'next'>>): Promise<void>;
+    loadNextPageCommentReplies(comment: CommentResponse, request?: Partial<Omit<GetCommentsRepliesRequest, 'comment_id' | 'next'>>): Promise<void>;
+    private loadNextPageFollows;
+    loadNextPageFollowers(request: Pick<QueryFollowsRequest, 'limit'>): Promise<void>;
+    loadNextPageFollowing(request: Pick<QueryFollowsRequest, 'limit'>): Promise<void>;
+    /**
+     * Method which queries followers of this feed (feeds which target this feed).
+     *
+     * _Note: Useful only for feeds with `groupId` of `user` value._
+     */
+    queryFollowers(request: Omit<QueryFollowsRequest, 'filter'>): Promise<StreamResponse<import("./gen/models").QueryFollowsResponse>>;
+    /**
+     * Method which queries following of this feed (target feeds of this feed).
+     *
+     * _Note: Useful only for feeds with `groupId` of `timeline` value._
+     */
+    queryFollowing(request: Omit<QueryFollowsRequest, 'filter'>): Promise<StreamResponse<import("./gen/models").QueryFollowsResponse>>;
+    follow(feedOrFid: Feed | string, options?: Omit<SingleFollowRequest, 'source' | 'target'>): Promise<StreamResponse<import("./gen/models").SingleFollowResponse>>;
+    unfollow(feedOrFid: Feed | string): Promise<StreamResponse<import("./gen/models").UnfollowResponse>>;
+    getNextPage(): Promise<StreamResponse<GetOrCreateFeedResponse>>;
+    addActivity(request: Omit<ActivityRequest, 'fids'>): Promise<StreamResponse<import("./gen/models").AddActivityResponse>>;
+    on: (eventName: "all" | "app.updated" | "feeds.activity.added" | "feeds.activity.deleted" | "feeds.activity.marked" | "feeds.activity.pinned" | "feeds.activity.reaction.added" | "feeds.activity.reaction.deleted" | "feeds.activity.reaction.updated" | "feeds.activity.removed_from_feed" | "feeds.activity.unpinned" | "feeds.activity.updated" | "feeds.bookmark.added" | "feeds.bookmark.deleted" | "feeds.bookmark.updated" | "feeds.comment.added" | "feeds.comment.deleted" | "feeds.comment.reaction.added" | "feeds.comment.reaction.deleted" | "feeds.comment.reaction.updated" | "feeds.comment.updated" | "feeds.feed.created" | "feeds.feed.deleted" | "feeds.feed.updated" | "feeds.feed_group.changed" | "feeds.feed_group.deleted" | "feeds.feed_member.added" | "feeds.feed_member.removed" | "feeds.feed_member.updated" | "feeds.follow.created" | "feeds.follow.deleted" | "feeds.follow.updated" | "feeds.poll.closed" | "feeds.poll.deleted" | "feeds.poll.updated" | "feeds.poll.vote_casted" | "feeds.poll.vote_changed" | "feeds.poll.vote_removed" | "health.check" | "user.updated" | "moderation.custom_action" | "moderation.flagged" | "moderation.mark_reviewed" | "user.banned" | "user.deactivated" | "user.muted" | "user.reactivated", handler: (event: WSEvent) => void) => () => void;
+    off: (eventName: "all" | "app.updated" | "feeds.activity.added" | "feeds.activity.deleted" | "feeds.activity.marked" | "feeds.activity.pinned" | "feeds.activity.reaction.added" | "feeds.activity.reaction.deleted" | "feeds.activity.reaction.updated" | "feeds.activity.removed_from_feed" | "feeds.activity.unpinned" | "feeds.activity.updated" | "feeds.bookmark.added" | "feeds.bookmark.deleted" | "feeds.bookmark.updated" | "feeds.comment.added" | "feeds.comment.deleted" | "feeds.comment.reaction.added" | "feeds.comment.reaction.deleted" | "feeds.comment.reaction.updated" | "feeds.comment.updated" | "feeds.feed.created" | "feeds.feed.deleted" | "feeds.feed.updated" | "feeds.feed_group.changed" | "feeds.feed_group.deleted" | "feeds.feed_member.added" | "feeds.feed_member.removed" | "feeds.feed_member.updated" | "feeds.follow.created" | "feeds.follow.deleted" | "feeds.follow.updated" | "feeds.poll.closed" | "feeds.poll.deleted" | "feeds.poll.updated" | "feeds.poll.vote_casted" | "feeds.poll.vote_changed" | "feeds.poll.vote_removed" | "health.check" | "user.updated" | "moderation.custom_action" | "moderation.flagged" | "moderation.mark_reviewed" | "user.banned" | "user.deactivated" | "user.muted" | "user.reactivated", handler: (event: WSEvent) => void) => void;
+    handleWSEvent(event: WSEvent): void;
+}

package/dist/src/FeedsClient.d.ts

@@ -0,0 +1,63 @@
+import { FeedsApi } from './gen/feeds/FeedsApi';
+import { ActivityResponse, FileUploadRequest, ImageUploadRequest, OwnUser, PollResponse, PollVotesResponse, QueryFeedsRequest, QueryPollVotesRequest, UserRequest } from './gen/models';
+import { FeedsEvent } from './types';
+import { StateStore } from './common/StateStore';
+import { Feed } from './Feed';
+import { FeedsClientOptions, StreamResponse } from './common/types';
+import { ModerationClient } from './ModerationClient';
+import { StreamPoll } from './common/Poll';
+export type FeedsClientState = {
+    connectedUser: OwnUser | undefined;
+};
+export declare class FeedsClient extends FeedsApi {
+    readonly state: StateStore<FeedsClientState>;
+    readonly moderation: ModerationClient;
+    private readonly tokenManager;
+    private wsConnection?;
+    private readonly connectionIdManager;
+    private readonly eventDispatcher;
+    private readonly polls_by_id;
+    private activeFeeds;
+    constructor(apiKey: string, options?: FeedsClientOptions);
+    pollFromState: (id: string) => StreamPoll | undefined;
+    hydratePollCache(activities: ActivityResponse[]): void;
+    connectUser: (user: UserRequest, tokenProvider: string | (() => Promise<string>)) => Promise<void>;
+    closePoll: (request: {
+        poll_id: string;
+    }) => Promise<StreamResponse<PollResponse>>;
+    uploadFile: (request: Omit<FileUploadRequest, "file"> & {
+        file: File;
+    }) => Promise<StreamResponse<import("./gen/models").FileUploadResponse>>;
+    uploadImage: (request: Omit<ImageUploadRequest, "file"> & {
+        file: File;
+    }) => Promise<StreamResponse<import("./gen/models").ImageUploadResponse>>;
+    queryPollAnswers: (request: QueryPollVotesRequest & {
+        poll_id: string;
+        user_id?: string;
+    }) => Promise<StreamResponse<PollVotesResponse>>;
+    queryPollOptionVotes: (request: QueryPollVotesRequest & {
+        filter: QueryPollVotesRequest["filter"] & {
+            option_id: string;
+        };
+        poll_id: string;
+        user_id?: string;
+    }) => Promise<StreamResponse<PollVotesResponse>>;
+    disconnectUser: () => Promise<void>;
+    on: (eventName: "all" | "app.updated" | "feeds.activity.added" | "feeds.activity.deleted" | "feeds.activity.marked" | "feeds.activity.pinned" | "feeds.activity.reaction.added" | "feeds.activity.reaction.deleted" | "feeds.activity.reaction.updated" | "feeds.activity.removed_from_feed" | "feeds.activity.unpinned" | "feeds.activity.updated" | "feeds.bookmark.added" | "feeds.bookmark.deleted" | "feeds.bookmark.updated" | "feeds.comment.added" | "feeds.comment.deleted" | "feeds.comment.reaction.added" | "feeds.comment.reaction.deleted" | "feeds.comment.reaction.updated" | "feeds.comment.updated" | "feeds.feed.created" | "feeds.feed.deleted" | "feeds.feed.updated" | "feeds.feed_group.changed" | "feeds.feed_group.deleted" | "feeds.feed_member.added" | "feeds.feed_member.removed" | "feeds.feed_member.updated" | "feeds.follow.created" | "feeds.follow.deleted" | "feeds.follow.updated" | "feeds.poll.closed" | "feeds.poll.deleted" | "feeds.poll.updated" | "feeds.poll.vote_casted" | "feeds.poll.vote_changed" | "feeds.poll.vote_removed" | "health.check" | "user.updated" | "moderation.custom_action" | "moderation.flagged" | "moderation.mark_reviewed" | "user.banned" | "user.deactivated" | "user.muted" | "user.reactivated" | "connection.changed" | "network.changed", handler: (event: FeedsEvent & {
+        fid?: string;
+    }) => void) => () => void;
+    off: (eventName: "all" | "app.updated" | "feeds.activity.added" | "feeds.activity.deleted" | "feeds.activity.marked" | "feeds.activity.pinned" | "feeds.activity.reaction.added" | "feeds.activity.reaction.deleted" | "feeds.activity.reaction.updated" | "feeds.activity.removed_from_feed" | "feeds.activity.unpinned" | "feeds.activity.updated" | "feeds.bookmark.added" | "feeds.bookmark.deleted" | "feeds.bookmark.updated" | "feeds.comment.added" | "feeds.comment.deleted" | "feeds.comment.reaction.added" | "feeds.comment.reaction.deleted" | "feeds.comment.reaction.updated" | "feeds.comment.updated" | "feeds.feed.created" | "feeds.feed.deleted" | "feeds.feed.updated" | "feeds.feed_group.changed" | "feeds.feed_group.deleted" | "feeds.feed_member.added" | "feeds.feed_member.removed" | "feeds.feed_member.updated" | "feeds.follow.created" | "feeds.follow.deleted" | "feeds.follow.updated" | "feeds.poll.closed" | "feeds.poll.deleted" | "feeds.poll.updated" | "feeds.poll.vote_casted" | "feeds.poll.vote_changed" | "feeds.poll.vote_removed" | "health.check" | "user.updated" | "moderation.custom_action" | "moderation.flagged" | "moderation.mark_reviewed" | "user.banned" | "user.deactivated" | "user.muted" | "user.reactivated" | "connection.changed" | "network.changed", handler: (event: FeedsEvent & {
+        fid?: string;
+    }) => void) => void;
+    feed: (groupId: string, id: string) => Feed;
+    queryFeeds(request?: QueryFeedsRequest): Promise<{
+        feeds: Feed[];
+        next: string | undefined;
+        prev: string | undefined;
+        metadata: import("./common/types").RequestMetadata;
+        duration: string;
+    }>;
+    private readonly getOrCreateActiveFeed;
+    private readonly updateNetworkConnectionStatus;
+    private findActiveFeedByActivityId;
+}

package/dist/src/ModerationClient.d.ts

@@ -0,0 +1,3 @@
+import { ModerationApi } from './gen/moderation/ModerationApi';
+export declare class ModerationClient extends ModerationApi {
+}

package/dist/src/common/ActivitySearchSource.d.ts

@@ -0,0 +1,17 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import type { SearchSourceOptions } from './BaseSearchSource';
+import { FeedsClient } from '../FeedsClient';
+import { ActivityResponse } from '../gen/models';
+export declare class ActivitySearchSource extends BaseSearchSource<ActivityResponse> {
+    readonly type: "activity";
+    private readonly client;
+    constructor(client: FeedsClient, options?: SearchSourceOptions);
+    protected query(searchQuery: string): Promise<{
+        items: never[];
+        next?: undefined;
+    } | {
+        items: ActivityResponse[];
+        next: string | undefined;
+    }>;
+    protected filterQueryResults(items: ActivityResponse[]): ActivityResponse[];
+}

package/dist/src/common/ApiClient.d.ts

@@ -0,0 +1,20 @@
+import { RequestMetadata, FeedsClientOptions } from './types';
+import { TokenManager } from './TokenManager';
+import { ConnectionIdManager } from './ConnectionIdManager';
+export declare class ApiClient {
+    readonly apiKey: string;
+    private readonly tokenManager;
+    private readonly connectionIdManager;
+    readonly baseUrl: string;
+    private readonly axiosInstance;
+    constructor(apiKey: string, tokenManager: TokenManager, connectionIdManager: ConnectionIdManager, options?: FeedsClientOptions);
+    sendRequest: <T>(method: string, url: string, pathParams?: Record<string, string>, queryParams?: Record<string, any>, body?: any, requestContentType?: string) => Promise<{
+        body: T;
+        metadata: RequestMetadata;
+    }>;
+    get webSocketBaseUrl(): string;
+    private get commonHeaders();
+    private isAxiosError;
+    private readonly queryParamsStringify;
+    private readonly getRequestMetadata;
+}

package/dist/src/common/BaseSearchSource.d.ts

@@ -0,0 +1,87 @@
+import { StateStore } from './StateStore';
+import { type DebouncedFunc } from './utils';
+export type SearchSourceType = 'channels' | 'users' | 'messages' | (string & {});
+export type QueryReturnValue<T> = {
+    items: T[];
+    next?: string | null;
+};
+export type DebounceOptions = {
+    debounceMs: number;
+};
+type DebouncedExecQueryFunction = DebouncedFunc<(searchString?: string) => Promise<void>>;
+export interface SearchSource<T = any> {
+    activate(): void;
+    cancelScheduledQuery(): void;
+    canExecuteQuery(newSearchString?: string): boolean;
+    deactivate(): void;
+    readonly hasNext: boolean;
+    readonly hasResults: boolean;
+    readonly initialState: SearchSourceState<T>;
+    readonly isActive: boolean;
+    readonly isLoading: boolean;
+    readonly items: T[] | undefined;
+    readonly lastQueryError: Error | undefined;
+    readonly next: string | undefined | null;
+    readonly offset: number | undefined;
+    resetState(): void;
+    search(text?: string): Promise<void> | undefined;
+    readonly searchQuery: string;
+    setDebounceOptions(options: DebounceOptions): void;
+    readonly state: StateStore<SearchSourceState<T>>;
+    readonly type: SearchSourceType;
+}
+export type SearchSourceState<T = any> = {
+    hasNext: boolean;
+    isActive: boolean;
+    isLoading: boolean;
+    items: T[] | undefined;
+    searchQuery: string;
+    lastQueryError?: Error;
+    next?: string | null;
+    offset?: number;
+};
+export type SearchSourceOptions = {
+    /** The number of milliseconds to debounce the search query. The default interval is 300ms. */
+    debounceMs?: number;
+    pageSize?: number;
+};
+export declare abstract class BaseSearchSource<T> implements SearchSource<T> {
+    state: StateStore<SearchSourceState<T>>;
+    protected pageSize: number;
+    abstract readonly type: SearchSourceType;
+    protected searchDebounced: DebouncedExecQueryFunction;
+    protected constructor(options?: SearchSourceOptions);
+    get lastQueryError(): Error | undefined;
+    get hasNext(): boolean;
+    get hasResults(): boolean;
+    get isActive(): boolean;
+    get isLoading(): boolean;
+    get initialState(): {
+        hasNext: boolean;
+        isActive: boolean;
+        isLoading: boolean;
+        items: undefined;
+        lastQueryError: undefined;
+        next: undefined;
+        offset: number;
+        searchQuery: string;
+    };
+    get items(): T[] | undefined;
+    get next(): string | null | undefined;
+    get offset(): number | undefined;
+    get searchQuery(): string;
+    protected abstract query(searchQuery: string): Promise<QueryReturnValue<T>>;
+    protected abstract filterQueryResults(items: T[]): T[] | Promise<T[]>;
+    setDebounceOptions: ({ debounceMs }: DebounceOptions) => void;
+    activate: () => void;
+    deactivate: () => void;
+    canExecuteQuery: (newSearchString?: string) => boolean;
+    protected getStateBeforeFirstQuery(newSearchString: string): SearchSourceState<T>;
+    protected getStateAfterQuery(stateUpdate: Partial<SearchSourceState<T>>, isFirstPage: boolean): SearchSourceState<T>;
+    executeQuery(newSearchString?: string): Promise<void>;
+    search: (searchQuery?: string) => Promise<void> | undefined;
+    cancelScheduledQuery(): void;
+    resetState(): void;
+    resetStateAndActivate(): void;
+}
+export {};

package/dist/src/common/ConnectionIdManager.d.ts

@@ -0,0 +1,11 @@
+export declare class ConnectionIdManager {
+    loadConnectionIdPromise: Promise<string> | undefined;
+    connectionId?: string;
+    private resolve?;
+    private reject?;
+    reset: () => void;
+    resetConnectionIdPromise: () => void;
+    resolveConnectionidPromise: (connectionId: string) => void;
+    rejectConnectionIdPromise: (reason: any) => void;
+    getConnectionId: () => string | Promise<string>;
+}

package/dist/src/common/EventDispatcher.d.ts

@@ -0,0 +1,11 @@
+import { FeedsEvent } from '../types';
+export declare class EventDispatcher<Type extends string = FeedsEvent['type'], Event extends {
+    type: string;
+} = FeedsEvent> {
+    private subscribers;
+    private readonly logger;
+    dispatch: (event: Event) => void;
+    on: (eventName: Type | "all", handler: (event: Event) => void) => () => void;
+    off: (eventName: Type | "all", handler: (event: Event) => void) => void;
+    offAll: (eventName?: Type | "all") => void;
+}

package/dist/src/common/FeedSearchSource.d.ts

@@ -0,0 +1,17 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import type { SearchSourceOptions } from './BaseSearchSource';
+import { FeedsClient } from '../FeedsClient';
+import { Feed } from '../Feed';
+export declare class FeedSearchSource extends BaseSearchSource<Feed> {
+    readonly type: "feed";
+    private readonly client;
+    constructor(client: FeedsClient, options?: SearchSourceOptions);
+    protected query(searchQuery: string): Promise<{
+        items: never[];
+        next?: undefined;
+    } | {
+        items: Feed[];
+        next: string | undefined;
+    }>;
+    protected filterQueryResults(items: Feed[]): Feed[];
+}

package/dist/src/common/Poll.d.ts

@@ -0,0 +1,34 @@
+import { StateStore } from './StateStore';
+import type { FeedsClient } from '../FeedsClient';
+import type { PollVote, QueryPollVotesRequest, PollUpdatedFeedEvent, PollClosedFeedEvent, PollVoteCastedFeedEvent, PollVoteChangedFeedEvent, PollVoteRemovedFeedEvent, Poll as PollType } from '../gen/models';
+export declare const isVoteAnswer: (vote: PollVote) => boolean;
+export type PollAnswersQueryParams = QueryPollVotesRequest & {
+    poll_id: string;
+    user_id?: string;
+};
+type OptionId = string;
+export type PollState = Omit<PollType, 'own_votes' | 'id'> & {
+    last_activity_at: Date;
+    max_voted_option_ids: OptionId[];
+    own_votes_by_option_id: Record<OptionId, PollVote>;
+    own_answer?: PollVote;
+};
+type PollInitOptions = {
+    client: FeedsClient;
+    poll: PollType;
+};
+export declare class StreamPoll {
+    readonly state: StateStore<PollState>;
+    id: string;
+    private readonly client;
+    constructor({ client, poll }: PollInitOptions);
+    private readonly getInitialStateFromPollResponse;
+    reinitializeState: (poll: PollInitOptions["poll"]) => void;
+    get data(): PollState;
+    handlePollUpdated: (event: PollUpdatedFeedEvent) => void;
+    handlePollClosed: (event: PollClosedFeedEvent) => void;
+    handleVoteCasted: (event: PollVoteCastedFeedEvent) => void;
+    handleVoteChanged: (event: PollVoteChangedFeedEvent) => void;
+    handleVoteRemoved: (event: PollVoteRemovedFeedEvent) => void;
+}
+export {};

package/dist/src/common/SearchController.d.ts

@@ -0,0 +1,41 @@
+import { StateStore } from './StateStore';
+import type { SearchSource } from './BaseSearchSource';
+export type SearchControllerState = {
+    isActive: boolean;
+    searchQuery: string;
+    sources: SearchSource[];
+};
+export type InternalSearchControllerState = {};
+export type SearchControllerConfig = {
+    keepSingleActiveSource: boolean;
+};
+export type SearchControllerOptions = {
+    config?: Partial<SearchControllerConfig>;
+    sources?: SearchSource[];
+};
+export declare class SearchController {
+    /**
+     * Not intended for direct use by integrators, might be removed without notice resulting in
+     * broken integrations.
+     */
+    _internalState: StateStore<InternalSearchControllerState>;
+    state: StateStore<SearchControllerState>;
+    config: SearchControllerConfig;
+    constructor({ config, sources }?: SearchControllerOptions);
+    get hasNext(): boolean;
+    get sources(): SearchSource<any>[];
+    get activeSources(): SearchSource<any>[];
+    get isActive(): boolean;
+    get searchQuery(): string;
+    get searchSourceTypes(): Array<SearchSource['type']>;
+    addSource: (source: SearchSource) => void;
+    getSource: (sourceType: SearchSource["type"]) => SearchSource<any> | undefined;
+    removeSource: (sourceType: SearchSource["type"]) => void;
+    activateSource: (sourceType: SearchSource["type"]) => void;
+    deactivateSource: (sourceType: SearchSource["type"]) => void;
+    activate: () => void;
+    search: (searchQuery?: string) => Promise<void>;
+    cancelSearchQueries: () => void;
+    clear: () => void;
+    exit: () => void;
+}

package/dist/src/common/StateStore.d.ts

@@ -0,0 +1,124 @@
+export type Patch<T> = (value: T) => T;
+export type ValueOrPatch<T> = T | Patch<T>;
+export type Handler<T> = (nextValue: T, previousValue: T | undefined) => void;
+export type Unsubscribe = () => void;
+export type RemovePreprocessor = Unsubscribe;
+export type Preprocessor<T> = Handler<T>;
+export declare const isPatch: <T>(value: ValueOrPatch<T>) => value is Patch<T>;
+export declare class StateStore<T extends Record<string, unknown>> {
+    protected value: T;
+    protected handlers: Set<Handler<T>>;
+    protected preprocessors: Set<Preprocessor<T>>;
+    constructor(value: T);
+    /**
+     * Allows merging two stores only if their keys differ otherwise there's no way to ensure the data type stability.
+     * @experimental
+     * This method is experimental and may change in future versions.
+     */
+    merge<Q extends StateStore<any>>(stateStore: Q extends StateStore<infer L> ? Extract<keyof T, keyof L> extends never ? Q : never : never): MergedStateStore<T, Q extends StateStore<infer L extends Record<string, unknown>> ? L : never>;
+    next(newValueOrPatch: ValueOrPatch<T>): void;
+    partialNext: (partial: Partial<T>) => void;
+    getLatestValue(): T;
+    subscribe(handler: Handler<T>): Unsubscribe;
+    subscribeWithSelector: <O extends Readonly<Record<string, unknown>> | readonly unknown[]>(selector: (nextValue: T) => O, handler: Handler<O>) => Unsubscribe;
+    /**
+     * Registers a preprocessor function that will be called before the state is updated.
+     *
+     * Preprocessors are invoked with the new and previous values whenever `next` or `partialNext` methods
+     * are called, allowing you to mutate or react to the new value before it is set. Preprocessors run in the
+     * order they were registered.
+     *
+     * @example
+     * ```ts
+     * const store = new StateStore<{ count: number; isMaxValue: bool; }>({ count: 0, isMaxValue: false });
+     *
+     * store.addPreprocessor((nextValue, prevValue) => {
+     *   if (nextValue.count > 10) {
+     *     nextValue.count = 10; // Clamp the value to a maximum of 10
+     *   }
+     *
+     *   if (nextValue.count === 10) {
+     *     nextValue.isMaxValue = true; // Set isMaxValue to true if count is 10
+     *   } else {
+     *     nextValue.isMaxValue = false; // Reset isMaxValue otherwise
+     *   }
+     * });
+     *
+     * store.partialNext({ count: 15 });
+     *
+     * store.getLatestValue(); // { count: 10, isMaxValue: true }
+     *
+     * store.partialNext({ count: 5 });
+     *
+     * store.getLatestValue(); // { count: 5, isMaxValue: false }
+     * ```
+     *
+     * @param preprocessor - The function to be called with the next and previous values before the state is updated.
+     * @returns A `RemovePreprocessor` function that removes the preprocessor when called.
+     */
+    addPreprocessor(preprocessor: Preprocessor<T>): RemovePreprocessor;
+}
+/**
+ * Represents a merged state store that combines two separate state stores into one.
+ *
+ * The MergedStateStore allows combining two stores with non-overlapping keys.
+ * It extends StateStore with the combined type of both source stores.
+ * Changes to either the original or merged store will propagate to the combined store.
+ *
+ * Note: Direct mutations (next, partialNext, addPreprocessor) are disabled on the merged store.
+ * You should instead call these methods on the original or merged stores.
+ *
+ * @template O The type of the original state store
+ * @template M The type of the merged state store
+ *
+ * @experimental
+ * This class is experimental and may change in future versions.
+ */
+export declare class MergedStateStore<O extends Record<string, unknown>, M extends Record<string, unknown>> extends StateStore<O & M> {
+    readonly original: StateStore<O>;
+    readonly merged: StateStore<M>;
+    private cachedOriginalValue;
+    private cachedMergedValue;
+    constructor({ original, merged, }: {
+        original: StateStore<O>;
+        merged: StateStore<M>;
+    });
+    /**
+     * Subscribes to changes in the merged state store.
+     *
+     * This method extends the base subscribe functionality to handle the merged nature of this store:
+     * 1. The first subscriber triggers registration of helper subscribers that listen to both source stores
+     * 2. Changes from either source store are propagated to this merged store
+     * 3. Source store values are cached to prevent unnecessary updates
+     *
+     * When the first subscriber is added, the method sets up listeners on both original and merged stores.
+     * These listeners update the combined store value whenever either source store changes.
+     * All subscriptions (helpers and the actual handler) are tracked so they can be properly cleaned up.
+     *
+     * @param handler - The callback function that will be executed when the state changes
+     * @returns An unsubscribe function that, when called, removes the subscription and any helper subscriptions
+     */
+    subscribe(handler: Handler<O & M>): () => void;
+    /**
+     * Retrieves the latest combined state from both original and merged stores.
+     *
+     * This method extends the base getLatestValue functionality to ensure the merged store
+     * remains in sync with its source stores even when there are no active subscribers.
+     *
+     * When there are no handlers registered, the method:
+     * 1. Fetches the latest values from both source stores
+     * 2. Compares them with the cached values to detect changes
+     * 3. If changes are detected, updates the internal value and caches
+     *    the new source values to maintain consistency
+     *
+     * This approach ensures that calling getLatestValue() always returns the most
+     * up-to-date combined state, even if the merged store hasn't been actively
+     * receiving updates through subscriptions.
+     *
+     * @returns The latest combined state from both original and merged stores
+     */
+    getLatestValue(): O & M;
+    next: () => void;
+    partialNext: () => void;
+    addPreprocessor(): () => void;
+}

package/dist/src/common/TokenManager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * TokenManager
+ *
+ * Handles all the operations around user token.
+ */
+export declare class TokenManager {
+    loadTokenPromise: Promise<string> | null;
+    type: 'static' | 'provider';
+    token?: string;
+    tokenProvider?: string | (() => Promise<string>);
+    constructor();
+    /**
+     * Set the static string token or token provider.
+     * Token provider should return a token string or a promise which resolves to string token.
+     *
+     * @param {TokenOrProvider} tokenOrProvider - the token or token provider.
+     * @param {UserResponse} user - the user object.
+     * @param {boolean} isAnonymous - whether the user is anonymous or not.
+     */
+    setTokenOrProvider: (tokenOrProvider?: string | (() => Promise<string>)) => void;
+    /**
+     * Resets the token manager.
+     * Useful for client disconnection or switching user.
+     */
+    reset: () => void;
+    loadToken: () => Promise<string>;
+    getToken: () => string | Promise<string>;
+    isStatic: () => boolean;
+}

package/dist/src/common/UserSearchSource.d.ts

@@ -0,0 +1,17 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import type { SearchSourceOptions } from './BaseSearchSource';
+import { FeedsClient } from '../FeedsClient';
+import { UserResponse } from '../gen/models';
+export declare class UserSearchSource extends BaseSearchSource<UserResponse> {
+    readonly type: "user";
+    private readonly client;
+    constructor(client: FeedsClient, options?: SearchSourceOptions);
+    protected query(searchQuery: string): Promise<{
+        items: never[];
+        next?: undefined;
+    } | {
+        items: import("../gen/models").FullUserResponse[];
+        next: undefined;
+    }>;
+    protected filterQueryResults(items: UserResponse[]): UserResponse[];
+}

package/dist/src/common/gen-imports.d.ts

@@ -0,0 +1,2 @@
+export type { ApiClient } from './ApiClient';
+export type { StreamResponse } from './types';

package/dist/src/common/rate-limit.d.ts

@@ -0,0 +1,2 @@
+import { RateLimit } from './types';
+export declare const getRateLimitFromResponseHeader: (response_headers: Record<string, string>) => RateLimit;