@towns-protocol/proto 0.0.191

package/dist/gen/protocol_pb.d.ts

@@ -0,0 +1,3972 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv1";
+import type { Empty, Timestamp } from "@bufbuild/protobuf/wkt";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file protocol.proto.
+ */
+export declare const file_protocol: GenFile;
+/**
+ * *
+ * Miniblock contains a list of events and the header event.
+ * Events must be in the same order as in the header, which is of type MiniblockHeader.
+ * Only signed data (Envelopes) should exist in this data structure.
+ *
+ * @generated from message river.Miniblock
+ */
+export type Miniblock = Message<"river.Miniblock"> & {
+    /**
+     * @generated from field: repeated river.Envelope events = 1;
+     */
+    events: Envelope[];
+    /**
+     * @generated from field: river.Envelope header = 2;
+     */
+    header?: Envelope;
+};
+/**
+ * Describes the message river.Miniblock.
+ * Use `create(MiniblockSchema)` to create a new message.
+ */
+export declare const MiniblockSchema: GenMessage<Miniblock>;
+/**
+ * *
+ * Envelope contains serialized event, and its hash and signature.
+ * hash is used as event id. Subsequent events reference this event by hash.
+ * event is a serialized StreamEvent
+ *
+ * @generated from message river.Envelope
+ */
+export type Envelope = Message<"river.Envelope"> & {
+    /**
+     * *
+     * Hash of event.
+     * While hash can be recalculated from the event, having it here explicitly
+     * makes it easier to work with event.
+     * For the event to be valid, must match hash of event field.
+     *
+     * @generated from field: bytes hash = 1;
+     */
+    hash: Uint8Array;
+    /**
+     * *
+     * Signature.
+     * For the event to be valid, signature must match event.creator_address
+     * or be signed by the address from event.delegate_sig.
+     *
+     * @generated from field: bytes signature = 2;
+     */
+    signature: Uint8Array;
+    /**
+     * @generated from field: bytes event = 3;
+     */
+    event: Uint8Array;
+};
+/**
+ * Describes the message river.Envelope.
+ * Use `create(EnvelopeSchema)` to create a new message.
+ */
+export declare const EnvelopeSchema: GenMessage<Envelope>;
+/**
+ * *
+ * StreamEvent is a single event in the stream.
+ *
+ * @generated from message river.StreamEvent
+ */
+export type StreamEvent = Message<"river.StreamEvent"> & {
+    /**
+     * *
+     * Address of the creator of the event.
+     * For user - address of the user's wallet.
+     * For server - address of the server's keypair in staking smart contract.
+     *
+     * For the event to be valid:
+     * If delegate_sig is present, creator_address must match delegate_sig.
+     * If delegate_sig is not present, creator_address must match event signature in the Envelope.
+     *
+     * @generated from field: bytes creator_address = 1;
+     */
+    creatorAddress: Uint8Array;
+    /**
+     * *
+     * delegate_sig allows event to be signed by a delegate keypair
+     *
+     * delegate_sig constains signature of the
+     * public key of the delegate keypair + the delegate_expiry_epoch_ms.
+     * User's wallet is used to produce this signature.
+     *
+     * If present, for the event to be valid:
+     * 1. creator_address must match delegate_sig's signer public key
+     * 2. delegate_sig should be signed as an Ethereum Signed Message (eip-191)
+     *
+     * Server nodes sign node-produced events with their own keypair and do not
+     * need to use delegate_sig.
+     *
+     * @generated from field: bytes delegate_sig = 2;
+     */
+    delegateSig: Uint8Array;
+    /**
+     * * Salt ensures that similar messages are not hashed to the same value. genId() from id.ts may be used.
+     *
+     * @generated from field: bytes salt = 3;
+     */
+    salt: Uint8Array;
+    /**
+     * * Hash of a preceding miniblock. Null for the inception event. Must be a recent miniblock
+     *
+     * @generated from field: optional bytes prev_miniblock_hash = 4;
+     */
+    prevMiniblockHash?: Uint8Array;
+    /**
+     * * CreatedAt is the time when the event was created.
+     * NOTE: this value is set by clients and is not reliable for anything other than displaying
+     * the value to the user. Never use this value to sort events from different users.
+     *
+     * @generated from field: int64 created_at_epoch_ms = 5;
+     */
+    createdAtEpochMs: bigint;
+    /**
+     * * DelegateExpiry is the time when the delegate signature expires.
+     *
+     * @generated from field: int64 delegate_expiry_epoch_ms = 6;
+     */
+    delegateExpiryEpochMs: bigint;
+    /**
+     * * Tags are optional, used for external systems to deliver notifications.
+     *
+     * @generated from field: river.Tags tags = 7;
+     */
+    tags?: Tags;
+    /**
+     * * prev_miniblock_num contains miniblock number for prev_miniblock_hash.
+     *
+     * @generated from field: optional int64 prev_miniblock_num = 8;
+     */
+    prevMiniblockNum?: bigint;
+    /**
+     * * Variable-type payload.
+     * Payloads should obey the following rules:
+     * - payloads should have their own unique type
+     * - each payload should have a oneof content field
+     * - each payload, with the exception of miniblock header and member payloads
+     *     should have an inception field inside the content oneof
+     * - each payload should have a unique Inception type
+     * - payloads can't violate previous type recursively to inception payload
+     *
+     * @generated from oneof river.StreamEvent.payload
+     */
+    payload: {
+        /**
+         * @generated from field: river.MiniblockHeader miniblock_header = 100;
+         */
+        value: MiniblockHeader;
+        case: "miniblockHeader";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload member_payload = 101;
+         */
+        value: MemberPayload;
+        case: "memberPayload";
+    } | {
+        /**
+         * @generated from field: river.SpacePayload space_payload = 102;
+         */
+        value: SpacePayload;
+        case: "spacePayload";
+    } | {
+        /**
+         * @generated from field: river.ChannelPayload channel_payload = 103;
+         */
+        value: ChannelPayload;
+        case: "channelPayload";
+    } | {
+        /**
+         * @generated from field: river.UserPayload user_payload = 104;
+         */
+        value: UserPayload;
+        case: "userPayload";
+    } | {
+        /**
+         * @generated from field: river.UserSettingsPayload user_settings_payload = 105;
+         */
+        value: UserSettingsPayload;
+        case: "userSettingsPayload";
+    } | {
+        /**
+         * @generated from field: river.UserMetadataPayload user_metadata_payload = 106;
+         */
+        value: UserMetadataPayload;
+        case: "userMetadataPayload";
+    } | {
+        /**
+         * @generated from field: river.UserInboxPayload user_inbox_payload = 107;
+         */
+        value: UserInboxPayload;
+        case: "userInboxPayload";
+    } | {
+        /**
+         * @generated from field: river.MediaPayload media_payload = 108;
+         */
+        value: MediaPayload;
+        case: "mediaPayload";
+    } | {
+        /**
+         * @generated from field: river.DmChannelPayload dm_channel_payload = 109;
+         */
+        value: DmChannelPayload;
+        case: "dmChannelPayload";
+    } | {
+        /**
+         * @generated from field: river.GdmChannelPayload gdm_channel_payload = 110;
+         */
+        value: GdmChannelPayload;
+        case: "gdmChannelPayload";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.StreamEvent.
+ * Use `create(StreamEventSchema)` to create a new message.
+ */
+export declare const StreamEventSchema: GenMessage<StreamEvent>;
+/**
+ * *
+ * MiniblockHeader is a special event that forms a block from set of the stream events.
+ * Hash of the serialized StreamEvent containing MiniblockHeader is used as a block hash.
+ *
+ * @generated from message river.MiniblockHeader
+ */
+export type MiniblockHeader = Message<"river.MiniblockHeader"> & {
+    /**
+     * Miniblock number.
+     * 0 for genesis block.
+     * Must be 1 greater than the previous block number.
+     *
+     * @generated from field: int64 miniblock_num = 1;
+     */
+    miniblockNum: bigint;
+    /**
+     * Hash of the previous block.
+     *
+     * @generated from field: bytes prev_miniblock_hash = 2;
+     */
+    prevMiniblockHash: Uint8Array;
+    /**
+     * Timestamp of the block.
+     * Must be greater than the previous block timestamp.
+     *
+     * @generated from field: google.protobuf.Timestamp timestamp = 3;
+     */
+    timestamp?: Timestamp;
+    /**
+     * Hashes of the events included in the block.
+     *
+     * @generated from field: repeated bytes event_hashes = 4;
+     */
+    eventHashes: Uint8Array[];
+    /**
+     * Snapshot of the state at the end of the block.
+     *
+     * @generated from field: optional river.Snapshot snapshot = 5;
+     */
+    snapshot?: Snapshot;
+    /**
+     * count of all events in the stream before this block
+     *
+     * @generated from field: int64 event_num_offset = 6;
+     */
+    eventNumOffset: bigint;
+    /**
+     * pointer to block with previous snapshot
+     *
+     * @generated from field: int64 prev_snapshot_miniblock_num = 7;
+     */
+    prevSnapshotMiniblockNum: bigint;
+    /**
+     * hash of the snapshot.
+     *
+     * @generated from field: optional bytes snapshot_hash = 8;
+     */
+    snapshotHash?: Uint8Array;
+    /**
+     * stream payloads are required to have a content field
+     *
+     * @generated from oneof river.MiniblockHeader.content
+     */
+    content: {
+        /**
+         * @generated from field: google.protobuf.Empty none = 100;
+         */
+        value: Empty;
+        case: "none";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.MiniblockHeader.
+ * Use `create(MiniblockHeaderSchema)` to create a new message.
+ */
+export declare const MiniblockHeaderSchema: GenMessage<MiniblockHeader>;
+/**
+ * *
+ * MemberPayload
+ * can appear in any stream
+ *
+ * @generated from message river.MemberPayload
+ */
+export type MemberPayload = Message<"river.MemberPayload"> & {
+    /**
+     * @generated from oneof river.MemberPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.MemberPayload.Membership membership = 1;
+         */
+        value: MemberPayload_Membership;
+        case: "membership";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.KeySolicitation key_solicitation = 2;
+         */
+        value: MemberPayload_KeySolicitation;
+        case: "keySolicitation";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.KeyFulfillment key_fulfillment = 3;
+         */
+        value: MemberPayload_KeyFulfillment;
+        case: "keyFulfillment";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData username = 4;
+         */
+        value: EncryptedData;
+        case: "username";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData display_name = 5;
+         */
+        value: EncryptedData;
+        case: "displayName";
+    } | {
+        /**
+         * @generated from field: bytes ens_address = 6;
+         */
+        value: Uint8Array;
+        case: "ensAddress";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.Nft nft = 7;
+         */
+        value: MemberPayload_Nft;
+        case: "nft";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.Pin pin = 8;
+         */
+        value: MemberPayload_Pin;
+        case: "pin";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.Unpin unpin = 9;
+         */
+        value: MemberPayload_Unpin;
+        case: "unpin";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.MemberBlockchainTransaction member_blockchain_transaction = 11;
+         */
+        value: MemberPayload_MemberBlockchainTransaction;
+        case: "memberBlockchainTransaction";
+    } | {
+        /**
+         * @generated from field: river.MemberPayload.EncryptionAlgorithm encryption_algorithm = 12;
+         */
+        value: MemberPayload_EncryptionAlgorithm;
+        case: "encryptionAlgorithm";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.MemberPayload.
+ * Use `create(MemberPayloadSchema)` to create a new message.
+ */
+export declare const MemberPayloadSchema: GenMessage<MemberPayload>;
+/**
+ * @generated from message river.MemberPayload.Snapshot
+ */
+export type MemberPayload_Snapshot = Message<"river.MemberPayload.Snapshot"> & {
+    /**
+     * @generated from field: repeated river.MemberPayload.Snapshot.Member joined = 1;
+     */
+    joined: MemberPayload_Snapshot_Member[];
+    /**
+     * @generated from field: repeated river.MemberPayload.SnappedPin pins = 2;
+     */
+    pins: MemberPayload_SnappedPin[];
+    /**
+     * @generated from field: river.MemberPayload.EncryptionAlgorithm encryption_algorithm = 4;
+     */
+    encryptionAlgorithm?: MemberPayload_EncryptionAlgorithm;
+    /**
+     * tips sent in this stream: map<currency, amount>
+     *
+     * @generated from field: map<string, uint64> tips = 5;
+     */
+    tips: {
+        [key: string]: bigint;
+    };
+};
+/**
+ * Describes the message river.MemberPayload.Snapshot.
+ * Use `create(MemberPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const MemberPayload_SnapshotSchema: GenMessage<MemberPayload_Snapshot>;
+/**
+ * @generated from message river.MemberPayload.Snapshot.Member
+ */
+export type MemberPayload_Snapshot_Member = Message<"river.MemberPayload.Snapshot.Member"> & {
+    /**
+     * @generated from field: bytes user_address = 1;
+     */
+    userAddress: Uint8Array;
+    /**
+     * @generated from field: int64 miniblock_num = 2;
+     */
+    miniblockNum: bigint;
+    /**
+     * @generated from field: int64 event_num = 3;
+     */
+    eventNum: bigint;
+    /**
+     * @generated from field: repeated river.MemberPayload.KeySolicitation solicitations = 4;
+     */
+    solicitations: MemberPayload_KeySolicitation[];
+    /**
+     * @generated from field: river.WrappedEncryptedData username = 5;
+     */
+    username?: WrappedEncryptedData;
+    /**
+     * @generated from field: river.WrappedEncryptedData display_name = 6;
+     */
+    displayName?: WrappedEncryptedData;
+    /**
+     * @generated from field: bytes ens_address = 7;
+     */
+    ensAddress: Uint8Array;
+    /**
+     * @generated from field: river.MemberPayload.Nft nft = 8;
+     */
+    nft?: MemberPayload_Nft;
+};
+/**
+ * Describes the message river.MemberPayload.Snapshot.Member.
+ * Use `create(MemberPayload_Snapshot_MemberSchema)` to create a new message.
+ */
+export declare const MemberPayload_Snapshot_MemberSchema: GenMessage<MemberPayload_Snapshot_Member>;
+/**
+ * @generated from message river.MemberPayload.KeyPackage
+ */
+export type MemberPayload_KeyPackage = Message<"river.MemberPayload.KeyPackage"> & {
+    /**
+     * @generated from field: bytes user_address = 1;
+     */
+    userAddress: Uint8Array;
+    /**
+     * @generated from field: bytes signature_public_key = 2;
+     */
+    signaturePublicKey: Uint8Array;
+    /**
+     * @generated from field: bytes key_package = 3;
+     */
+    keyPackage: Uint8Array;
+};
+/**
+ * Describes the message river.MemberPayload.KeyPackage.
+ * Use `create(MemberPayload_KeyPackageSchema)` to create a new message.
+ */
+export declare const MemberPayload_KeyPackageSchema: GenMessage<MemberPayload_KeyPackage>;
+/**
+ * @generated from message river.MemberPayload.Membership
+ */
+export type MemberPayload_Membership = Message<"river.MemberPayload.Membership"> & {
+    /**
+     * @generated from field: river.MembershipOp op = 1;
+     */
+    op: MembershipOp;
+    /**
+     * @generated from field: bytes user_address = 2;
+     */
+    userAddress: Uint8Array;
+    /**
+     * @generated from field: bytes initiator_address = 3;
+     */
+    initiatorAddress: Uint8Array;
+    /**
+     * @generated from field: optional bytes stream_parent_id = 4;
+     */
+    streamParentId?: Uint8Array;
+};
+/**
+ * Describes the message river.MemberPayload.Membership.
+ * Use `create(MemberPayload_MembershipSchema)` to create a new message.
+ */
+export declare const MemberPayload_MembershipSchema: GenMessage<MemberPayload_Membership>;
+/**
+ * @generated from message river.MemberPayload.KeySolicitation
+ */
+export type MemberPayload_KeySolicitation = Message<"river.MemberPayload.KeySolicitation"> & {
+    /**
+     * requesters device_key
+     *
+     * @generated from field: string device_key = 1;
+     */
+    deviceKey: string;
+    /**
+     * requesters fallback_key
+     *
+     * @generated from field: string fallback_key = 2;
+     */
+    fallbackKey: string;
+    /**
+     * true if this is a new device, session_ids will be empty
+     *
+     * @generated from field: bool is_new_device = 3;
+     */
+    isNewDevice: boolean;
+    /**
+     * @generated from field: repeated string session_ids = 4;
+     */
+    sessionIds: string[];
+};
+/**
+ * Describes the message river.MemberPayload.KeySolicitation.
+ * Use `create(MemberPayload_KeySolicitationSchema)` to create a new message.
+ */
+export declare const MemberPayload_KeySolicitationSchema: GenMessage<MemberPayload_KeySolicitation>;
+/**
+ * @generated from message river.MemberPayload.KeyFulfillment
+ */
+export type MemberPayload_KeyFulfillment = Message<"river.MemberPayload.KeyFulfillment"> & {
+    /**
+     * @generated from field: bytes user_address = 1;
+     */
+    userAddress: Uint8Array;
+    /**
+     * @generated from field: string device_key = 2;
+     */
+    deviceKey: string;
+    /**
+     * @generated from field: repeated string session_ids = 3;
+     */
+    sessionIds: string[];
+};
+/**
+ * Describes the message river.MemberPayload.KeyFulfillment.
+ * Use `create(MemberPayload_KeyFulfillmentSchema)` to create a new message.
+ */
+export declare const MemberPayload_KeyFulfillmentSchema: GenMessage<MemberPayload_KeyFulfillment>;
+/**
+ * @generated from message river.MemberPayload.Nft
+ */
+export type MemberPayload_Nft = Message<"river.MemberPayload.Nft"> & {
+    /**
+     * @generated from field: int32 chain_id = 1;
+     */
+    chainId: number;
+    /**
+     * @generated from field: bytes contract_address = 2;
+     */
+    contractAddress: Uint8Array;
+    /**
+     * @generated from field: bytes token_id = 3;
+     */
+    tokenId: Uint8Array;
+};
+/**
+ * Describes the message river.MemberPayload.Nft.
+ * Use `create(MemberPayload_NftSchema)` to create a new message.
+ */
+export declare const MemberPayload_NftSchema: GenMessage<MemberPayload_Nft>;
+/**
+ * @generated from message river.MemberPayload.SnappedPin
+ */
+export type MemberPayload_SnappedPin = Message<"river.MemberPayload.SnappedPin"> & {
+    /**
+     * @generated from field: bytes creator_address = 1;
+     */
+    creatorAddress: Uint8Array;
+    /**
+     * @generated from field: river.MemberPayload.Pin pin = 2;
+     */
+    pin?: MemberPayload_Pin;
+};
+/**
+ * Describes the message river.MemberPayload.SnappedPin.
+ * Use `create(MemberPayload_SnappedPinSchema)` to create a new message.
+ */
+export declare const MemberPayload_SnappedPinSchema: GenMessage<MemberPayload_SnappedPin>;
+/**
+ * @generated from message river.MemberPayload.Pin
+ */
+export type MemberPayload_Pin = Message<"river.MemberPayload.Pin"> & {
+    /**
+     * @generated from field: bytes event_id = 1;
+     */
+    eventId: Uint8Array;
+    /**
+     * @generated from field: river.StreamEvent event = 2;
+     */
+    event?: StreamEvent;
+};
+/**
+ * Describes the message river.MemberPayload.Pin.
+ * Use `create(MemberPayload_PinSchema)` to create a new message.
+ */
+export declare const MemberPayload_PinSchema: GenMessage<MemberPayload_Pin>;
+/**
+ * @generated from message river.MemberPayload.Unpin
+ */
+export type MemberPayload_Unpin = Message<"river.MemberPayload.Unpin"> & {
+    /**
+     * @generated from field: bytes event_id = 1;
+     */
+    eventId: Uint8Array;
+};
+/**
+ * Describes the message river.MemberPayload.Unpin.
+ * Use `create(MemberPayload_UnpinSchema)` to create a new message.
+ */
+export declare const MemberPayload_UnpinSchema: GenMessage<MemberPayload_Unpin>;
+/**
+ * @generated from message river.MemberPayload.EncryptionAlgorithm
+ */
+export type MemberPayload_EncryptionAlgorithm = Message<"river.MemberPayload.EncryptionAlgorithm"> & {
+    /**
+     * @generated from field: optional string algorithm = 1;
+     */
+    algorithm?: string;
+};
+/**
+ * Describes the message river.MemberPayload.EncryptionAlgorithm.
+ * Use `create(MemberPayload_EncryptionAlgorithmSchema)` to create a new message.
+ */
+export declare const MemberPayload_EncryptionAlgorithmSchema: GenMessage<MemberPayload_EncryptionAlgorithm>;
+/**
+ * @generated from message river.MemberPayload.MemberBlockchainTransaction
+ */
+export type MemberPayload_MemberBlockchainTransaction = Message<"river.MemberPayload.MemberBlockchainTransaction"> & {
+    /**
+     * @generated from field: river.BlockchainTransaction transaction = 1;
+     */
+    transaction?: BlockchainTransaction;
+    /**
+     * @generated from field: bytes from_user_address = 2;
+     */
+    fromUserAddress: Uint8Array;
+};
+/**
+ * Describes the message river.MemberPayload.MemberBlockchainTransaction.
+ * Use `create(MemberPayload_MemberBlockchainTransactionSchema)` to create a new message.
+ */
+export declare const MemberPayload_MemberBlockchainTransactionSchema: GenMessage<MemberPayload_MemberBlockchainTransaction>;
+/**
+ * *
+ * SpacePayload
+ *
+ * @generated from message river.SpacePayload
+ */
+export type SpacePayload = Message<"river.SpacePayload"> & {
+    /**
+     * @generated from oneof river.SpacePayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.SpacePayload.Inception inception = 1;
+         */
+        value: SpacePayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.SpacePayload.ChannelUpdate channel = 2;
+         */
+        value: SpacePayload_ChannelUpdate;
+        case: "channel";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData space_image = 3;
+         */
+        value: EncryptedData;
+        case: "spaceImage";
+    } | {
+        /**
+         * @generated from field: river.SpacePayload.UpdateChannelAutojoin update_channel_autojoin = 4;
+         */
+        value: SpacePayload_UpdateChannelAutojoin;
+        case: "updateChannelAutojoin";
+    } | {
+        /**
+         * @generated from field: river.SpacePayload.UpdateChannelHideUserJoinLeaveEvents update_channel_hide_user_join_leave_events = 5;
+         */
+        value: SpacePayload_UpdateChannelHideUserJoinLeaveEvents;
+        case: "updateChannelHideUserJoinLeaveEvents";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.SpacePayload.
+ * Use `create(SpacePayloadSchema)` to create a new message.
+ */
+export declare const SpacePayloadSchema: GenMessage<SpacePayload>;
+/**
+ * @generated from message river.SpacePayload.Snapshot
+ */
+export type SpacePayload_Snapshot = Message<"river.SpacePayload.Snapshot"> & {
+    /**
+     * inception
+     *
+     * @generated from field: river.SpacePayload.Inception inception = 1;
+     */
+    inception?: SpacePayload_Inception;
+    /**
+     * channels: sorted by channel_id
+     *
+     * @generated from field: repeated river.SpacePayload.ChannelMetadata channels = 2;
+     */
+    channels: SpacePayload_ChannelMetadata[];
+    /**
+     * @generated from field: river.SpacePayload.SnappedSpaceImage space_image = 3;
+     */
+    spaceImage?: SpacePayload_SnappedSpaceImage;
+};
+/**
+ * Describes the message river.SpacePayload.Snapshot.
+ * Use `create(SpacePayload_SnapshotSchema)` to create a new message.
+ */
+export declare const SpacePayload_SnapshotSchema: GenMessage<SpacePayload_Snapshot>;
+/**
+ * @generated from message river.SpacePayload.SnappedSpaceImage
+ */
+export type SpacePayload_SnappedSpaceImage = Message<"river.SpacePayload.SnappedSpaceImage"> & {
+    /**
+     * @generated from field: bytes creator_address = 1;
+     */
+    creatorAddress: Uint8Array;
+    /**
+     * @generated from field: river.EncryptedData data = 2;
+     */
+    data?: EncryptedData;
+    /**
+     * @generated from field: int64 event_num = 3;
+     */
+    eventNum: bigint;
+    /**
+     * @generated from field: bytes event_hash = 4;
+     */
+    eventHash: Uint8Array;
+};
+/**
+ * Describes the message river.SpacePayload.SnappedSpaceImage.
+ * Use `create(SpacePayload_SnappedSpaceImageSchema)` to create a new message.
+ */
+export declare const SpacePayload_SnappedSpaceImageSchema: GenMessage<SpacePayload_SnappedSpaceImage>;
+/**
+ * @generated from message river.SpacePayload.Inception
+ */
+export type SpacePayload_Inception = Message<"river.SpacePayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 2;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.SpacePayload.Inception.
+ * Use `create(SpacePayload_InceptionSchema)` to create a new message.
+ */
+export declare const SpacePayload_InceptionSchema: GenMessage<SpacePayload_Inception>;
+/**
+ * @generated from message river.SpacePayload.ChannelSettings
+ */
+export type SpacePayload_ChannelSettings = Message<"river.SpacePayload.ChannelSettings"> & {
+    /**
+     * @generated from field: bool autojoin = 1;
+     */
+    autojoin: boolean;
+    /**
+     * @generated from field: bool hide_user_join_leave_events = 2;
+     */
+    hideUserJoinLeaveEvents: boolean;
+};
+/**
+ * Describes the message river.SpacePayload.ChannelSettings.
+ * Use `create(SpacePayload_ChannelSettingsSchema)` to create a new message.
+ */
+export declare const SpacePayload_ChannelSettingsSchema: GenMessage<SpacePayload_ChannelSettings>;
+/**
+ * @generated from message river.SpacePayload.ChannelMetadata
+ */
+export type SpacePayload_ChannelMetadata = Message<"river.SpacePayload.ChannelMetadata"> & {
+    /**
+     * @generated from field: river.ChannelOp op = 1;
+     */
+    op: ChannelOp;
+    /**
+     * @generated from field: bytes channel_id = 2;
+     */
+    channelId: Uint8Array;
+    /**
+     * @generated from field: river.EventRef origin_event = 3;
+     */
+    originEvent?: EventRef;
+    /**
+     * @generated from field: int64 updated_at_event_num = 6;
+     */
+    updatedAtEventNum: bigint;
+    /**
+     * @generated from field: river.SpacePayload.ChannelSettings settings = 7;
+     */
+    settings?: SpacePayload_ChannelSettings;
+};
+/**
+ * Describes the message river.SpacePayload.ChannelMetadata.
+ * Use `create(SpacePayload_ChannelMetadataSchema)` to create a new message.
+ */
+export declare const SpacePayload_ChannelMetadataSchema: GenMessage<SpacePayload_ChannelMetadata>;
+/**
+ * @generated from message river.SpacePayload.ChannelUpdate
+ */
+export type SpacePayload_ChannelUpdate = Message<"river.SpacePayload.ChannelUpdate"> & {
+    /**
+     * @generated from field: river.ChannelOp op = 1;
+     */
+    op: ChannelOp;
+    /**
+     * @generated from field: bytes channel_id = 2;
+     */
+    channelId: Uint8Array;
+    /**
+     * @generated from field: river.EventRef origin_event = 3;
+     */
+    originEvent?: EventRef;
+    /**
+     * @generated from field: river.SpacePayload.ChannelSettings settings = 6;
+     */
+    settings?: SpacePayload_ChannelSettings;
+};
+/**
+ * Describes the message river.SpacePayload.ChannelUpdate.
+ * Use `create(SpacePayload_ChannelUpdateSchema)` to create a new message.
+ */
+export declare const SpacePayload_ChannelUpdateSchema: GenMessage<SpacePayload_ChannelUpdate>;
+/**
+ * @generated from message river.SpacePayload.UpdateChannelAutojoin
+ */
+export type SpacePayload_UpdateChannelAutojoin = Message<"river.SpacePayload.UpdateChannelAutojoin"> & {
+    /**
+     * @generated from field: bytes channel_id = 1;
+     */
+    channelId: Uint8Array;
+    /**
+     * @generated from field: bool autojoin = 2;
+     */
+    autojoin: boolean;
+};
+/**
+ * Describes the message river.SpacePayload.UpdateChannelAutojoin.
+ * Use `create(SpacePayload_UpdateChannelAutojoinSchema)` to create a new message.
+ */
+export declare const SpacePayload_UpdateChannelAutojoinSchema: GenMessage<SpacePayload_UpdateChannelAutojoin>;
+/**
+ * @generated from message river.SpacePayload.UpdateChannelHideUserJoinLeaveEvents
+ */
+export type SpacePayload_UpdateChannelHideUserJoinLeaveEvents = Message<"river.SpacePayload.UpdateChannelHideUserJoinLeaveEvents"> & {
+    /**
+     * @generated from field: bytes channel_id = 1;
+     */
+    channelId: Uint8Array;
+    /**
+     * @generated from field: bool hide_user_join_leave_events = 2;
+     */
+    hideUserJoinLeaveEvents: boolean;
+};
+/**
+ * Describes the message river.SpacePayload.UpdateChannelHideUserJoinLeaveEvents.
+ * Use `create(SpacePayload_UpdateChannelHideUserJoinLeaveEventsSchema)` to create a new message.
+ */
+export declare const SpacePayload_UpdateChannelHideUserJoinLeaveEventsSchema: GenMessage<SpacePayload_UpdateChannelHideUserJoinLeaveEvents>;
+/**
+ * *
+ * ChannelPayload
+ *
+ * @generated from message river.ChannelPayload
+ */
+export type ChannelPayload = Message<"river.ChannelPayload"> & {
+    /**
+     * @generated from oneof river.ChannelPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.ChannelPayload.Inception inception = 1;
+         */
+        value: ChannelPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData message = 2;
+         */
+        value: EncryptedData;
+        case: "message";
+    } | {
+        /**
+         * @generated from field: river.ChannelPayload.Redaction redaction = 3;
+         */
+        value: ChannelPayload_Redaction;
+        case: "redaction";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.ChannelPayload.
+ * Use `create(ChannelPayloadSchema)` to create a new message.
+ */
+export declare const ChannelPayloadSchema: GenMessage<ChannelPayload>;
+/**
+ * @generated from message river.ChannelPayload.Snapshot
+ */
+export type ChannelPayload_Snapshot = Message<"river.ChannelPayload.Snapshot"> & {
+    /**
+     * inception
+     *
+     * @generated from field: river.ChannelPayload.Inception inception = 1;
+     */
+    inception?: ChannelPayload_Inception;
+};
+/**
+ * Describes the message river.ChannelPayload.Snapshot.
+ * Use `create(ChannelPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const ChannelPayload_SnapshotSchema: GenMessage<ChannelPayload_Snapshot>;
+/**
+ * @generated from message river.ChannelPayload.Inception
+ */
+export type ChannelPayload_Inception = Message<"river.ChannelPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: bytes space_id = 3;
+     */
+    spaceId: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 5;
+     */
+    settings?: StreamSettings;
+    /**
+     * @generated from field: river.SpacePayload.ChannelSettings channel_settings = 7;
+     */
+    channelSettings?: SpacePayload_ChannelSettings;
+};
+/**
+ * Describes the message river.ChannelPayload.Inception.
+ * Use `create(ChannelPayload_InceptionSchema)` to create a new message.
+ */
+export declare const ChannelPayload_InceptionSchema: GenMessage<ChannelPayload_Inception>;
+/**
+ * @generated from message river.ChannelPayload.Redaction
+ */
+export type ChannelPayload_Redaction = Message<"river.ChannelPayload.Redaction"> & {
+    /**
+     * @generated from field: bytes event_id = 1;
+     */
+    eventId: Uint8Array;
+};
+/**
+ * Describes the message river.ChannelPayload.Redaction.
+ * Use `create(ChannelPayload_RedactionSchema)` to create a new message.
+ */
+export declare const ChannelPayload_RedactionSchema: GenMessage<ChannelPayload_Redaction>;
+/**
+ * *
+ * DmChannelPayload
+ *
+ * @generated from message river.DmChannelPayload
+ */
+export type DmChannelPayload = Message<"river.DmChannelPayload"> & {
+    /**
+     * @generated from oneof river.DmChannelPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.DmChannelPayload.Inception inception = 1;
+         */
+        value: DmChannelPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData message = 3;
+         */
+        value: EncryptedData;
+        case: "message";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.DmChannelPayload.
+ * Use `create(DmChannelPayloadSchema)` to create a new message.
+ */
+export declare const DmChannelPayloadSchema: GenMessage<DmChannelPayload>;
+/**
+ * @generated from message river.DmChannelPayload.Snapshot
+ */
+export type DmChannelPayload_Snapshot = Message<"river.DmChannelPayload.Snapshot"> & {
+    /**
+     * @generated from field: river.DmChannelPayload.Inception inception = 1;
+     */
+    inception?: DmChannelPayload_Inception;
+};
+/**
+ * Describes the message river.DmChannelPayload.Snapshot.
+ * Use `create(DmChannelPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const DmChannelPayload_SnapshotSchema: GenMessage<DmChannelPayload_Snapshot>;
+/**
+ * @generated from message river.DmChannelPayload.Inception
+ */
+export type DmChannelPayload_Inception = Message<"river.DmChannelPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: bytes first_party_address = 2;
+     */
+    firstPartyAddress: Uint8Array;
+    /**
+     * @generated from field: bytes second_party_address = 3;
+     */
+    secondPartyAddress: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 4;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.DmChannelPayload.Inception.
+ * Use `create(DmChannelPayload_InceptionSchema)` to create a new message.
+ */
+export declare const DmChannelPayload_InceptionSchema: GenMessage<DmChannelPayload_Inception>;
+/**
+ * *
+ * GdmChannelPayload
+ *
+ * @generated from message river.GdmChannelPayload
+ */
+export type GdmChannelPayload = Message<"river.GdmChannelPayload"> & {
+    /**
+     * @generated from oneof river.GdmChannelPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.GdmChannelPayload.Inception inception = 1;
+         */
+        value: GdmChannelPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData message = 2;
+         */
+        value: EncryptedData;
+        case: "message";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData channel_properties = 3;
+         */
+        value: EncryptedData;
+        case: "channelProperties";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.GdmChannelPayload.
+ * Use `create(GdmChannelPayloadSchema)` to create a new message.
+ */
+export declare const GdmChannelPayloadSchema: GenMessage<GdmChannelPayload>;
+/**
+ * @generated from message river.GdmChannelPayload.Snapshot
+ */
+export type GdmChannelPayload_Snapshot = Message<"river.GdmChannelPayload.Snapshot"> & {
+    /**
+     * @generated from field: river.GdmChannelPayload.Inception inception = 1;
+     */
+    inception?: GdmChannelPayload_Inception;
+    /**
+     * @generated from field: river.WrappedEncryptedData channel_properties = 2;
+     */
+    channelProperties?: WrappedEncryptedData;
+};
+/**
+ * Describes the message river.GdmChannelPayload.Snapshot.
+ * Use `create(GdmChannelPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const GdmChannelPayload_SnapshotSchema: GenMessage<GdmChannelPayload_Snapshot>;
+/**
+ * @generated from message river.GdmChannelPayload.Inception
+ */
+export type GdmChannelPayload_Inception = Message<"river.GdmChannelPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.EncryptedData channel_properties = 2;
+     */
+    channelProperties?: EncryptedData;
+    /**
+     * @generated from field: river.StreamSettings settings = 3;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.GdmChannelPayload.Inception.
+ * Use `create(GdmChannelPayload_InceptionSchema)` to create a new message.
+ */
+export declare const GdmChannelPayload_InceptionSchema: GenMessage<GdmChannelPayload_Inception>;
+/**
+ * *
+ * UserPayload
+ *
+ * @generated from message river.UserPayload
+ */
+export type UserPayload = Message<"river.UserPayload"> & {
+    /**
+     * @generated from oneof river.UserPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.UserPayload.Inception inception = 1;
+         */
+        value: UserPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.UserPayload.UserMembership user_membership = 2;
+         */
+        value: UserPayload_UserMembership;
+        case: "userMembership";
+    } | {
+        /**
+         * @generated from field: river.UserPayload.UserMembershipAction user_membership_action = 3;
+         */
+        value: UserPayload_UserMembershipAction;
+        case: "userMembershipAction";
+    } | {
+        /**
+         * added by user
+         *
+         * @generated from field: river.BlockchainTransaction blockchain_transaction = 4;
+         */
+        value: BlockchainTransaction;
+        case: "blockchainTransaction";
+    } | {
+        /**
+         * added by nodes
+         *
+         * @generated from field: river.UserPayload.ReceivedBlockchainTransaction received_blockchain_transaction = 5;
+         */
+        value: UserPayload_ReceivedBlockchainTransaction;
+        case: "receivedBlockchainTransaction";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.UserPayload.
+ * Use `create(UserPayloadSchema)` to create a new message.
+ */
+export declare const UserPayloadSchema: GenMessage<UserPayload>;
+/**
+ * @generated from message river.UserPayload.Snapshot
+ */
+export type UserPayload_Snapshot = Message<"river.UserPayload.Snapshot"> & {
+    /**
+     * inception
+     *
+     * @generated from field: river.UserPayload.Inception inception = 1;
+     */
+    inception?: UserPayload_Inception;
+    /**
+     * memberships, sorted by stream_id
+     *
+     * @generated from field: repeated river.UserPayload.UserMembership memberships = 2;
+     */
+    memberships: UserPayload_UserMembership[];
+    /**
+     * tips sent by this user: map<currency, amount>
+     *
+     * @generated from field: map<string, uint64> tips_sent = 3;
+     */
+    tipsSent: {
+        [key: string]: bigint;
+    };
+    /**
+     * tips received by this user: map<currency, amount>
+     *
+     * @generated from field: map<string, uint64> tips_received = 4;
+     */
+    tipsReceived: {
+        [key: string]: bigint;
+    };
+};
+/**
+ * Describes the message river.UserPayload.Snapshot.
+ * Use `create(UserPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const UserPayload_SnapshotSchema: GenMessage<UserPayload_Snapshot>;
+/**
+ * @generated from message river.UserPayload.Inception
+ */
+export type UserPayload_Inception = Message<"river.UserPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 2;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.UserPayload.Inception.
+ * Use `create(UserPayload_InceptionSchema)` to create a new message.
+ */
+export declare const UserPayload_InceptionSchema: GenMessage<UserPayload_Inception>;
+/**
+ * update own membership
+ *
+ * @generated from message river.UserPayload.UserMembership
+ */
+export type UserPayload_UserMembership = Message<"river.UserPayload.UserMembership"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.MembershipOp op = 2;
+     */
+    op: MembershipOp;
+    /**
+     * @generated from field: optional bytes inviter = 3;
+     */
+    inviter?: Uint8Array;
+    /**
+     * @generated from field: optional bytes stream_parent_id = 4;
+     */
+    streamParentId?: Uint8Array;
+};
+/**
+ * Describes the message river.UserPayload.UserMembership.
+ * Use `create(UserPayload_UserMembershipSchema)` to create a new message.
+ */
+export declare const UserPayload_UserMembershipSchema: GenMessage<UserPayload_UserMembership>;
+/**
+ * update someone else's membership
+ *
+ * @generated from message river.UserPayload.UserMembershipAction
+ */
+export type UserPayload_UserMembershipAction = Message<"river.UserPayload.UserMembershipAction"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: bytes user_id = 2;
+     */
+    userId: Uint8Array;
+    /**
+     * @generated from field: river.MembershipOp op = 3;
+     */
+    op: MembershipOp;
+    /**
+     * @generated from field: optional bytes stream_parent_id = 4;
+     */
+    streamParentId?: Uint8Array;
+};
+/**
+ * Describes the message river.UserPayload.UserMembershipAction.
+ * Use `create(UserPayload_UserMembershipActionSchema)` to create a new message.
+ */
+export declare const UserPayload_UserMembershipActionSchema: GenMessage<UserPayload_UserMembershipAction>;
+/**
+ * derived event, only send from nodes
+ *
+ * @generated from message river.UserPayload.ReceivedBlockchainTransaction
+ */
+export type UserPayload_ReceivedBlockchainTransaction = Message<"river.UserPayload.ReceivedBlockchainTransaction"> & {
+    /**
+     * @generated from field: river.BlockchainTransaction transaction = 1;
+     */
+    transaction?: BlockchainTransaction;
+    /**
+     * @generated from field: bytes from_user_address = 2;
+     */
+    fromUserAddress: Uint8Array;
+};
+/**
+ * Describes the message river.UserPayload.ReceivedBlockchainTransaction.
+ * Use `create(UserPayload_ReceivedBlockchainTransactionSchema)` to create a new message.
+ */
+export declare const UserPayload_ReceivedBlockchainTransactionSchema: GenMessage<UserPayload_ReceivedBlockchainTransaction>;
+/**
+ * *
+ * UserInboxPayload
+ * messages to a user encrypted per deviceId
+ *
+ * @generated from message river.UserInboxPayload
+ */
+export type UserInboxPayload = Message<"river.UserInboxPayload"> & {
+    /**
+     * @generated from oneof river.UserInboxPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.UserInboxPayload.Inception inception = 1;
+         */
+        value: UserInboxPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.UserInboxPayload.Ack ack = 2;
+         */
+        value: UserInboxPayload_Ack;
+        case: "ack";
+    } | {
+        /**
+         * @generated from field: river.UserInboxPayload.GroupEncryptionSessions group_encryption_sessions = 3;
+         */
+        value: UserInboxPayload_GroupEncryptionSessions;
+        case: "groupEncryptionSessions";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.UserInboxPayload.
+ * Use `create(UserInboxPayloadSchema)` to create a new message.
+ */
+export declare const UserInboxPayloadSchema: GenMessage<UserInboxPayload>;
+/**
+ * @generated from message river.UserInboxPayload.Snapshot
+ */
+export type UserInboxPayload_Snapshot = Message<"river.UserInboxPayload.Snapshot"> & {
+    /**
+     * @generated from field: river.UserInboxPayload.Inception inception = 1;
+     */
+    inception?: UserInboxPayload_Inception;
+    /**
+     * deviceKey: miniblockNum that the ack was snapshotted
+     *
+     * @generated from field: map<string, river.UserInboxPayload.Snapshot.DeviceSummary> device_summary = 2;
+     */
+    deviceSummary: {
+        [key: string]: UserInboxPayload_Snapshot_DeviceSummary;
+    };
+};
+/**
+ * Describes the message river.UserInboxPayload.Snapshot.
+ * Use `create(UserInboxPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const UserInboxPayload_SnapshotSchema: GenMessage<UserInboxPayload_Snapshot>;
+/**
+ * @generated from message river.UserInboxPayload.Snapshot.DeviceSummary
+ */
+export type UserInboxPayload_Snapshot_DeviceSummary = Message<"river.UserInboxPayload.Snapshot.DeviceSummary"> & {
+    /**
+     * *
+     * UpperBound = latest to device event sent from other client per deviceKey
+     * LowerBound = latest ack sent by stream owner per deviceKey
+     * on ack, if UpperBound <= LowerBound then delete this deviceKey entry from the record
+     * on ack or new session, if any device’s lower bound < N generations ago, delete the deviceKey entry from the record
+     *
+     * @generated from field: int64 lower_bound = 1;
+     */
+    lowerBound: bigint;
+    /**
+     * @generated from field: int64 upper_bound = 2;
+     */
+    upperBound: bigint;
+};
+/**
+ * Describes the message river.UserInboxPayload.Snapshot.DeviceSummary.
+ * Use `create(UserInboxPayload_Snapshot_DeviceSummarySchema)` to create a new message.
+ */
+export declare const UserInboxPayload_Snapshot_DeviceSummarySchema: GenMessage<UserInboxPayload_Snapshot_DeviceSummary>;
+/**
+ * @generated from message river.UserInboxPayload.Inception
+ */
+export type UserInboxPayload_Inception = Message<"river.UserInboxPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 2;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.UserInboxPayload.Inception.
+ * Use `create(UserInboxPayload_InceptionSchema)` to create a new message.
+ */
+export declare const UserInboxPayload_InceptionSchema: GenMessage<UserInboxPayload_Inception>;
+/**
+ * @generated from message river.UserInboxPayload.GroupEncryptionSessions
+ */
+export type UserInboxPayload_GroupEncryptionSessions = Message<"river.UserInboxPayload.GroupEncryptionSessions"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: string sender_key = 2;
+     */
+    senderKey: string;
+    /**
+     * @generated from field: repeated string session_ids = 3;
+     */
+    sessionIds: string[];
+    /**
+     * deviceKey: per device ciphertext of encrypted session keys that match session_ids
+     *
+     * @generated from field: map<string, string> ciphertexts = 4;
+     */
+    ciphertexts: {
+        [key: string]: string;
+    };
+    /**
+     * @generated from field: string algorithm = 5;
+     */
+    algorithm: string;
+};
+/**
+ * Describes the message river.UserInboxPayload.GroupEncryptionSessions.
+ * Use `create(UserInboxPayload_GroupEncryptionSessionsSchema)` to create a new message.
+ */
+export declare const UserInboxPayload_GroupEncryptionSessionsSchema: GenMessage<UserInboxPayload_GroupEncryptionSessions>;
+/**
+ * @generated from message river.UserInboxPayload.Ack
+ */
+export type UserInboxPayload_Ack = Message<"river.UserInboxPayload.Ack"> & {
+    /**
+     * @generated from field: string device_key = 1;
+     */
+    deviceKey: string;
+    /**
+     * @generated from field: int64 miniblock_num = 2;
+     */
+    miniblockNum: bigint;
+};
+/**
+ * Describes the message river.UserInboxPayload.Ack.
+ * Use `create(UserInboxPayload_AckSchema)` to create a new message.
+ */
+export declare const UserInboxPayload_AckSchema: GenMessage<UserInboxPayload_Ack>;
+/**
+ * *
+ * UserSettingsPayload
+ *
+ * @generated from message river.UserSettingsPayload
+ */
+export type UserSettingsPayload = Message<"river.UserSettingsPayload"> & {
+    /**
+     * @generated from oneof river.UserSettingsPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.UserSettingsPayload.Inception inception = 1;
+         */
+        value: UserSettingsPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.UserSettingsPayload.FullyReadMarkers fully_read_markers = 2;
+         */
+        value: UserSettingsPayload_FullyReadMarkers;
+        case: "fullyReadMarkers";
+    } | {
+        /**
+         * @generated from field: river.UserSettingsPayload.UserBlock user_block = 3;
+         */
+        value: UserSettingsPayload_UserBlock;
+        case: "userBlock";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.UserSettingsPayload.
+ * Use `create(UserSettingsPayloadSchema)` to create a new message.
+ */
+export declare const UserSettingsPayloadSchema: GenMessage<UserSettingsPayload>;
+/**
+ * @generated from message river.UserSettingsPayload.Snapshot
+ */
+export type UserSettingsPayload_Snapshot = Message<"river.UserSettingsPayload.Snapshot"> & {
+    /**
+     * inception
+     *
+     * @generated from field: river.UserSettingsPayload.Inception inception = 1;
+     */
+    inception?: UserSettingsPayload_Inception;
+    /**
+     * fullyReadMarkers: sorted by stream_id
+     *
+     * @generated from field: repeated river.UserSettingsPayload.FullyReadMarkers fully_read_markers = 2;
+     */
+    fullyReadMarkers: UserSettingsPayload_FullyReadMarkers[];
+    /**
+     * @generated from field: repeated river.UserSettingsPayload.Snapshot.UserBlocks user_blocks_list = 3;
+     */
+    userBlocksList: UserSettingsPayload_Snapshot_UserBlocks[];
+};
+/**
+ * Describes the message river.UserSettingsPayload.Snapshot.
+ * Use `create(UserSettingsPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_SnapshotSchema: GenMessage<UserSettingsPayload_Snapshot>;
+/**
+ * for a specific blocked user, there might be multiple block or unblock events
+ *
+ * @generated from message river.UserSettingsPayload.Snapshot.UserBlocks
+ */
+export type UserSettingsPayload_Snapshot_UserBlocks = Message<"river.UserSettingsPayload.Snapshot.UserBlocks"> & {
+    /**
+     * @generated from field: bytes user_id = 1;
+     */
+    userId: Uint8Array;
+    /**
+     * @generated from field: repeated river.UserSettingsPayload.Snapshot.UserBlocks.Block blocks = 2;
+     */
+    blocks: UserSettingsPayload_Snapshot_UserBlocks_Block[];
+};
+/**
+ * Describes the message river.UserSettingsPayload.Snapshot.UserBlocks.
+ * Use `create(UserSettingsPayload_Snapshot_UserBlocksSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_Snapshot_UserBlocksSchema: GenMessage<UserSettingsPayload_Snapshot_UserBlocks>;
+/**
+ * @generated from message river.UserSettingsPayload.Snapshot.UserBlocks.Block
+ */
+export type UserSettingsPayload_Snapshot_UserBlocks_Block = Message<"river.UserSettingsPayload.Snapshot.UserBlocks.Block"> & {
+    /**
+     * @generated from field: bool is_blocked = 1;
+     */
+    isBlocked: boolean;
+    /**
+     * @generated from field: int64 event_num = 2;
+     */
+    eventNum: bigint;
+};
+/**
+ * Describes the message river.UserSettingsPayload.Snapshot.UserBlocks.Block.
+ * Use `create(UserSettingsPayload_Snapshot_UserBlocks_BlockSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_Snapshot_UserBlocks_BlockSchema: GenMessage<UserSettingsPayload_Snapshot_UserBlocks_Block>;
+/**
+ * @generated from message river.UserSettingsPayload.Inception
+ */
+export type UserSettingsPayload_Inception = Message<"river.UserSettingsPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 2;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.UserSettingsPayload.Inception.
+ * Use `create(UserSettingsPayload_InceptionSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_InceptionSchema: GenMessage<UserSettingsPayload_Inception>;
+/**
+ * @generated from message river.UserSettingsPayload.MarkerContent
+ */
+export type UserSettingsPayload_MarkerContent = Message<"river.UserSettingsPayload.MarkerContent"> & {
+    /**
+     * @generated from field: string data = 1;
+     */
+    data: string;
+};
+/**
+ * Describes the message river.UserSettingsPayload.MarkerContent.
+ * Use `create(UserSettingsPayload_MarkerContentSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_MarkerContentSchema: GenMessage<UserSettingsPayload_MarkerContent>;
+/**
+ * @generated from message river.UserSettingsPayload.FullyReadMarkers
+ */
+export type UserSettingsPayload_FullyReadMarkers = Message<"river.UserSettingsPayload.FullyReadMarkers"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.UserSettingsPayload.MarkerContent content = 2;
+     */
+    content?: UserSettingsPayload_MarkerContent;
+};
+/**
+ * Describes the message river.UserSettingsPayload.FullyReadMarkers.
+ * Use `create(UserSettingsPayload_FullyReadMarkersSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_FullyReadMarkersSchema: GenMessage<UserSettingsPayload_FullyReadMarkers>;
+/**
+ * @generated from message river.UserSettingsPayload.UserBlock
+ */
+export type UserSettingsPayload_UserBlock = Message<"river.UserSettingsPayload.UserBlock"> & {
+    /**
+     * @generated from field: bytes user_id = 1;
+     */
+    userId: Uint8Array;
+    /**
+     * @generated from field: bool is_blocked = 2;
+     */
+    isBlocked: boolean;
+    /**
+     * @generated from field: int64 event_num = 3;
+     */
+    eventNum: bigint;
+};
+/**
+ * Describes the message river.UserSettingsPayload.UserBlock.
+ * Use `create(UserSettingsPayload_UserBlockSchema)` to create a new message.
+ */
+export declare const UserSettingsPayload_UserBlockSchema: GenMessage<UserSettingsPayload_UserBlock>;
+/**
+ * *
+ * UserMetadataPayload
+ *
+ * @generated from message river.UserMetadataPayload
+ */
+export type UserMetadataPayload = Message<"river.UserMetadataPayload"> & {
+    /**
+     * @generated from oneof river.UserMetadataPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.UserMetadataPayload.Inception inception = 1;
+         */
+        value: UserMetadataPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.UserMetadataPayload.EncryptionDevice encryption_device = 2;
+         */
+        value: UserMetadataPayload_EncryptionDevice;
+        case: "encryptionDevice";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData profile_image = 3;
+         */
+        value: EncryptedData;
+        case: "profileImage";
+    } | {
+        /**
+         * @generated from field: river.EncryptedData bio = 4;
+         */
+        value: EncryptedData;
+        case: "bio";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.UserMetadataPayload.
+ * Use `create(UserMetadataPayloadSchema)` to create a new message.
+ */
+export declare const UserMetadataPayloadSchema: GenMessage<UserMetadataPayload>;
+/**
+ * @generated from message river.UserMetadataPayload.Snapshot
+ */
+export type UserMetadataPayload_Snapshot = Message<"river.UserMetadataPayload.Snapshot"> & {
+    /**
+     * inception
+     *
+     * @generated from field: river.UserMetadataPayload.Inception inception = 1;
+     */
+    inception?: UserMetadataPayload_Inception;
+    /**
+     * device keys for this user, unique by device_key, capped at N, most recent last
+     *
+     * @generated from field: repeated river.UserMetadataPayload.EncryptionDevice encryption_devices = 2;
+     */
+    encryptionDevices: UserMetadataPayload_EncryptionDevice[];
+    /**
+     * user profile image
+     *
+     * @generated from field: river.WrappedEncryptedData profile_image = 3;
+     */
+    profileImage?: WrappedEncryptedData;
+    /**
+     * user bio
+     *
+     * @generated from field: river.WrappedEncryptedData bio = 4;
+     */
+    bio?: WrappedEncryptedData;
+};
+/**
+ * Describes the message river.UserMetadataPayload.Snapshot.
+ * Use `create(UserMetadataPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const UserMetadataPayload_SnapshotSchema: GenMessage<UserMetadataPayload_Snapshot>;
+/**
+ * @generated from message river.UserMetadataPayload.Inception
+ */
+export type UserMetadataPayload_Inception = Message<"river.UserMetadataPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.StreamSettings settings = 2;
+     */
+    settings?: StreamSettings;
+};
+/**
+ * Describes the message river.UserMetadataPayload.Inception.
+ * Use `create(UserMetadataPayload_InceptionSchema)` to create a new message.
+ */
+export declare const UserMetadataPayload_InceptionSchema: GenMessage<UserMetadataPayload_Inception>;
+/**
+ * @generated from message river.UserMetadataPayload.EncryptionDevice
+ */
+export type UserMetadataPayload_EncryptionDevice = Message<"river.UserMetadataPayload.EncryptionDevice"> & {
+    /**
+     * @generated from field: string device_key = 1;
+     */
+    deviceKey: string;
+    /**
+     * @generated from field: string fallback_key = 2;
+     */
+    fallbackKey: string;
+};
+/**
+ * Describes the message river.UserMetadataPayload.EncryptionDevice.
+ * Use `create(UserMetadataPayload_EncryptionDeviceSchema)` to create a new message.
+ */
+export declare const UserMetadataPayload_EncryptionDeviceSchema: GenMessage<UserMetadataPayload_EncryptionDevice>;
+/**
+ * *
+ * MediaPayload
+ *
+ * @generated from message river.MediaPayload
+ */
+export type MediaPayload = Message<"river.MediaPayload"> & {
+    /**
+     * @generated from oneof river.MediaPayload.content
+     */
+    content: {
+        /**
+         * @generated from field: river.MediaPayload.Inception inception = 1;
+         */
+        value: MediaPayload_Inception;
+        case: "inception";
+    } | {
+        /**
+         * @generated from field: river.MediaPayload.Chunk chunk = 2;
+         */
+        value: MediaPayload_Chunk;
+        case: "chunk";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.MediaPayload.
+ * Use `create(MediaPayloadSchema)` to create a new message.
+ */
+export declare const MediaPayloadSchema: GenMessage<MediaPayload>;
+/**
+ * @generated from message river.MediaPayload.Snapshot
+ */
+export type MediaPayload_Snapshot = Message<"river.MediaPayload.Snapshot"> & {
+    /**
+     * @generated from field: river.MediaPayload.Inception inception = 1;
+     */
+    inception?: MediaPayload_Inception;
+};
+/**
+ * Describes the message river.MediaPayload.Snapshot.
+ * Use `create(MediaPayload_SnapshotSchema)` to create a new message.
+ */
+export declare const MediaPayload_SnapshotSchema: GenMessage<MediaPayload_Snapshot>;
+/**
+ * @generated from message river.MediaPayload.Inception
+ */
+export type MediaPayload_Inception = Message<"river.MediaPayload.Inception"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: optional bytes channel_id = 2;
+     */
+    channelId?: Uint8Array;
+    /**
+     * @generated from field: int32 chunk_count = 3;
+     */
+    chunkCount: number;
+    /**
+     * @generated from field: river.StreamSettings settings = 4;
+     */
+    settings?: StreamSettings;
+    /**
+     * @generated from field: optional bytes space_id = 5;
+     */
+    spaceId?: Uint8Array;
+    /**
+     * @generated from field: optional bytes user_id = 6;
+     */
+    userId?: Uint8Array;
+    /**
+     * Setting for enabling per chunk encryption for media payloads.
+     * Meaning, the given media stream has each chunk individually encrypted
+     * rather than encrypting the full data and splitting into chunks.
+     *
+     * @generated from field: optional bool per_chunk_encryption = 7;
+     */
+    perChunkEncryption?: boolean;
+};
+/**
+ * Describes the message river.MediaPayload.Inception.
+ * Use `create(MediaPayload_InceptionSchema)` to create a new message.
+ */
+export declare const MediaPayload_InceptionSchema: GenMessage<MediaPayload_Inception>;
+/**
+ * @generated from message river.MediaPayload.Chunk
+ */
+export type MediaPayload_Chunk = Message<"river.MediaPayload.Chunk"> & {
+    /**
+     * @generated from field: bytes data = 1;
+     */
+    data: Uint8Array;
+    /**
+     * @generated from field: int32 chunk_index = 2;
+     */
+    chunkIndex: number;
+    /**
+     * @generated from field: optional bytes iv = 3;
+     */
+    iv?: Uint8Array;
+};
+/**
+ * Describes the message river.MediaPayload.Chunk.
+ * Use `create(MediaPayload_ChunkSchema)` to create a new message.
+ */
+export declare const MediaPayload_ChunkSchema: GenMessage<MediaPayload_Chunk>;
+/**
+ * *
+ * Snapshot contains a summary of all state events up to the most recent miniblock
+ *
+ * @generated from message river.Snapshot
+ */
+export type Snapshot = Message<"river.Snapshot"> & {
+    /**
+     * @generated from field: river.MemberPayload.Snapshot members = 1;
+     */
+    members?: MemberPayload_Snapshot;
+    /**
+     * @generated from field: int32 snapshot_version = 2;
+     */
+    snapshotVersion: number;
+    /**
+     * Snapshot data specific for each stream type.
+     *
+     * @generated from oneof river.Snapshot.content
+     */
+    content: {
+        /**
+         * @generated from field: river.SpacePayload.Snapshot space_content = 101;
+         */
+        value: SpacePayload_Snapshot;
+        case: "spaceContent";
+    } | {
+        /**
+         * @generated from field: river.ChannelPayload.Snapshot channel_content = 102;
+         */
+        value: ChannelPayload_Snapshot;
+        case: "channelContent";
+    } | {
+        /**
+         * @generated from field: river.UserPayload.Snapshot user_content = 103;
+         */
+        value: UserPayload_Snapshot;
+        case: "userContent";
+    } | {
+        /**
+         * @generated from field: river.UserSettingsPayload.Snapshot user_settings_content = 104;
+         */
+        value: UserSettingsPayload_Snapshot;
+        case: "userSettingsContent";
+    } | {
+        /**
+         * @generated from field: river.UserMetadataPayload.Snapshot user_metadata_content = 105;
+         */
+        value: UserMetadataPayload_Snapshot;
+        case: "userMetadataContent";
+    } | {
+        /**
+         * @generated from field: river.MediaPayload.Snapshot media_content = 106;
+         */
+        value: MediaPayload_Snapshot;
+        case: "mediaContent";
+    } | {
+        /**
+         * @generated from field: river.DmChannelPayload.Snapshot dm_channel_content = 107;
+         */
+        value: DmChannelPayload_Snapshot;
+        case: "dmChannelContent";
+    } | {
+        /**
+         * @generated from field: river.GdmChannelPayload.Snapshot gdm_channel_content = 108;
+         */
+        value: GdmChannelPayload_Snapshot;
+        case: "gdmChannelContent";
+    } | {
+        /**
+         * @generated from field: river.UserInboxPayload.Snapshot user_inbox_content = 109;
+         */
+        value: UserInboxPayload_Snapshot;
+        case: "userInboxContent";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.Snapshot.
+ * Use `create(SnapshotSchema)` to create a new message.
+ */
+export declare const SnapshotSchema: GenMessage<Snapshot>;
+/**
+ * @generated from message river.BlockchainTransaction
+ */
+export type BlockchainTransaction = Message<"river.BlockchainTransaction"> & {
+    /**
+     * required fields
+     *
+     * @generated from field: river.BlockchainTransactionReceipt receipt = 1;
+     */
+    receipt?: BlockchainTransactionReceipt;
+    /**
+     * @generated from field: river.SolanaBlockchainTransactionReceipt solana_receipt = 2;
+     */
+    solanaReceipt?: SolanaBlockchainTransactionReceipt;
+    /**
+     * optional metadata to be verified by the node
+     *
+     * @generated from oneof river.BlockchainTransaction.content
+     */
+    content: {
+        /**
+         * @generated from field: river.BlockchainTransaction.Tip tip = 101;
+         */
+        value: BlockchainTransaction_Tip;
+        case: "tip";
+    } | {
+        /**
+         * @generated from field: river.BlockchainTransaction.TokenTransfer token_transfer = 102;
+         */
+        value: BlockchainTransaction_TokenTransfer;
+        case: "tokenTransfer";
+    } | {
+        /**
+         * @generated from field: river.BlockchainTransaction.SpaceReview space_review = 103;
+         */
+        value: BlockchainTransaction_SpaceReview;
+        case: "spaceReview";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message river.BlockchainTransaction.
+ * Use `create(BlockchainTransactionSchema)` to create a new message.
+ */
+export declare const BlockchainTransactionSchema: GenMessage<BlockchainTransaction>;
+/**
+ * metadata for tip transactions
+ *
+ * @generated from message river.BlockchainTransaction.Tip
+ */
+export type BlockchainTransaction_Tip = Message<"river.BlockchainTransaction.Tip"> & {
+    /**
+     * event emitted by the tipping facet
+     *
+     * @generated from field: river.BlockchainTransaction.Tip.Event event = 1;
+     */
+    event?: BlockchainTransaction_Tip_Event;
+    /**
+     * user that received funds
+     *
+     * @generated from field: bytes toUserAddress = 2;
+     */
+    toUserAddress: Uint8Array;
+};
+/**
+ * Describes the message river.BlockchainTransaction.Tip.
+ * Use `create(BlockchainTransaction_TipSchema)` to create a new message.
+ */
+export declare const BlockchainTransaction_TipSchema: GenMessage<BlockchainTransaction_Tip>;
+/**
+ * @generated from message river.BlockchainTransaction.Tip.Event
+ */
+export type BlockchainTransaction_Tip_Event = Message<"river.BlockchainTransaction.Tip.Event"> & {
+    /**
+     * @generated from field: uint64 token_id = 1;
+     */
+    tokenId: bigint;
+    /**
+     * @generated from field: bytes currency = 2;
+     */
+    currency: Uint8Array;
+    /**
+     * wallet that sent funds
+     *
+     * @generated from field: bytes sender = 3;
+     */
+    sender: Uint8Array;
+    /**
+     * wallet that received funds
+     *
+     * @generated from field: bytes receiver = 4;
+     */
+    receiver: Uint8Array;
+    /**
+     * @generated from field: uint64 amount = 5;
+     */
+    amount: bigint;
+    /**
+     * @generated from field: bytes message_id = 6;
+     */
+    messageId: Uint8Array;
+    /**
+     * @generated from field: bytes channel_id = 7;
+     */
+    channelId: Uint8Array;
+};
+/**
+ * Describes the message river.BlockchainTransaction.Tip.Event.
+ * Use `create(BlockchainTransaction_Tip_EventSchema)` to create a new message.
+ */
+export declare const BlockchainTransaction_Tip_EventSchema: GenMessage<BlockchainTransaction_Tip_Event>;
+/**
+ * @generated from message river.BlockchainTransaction.TokenTransfer
+ */
+export type BlockchainTransaction_TokenTransfer = Message<"river.BlockchainTransaction.TokenTransfer"> & {
+    /**
+     * @generated from field: bytes address = 1;
+     */
+    address: Uint8Array;
+    /**
+     * uint64 isn't big enough
+     *
+     * @generated from field: string amount = 2;
+     */
+    amount: string;
+    /**
+     * @generated from field: bytes sender = 3;
+     */
+    sender: Uint8Array;
+    /**
+     * @generated from field: bytes message_id = 4;
+     */
+    messageId: Uint8Array;
+    /**
+     * @generated from field: bytes channel_id = 5;
+     */
+    channelId: Uint8Array;
+    /**
+     * @generated from field: bool is_buy = 6;
+     */
+    isBuy: boolean;
+};
+/**
+ * Describes the message river.BlockchainTransaction.TokenTransfer.
+ * Use `create(BlockchainTransaction_TokenTransferSchema)` to create a new message.
+ */
+export declare const BlockchainTransaction_TokenTransferSchema: GenMessage<BlockchainTransaction_TokenTransfer>;
+/**
+ * @generated from message river.BlockchainTransaction.SpaceReview
+ */
+export type BlockchainTransaction_SpaceReview = Message<"river.BlockchainTransaction.SpaceReview"> & {
+    /**
+     * space that was reviewed
+     *
+     * @generated from field: bytes space_address = 1;
+     */
+    spaceAddress: Uint8Array;
+    /**
+     * action that was taken (add, update, delete)
+     *
+     * @generated from field: river.BlockchainTransaction.SpaceReview.Action action = 2;
+     */
+    action: BlockchainTransaction_SpaceReview_Action;
+    /**
+     * event emitted by the space review facet
+     *
+     * @generated from field: river.BlockchainTransaction.SpaceReview.Event event = 3;
+     */
+    event?: BlockchainTransaction_SpaceReview_Event;
+};
+/**
+ * Describes the message river.BlockchainTransaction.SpaceReview.
+ * Use `create(BlockchainTransaction_SpaceReviewSchema)` to create a new message.
+ */
+export declare const BlockchainTransaction_SpaceReviewSchema: GenMessage<BlockchainTransaction_SpaceReview>;
+/**
+ * @generated from message river.BlockchainTransaction.SpaceReview.Event
+ */
+export type BlockchainTransaction_SpaceReview_Event = Message<"river.BlockchainTransaction.SpaceReview.Event"> & {
+    /**
+     * @generated from field: bytes user = 1;
+     */
+    user: Uint8Array;
+    /**
+     * the comment can be found in the receipt logs
+     *
+     * @generated from field: int32 rating = 2;
+     */
+    rating: number;
+};
+/**
+ * Describes the message river.BlockchainTransaction.SpaceReview.Event.
+ * Use `create(BlockchainTransaction_SpaceReview_EventSchema)` to create a new message.
+ */
+export declare const BlockchainTransaction_SpaceReview_EventSchema: GenMessage<BlockchainTransaction_SpaceReview_Event>;
+/**
+ * @generated from enum river.BlockchainTransaction.SpaceReview.Action
+ */
+export declare enum BlockchainTransaction_SpaceReview_Action {
+    /**
+     * @generated from enum value: Add = 0;
+     */
+    Add = 0,
+    /**
+     * @generated from enum value: Update = 1;
+     */
+    Update = 1,
+    /**
+     * @generated from enum value: Delete = 2;
+     */
+    Delete = 2
+}
+/**
+ * Describes the enum river.BlockchainTransaction.SpaceReview.Action.
+ */
+export declare const BlockchainTransaction_SpaceReview_ActionSchema: GenEnum<BlockchainTransaction_SpaceReview_Action>;
+/**
+ * * blockchain transaction receipt
+ *
+ * @generated from message river.BlockchainTransactionReceipt
+ */
+export type BlockchainTransactionReceipt = Message<"river.BlockchainTransactionReceipt"> & {
+    /**
+     * @generated from field: uint64 chain_id = 1;
+     */
+    chainId: bigint;
+    /**
+     * @generated from field: bytes transaction_hash = 2;
+     */
+    transactionHash: Uint8Array;
+    /**
+     * @generated from field: uint64 block_number = 3;
+     */
+    blockNumber: bigint;
+    /**
+     * @generated from field: bytes to = 4;
+     */
+    to: Uint8Array;
+    /**
+     * @generated from field: bytes from = 5;
+     */
+    from: Uint8Array;
+    /**
+     * @generated from field: repeated river.BlockchainTransactionReceipt.Log logs = 6;
+     */
+    logs: BlockchainTransactionReceipt_Log[];
+};
+/**
+ * Describes the message river.BlockchainTransactionReceipt.
+ * Use `create(BlockchainTransactionReceiptSchema)` to create a new message.
+ */
+export declare const BlockchainTransactionReceiptSchema: GenMessage<BlockchainTransactionReceipt>;
+/**
+ * @generated from message river.BlockchainTransactionReceipt.Log
+ */
+export type BlockchainTransactionReceipt_Log = Message<"river.BlockchainTransactionReceipt.Log"> & {
+    /**
+     * @generated from field: bytes address = 1;
+     */
+    address: Uint8Array;
+    /**
+     * @generated from field: repeated bytes topics = 2;
+     */
+    topics: Uint8Array[];
+    /**
+     * @generated from field: bytes data = 3;
+     */
+    data: Uint8Array;
+};
+/**
+ * Describes the message river.BlockchainTransactionReceipt.Log.
+ * Use `create(BlockchainTransactionReceipt_LogSchema)` to create a new message.
+ */
+export declare const BlockchainTransactionReceipt_LogSchema: GenMessage<BlockchainTransactionReceipt_Log>;
+/**
+ * @generated from message river.SolanaBlockchainTransactionReceipt
+ */
+export type SolanaBlockchainTransactionReceipt = Message<"river.SolanaBlockchainTransactionReceipt"> & {
+    /**
+     * @generated from field: uint64 slot = 1;
+     */
+    slot: bigint;
+    /**
+     * @generated from field: river.SolanaBlockchainTransactionReceipt.Transaction transaction = 2;
+     */
+    transaction?: SolanaBlockchainTransactionReceipt_Transaction;
+    /**
+     * @generated from field: river.SolanaBlockchainTransactionReceipt.Meta meta = 3;
+     */
+    meta?: SolanaBlockchainTransactionReceipt_Meta;
+};
+/**
+ * Describes the message river.SolanaBlockchainTransactionReceipt.
+ * Use `create(SolanaBlockchainTransactionReceiptSchema)` to create a new message.
+ */
+export declare const SolanaBlockchainTransactionReceiptSchema: GenMessage<SolanaBlockchainTransactionReceipt>;
+/**
+ * @generated from message river.SolanaBlockchainTransactionReceipt.Transaction
+ */
+export type SolanaBlockchainTransactionReceipt_Transaction = Message<"river.SolanaBlockchainTransactionReceipt.Transaction"> & {
+    /**
+     * @generated from field: repeated string signatures = 1;
+     */
+    signatures: string[];
+};
+/**
+ * Describes the message river.SolanaBlockchainTransactionReceipt.Transaction.
+ * Use `create(SolanaBlockchainTransactionReceipt_TransactionSchema)` to create a new message.
+ */
+export declare const SolanaBlockchainTransactionReceipt_TransactionSchema: GenMessage<SolanaBlockchainTransactionReceipt_Transaction>;
+/**
+ * @generated from message river.SolanaBlockchainTransactionReceipt.Meta
+ */
+export type SolanaBlockchainTransactionReceipt_Meta = Message<"river.SolanaBlockchainTransactionReceipt.Meta"> & {
+    /**
+     * @generated from field: repeated river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance pre_token_balances = 1;
+     */
+    preTokenBalances: SolanaBlockchainTransactionReceipt_Meta_TokenBalance[];
+    /**
+     * @generated from field: repeated river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance post_token_balances = 2;
+     */
+    postTokenBalances: SolanaBlockchainTransactionReceipt_Meta_TokenBalance[];
+};
+/**
+ * Describes the message river.SolanaBlockchainTransactionReceipt.Meta.
+ * Use `create(SolanaBlockchainTransactionReceipt_MetaSchema)` to create a new message.
+ */
+export declare const SolanaBlockchainTransactionReceipt_MetaSchema: GenMessage<SolanaBlockchainTransactionReceipt_Meta>;
+/**
+ * @generated from message river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance
+ */
+export type SolanaBlockchainTransactionReceipt_Meta_TokenBalance = Message<"river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance"> & {
+    /**
+     * @generated from field: string mint = 1;
+     */
+    mint: string;
+    /**
+     * @generated from field: string owner = 2;
+     */
+    owner: string;
+    /**
+     * @generated from field: river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance.UITokenAmount amount = 3;
+     */
+    amount?: SolanaBlockchainTransactionReceipt_Meta_TokenBalance_UITokenAmount;
+};
+/**
+ * Describes the message river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance.
+ * Use `create(SolanaBlockchainTransactionReceipt_Meta_TokenBalanceSchema)` to create a new message.
+ */
+export declare const SolanaBlockchainTransactionReceipt_Meta_TokenBalanceSchema: GenMessage<SolanaBlockchainTransactionReceipt_Meta_TokenBalance>;
+/**
+ * @generated from message river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance.UITokenAmount
+ */
+export type SolanaBlockchainTransactionReceipt_Meta_TokenBalance_UITokenAmount = Message<"river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance.UITokenAmount"> & {
+    /**
+     * @generated from field: string amount = 1;
+     */
+    amount: string;
+    /**
+     * @generated from field: uint32 decimals = 2;
+     */
+    decimals: number;
+};
+/**
+ * Describes the message river.SolanaBlockchainTransactionReceipt.Meta.TokenBalance.UITokenAmount.
+ * Use `create(SolanaBlockchainTransactionReceipt_Meta_TokenBalance_UITokenAmountSchema)` to create a new message.
+ */
+export declare const SolanaBlockchainTransactionReceipt_Meta_TokenBalance_UITokenAmountSchema: GenMessage<SolanaBlockchainTransactionReceipt_Meta_TokenBalance_UITokenAmount>;
+/**
+ * *
+ * A derived event is produced by the server when there should be an additional event to compliment the
+ * received event. For example, when a user joins a space through an event in the space stream,
+ * the server will produce a derived event in the user stream to indicate that the user joined a
+ * particular space.
+ *
+ * EventRef is used to reference the event that caused the derived event to be produced.
+ *
+ * @generated from message river.EventRef
+ */
+export type EventRef = Message<"river.EventRef"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: bytes hash = 2;
+     */
+    hash: Uint8Array;
+    /**
+     * @generated from field: bytes signature = 3;
+     */
+    signature: Uint8Array;
+};
+/**
+ * Describes the message river.EventRef.
+ * Use `create(EventRefSchema)` to create a new message.
+ */
+export declare const EventRefSchema: GenMessage<EventRef>;
+/**
+ * *
+ * StreamSettings is a part of inception payload for each stream type.
+ *
+ * @generated from message river.StreamSettings
+ */
+export type StreamSettings = Message<"river.StreamSettings"> & {
+    /**
+     * Test setting for testing with manual miniblock creation through Info debug request.
+     *
+     * @generated from field: bool disable_miniblock_creation = 1;
+     */
+    disableMiniblockCreation: boolean;
+};
+/**
+ * Describes the message river.StreamSettings.
+ * Use `create(StreamSettingsSchema)` to create a new message.
+ */
+export declare const StreamSettingsSchema: GenMessage<StreamSettings>;
+/**
+ * *
+ * EncryptedData
+ *
+ * @generated from message river.EncryptedData
+ */
+export type EncryptedData = Message<"river.EncryptedData"> & {
+    /**
+     * *
+     * Ciphertext of the encryption envelope.
+     *
+     * @generated from field: string ciphertext = 1;
+     */
+    ciphertext: string;
+    /**
+     * *
+     * Encryption algorithm  used to encrypt this event.
+     *
+     * @generated from field: string algorithm = 2;
+     */
+    algorithm: string;
+    /**
+     * *
+     * Sender device public key identifying the sender's device.
+     *
+     * @generated from field: string sender_key = 3;
+     */
+    senderKey: string;
+    /**
+     * *
+     * The ID of the session used to encrypt the message in some protocols,
+     * deprecated in favor of session_id_bytes.
+     *
+     * @generated from field: string session_id = 4;
+     */
+    sessionId: string;
+    /**
+     * *
+     * Optional checksum of the cleartext data.
+     *
+     * @generated from field: optional string checksum = 5;
+     */
+    checksum?: string;
+    /**
+     * *
+     * Optional reference to parent event ID
+     *
+     * @generated from field: optional string ref_event_id = 6;
+     */
+    refEventId?: string;
+    /**
+     * Used if algorithm is set to 'grpaes'
+     *
+     * @generated from field: bytes ciphertext_bytes = 8;
+     */
+    ciphertextBytes: Uint8Array;
+    /**
+     * Used if algorithm is set to 'grpaes'
+     *
+     * @generated from field: bytes iv_bytes = 9;
+     */
+    ivBytes: Uint8Array;
+    /**
+     * Used if algorithm is set to 'grpaes'
+     *
+     * @generated from field: bytes session_id_bytes = 10;
+     */
+    sessionIdBytes: Uint8Array;
+    /**
+     * used to parse data after it's decrypted
+     *
+     * @generated from field: river.EncryptedDataVersion version = 11;
+     */
+    version: EncryptedDataVersion;
+};
+/**
+ * Describes the message river.EncryptedData.
+ * Use `create(EncryptedDataSchema)` to create a new message.
+ */
+export declare const EncryptedDataSchema: GenMessage<EncryptedData>;
+/**
+ * @generated from message river.WrappedEncryptedData
+ */
+export type WrappedEncryptedData = Message<"river.WrappedEncryptedData"> & {
+    /**
+     * @generated from field: river.EncryptedData data = 1;
+     */
+    data?: EncryptedData;
+    /**
+     * @generated from field: int64 event_num = 2;
+     */
+    eventNum: bigint;
+    /**
+     * @generated from field: bytes event_hash = 3;
+     */
+    eventHash: Uint8Array;
+};
+/**
+ * Describes the message river.WrappedEncryptedData.
+ * Use `create(WrappedEncryptedDataSchema)` to create a new message.
+ */
+export declare const WrappedEncryptedDataSchema: GenMessage<WrappedEncryptedData>;
+/**
+ * @generated from message river.SyncCookie
+ */
+export type SyncCookie = Message<"river.SyncCookie"> & {
+    /**
+     * @generated from field: bytes node_address = 1;
+     */
+    nodeAddress: Uint8Array;
+    /**
+     * @generated from field: bytes stream_id = 2;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: int64 minipool_gen = 3;
+     */
+    minipoolGen: bigint;
+    /**
+     * @generated from field: bytes prev_miniblock_hash = 5;
+     */
+    prevMiniblockHash: Uint8Array;
+};
+/**
+ * Describes the message river.SyncCookie.
+ * Use `create(SyncCookieSchema)` to create a new message.
+ */
+export declare const SyncCookieSchema: GenMessage<SyncCookie>;
+/**
+ * @generated from message river.CreationCookie
+ */
+export type CreationCookie = Message<"river.CreationCookie"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: repeated bytes nodes = 2;
+     */
+    nodes: Uint8Array[];
+    /**
+     * @generated from field: int64 miniblock_num = 3;
+     */
+    miniblockNum: bigint;
+    /**
+     * @generated from field: bytes prev_miniblock_hash = 4;
+     */
+    prevMiniblockHash: Uint8Array;
+};
+/**
+ * Describes the message river.CreationCookie.
+ * Use `create(CreationCookieSchema)` to create a new message.
+ */
+export declare const CreationCookieSchema: GenMessage<CreationCookie>;
+/**
+ * @generated from message river.StreamAndCookie
+ */
+export type StreamAndCookie = Message<"river.StreamAndCookie"> & {
+    /**
+     * @generated from field: repeated river.Envelope events = 1;
+     */
+    events: Envelope[];
+    /**
+     * @generated from field: river.SyncCookie next_sync_cookie = 2;
+     */
+    nextSyncCookie?: SyncCookie;
+    /**
+     * if non-empty, contains all blocks since the latest snapshot
+     *
+     * @generated from field: repeated river.Miniblock miniblocks = 3;
+     */
+    miniblocks: Miniblock[];
+    /**
+     * @generated from field: bool sync_reset = 4;
+     */
+    syncReset: boolean;
+    /**
+     * if non-empty, contains the latest snapshot of the stream
+     *
+     * @generated from field: optional river.Envelope snapshot = 5;
+     */
+    snapshot?: Envelope;
+};
+/**
+ * Describes the message river.StreamAndCookie.
+ * Use `create(StreamAndCookieSchema)` to create a new message.
+ */
+export declare const StreamAndCookieSchema: GenMessage<StreamAndCookie>;
+/**
+ * @generated from message river.Minipool
+ */
+export type Minipool = Message<"river.Minipool"> & {
+    /**
+     * @generated from field: repeated river.Envelope events = 1;
+     */
+    events: Envelope[];
+};
+/**
+ * Describes the message river.Minipool.
+ * Use `create(MinipoolSchema)` to create a new message.
+ */
+export declare const MinipoolSchema: GenMessage<Minipool>;
+/**
+ * @generated from message river.Tags
+ */
+export type Tags = Message<"river.Tags"> & {
+    /**
+     * @generated from field: river.MessageInteractionType message_interaction_type = 1;
+     */
+    messageInteractionType: MessageInteractionType;
+    /**
+     * @generated from field: repeated river.GroupMentionType group_mention_types = 2;
+     */
+    groupMentionTypes: GroupMentionType[];
+    /**
+     * @generated from field: repeated bytes mentioned_user_addresses = 3;
+     */
+    mentionedUserAddresses: Uint8Array[];
+    /**
+     * @generated from field: repeated bytes participating_user_addresses = 4;
+     */
+    participatingUserAddresses: Uint8Array[];
+    /**
+     * @generated from field: optional bytes thread_id = 5;
+     */
+    threadId?: Uint8Array;
+};
+/**
+ * Describes the message river.Tags.
+ * Use `create(TagsSchema)` to create a new message.
+ */
+export declare const TagsSchema: GenMessage<Tags>;
+/**
+ * @generated from message river.InfoRequest
+ */
+export type InfoRequest = Message<"river.InfoRequest"> & {
+    /**
+     * @generated from field: repeated string debug = 1;
+     */
+    debug: string[];
+};
+/**
+ * Describes the message river.InfoRequest.
+ * Use `create(InfoRequestSchema)` to create a new message.
+ */
+export declare const InfoRequestSchema: GenMessage<InfoRequest>;
+/**
+ * @generated from message river.InfoResponse
+ */
+export type InfoResponse = Message<"river.InfoResponse"> & {
+    /**
+     * @generated from field: string graffiti = 1;
+     */
+    graffiti: string;
+    /**
+     * @generated from field: google.protobuf.Timestamp start_time = 2;
+     */
+    startTime?: Timestamp;
+    /**
+     * @generated from field: string version = 3;
+     */
+    version: string;
+};
+/**
+ * Describes the message river.InfoResponse.
+ * Use `create(InfoResponseSchema)` to create a new message.
+ */
+export declare const InfoResponseSchema: GenMessage<InfoResponse>;
+/**
+ * @generated from message river.GetStreamExRequest
+ */
+export type GetStreamExRequest = Message<"river.GetStreamExRequest"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: bool omit_snapshot = 2;
+     */
+    omitSnapshot: boolean;
+};
+/**
+ * Describes the message river.GetStreamExRequest.
+ * Use `create(GetStreamExRequestSchema)` to create a new message.
+ */
+export declare const GetStreamExRequestSchema: GenMessage<GetStreamExRequest>;
+/**
+ * GetStreamExResponse is a stream of raw data that represents the current state of the requested stream.
+ * These responses represent streams that are not expected to change once finalized, and have a optimized code path
+ * for retrieval. Response may potentially be very large, and are streamed back to the client. The client is expected
+ * to martial the raw data back into protobuf messages.
+ *
+ * @generated from message river.GetStreamExResponse
+ */
+export type GetStreamExResponse = Message<"river.GetStreamExResponse"> & {
+    /**
+     * @generated from oneof river.GetStreamExResponse.data
+     */
+    data: {
+        /**
+         * @generated from field: river.Miniblock miniblock = 1;
+         */
+        value: Miniblock;
+        case: "miniblock";
+    } | {
+        /**
+         * @generated from field: river.Minipool minipool = 2;
+         */
+        value: Minipool;
+        case: "minipool";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    /**
+     * @generated from field: optional river.Envelope snapshot = 3;
+     */
+    snapshot?: Envelope;
+};
+/**
+ * Describes the message river.GetStreamExResponse.
+ * Use `create(GetStreamExResponseSchema)` to create a new message.
+ */
+export declare const GetStreamExResponseSchema: GenMessage<GetStreamExResponse>;
+/**
+ * @generated from message river.CreateStreamRequest
+ */
+export type CreateStreamRequest = Message<"river.CreateStreamRequest"> & {
+    /**
+     * @generated from field: repeated river.Envelope events = 1;
+     */
+    events: Envelope[];
+    /**
+     * stream_id should match the stream_id in the inception payload of the first event
+     *
+     * @generated from field: bytes stream_id = 2;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: map<string, bytes> metadata = 3;
+     */
+    metadata: {
+        [key: string]: Uint8Array;
+    };
+};
+/**
+ * Describes the message river.CreateStreamRequest.
+ * Use `create(CreateStreamRequestSchema)` to create a new message.
+ */
+export declare const CreateStreamRequestSchema: GenMessage<CreateStreamRequest>;
+/**
+ * @generated from message river.CreateStreamResponse
+ */
+export type CreateStreamResponse = Message<"river.CreateStreamResponse"> & {
+    /**
+     * all events in current minipool and cookie allowing to sync from the end of the stream
+     *
+     * @generated from field: river.StreamAndCookie stream = 1;
+     */
+    stream?: StreamAndCookie;
+    /**
+     * derived events created in other streams when this stream was created
+     *
+     * @generated from field: repeated river.EventRef derived_events = 2;
+     */
+    derivedEvents: EventRef[];
+};
+/**
+ * Describes the message river.CreateStreamResponse.
+ * Use `create(CreateStreamResponseSchema)` to create a new message.
+ */
+export declare const CreateStreamResponseSchema: GenMessage<CreateStreamResponse>;
+/**
+ * @generated from message river.CreateMediaStreamRequest
+ */
+export type CreateMediaStreamRequest = Message<"river.CreateMediaStreamRequest"> & {
+    /**
+     * @generated from field: repeated river.Envelope events = 1;
+     */
+    events: Envelope[];
+    /**
+     * stream_id should match the stream_id in the inception payload of the first event
+     *
+     * @generated from field: bytes stream_id = 2;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: map<string, bytes> metadata = 3;
+     */
+    metadata: {
+        [key: string]: Uint8Array;
+    };
+};
+/**
+ * Describes the message river.CreateMediaStreamRequest.
+ * Use `create(CreateMediaStreamRequestSchema)` to create a new message.
+ */
+export declare const CreateMediaStreamRequestSchema: GenMessage<CreateMediaStreamRequest>;
+/**
+ * @generated from message river.CreateMediaStreamResponse
+ */
+export type CreateMediaStreamResponse = Message<"river.CreateMediaStreamResponse"> & {
+    /**
+     * @generated from field: river.CreationCookie next_creation_cookie = 1;
+     */
+    nextCreationCookie?: CreationCookie;
+};
+/**
+ * Describes the message river.CreateMediaStreamResponse.
+ * Use `create(CreateMediaStreamResponseSchema)` to create a new message.
+ */
+export declare const CreateMediaStreamResponseSchema: GenMessage<CreateMediaStreamResponse>;
+/**
+ * @generated from message river.GetStreamRequest
+ */
+export type GetStreamRequest = Message<"river.GetStreamRequest"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * if optional is true and stream doesn't exist, response will be a nil stream instead of ERROR NOT_FOUND
+     *
+     * @generated from field: bool optional = 2;
+     */
+    optional: boolean;
+    /**
+     * if a sync cookie is provided, the response will be a delta from the sync cookie
+     * or a new sync cookie with sync_reset set to true if the stream has advanced far enough
+     *
+     * @generated from field: river.SyncCookie sync_cookie = 3;
+     */
+    syncCookie?: SyncCookie;
+};
+/**
+ * Describes the message river.GetStreamRequest.
+ * Use `create(GetStreamRequestSchema)` to create a new message.
+ */
+export declare const GetStreamRequestSchema: GenMessage<GetStreamRequest>;
+/**
+ * @generated from message river.GetStreamResponse
+ */
+export type GetStreamResponse = Message<"river.GetStreamResponse"> & {
+    /**
+     * all events in current minipool and cookie allowing to sync from the end of the stream
+     *
+     * @generated from field: river.StreamAndCookie stream = 1;
+     */
+    stream?: StreamAndCookie;
+};
+/**
+ * Describes the message river.GetStreamResponse.
+ * Use `create(GetStreamResponseSchema)` to create a new message.
+ */
+export declare const GetStreamResponseSchema: GenMessage<GetStreamResponse>;
+/**
+ * @generated from message river.GetMiniblocksRequest
+ */
+export type GetMiniblocksRequest = Message<"river.GetMiniblocksRequest"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: int64 from_inclusive = 2;
+     */
+    fromInclusive: bigint;
+    /**
+     * @generated from field: int64 to_exclusive = 3;
+     */
+    toExclusive: bigint;
+    /**
+     * @generated from field: bool omit_snapshots = 4;
+     */
+    omitSnapshots: boolean;
+};
+/**
+ * Describes the message river.GetMiniblocksRequest.
+ * Use `create(GetMiniblocksRequestSchema)` to create a new message.
+ */
+export declare const GetMiniblocksRequestSchema: GenMessage<GetMiniblocksRequest>;
+/**
+ * @generated from message river.GetMiniblocksResponse
+ */
+export type GetMiniblocksResponse = Message<"river.GetMiniblocksResponse"> & {
+    /**
+     * @generated from field: repeated river.Miniblock miniblocks = 1;
+     */
+    miniblocks: Miniblock[];
+    /**
+     * terminus: true if there are no more blocks to fetch because they've been garbage collected, or you've reached block 0
+     *
+     * @generated from field: bool terminus = 2;
+     */
+    terminus: boolean;
+    /**
+     * @generated from field: int64 from_inclusive = 3;
+     */
+    fromInclusive: bigint;
+    /**
+     * @generated from field: int64 limit = 4;
+     */
+    limit: bigint;
+    /**
+     * @generated from field: bool omit_snapshots = 5;
+     */
+    omitSnapshots: boolean;
+    /**
+     * @generated from field: map<int64, river.Envelope> snapshots = 6;
+     */
+    snapshots: {
+        [key: string]: Envelope;
+    };
+};
+/**
+ * Describes the message river.GetMiniblocksResponse.
+ * Use `create(GetMiniblocksResponseSchema)` to create a new message.
+ */
+export declare const GetMiniblocksResponseSchema: GenMessage<GetMiniblocksResponse>;
+/**
+ * @generated from message river.GetLastMiniblockHashRequest
+ */
+export type GetLastMiniblockHashRequest = Message<"river.GetLastMiniblockHashRequest"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+};
+/**
+ * Describes the message river.GetLastMiniblockHashRequest.
+ * Use `create(GetLastMiniblockHashRequestSchema)` to create a new message.
+ */
+export declare const GetLastMiniblockHashRequestSchema: GenMessage<GetLastMiniblockHashRequest>;
+/**
+ * @generated from message river.GetLastMiniblockHashResponse
+ */
+export type GetLastMiniblockHashResponse = Message<"river.GetLastMiniblockHashResponse"> & {
+    /**
+     * @generated from field: bytes hash = 1;
+     */
+    hash: Uint8Array;
+    /**
+     * @generated from field: int64 miniblock_num = 2;
+     */
+    miniblockNum: bigint;
+};
+/**
+ * Describes the message river.GetLastMiniblockHashResponse.
+ * Use `create(GetLastMiniblockHashResponseSchema)` to create a new message.
+ */
+export declare const GetLastMiniblockHashResponseSchema: GenMessage<GetLastMiniblockHashResponse>;
+/**
+ * @generated from message river.AddEventRequest
+ */
+export type AddEventRequest = Message<"river.AddEventRequest"> & {
+    /**
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * @generated from field: river.Envelope event = 2;
+     */
+    event?: Envelope;
+    /**
+     * if true, response will contain non nil error if event didn't pass validation
+     *
+     * @generated from field: bool optional = 3;
+     */
+    optional: boolean;
+};
+/**
+ * Describes the message river.AddEventRequest.
+ * Use `create(AddEventRequestSchema)` to create a new message.
+ */
+export declare const AddEventRequestSchema: GenMessage<AddEventRequest>;
+/**
+ * @generated from message river.AddEventResponse
+ */
+export type AddEventResponse = Message<"river.AddEventResponse"> & {
+    /**
+     * error thrown during this request, only set if AddEventRequest.optional is true, otherwise the request will fail with this error
+     *
+     * @generated from field: river.AddEventResponse.Error error = 1;
+     */
+    error?: AddEventResponse_Error;
+    /**
+     * all events created during this request including parent events
+     *
+     * @generated from field: repeated river.EventRef new_events = 2;
+     */
+    newEvents: EventRef[];
+};
+/**
+ * Describes the message river.AddEventResponse.
+ * Use `create(AddEventResponseSchema)` to create a new message.
+ */
+export declare const AddEventResponseSchema: GenMessage<AddEventResponse>;
+/**
+ * @generated from message river.AddEventResponse.Error
+ */
+export type AddEventResponse_Error = Message<"river.AddEventResponse.Error"> & {
+    /**
+     * @generated from field: river.Err code = 1;
+     */
+    code: Err;
+    /**
+     * @generated from field: string msg = 2;
+     */
+    msg: string;
+    /**
+     * @generated from field: repeated string funcs = 3;
+     */
+    funcs: string[];
+};
+/**
+ * Describes the message river.AddEventResponse.Error.
+ * Use `create(AddEventResponse_ErrorSchema)` to create a new message.
+ */
+export declare const AddEventResponse_ErrorSchema: GenMessage<AddEventResponse_Error>;
+/**
+ * @generated from message river.AddMediaEventRequest
+ */
+export type AddMediaEventRequest = Message<"river.AddMediaEventRequest"> & {
+    /**
+     * @generated from field: river.Envelope event = 1;
+     */
+    event?: Envelope;
+    /**
+     * @generated from field: river.CreationCookie creation_cookie = 2;
+     */
+    creationCookie?: CreationCookie;
+    /**
+     * @generated from field: bool last = 3;
+     */
+    last: boolean;
+};
+/**
+ * Describes the message river.AddMediaEventRequest.
+ * Use `create(AddMediaEventRequestSchema)` to create a new message.
+ */
+export declare const AddMediaEventRequestSchema: GenMessage<AddMediaEventRequest>;
+/**
+ * @generated from message river.AddMediaEventResponse
+ */
+export type AddMediaEventResponse = Message<"river.AddMediaEventResponse"> & {
+    /**
+     * @generated from field: river.CreationCookie creation_cookie = 1;
+     */
+    creationCookie?: CreationCookie;
+};
+/**
+ * Describes the message river.AddMediaEventResponse.
+ * Use `create(AddMediaEventResponseSchema)` to create a new message.
+ */
+export declare const AddMediaEventResponseSchema: GenMessage<AddMediaEventResponse>;
+/**
+ * SyncStreamsRequest is a request to start a streams sync session.
+ *
+ * @generated from message river.SyncStreamsRequest
+ */
+export type SyncStreamsRequest = Message<"river.SyncStreamsRequest"> & {
+    /**
+     * sync_pos is the list of streams and positions in those streams to receive updates from.
+     *
+     * @generated from field: repeated river.SyncCookie sync_pos = 1;
+     */
+    syncPos: SyncCookie[];
+};
+/**
+ * Describes the message river.SyncStreamsRequest.
+ * Use `create(SyncStreamsRequestSchema)` to create a new message.
+ */
+export declare const SyncStreamsRequestSchema: GenMessage<SyncStreamsRequest>;
+/**
+ * SyncStreamsResponse is a stream of updates that the client receives for streams it subscribed to within a streams
+ * sync session.
+ *
+ * @generated from message river.SyncStreamsResponse
+ */
+export type SyncStreamsResponse = Message<"river.SyncStreamsResponse"> & {
+    /**
+     * sync_id is the id of the sync session.
+     *
+     * @generated from field: string sync_id = 1;
+     */
+    syncId: string;
+    /**
+     * sync_op marks the type of update.
+     *
+     * @generated from field: river.SyncOp sync_op = 2;
+     */
+    syncOp: SyncOp;
+    /**
+     * stream indicates an update of a stream.
+     * only set when sync_op = SYNC_UPDATE
+     *
+     * @generated from field: river.StreamAndCookie stream = 3;
+     */
+    stream?: StreamAndCookie;
+    /**
+     * pong_nonce is returned after a ping request was made to the sync session through PingSync.
+     * Set with the ping value from the PingSync request when sync_op = SYNC_PONG
+     *
+     * @generated from field: string pong_nonce = 4;
+     */
+    pongNonce: string;
+    /**
+     * stream_id is set when sync_op = SYNC_DOWN and indicates it will not receive updates anymore for this stream.
+     * If the client is still is interested in updates for this stream it must re-add the stream to the sync session.
+     *
+     * @generated from field: bytes stream_id = 5;
+     */
+    streamId: Uint8Array;
+};
+/**
+ * Describes the message river.SyncStreamsResponse.
+ * Use `create(SyncStreamsResponseSchema)` to create a new message.
+ */
+export declare const SyncStreamsResponseSchema: GenMessage<SyncStreamsResponse>;
+/**
+ * AddStreamToSyncRequest is a request to add a stream to an existing streams sync session.
+ *
+ * @generated from message river.AddStreamToSyncRequest
+ */
+export type AddStreamToSyncRequest = Message<"river.AddStreamToSyncRequest"> & {
+    /**
+     * sync_id is the id of the sync session.
+     *
+     * @generated from field: string sync_id = 1;
+     */
+    syncId: string;
+    /**
+     * sync_pos identifies the stream and position in the stream to receive updates from.
+     *
+     * @generated from field: river.SyncCookie sync_pos = 2;
+     */
+    syncPos?: SyncCookie;
+};
+/**
+ * Describes the message river.AddStreamToSyncRequest.
+ * Use `create(AddStreamToSyncRequestSchema)` to create a new message.
+ */
+export declare const AddStreamToSyncRequestSchema: GenMessage<AddStreamToSyncRequest>;
+/**
+ * @generated from message river.AddStreamToSyncResponse
+ */
+export type AddStreamToSyncResponse = Message<"river.AddStreamToSyncResponse"> & {};
+/**
+ * Describes the message river.AddStreamToSyncResponse.
+ * Use `create(AddStreamToSyncResponseSchema)` to create a new message.
+ */
+export declare const AddStreamToSyncResponseSchema: GenMessage<AddStreamToSyncResponse>;
+/**
+ * RemoveStreamFromSyncRequest stops the client to receive updates from this stream in the sync session.
+ * Note that due to buffering in the stream it is possible still receives several updates for this stream after it was
+ * removed.
+ *
+ * @generated from message river.RemoveStreamFromSyncRequest
+ */
+export type RemoveStreamFromSyncRequest = Message<"river.RemoveStreamFromSyncRequest"> & {
+    /**
+     * @generated from field: string sync_id = 1;
+     */
+    syncId: string;
+    /**
+     * @generated from field: bytes stream_id = 2;
+     */
+    streamId: Uint8Array;
+};
+/**
+ * Describes the message river.RemoveStreamFromSyncRequest.
+ * Use `create(RemoveStreamFromSyncRequestSchema)` to create a new message.
+ */
+export declare const RemoveStreamFromSyncRequestSchema: GenMessage<RemoveStreamFromSyncRequest>;
+/**
+ * @generated from message river.RemoveStreamFromSyncResponse
+ */
+export type RemoveStreamFromSyncResponse = Message<"river.RemoveStreamFromSyncResponse"> & {};
+/**
+ * Describes the message river.RemoveStreamFromSyncResponse.
+ * Use `create(RemoveStreamFromSyncResponseSchema)` to create a new message.
+ */
+export declare const RemoveStreamFromSyncResponseSchema: GenMessage<RemoveStreamFromSyncResponse>;
+/**
+ * ModifySyncRequest adds or removes streams from an existing sync session.
+ *
+ * @generated from message river.ModifySyncRequest
+ */
+export type ModifySyncRequest = Message<"river.ModifySyncRequest"> & {
+    /**
+     * sync_id is the id of the sync session.
+     *
+     * @generated from field: string sync_id = 1;
+     */
+    syncId: string;
+    /**
+     * add_streams contains the stream cookies for streams to add to the stream sync session.
+     *
+     * @generated from field: repeated river.SyncCookie add_streams = 2;
+     */
+    addStreams: SyncCookie[];
+    /**
+     * remove_streams contains the stream id's to remove from the sync session.
+     *
+     * @generated from field: repeated bytes remove_streams = 3;
+     */
+    removeStreams: Uint8Array[];
+};
+/**
+ * Describes the message river.ModifySyncRequest.
+ * Use `create(ModifySyncRequestSchema)` to create a new message.
+ */
+export declare const ModifySyncRequestSchema: GenMessage<ModifySyncRequest>;
+/**
+ * SyncStreamOpStatus contains details why adding or removing a stream to/from a sync session failed.
+ *
+ * @generated from message river.SyncStreamOpStatus
+ */
+export type SyncStreamOpStatus = Message<"river.SyncStreamOpStatus"> & {
+    /**
+     * stream_id that failed to add/remove to/from the sync session.
+     *
+     * @generated from field: bytes stream_id = 1;
+     */
+    streamId: Uint8Array;
+    /**
+     * code represents the error code
+     *
+     * @generated from field: int32 code = 2;
+     */
+    code: number;
+    /**
+     * message describing what happened
+     *
+     * @generated from field: string message = 3;
+     */
+    message: string;
+};
+/**
+ * Describes the message river.SyncStreamOpStatus.
+ * Use `create(SyncStreamOpStatusSchema)` to create a new message.
+ */
+export declare const SyncStreamOpStatusSchema: GenMessage<SyncStreamOpStatus>;
+/**
+ * ModifySyncResponse contains the details of a stream sync modification request.
+ *
+ * @generated from message river.ModifySyncResponse
+ */
+export type ModifySyncResponse = Message<"river.ModifySyncResponse"> & {
+    /**
+     * List with streams that failed to add to the sync operation.
+     *
+     * @generated from field: repeated river.SyncStreamOpStatus adds = 1;
+     */
+    adds: SyncStreamOpStatus[];
+    /**
+     * List with streams that failed to be removed from the sync operation.
+     *
+     * @generated from field: repeated river.SyncStreamOpStatus removals = 2;
+     */
+    removals: SyncStreamOpStatus[];
+};
+/**
+ * Describes the message river.ModifySyncResponse.
+ * Use `create(ModifySyncResponseSchema)` to create a new message.
+ */
+export declare const ModifySyncResponseSchema: GenMessage<ModifySyncResponse>;
+/**
+ * CancelSyncRequest cancels the sync session.
+ *
+ * @generated from message river.CancelSyncRequest
+ */
+export type CancelSyncRequest = Message<"river.CancelSyncRequest"> & {
+    /**
+     * sync_id is the unique id of the sync session.
+     *
+     * @generated from field: string sync_id = 1;
+     */
+    syncId: string;
+};
+/**
+ * Describes the message river.CancelSyncRequest.
+ * Use `create(CancelSyncRequestSchema)` to create a new message.
+ */
+export declare const CancelSyncRequestSchema: GenMessage<CancelSyncRequest>;
+/**
+ * @generated from message river.CancelSyncResponse
+ */
+export type CancelSyncResponse = Message<"river.CancelSyncResponse"> & {};
+/**
+ * Describes the message river.CancelSyncResponse.
+ * Use `create(CancelSyncResponseSchema)` to create a new message.
+ */
+export declare const CancelSyncResponseSchema: GenMessage<CancelSyncResponse>;
+/**
+ * PingSyncRequest is a request to receive a pong in the sync session stream.
+ *
+ * @generated from message river.PingSyncRequest
+ */
+export type PingSyncRequest = Message<"river.PingSyncRequest"> & {
+    /**
+     * sync_id is the unique id of the sync session.
+     *
+     * @generated from field: string sync_id = 1;
+     */
+    syncId: string;
+    /**
+     * nonce is the pong to return in the sync session stream.
+     *
+     * @generated from field: string nonce = 2;
+     */
+    nonce: string;
+};
+/**
+ * Describes the message river.PingSyncRequest.
+ * Use `create(PingSyncRequestSchema)` to create a new message.
+ */
+export declare const PingSyncRequestSchema: GenMessage<PingSyncRequest>;
+/**
+ * @generated from message river.PingSyncResponse
+ */
+export type PingSyncResponse = Message<"river.PingSyncResponse"> & {};
+/**
+ * Describes the message river.PingSyncResponse.
+ * Use `create(PingSyncResponseSchema)` to create a new message.
+ */
+export declare const PingSyncResponseSchema: GenMessage<PingSyncResponse>;
+/**
+ * @generated from enum river.SyncOp
+ */
+export declare enum SyncOp {
+    /**
+     * @generated from enum value: SYNC_UNSPECIFIED = 0;
+     */
+    SYNC_UNSPECIFIED = 0,
+    /**
+     * new sync
+     *
+     * @generated from enum value: SYNC_NEW = 1;
+     */
+    SYNC_NEW = 1,
+    /**
+     * close the sync
+     *
+     * @generated from enum value: SYNC_CLOSE = 2;
+     */
+    SYNC_CLOSE = 2,
+    /**
+     * update from server
+     *
+     * @generated from enum value: SYNC_UPDATE = 3;
+     */
+    SYNC_UPDATE = 3,
+    /**
+     * respond to the ping message from the client.
+     *
+     * @generated from enum value: SYNC_PONG = 4;
+     */
+    SYNC_PONG = 4,
+    /**
+     * indication that stream updates could (temporarily) not be provided
+     *
+     * @generated from enum value: SYNC_DOWN = 5;
+     */
+    SYNC_DOWN = 5
+}
+/**
+ * Describes the enum river.SyncOp.
+ */
+export declare const SyncOpSchema: GenEnum<SyncOp>;
+/**
+ * @generated from enum river.MembershipOp
+ */
+export declare enum MembershipOp {
+    /**
+     * @generated from enum value: SO_UNSPECIFIED = 0;
+     */
+    SO_UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: SO_INVITE = 1;
+     */
+    SO_INVITE = 1,
+    /**
+     * @generated from enum value: SO_JOIN = 2;
+     */
+    SO_JOIN = 2,
+    /**
+     * @generated from enum value: SO_LEAVE = 3;
+     */
+    SO_LEAVE = 3
+}
+/**
+ * Describes the enum river.MembershipOp.
+ */
+export declare const MembershipOpSchema: GenEnum<MembershipOp>;
+/**
+ * @generated from enum river.ChannelOp
+ */
+export declare enum ChannelOp {
+    /**
+     * @generated from enum value: CO_UNSPECIFIED = 0;
+     */
+    CO_UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: CO_CREATED = 1;
+     */
+    CO_CREATED = 1,
+    /**
+     * @generated from enum value: CO_DELETED = 2;
+     */
+    CO_DELETED = 2,
+    /**
+     * @generated from enum value: CO_UPDATED = 4;
+     */
+    CO_UPDATED = 4
+}
+/**
+ * Describes the enum river.ChannelOp.
+ */
+export declare const ChannelOpSchema: GenEnum<ChannelOp>;
+/**
+ * @generated from enum river.MessageInteractionType
+ */
+export declare enum MessageInteractionType {
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_REPLY = 1;
+     */
+    REPLY = 1,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_REACTION = 2;
+     */
+    REACTION = 2,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_POST = 3;
+     */
+    POST = 3,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_EDIT = 4;
+     */
+    EDIT = 4,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_REDACTION = 5;
+     */
+    REDACTION = 5,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_TIP = 6;
+     */
+    TIP = 6,
+    /**
+     * @generated from enum value: MESSAGE_INTERACTION_TYPE_TRADE = 7;
+     */
+    TRADE = 7
+}
+/**
+ * Describes the enum river.MessageInteractionType.
+ */
+export declare const MessageInteractionTypeSchema: GenEnum<MessageInteractionType>;
+/**
+ * @generated from enum river.GroupMentionType
+ */
+export declare enum GroupMentionType {
+    /**
+     * @generated from enum value: GROUP_MENTION_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: GROUP_MENTION_TYPE_AT_CHANNEL = 1;
+     */
+    AT_CHANNEL = 1
+}
+/**
+ * Describes the enum river.GroupMentionType.
+ */
+export declare const GroupMentionTypeSchema: GenEnum<GroupMentionType>;
+/**
+ * @generated from enum river.EncryptedDataVersion
+ */
+export declare enum EncryptedDataVersion {
+    /**
+     * @generated from enum value: ENCRYPTED_DATA_VERSION_0 = 0;
+     */
+    ENCRYPTED_DATA_VERSION_0 = 0,
+    /**
+     * @generated from enum value: ENCRYPTED_DATA_VERSION_1 = 1;
+     */
+    ENCRYPTED_DATA_VERSION_1 = 1
+}
+/**
+ * Describes the enum river.EncryptedDataVersion.
+ */
+export declare const EncryptedDataVersionSchema: GenEnum<EncryptedDataVersion>;
+/**
+ * Codes from 1 to 16 match gRPC/Connect codes.
+ *
+ * @generated from enum river.Err
+ */
+export declare enum Err {
+    /**
+     * @generated from enum value: ERR_UNSPECIFIED = 0;
+     */
+    ERR_UNSPECIFIED = 0,
+    /**
+     * Canceled indicates that the operation was canceled, typically by the
+     * caller.
+     *
+     * @generated from enum value: CANCELED = 1;
+     */
+    CANCELED = 1,
+    /**
+     * Unknown indicates that the operation failed for an unknown reason.
+     *
+     * @generated from enum value: UNKNOWN = 2;
+     */
+    UNKNOWN = 2,
+    /**
+     * InvalidArgument indicates that client supplied an invalid argument.
+     *
+     * @generated from enum value: INVALID_ARGUMENT = 3;
+     */
+    INVALID_ARGUMENT = 3,
+    /**
+     * DeadlineExceeded indicates that deadline expired before the operation
+     * could complete.
+     *
+     * @generated from enum value: DEADLINE_EXCEEDED = 4;
+     */
+    DEADLINE_EXCEEDED = 4,
+    /**
+     * NotFound indicates that some requested entity (for example, a file or
+     * directory) was not found.
+     *
+     * @generated from enum value: NOT_FOUND = 5;
+     */
+    NOT_FOUND = 5,
+    /**
+     * AlreadyExists indicates that client attempted to create an entity (for
+     * example, a file or directory) that already exists.
+     *
+     * @generated from enum value: ALREADY_EXISTS = 6;
+     */
+    ALREADY_EXISTS = 6,
+    /**
+     * PermissionDenied indicates that the caller doesn't have permission to
+     * execute the specified operation.
+     *
+     * @generated from enum value: PERMISSION_DENIED = 7;
+     */
+    PERMISSION_DENIED = 7,
+    /**
+     * ResourceExhausted indicates that some resource has been exhausted. For
+     * example, a per-user quota may be exhausted or the entire file system may
+     * be full.
+     *
+     * @generated from enum value: RESOURCE_EXHAUSTED = 8;
+     */
+    RESOURCE_EXHAUSTED = 8,
+    /**
+     * FailedPrecondition indicates that the system is not in a state
+     * required for the operation's execution.
+     *
+     * @generated from enum value: FAILED_PRECONDITION = 9;
+     */
+    FAILED_PRECONDITION = 9,
+    /**
+     * Aborted indicates that operation was aborted by the system, usually
+     * because of a concurrency issue such as a sequencer check failure or
+     * transaction abort.
+     *
+     * @generated from enum value: ABORTED = 10;
+     */
+    ABORTED = 10,
+    /**
+     * OutOfRange indicates that the operation was attempted past the valid
+     * range (for example, seeking past end-of-file).
+     *
+     * @generated from enum value: OUT_OF_RANGE = 11;
+     */
+    OUT_OF_RANGE = 11,
+    /**
+     * Unimplemented indicates that the operation isn't implemented,
+     * supported, or enabled in this service.
+     *
+     * @generated from enum value: UNIMPLEMENTED = 12;
+     */
+    UNIMPLEMENTED = 12,
+    /**
+     * Internal indicates that some invariants expected by the underlying
+     * system have been broken. This code is reserved for serious errors.
+     *
+     * @generated from enum value: INTERNAL = 13;
+     */
+    INTERNAL = 13,
+    /**
+     * Unavailable indicates that the service is currently unavailable. This
+     * is usually temporary, so clients can back off and retry idempotent
+     * operations.
+     *
+     * @generated from enum value: UNAVAILABLE = 14;
+     */
+    UNAVAILABLE = 14,
+    /**
+     * DataLoss indicates that the operation has resulted in unrecoverable
+     * data loss or corruption.
+     *
+     * @generated from enum value: DATA_LOSS = 15;
+     */
+    DATA_LOSS = 15,
+    /**
+     * Unauthenticated indicates that the request does not have valid
+     * authentication credentials for the operation.
+     *
+     * @generated from enum value: UNAUTHENTICATED = 16;
+     */
+    UNAUTHENTICATED = 16,
+    /**
+     * @generated from enum value: DEBUG_ERROR = 17;
+     */
+    DEBUG_ERROR = 17,
+    /**
+     * @generated from enum value: BAD_STREAM_ID = 18;
+     */
+    BAD_STREAM_ID = 18,
+    /**
+     * @generated from enum value: BAD_STREAM_CREATION_PARAMS = 19;
+     */
+    BAD_STREAM_CREATION_PARAMS = 19,
+    /**
+     * @generated from enum value: INTERNAL_ERROR_SWITCH = 20;
+     */
+    INTERNAL_ERROR_SWITCH = 20,
+    /**
+     * @generated from enum value: BAD_EVENT_ID = 21;
+     */
+    BAD_EVENT_ID = 21,
+    /**
+     * @generated from enum value: BAD_EVENT_SIGNATURE = 22;
+     */
+    BAD_EVENT_SIGNATURE = 22,
+    /**
+     * @generated from enum value: BAD_HASH_FORMAT = 23;
+     */
+    BAD_HASH_FORMAT = 23,
+    /**
+     * @generated from enum value: BAD_PREV_MINIBLOCK_HASH = 24;
+     */
+    BAD_PREV_MINIBLOCK_HASH = 24,
+    /**
+     * @generated from enum value: NO_EVENT_SPECIFIED = 25;
+     */
+    NO_EVENT_SPECIFIED = 25,
+    /**
+     * @generated from enum value: BAD_EVENT = 26;
+     */
+    BAD_EVENT = 26,
+    /**
+     * @generated from enum value: USER_CANT_POST = 27;
+     */
+    USER_CANT_POST = 27,
+    /**
+     * @generated from enum value: STREAM_BAD_HASHES = 28;
+     */
+    STREAM_BAD_HASHES = 28,
+    /**
+     * @generated from enum value: STREAM_EMPTY = 29;
+     */
+    STREAM_EMPTY = 29,
+    /**
+     * @generated from enum value: STREAM_BAD_EVENT = 30;
+     */
+    STREAM_BAD_EVENT = 30,
+    /**
+     * @generated from enum value: BAD_DELEGATE_SIG = 31;
+     */
+    BAD_DELEGATE_SIG = 31,
+    /**
+     * @generated from enum value: BAD_PUBLIC_KEY = 32;
+     */
+    BAD_PUBLIC_KEY = 32,
+    /**
+     * @generated from enum value: BAD_PAYLOAD = 33;
+     */
+    BAD_PAYLOAD = 33,
+    /**
+     * @generated from enum value: BAD_HEX_STRING = 34;
+     */
+    BAD_HEX_STRING = 34,
+    /**
+     * @generated from enum value: BAD_EVENT_HASH = 35;
+     */
+    BAD_EVENT_HASH = 35,
+    /**
+     * @generated from enum value: BAD_SYNC_COOKIE = 36;
+     */
+    BAD_SYNC_COOKIE = 36,
+    /**
+     * @generated from enum value: DUPLICATE_EVENT = 37;
+     */
+    DUPLICATE_EVENT = 37,
+    /**
+     * @generated from enum value: BAD_BLOCK = 38;
+     */
+    BAD_BLOCK = 38,
+    /**
+     * @generated from enum value: STREAM_NO_INCEPTION_EVENT = 39;
+     */
+    STREAM_NO_INCEPTION_EVENT = 39,
+    /**
+     * @generated from enum value: BAD_BLOCK_NUMBER = 40;
+     */
+    BAD_BLOCK_NUMBER = 40,
+    /**
+     * @generated from enum value: BAD_MINIPOOL_SLOT = 41;
+     */
+    BAD_MINIPOOL_SLOT = 41,
+    /**
+     * @generated from enum value: BAD_CREATOR_ADDRESS = 42;
+     */
+    BAD_CREATOR_ADDRESS = 42,
+    /**
+     * @generated from enum value: STALE_DELEGATE = 43;
+     */
+    STALE_DELEGATE = 43,
+    /**
+     * @generated from enum value: BAD_LINK_WALLET_BAD_SIGNATURE = 44;
+     */
+    BAD_LINK_WALLET_BAD_SIGNATURE = 44,
+    /**
+     * @generated from enum value: BAD_ROOT_KEY_ID = 45;
+     */
+    BAD_ROOT_KEY_ID = 45,
+    /**
+     * @generated from enum value: UNKNOWN_NODE = 46;
+     */
+    UNKNOWN_NODE = 46,
+    /**
+     * @generated from enum value: DB_OPERATION_FAILURE = 47;
+     */
+    DB_OPERATION_FAILURE = 47,
+    /**
+     * @generated from enum value: MINIBLOCKS_STORAGE_FAILURE = 48;
+     */
+    MINIBLOCKS_STORAGE_FAILURE = 48,
+    /**
+     * @generated from enum value: BAD_ADDRESS = 49;
+     */
+    BAD_ADDRESS = 49,
+    /**
+     * @generated from enum value: BUFFER_FULL = 50;
+     */
+    BUFFER_FULL = 50,
+    /**
+     * @generated from enum value: BAD_CONFIG = 51;
+     */
+    BAD_CONFIG = 51,
+    /**
+     * @generated from enum value: BAD_CONTRACT = 52;
+     */
+    BAD_CONTRACT = 52,
+    /**
+     * @generated from enum value: CANNOT_CONNECT = 53;
+     */
+    CANNOT_CONNECT = 53,
+    /**
+     * @generated from enum value: CANNOT_GET_LINKED_WALLETS = 54;
+     */
+    CANNOT_GET_LINKED_WALLETS = 54,
+    /**
+     * @generated from enum value: CANNOT_CHECK_ENTITLEMENTS = 55;
+     */
+    CANNOT_CHECK_ENTITLEMENTS = 55,
+    /**
+     * @generated from enum value: CANNOT_CALL_CONTRACT = 56;
+     */
+    CANNOT_CALL_CONTRACT = 56,
+    /**
+     * @generated from enum value: SPACE_DISABLED = 57;
+     */
+    SPACE_DISABLED = 57,
+    /**
+     * @generated from enum value: CHANNEL_DISABLED = 58;
+     */
+    CHANNEL_DISABLED = 58,
+    /**
+     * @generated from enum value: WRONG_STREAM_TYPE = 59;
+     */
+    WRONG_STREAM_TYPE = 59,
+    /**
+     * @generated from enum value: MINIPOOL_MISSING_EVENTS = 60;
+     */
+    MINIPOOL_MISSING_EVENTS = 60,
+    /**
+     * @generated from enum value: STREAM_LAST_BLOCK_MISMATCH = 61;
+     */
+    STREAM_LAST_BLOCK_MISMATCH = 61,
+    /**
+     * @generated from enum value: DOWNSTREAM_NETWORK_ERROR = 62;
+     */
+    DOWNSTREAM_NETWORK_ERROR = 62,
+    /**
+     * Stream replica on the local node does not have miniblock with given number yet.
+     * This is a temporary state and the node will have the miniblock at a later point in time.
+     * The client should retry with an increasing delay, starting at 100ms.
+     *
+     * @generated from enum value: MINIBLOCK_TOO_NEW = 63;
+     */
+    MINIBLOCK_TOO_NEW = 63,
+    /**
+     * Stream replica on the local node already has a miniblock with the requested
+     * proposal number.
+     *
+     * @generated from enum value: MINIBLOCK_TOO_OLD = 64;
+     */
+    MINIBLOCK_TOO_OLD = 64,
+    /**
+     * Quorum failed to be reached for write operation.
+     *
+     * @generated from enum value: QUORUM_FAILED = 65;
+     */
+    QUORUM_FAILED = 65,
+    /**
+     * App webhook could not successfully be called.
+     *
+     * @generated from enum value: CANNOT_CALL_WEBHOOK = 66;
+     */
+    CANNOT_CALL_WEBHOOK = 66,
+    /**
+     * App webhook response was unparsable as JSON or did not match expected schema.
+     *
+     * @generated from enum value: MALFORMED_WEBHOOK_RESPONSE = 67;
+     */
+    MALFORMED_WEBHOOK_RESPONSE = 67,
+    /**
+     * The encryption device returned by the app service webhook does not match the first
+     * encryption device found in the app's user metadata stream.
+     *
+     * @generated from enum value: BAD_ENCRYPTION_DEVICE = 68;
+     */
+    BAD_ENCRYPTION_DEVICE = 68
+}
+/**
+ * Describes the enum river.Err.
+ */
+export declare const ErrSchema: GenEnum<Err>;
+/**
+ * @generated from service river.StreamService
+ */
+export declare const StreamService: GenService<{
+    /**
+     * @generated from rpc river.StreamService.Info
+     */
+    info: {
+        methodKind: "unary";
+        input: typeof InfoRequestSchema;
+        output: typeof InfoResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.CreateStream
+     */
+    createStream: {
+        methodKind: "unary";
+        input: typeof CreateStreamRequestSchema;
+        output: typeof CreateStreamResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.CreateMediaStream
+     */
+    createMediaStream: {
+        methodKind: "unary";
+        input: typeof CreateMediaStreamRequestSchema;
+        output: typeof CreateMediaStreamResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.GetStream
+     */
+    getStream: {
+        methodKind: "unary";
+        input: typeof GetStreamRequestSchema;
+        output: typeof GetStreamResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.GetStreamEx
+     */
+    getStreamEx: {
+        methodKind: "server_streaming";
+        input: typeof GetStreamExRequestSchema;
+        output: typeof GetStreamExResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.GetMiniblocks
+     */
+    getMiniblocks: {
+        methodKind: "unary";
+        input: typeof GetMiniblocksRequestSchema;
+        output: typeof GetMiniblocksResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.GetLastMiniblockHash
+     */
+    getLastMiniblockHash: {
+        methodKind: "unary";
+        input: typeof GetLastMiniblockHashRequestSchema;
+        output: typeof GetLastMiniblockHashResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.AddEvent
+     */
+    addEvent: {
+        methodKind: "unary";
+        input: typeof AddEventRequestSchema;
+        output: typeof AddEventResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.AddMediaEvent
+     */
+    addMediaEvent: {
+        methodKind: "unary";
+        input: typeof AddMediaEventRequestSchema;
+        output: typeof AddMediaEventResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.SyncStreams
+     */
+    syncStreams: {
+        methodKind: "server_streaming";
+        input: typeof SyncStreamsRequestSchema;
+        output: typeof SyncStreamsResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.AddStreamToSync
+     */
+    addStreamToSync: {
+        methodKind: "unary";
+        input: typeof AddStreamToSyncRequestSchema;
+        output: typeof AddStreamToSyncResponseSchema;
+    };
+    /**
+     * ModifySync adds/removes streams to/from an in progress sync session.
+     * The client must check ModifySyncResponse to determine which streams failed to add/remove.
+     *
+     * Note that it is possible for the client to receive stream updates for streams that are added
+     * or stops receiving stream updates for streams that are removed before this calls returns.
+     *
+     * @generated from rpc river.StreamService.ModifySync
+     */
+    modifySync: {
+        methodKind: "unary";
+        input: typeof ModifySyncRequestSchema;
+        output: typeof ModifySyncResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.CancelSync
+     */
+    cancelSync: {
+        methodKind: "unary";
+        input: typeof CancelSyncRequestSchema;
+        output: typeof CancelSyncResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.RemoveStreamFromSync
+     */
+    removeStreamFromSync: {
+        methodKind: "unary";
+        input: typeof RemoveStreamFromSyncRequestSchema;
+        output: typeof RemoveStreamFromSyncResponseSchema;
+    };
+    /**
+     * @generated from rpc river.StreamService.PingSync
+     */
+    pingSync: {
+        methodKind: "unary";
+        input: typeof PingSyncRequestSchema;
+        output: typeof PingSyncResponseSchema;
+    };
+}>;
+//# sourceMappingURL=protocol_pb.d.ts.map