@river-build/sdk/dist/client.d.ts

For more details, visit the following resources:

import { SpaceReviewEventObject } from '@river-build/web3';
import { PlainMessage, ChannelMessage_Post_Mention, ChannelMessage, ChannelMessage_Post, ChannelMessage_Post_Content_Text, ChannelMessage_Post_Content_Image, ChannelMessage_Post_Content_GM, ChannelMessage_Reaction, ChannelMessage_Redaction, StreamEvent, EncryptedData, StreamSettings, SpacePayload_ChannelSettings, FullyReadMarker, Envelope, ChannelMessage_Post_Attachment, AddEventResponse_Error, ChunkedMedia, UserBio, Tags, BlockchainTransaction, MiniblockHeader, CreationCookie, BlockchainTransaction_TokenTransfer } from '@river-build/proto';
import { CryptoStore, DecryptionEvents, EntitlementsDelegate, GroupEncryptionAlgorithmId, GroupEncryptionCrypto, GroupEncryptionSession, IGroupEncryptionClient, UserDevice, UserDeviceCollection, type EncryptionDeviceInitOpts } from '@river-build/encryption';
import { StreamRpcClient } from './makeStreamRpcClient';
import TypedEmitter from 'typed-emitter';
import { UnpackEnvelopeOpts } from './sign';
import { StreamEvents } from './streamEvents';
import { StreamStateView } from './streamStateView';
import { StreamTimelineEvent, ParsedMiniblock, ClientInitStatus, ContractReceipt, SolanaTransactionReceipt } from './types';
import { Stream } from './stream';
import { LoadedStream } from './persistenceStore';
import { SyncedStreams } from './syncedStreams';
import { SyncedStream } from './syncedStream';
import { SignerContext } from './signerContext';
import { TipEventObject } from '@river-build/generated/dev/typings/ITipping';
export type ClientEvents = StreamEvents & DecryptionEvents;
export type ClientOptions = {
    persistenceStoreName?: string;
    logNamespaceFilter?: string;
    highPriorityStreamIds?: string[];
    unpackEnvelopeOpts?: UnpackEnvelopeOpts;
    defaultGroupEncryptionAlgorithm?: GroupEncryptionAlgorithmId;
    logId?: string;
    streamOpts?: {
        useModifySync?: boolean;
    };
};
type SendChannelMessageOptions = {
    beforeSendEventHook?: Promise<void>;
    onLocalEventAppended?: (localId: string) => void;
    disableTags?: boolean;
};
type SendBlockchainTransactionOptions = {
    disableTags?: boolean;
};
declare const Client_base: new () => TypedEmitter<ClientEvents>;
export declare class Client extends Client_base implements IGroupEncryptionClient {
    opts?: ClientOptions | undefined;
    readonly signerContext: SignerContext;
    readonly rpcClient: StreamRpcClient;
    readonly userId: string;
    readonly streams: SyncedStreams;
    userStreamId?: string;
    userSettingsStreamId?: string;
    userMetadataStreamId?: string;
    userInboxStreamId?: string;
    private readonly logCall;
    private readonly logSync;
    private readonly logEmitFromStream;
    private readonly logEmitFromClient;
    private readonly logEvent;
    private readonly logError;
    private readonly logInfo;
    private readonly logDebug;
    cryptoBackend?: GroupEncryptionCrypto;
    cryptoStore: CryptoStore;
    private getStreamRequests;
    private getStreamExRequests;
    private initStreamRequests;
    private getScrollbackRequests;
    private creatingStreamIds;
    private entitlementsDelegate;
    private decryptionExtensions?;
    private syncedStreamsExtensions?;
    private persistenceStore;
    private defaultGroupEncryptionAlgorithm;
    private logId;
    constructor(signerContext: SignerContext, rpcClient: StreamRpcClient, cryptoStore: CryptoStore, entitlementsDelegate: EntitlementsDelegate, opts?: ClientOptions | undefined);
    get streamSyncActive(): boolean;
    get clientInitStatus(): ClientInitStatus;
    get cryptoInitialized(): boolean;
    stop(): Promise<void>;
    stream(streamId: string | Uint8Array): SyncedStream | undefined;
    createSyncedStream(streamId: string | Uint8Array): SyncedStream;
    private initUserJoinedStreams;
    initializeUser(opts?: {
        spaceId?: Uint8Array | string;
        encryptionDeviceInit?: EncryptionDeviceInitOpts;
    }): Promise<{
        initCryptoTime: number;
        initUserStreamTime: number;
        initUserInboxStreamTime: number;
        initUserMetadataStreamTime: number;
        initUserSettingsStreamTime: number;
    }>;
    onNetworkStatusChanged(isOnline: boolean): void;
    private initUserStream;
    private initUserInboxStream;
    private initUserMetadataStream;
    private initUserSettingsStream;
    private getUserStream;
    private createUserStream;
    private createUserMetadataStream;
    private createUserInboxStream;
    private createUserSettingsStream;
    private createStreamAndSync;
    createSpace(spaceAddressOrId: string): Promise<{
        streamId: string;
    }>;
    createChannel(spaceId: string | Uint8Array, channelName: string, channelTopic: string, inChannelId: string | Uint8Array, streamSettings?: PlainMessage<StreamSettings>, channelSettings?: PlainMessage<SpacePayload_ChannelSettings>): Promise<{
        streamId: string;
    }>;
    createDMChannel(userId: string, streamSettings?: PlainMessage<StreamSettings>): Promise<{
        streamId: string;
    }>;
    createGDMChannel(userIds: string[], channelProperties?: EncryptedData, streamSettings?: PlainMessage<StreamSettings>): Promise<{
        streamId: string;
    }>;
    createMediaStream(channelId: string | Uint8Array | undefined, spaceId: string | Uint8Array | undefined, userId: string | undefined, chunkCount: number, streamSettings?: PlainMessage<StreamSettings>, perChunkEncryption?: boolean): Promise<{
        creationCookie: CreationCookie;
    }>;
    updateChannel(spaceId: string | Uint8Array, channelId: string | Uint8Array, unused1: string, unused2: string): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    updateChannelAutojoin(spaceId: string | Uint8Array, channelId: string | Uint8Array, autojoin: boolean): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    updateChannelHideUserJoinLeaveEvents(spaceId: string | Uint8Array, channelId: string | Uint8Array, hideUserJoinLeaveEvents: boolean): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    updateGDMChannelProperties(streamId: string, channelName: string, channelTopic: string): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    setStreamEncryptionAlgorithm(streamId: string, encryptionAlgorithm?: string): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    sendFullyReadMarkers(channelId: string | Uint8Array, fullyReadMarkers: Record<string, FullyReadMarker>): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    updateUserBlock(userId: string, isBlocked: boolean): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    setSpaceImage(spaceStreamId: string, chunkedMediaInfo: PlainMessage<ChunkedMedia>): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    setUserProfileImage(chunkedMediaInfo: PlainMessage<ChunkedMedia>): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    getUserProfileImage(userId: string | Uint8Array): Promise<ChunkedMedia | undefined>;
    setUserBio(bio: PlainMessage<UserBio>): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    getUserBio(userId: string | Uint8Array): Promise<UserBio | undefined>;
    setDisplayName(streamId: string, displayName: string): Promise<void>;
    setUsername(streamId: string, username: string): Promise<void>;
    setEnsAddress(streamId: string, walletAddress: string | Uint8Array): Promise<void>;
    setNft(streamId: string, tokenId: string, chainId: number, contractAddress: string): Promise<void>;
    pin(streamId: string, eventId: string): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    unpin(streamId: string, eventId: string): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    isUsernameAvailable(streamId: string, username: string): boolean;
    waitForStream(inStreamId: string | Uint8Array, opts?: {
        timeoutMs?: number;
        logId?: string;
    }): Promise<Stream>;
    getStream(streamId: string): Promise<StreamStateView>;
    private _getStream;
    private streamViewFromUnpackedResponse;
    getStreamEx(streamId: string): Promise<StreamStateView>;
    private _getStreamEx;
    initStream(streamId: string | Uint8Array, allowGetStream?: boolean, persistedData?: LoadedStream): Promise<Stream>;
    private _initStream;
    private onJoinedStream;
    private onInvitedToStream;
    private onLeftStream;
    private onStreamInitialized;
    startSync(): void;
    stopSync(): Promise<void>;
    emit<E extends keyof ClientEvents>(event: E, ...args: Parameters<ClientEvents[E]>): boolean;
    sendMessage(streamId: string, body: string, mentions?: PlainMessage<ChannelMessage_Post_Mention>[], attachments?: PlainMessage<ChannelMessage_Post_Attachment>[]): Promise<{
        eventId: string;
    }>;
    sendChannelMessage(streamId: string, inPayload: PlainMessage<ChannelMessage>, opts?: SendChannelMessageOptions): Promise<{
        eventId: string;
    }>;
    private makeAndSendChannelMessageEvent;
    sendChannelMessage_Text(streamId: string, payload: Omit<PlainMessage<ChannelMessage_Post>, 'content'> & {
        content: PlainMessage<ChannelMessage_Post_Content_Text>;
    }, opts?: SendChannelMessageOptions): Promise<{
        eventId: string;
    }>;
    sendChannelMessage_Image(streamId: string, payload: Omit<PlainMessage<ChannelMessage_Post>, 'content'> & {
        content: PlainMessage<ChannelMessage_Post_Content_Image>;
    }, opts?: SendChannelMessageOptions): Promise<{
        eventId: string;
    }>;
    sendChannelMessage_GM(streamId: string, payload: Omit<PlainMessage<ChannelMessage_Post>, 'content'> & {
        content: PlainMessage<ChannelMessage_Post_Content_GM>;
    }, opts?: SendChannelMessageOptions): Promise<{
        eventId: string;
    }>;
    sendMediaPayload(creationCookie: CreationCookie, last: boolean, data: Uint8Array, chunkIndex: number, iv?: Uint8Array): Promise<{
        creationCookie: CreationCookie;
    }>;
    getMediaPayload(streamId: string, secretKey: Uint8Array, iv: Uint8Array): Promise<Uint8Array | undefined>;
    sendChannelMessage_Reaction(streamId: string, payload: PlainMessage<ChannelMessage_Reaction>, opts?: SendChannelMessageOptions): Promise<{
        eventId: string;
    }>;
    sendChannelMessage_Redaction(streamId: string, payload: PlainMessage<ChannelMessage_Redaction>): Promise<{
        eventId: string;
    }>;
    sendChannelMessage_Edit(streamId: string, refEventId: string, newPost: PlainMessage<ChannelMessage_Post>): Promise<{
        eventId: string;
    }>;
    sendChannelMessage_Edit_Text(streamId: string, refEventId: string, payload: Omit<PlainMessage<ChannelMessage_Post>, 'content'> & {
        content: PlainMessage<ChannelMessage_Post_Content_Text>;
    }): Promise<{
        eventId: string;
    }>;
    redactMessage(streamId: string, eventId: string): Promise<{
        eventId: string;
    }>;
    retrySendMessage(streamId: string, localId: string): Promise<void>;
    inviteUser(streamId: string | Uint8Array, userId: string): Promise<{
        eventId: string;
    }>;
    joinUser(streamId: string | Uint8Array, userId: string): Promise<{
        eventId: string;
    }>;
    joinStream(streamId: string | Uint8Array, opts?: {
        skipWaitForMiniblockConfirmation?: boolean;
        skipWaitForUserStreamUpdate?: boolean;
    }): Promise<Stream>;
    leaveStream(streamId: string | Uint8Array): Promise<{
        eventId: string;
    }>;
    removeUser(streamId: string | Uint8Array, userId: string): Promise<{
        eventId: string;
    }>;
    addTransaction(chainId: number, receipt: ContractReceipt | SolanaTransactionReceipt, content?: PlainMessage<BlockchainTransaction>['content'], tags?: PlainMessage<Tags>): Promise<{
        eventId: string;
    }>;
    addTransaction_Tip(chainId: number, receipt: ContractReceipt, event: TipEventObject, toUserId: string, opts?: SendBlockchainTransactionOptions): Promise<{
        eventId: string;
    }>;
    addTransaction_Transfer(chainId: number, receipt: ContractReceipt | SolanaTransactionReceipt, event: PlainMessage<BlockchainTransaction_TokenTransfer>, opts?: SendBlockchainTransactionOptions): Promise<{
        eventId: string;
    }>;
    addTransaction_SpaceReview(chainId: number, receipt: ContractReceipt, event: SpaceReviewEventObject, spaceId: string): Promise<{
        eventId: string;
    }>;
    getMiniblocks(streamId: string | Uint8Array, fromInclusive: bigint, toExclusive: bigint): Promise<{
        miniblocks: ParsedMiniblock[];
        terminus: boolean;
    }>;
    getMiniblockHeader(streamId: string, miniblockNum: bigint, unpackOpts?: UnpackEnvelopeOpts | undefined): Promise<MiniblockHeader>;
    scrollback(streamId: string): Promise<{
        terminus: boolean;
        firstEvent?: StreamTimelineEvent;
    }>;
    /**
     * Get the list of active devices for all users in the room
     *
     *
     * @returns Promise which resolves to `null`, or an array whose
     *     first element is a {@link DeviceInfoMap} indicating
     *     the devices that messages should be encrypted to, and whose second
     *     element is a map from userId to deviceId to data indicating the devices
     *     that are in the room but that have been blocked.
     */
    getDevicesInStream(stream_id: string): Promise<UserDeviceCollection>;
    getMiniblockInfo(streamId: string): Promise<{
        miniblockNum: bigint;
        miniblockHash: Uint8Array;
    }>;
    downloadNewInboxMessages(): Promise<void>;
    downloadUserDeviceInfo(userIds: string[]): Promise<UserDeviceCollection>;
    knownDevicesForUserId(userId: string): Promise<UserDevice[]>;
    makeEventAndAddToStream(streamId: string | Uint8Array, payload: PlainMessage<StreamEvent>['payload'], options?: {
        method?: string;
        localId?: string;
        cleartext?: Uint8Array;
        optional?: boolean;
        tags?: PlainMessage<Tags>;
    }): Promise<{
        eventId: string;
        error?: AddEventResponse_Error;
    }>;
    makeEventWithHashAndAddToStream(streamId: string | Uint8Array, payload: PlainMessage<StreamEvent>['payload'], prevMiniblockHash: Uint8Array, optional?: boolean, localId?: string, cleartext?: Uint8Array, tags?: PlainMessage<Tags>, retryCount?: number): Promise<{
        prevMiniblockHash: Uint8Array;
        eventId: string;
        error?: AddEventResponse_Error;
    }>;
    makeMediaEventWithHashAndAddToMediaStream(creationCookie: CreationCookie, last: boolean, payload: PlainMessage<StreamEvent>['payload']): Promise<{
        creationCookie: CreationCookie;
    }>;
    getStreamLastMiniblockHash(streamId: string | Uint8Array): Promise<Uint8Array>;
    private initCrypto;
    /**
     * Resets crypto backend and creates a new encryption account, uploading device keys to UserDeviceKey stream.
     */
    resetCrypto(): Promise<void>;
    uploadDeviceKeys(): Promise<{
        eventId: string;
        error?: AddEventResponse_Error | undefined;
    }>;
    ackInboxStream(): Promise<void>;
    setHighPriorityStreams(streamIds: string[]): void;
    ensureOutboundSession(streamId: string, opts: {
        awaitInitialShareSession: boolean;
    }): Promise<void>;
    /**
     * decrypts and updates the decrypted event
     */
    decryptGroupEvent(streamId: string, eventId: string, kind: string, // kind of data
    encryptedData: EncryptedData): Promise<void>;
    private cleartextForGroupEvent;
    encryptAndShareGroupSessions(inStreamId: string | Uint8Array, sessions: GroupEncryptionSession[], toDevices: UserDeviceCollection, algorithm: GroupEncryptionAlgorithmId): Promise<void>;
    encryptGroupEvent(event: Uint8Array, streamId: string, algorithm: GroupEncryptionAlgorithmId): Promise<EncryptedData>;
    encryptWithDeviceKeys(payloadClearText: string, deviceKeys: UserDevice[]): Promise<Record<string, string>>;
    userDeviceKey(): UserDevice;
    debugForceMakeMiniblock(streamId: string, opts?: {
        forceSnapshot?: boolean;
    }): Promise<void>;
    debugForceAddEvent(streamId: string, event: Envelope): Promise<void>;
    debugDropStream(syncId: string, streamId: string): Promise<void>;
}
export {};
//# sourceMappingURL=client.d.ts.map