@towns-protocol/sdk/dist/streamStateView.d.ts

For more details, visit the following resources:

import { ChannelMessage, SnapshotCaseType, SyncCookie, Snapshot } from '@towns-protocol/proto';
import TypedEmitter from 'typed-emitter';
import { LocalEventStatus, LocalTimelineEvent, ParsedEvent, ParsedMiniblock, RemoteTimelineEvent, StreamTimelineEvent } from './types';
import { StreamStateView_Space } from './streamStateView_Space';
import { StreamStateView_Channel } from './streamStateView_Channel';
import { StreamStateView_User } from './streamStateView_User';
import { StreamStateView_UserSettings } from './streamStateView_UserSettings';
import { StreamStateView_UserMetadata } from './streamStateView_UserMetadata';
import { StreamStateView_Members } from './streamStateView_Members';
import { StreamStateView_Media } from './streamStateView_Media';
import { StreamStateView_GDMChannel } from './streamStateView_GDMChannel';
import { StreamStateView_AbstractContent } from './streamStateView_AbstractContent';
import { StreamStateView_DMChannel } from './streamStateView_DMChannel';
import { StreamStateView_UserInbox } from './streamStateView_UserInbox';
import { DecryptedContent } from './encryptedContentTypes';
import { StreamStateView_MemberMetadata } from './streamStateView_MemberMetadata';
import { StreamEvents, StreamEncryptionEvents, StreamStateEvents } from './streamEvents';
import { DecryptionSessionError } from './decryptionExtensions';
import { StreamsView } from './views/streamsView';
import { TimelineEvent } from './views/models/timelineTypes';
export declare class StreamStateView {
    readonly streamId: string;
    readonly userId: string;
    readonly streamsView: StreamsView;
    readonly contentKind: SnapshotCaseType;
    readonly minipoolEvents: Map<string, StreamTimelineEvent>;
    prevMiniblockHash?: Uint8Array;
    prevMiniblockNum?: bigint;
    lastEventNum: bigint;
    prevSnapshotMiniblockNum: bigint;
    miniblockInfo?: {
        max: bigint;
        min: bigint;
        terminusReached: boolean;
    };
    syncCookie?: SyncCookie;
    membershipContent: StreamStateView_Members;
    get isInitialized(): boolean;
    set isInitialized(value: boolean);
    get timeline(): TimelineEvent[];
    private readonly _spaceContent?;
    get spaceContent(): StreamStateView_Space;
    private readonly _channelContent?;
    get channelContent(): StreamStateView_Channel;
    private readonly _dmChannelContent?;
    get dmChannelContent(): StreamStateView_DMChannel;
    private readonly _gdmChannelContent?;
    get gdmChannelContent(): StreamStateView_GDMChannel;
    private readonly _userContent?;
    get userContent(): StreamStateView_User;
    private readonly _userSettingsContent?;
    get userSettingsContent(): StreamStateView_UserSettings;
    private readonly _userMetadataContent?;
    get userMetadataContent(): StreamStateView_UserMetadata;
    private readonly _userInboxContent?;
    get userInboxContent(): StreamStateView_UserInbox;
    private readonly _mediaContent?;
    get mediaContent(): StreamStateView_Media;
    constructor(userId: string, streamId: string, streamsView: StreamsView | undefined);
    private applySnapshot;
    private appendStreamAndCookie;
    private processAppendedEvent;
    private processMiniblockHeader;
    private processPrependedEvent;
    private updateMiniblockInfo;
    updateDecryptedContent(eventId: string, content: DecryptedContent, emitter: TypedEmitter<StreamStateEvents>): void;
    updateDecryptedContentError(eventId: string, content: DecryptionSessionError, _emitter: TypedEmitter<StreamStateEvents>): void;
    initialize(nextSyncCookie: SyncCookie, minipoolEvents: ParsedEvent[], snapshot: Snapshot, miniblocks: ParsedMiniblock[], prependedMiniblocks: ParsedMiniblock[], prevSnapshotMiniblockNum: bigint, cleartexts: Record<string, Uint8Array | string> | undefined, localEvents: LocalTimelineEvent[], emitter: TypedEmitter<StreamEvents> | undefined): void;
    appendEvents(events: ParsedEvent[], nextSyncCookie: SyncCookie, cleartexts: Record<string, Uint8Array | string> | undefined, emitter: TypedEmitter<StreamEvents>): void;
    prependEvents(miniblocks: ParsedMiniblock[], cleartexts: Record<string, Uint8Array | string> | undefined, terminus: boolean, encryptionEmitter: TypedEmitter<StreamEncryptionEvents> | undefined, stateEmitter: TypedEmitter<StreamStateEvents> | undefined): RemoteTimelineEvent[];
    appendLocalEvent(channelMessage: ChannelMessage, status: LocalEventStatus, emitter: TypedEmitter<StreamEvents> | undefined): string;
    updateLocalEvent(localId: string, parsedEventHash: string, status: LocalEventStatus, emitter: TypedEmitter<StreamEvents>): void;
    getMembers(): StreamStateView_Members;
    getMemberMetadata(): StreamStateView_MemberMetadata;
    getContent(): StreamStateView_AbstractContent;
    /**
     * Streams behave slightly differently.
     * Regular channels: the user needs to be an active member. SO_JOIN
     * DMs: always open for key exchange for any of the two participants
     */
    userIsEntitledToKeyExchange(userId: string): boolean;
    getUsersEntitledToKeyExchange(): Set<string>;
}
//# sourceMappingURL=streamStateView.d.ts.map