@quilibrium/quorum-shared 2.1.0-1

package/dist/index.d.mts

@@ -0,0 +1,2414 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as _tanstack_query_core from '@tanstack/query-core';
+
+/**
+ * Space-related types for Quorum
+ */
+type Permission = 'message:delete' | 'message:pin' | 'mention:everyone' | 'user:mute';
+type Role = {
+    roleId: string;
+    displayName: string;
+    roleTag: string;
+    color: string;
+    members: string[];
+    permissions: Permission[];
+    isPublic?: boolean;
+};
+type Emoji = {
+    name: string;
+    id: string;
+    imgUrl: string;
+};
+type Sticker = {
+    name: string;
+    id: string;
+    imgUrl: string;
+};
+type Group = {
+    groupName: string;
+    channels: Channel[];
+    icon?: string;
+    iconColor?: string;
+    iconVariant?: 'outline' | 'filled';
+};
+type Channel = {
+    channelId: string;
+    spaceId: string;
+    channelName: string;
+    channelTopic: string;
+    channelKey?: string;
+    createdDate: number;
+    modifiedDate: number;
+    mentionCount?: number;
+    mentions?: string;
+    isReadOnly?: boolean;
+    managerRoleIds?: string[];
+    isPinned?: boolean;
+    pinnedAt?: number;
+    icon?: string;
+    iconColor?: string;
+    iconVariant?: 'outline' | 'filled';
+};
+type Space = {
+    spaceId: string;
+    spaceName: string;
+    description?: string;
+    vanityUrl: string;
+    inviteUrl: string;
+    iconUrl: string;
+    bannerUrl: string;
+    defaultChannelId: string;
+    hubAddress: string;
+    createdDate: number;
+    modifiedDate: number;
+    isRepudiable: boolean;
+    isPublic: boolean;
+    saveEditHistory?: boolean;
+    groups: Group[];
+    roles: Role[];
+    emojis: Emoji[];
+    stickers: Sticker[];
+};
+
+/**
+ * Message-related types for Quorum
+ */
+/** Client-side ephemeral status - NEVER persist to storage or include in network payload */
+type MessageSendStatus = 'sending' | 'sent' | 'failed';
+type PostMessage = {
+    senderId: string;
+    type: 'post';
+    text: string | string[];
+    repliesToMessageId?: string;
+};
+type UpdateProfileMessage = {
+    senderId: string;
+    type: 'update-profile';
+    displayName: string;
+    userIcon: string;
+};
+type RemoveMessage = {
+    senderId: string;
+    type: 'remove-message';
+    removeMessageId: string;
+};
+type EventMessage = {
+    senderId: string;
+    type: 'event';
+    text: string;
+    repliesToMessageId?: string;
+};
+type EmbedMessage = {
+    senderId: string;
+    type: 'embed';
+    imageUrl?: string;
+    thumbnailUrl?: string;
+    videoUrl?: string;
+    width?: string;
+    height?: string;
+    isLargeGif?: boolean;
+    repliesToMessageId?: string;
+};
+type ReactionMessage = {
+    senderId: string;
+    type: 'reaction';
+    reaction: string;
+    messageId: string;
+};
+type RemoveReactionMessage = {
+    senderId: string;
+    type: 'remove-reaction';
+    reaction: string;
+    messageId: string;
+};
+type JoinMessage = {
+    senderId: string;
+    type: 'join';
+};
+type LeaveMessage = {
+    senderId: string;
+    type: 'leave';
+};
+type KickMessage = {
+    senderId: string;
+    type: 'kick';
+};
+type MuteMessage = {
+    senderId: string;
+    type: 'mute';
+    targetUserId: string;
+    muteId: string;
+    timestamp: number;
+    action: 'mute' | 'unmute';
+    duration?: number;
+};
+type StickerMessage = {
+    senderId: string;
+    type: 'sticker';
+    stickerId: string;
+    repliesToMessageId?: string;
+};
+type PinMessage = {
+    senderId: string;
+    type: 'pin';
+    targetMessageId: string;
+    action: 'pin' | 'unpin';
+};
+type DeleteConversationMessage = {
+    senderId: string;
+    type: 'delete-conversation';
+};
+type EditMessage = {
+    senderId: string;
+    type: 'edit-message';
+    originalMessageId: string;
+    editedText: string | string[];
+    editedAt: number;
+    editNonce: string;
+    editSignature?: string;
+};
+type MessageContent = PostMessage | EventMessage | EmbedMessage | ReactionMessage | RemoveReactionMessage | RemoveMessage | JoinMessage | LeaveMessage | KickMessage | MuteMessage | UpdateProfileMessage | StickerMessage | PinMessage | DeleteConversationMessage | EditMessage;
+type Reaction = {
+    emojiId: string;
+    spaceId: string;
+    emojiName: string;
+    count: number;
+    memberIds: string[];
+};
+type Mentions = {
+    memberIds: string[];
+    roleIds: string[];
+    channelIds: string[];
+    everyone?: boolean;
+    totalMentionCount?: number;
+};
+type Message = {
+    channelId: string;
+    spaceId: string;
+    messageId: string;
+    digestAlgorithm: string;
+    nonce: string;
+    createdDate: number;
+    modifiedDate: number;
+    lastModifiedHash: string;
+    content: MessageContent;
+    reactions: Reaction[];
+    mentions: Mentions;
+    replyMetadata?: {
+        parentAuthor: string;
+        parentChannelId: string;
+    };
+    publicKey?: string;
+    signature?: string;
+    isPinned?: boolean;
+    pinnedAt?: number;
+    pinnedBy?: string;
+    edits?: Array<{
+        text: string | string[];
+        modifiedDate: number;
+        lastModifiedHash: string;
+    }>;
+    /** Client-side ephemeral - NEVER persist or transmit */
+    sendStatus?: MessageSendStatus;
+    /** Client-side ephemeral - sanitized error message for display */
+    sendError?: string;
+};
+
+/**
+ * Conversation (DM) types for Quorum
+ */
+type ConversationSource = 'quorum' | 'farcaster';
+type Conversation = {
+    conversationId: string;
+    type: 'direct' | 'group';
+    timestamp: number;
+    address: string;
+    icon: string;
+    displayName: string;
+    lastReadTimestamp?: number;
+    isRepudiable?: boolean;
+    saveEditHistory?: boolean;
+    lastMessageId?: string;
+    source?: ConversationSource;
+    farcasterConversationId?: string;
+    farcasterFid?: number;
+    farcasterUsername?: string;
+    farcasterParticipantFids?: number[];
+    unreadCount?: number;
+};
+
+/**
+ * Bookmark types for Quorum
+ */
+type Bookmark = {
+    bookmarkId: string;
+    messageId: string;
+    spaceId?: string;
+    channelId?: string;
+    conversationId?: string;
+    sourceType: 'channel' | 'dm';
+    createdAt: number;
+    cachedPreview: {
+        senderAddress: string;
+        senderName: string;
+        textSnippet: string;
+        messageDate: number;
+        sourceName: string;
+        contentType: 'text' | 'image' | 'sticker';
+        imageUrl?: string;
+        thumbnailUrl?: string;
+        stickerId?: string;
+    };
+};
+declare const BOOKMARKS_CONFIG: {
+    readonly MAX_BOOKMARKS: 200;
+    readonly PREVIEW_SNIPPET_LENGTH: 150;
+};
+
+/**
+ * User-related types for Quorum
+ */
+
+type FolderColor = string;
+type NavItem = {
+    type: 'space';
+    id: string;
+} | {
+    type: 'folder';
+    id: string;
+    name: string;
+    spaceIds: string[];
+    icon?: string;
+    color?: FolderColor;
+    createdDate: number;
+    modifiedDate: number;
+};
+type NotificationSettings = {
+    enabled?: boolean;
+    mentions?: boolean;
+    replies?: boolean;
+    all?: boolean;
+};
+type UserConfig = {
+    address: string;
+    spaceIds: string[];
+    items?: NavItem[];
+    timestamp?: number;
+    nonRepudiable?: boolean;
+    allowSync?: boolean;
+    name?: string;
+    profile_image?: string;
+    spaceKeys?: {
+        spaceId: string;
+        encryptionState: {
+            conversationId: string;
+            inboxId: string;
+            state: string;
+            timestamp: number;
+        };
+        keys: {
+            keyId: string;
+            address?: string;
+            publicKey: string;
+            privateKey: string;
+            spaceId: string;
+        }[];
+    }[];
+    notificationSettings?: {
+        [spaceId: string]: NotificationSettings;
+    };
+    bookmarks?: Bookmark[];
+    deletedBookmarkIds?: string[];
+};
+type UserProfile = {
+    address: string;
+    name?: string;
+    display_name?: string;
+    profile_image?: string;
+    bio?: string;
+};
+type SpaceMember = UserProfile & {
+    inbox_address: string;
+    isKicked?: boolean;
+};
+
+/**
+ * Sync Protocol Types
+ *
+ * Hash-based delta synchronization for efficient data transfer.
+ * Reduces bandwidth by only sending data the recipient is missing.
+ */
+
+/** Compact message reference for sync comparison */
+interface MessageDigest {
+    /** Unique message identifier */
+    messageId: string;
+    /** Message creation timestamp */
+    createdDate: number;
+    /** SHA-256 hash of canonical message content */
+    contentHash: string;
+    /** Last modification timestamp (for detecting edits) */
+    modifiedDate?: number;
+}
+/** Compact reaction reference for sync comparison */
+interface ReactionDigest {
+    /** Message this reaction is on */
+    messageId: string;
+    /** Emoji/reaction identifier */
+    emojiId: string;
+    /** Number of users who reacted */
+    count: number;
+    /** Hash of sorted member IDs who reacted */
+    membersHash: string;
+}
+/** Manifest of all messages in a channel */
+interface SyncManifest {
+    spaceId: string;
+    channelId: string;
+    messageCount: number;
+    oldestTimestamp: number;
+    newestTimestamp: number;
+    /** Message digests sorted by createdDate ascending */
+    digests: MessageDigest[];
+    /** Reaction digests for quick comparison */
+    reactionDigests: ReactionDigest[];
+}
+/** Delta response containing only needed messages */
+interface MessageDelta {
+    spaceId: string;
+    channelId: string;
+    /** Messages the recipient is missing */
+    newMessages: Message[];
+    /** Messages that have been edited since recipient's version */
+    updatedMessages: Message[];
+    /** Message IDs that have been deleted (tombstones) */
+    deletedMessageIds: string[];
+}
+/** Delta response for reactions only */
+interface ReactionDelta {
+    spaceId: string;
+    channelId: string;
+    /** Reactions to add: { messageId, emojiId, memberIds[] } */
+    added: Array<{
+        messageId: string;
+        emojiId: string;
+        memberIds: string[];
+    }>;
+    /** Reactions to remove: { messageId, emojiId, memberIds[] } */
+    removed: Array<{
+        messageId: string;
+        emojiId: string;
+        memberIds: string[];
+    }>;
+}
+/** Compact member reference */
+interface MemberDigest {
+    /** User's address */
+    address: string;
+    /** User's inbox address */
+    inboxAddress: string;
+    /** SHA-256 hash of display_name (or empty string) */
+    displayNameHash: string;
+    /** SHA-256 hash of icon URL/data (or empty string) */
+    iconHash: string;
+}
+/** Member delta containing only changes */
+interface MemberDelta {
+    spaceId: string;
+    /** New or updated members (full data) */
+    members: SpaceMember[];
+    /** Addresses of removed/kicked members */
+    removedAddresses: string[];
+}
+/** Peer map entry for Triple Ratchet */
+interface PeerEntry {
+    /** Peer's ID in the ratchet */
+    peerId: number;
+    /** Peer's public key (hex or base64) */
+    publicKey: string;
+    /** Peer's identity public key (hex or base64) - optional for minimal sync */
+    identityPublicKey?: string;
+    /** Peer's signed pre-key (hex or base64) - optional for minimal sync */
+    signedPrePublicKey?: string;
+}
+/** Peer map delta */
+interface PeerMapDelta {
+    spaceId: string;
+    /** New peer entries */
+    added: PeerEntry[];
+    /** Updated peer entries (changed keys) */
+    updated: PeerEntry[];
+    /** Removed peer IDs */
+    removed: number[];
+}
+/** Tombstone for a deleted message */
+interface DeletedMessageTombstone {
+    messageId: string;
+    spaceId: string;
+    channelId: string;
+    deletedAt: number;
+}
+/** Summary of sync data for comparison */
+interface SyncSummary {
+    memberCount: number;
+    messageCount: number;
+    newestMessageTimestamp: number;
+    oldestMessageTimestamp: number;
+    /** Hash of all message IDs for quick comparison */
+    manifestHash?: string;
+}
+/** sync-request payload (broadcast via hub) */
+interface SyncRequestPayload {
+    type: 'sync-request';
+    /** Our inbox address for responses */
+    inboxAddress: string;
+    /** Request expiry timestamp */
+    expiry: number;
+    /** Summary of our data */
+    summary: SyncSummary;
+}
+/** sync-info payload (direct to requester) */
+interface SyncInfoPayload {
+    type: 'sync-info';
+    /** Our inbox address */
+    inboxAddress: string;
+    /** Summary of our data */
+    summary: SyncSummary;
+}
+/** sync-initiate payload (direct to best peer) */
+interface SyncInitiatePayload {
+    type: 'sync-initiate';
+    /** Our inbox address (for peer to send data back to) */
+    inboxAddress: string;
+    /** Our manifest for comparison */
+    manifest?: SyncManifest;
+    /** Our member digests for comparison */
+    memberDigests?: MemberDigest[];
+    /** Our peer IDs for comparison */
+    peerIds?: number[];
+}
+/** sync-manifest payload (response to sync-initiate with our data summary) */
+interface SyncManifestPayload {
+    type: 'sync-manifest';
+    /** Our inbox address (for peer to send data back to) */
+    inboxAddress: string;
+    /** Our full manifest */
+    manifest: SyncManifest;
+    /** Our member digests */
+    memberDigests: MemberDigest[];
+    /** Our peer IDs */
+    peerIds: number[];
+}
+/** sync-delta payload (actual data transfer) */
+interface SyncDeltaPayload {
+    type: 'sync-delta';
+    /** Message changes */
+    messageDelta?: MessageDelta;
+    /** Reaction changes (synced independently) */
+    reactionDelta?: ReactionDelta;
+    /** Member changes */
+    memberDelta?: MemberDelta;
+    /** Peer map changes */
+    peerMapDelta?: PeerMapDelta;
+    /** Whether this is the final delta chunk */
+    isFinal?: boolean;
+}
+/** Candidate from sync-info response */
+interface SyncCandidate {
+    inboxAddress: string;
+    summary: SyncSummary;
+}
+/** Active sync session state */
+interface SyncSession {
+    spaceId: string;
+    channelId: string;
+    /** Request expiry timestamp */
+    expiry: number;
+    /** Candidates who responded to sync-request */
+    candidates: SyncCandidate[];
+    /** Timeout handle for initiating sync */
+    timeout?: ReturnType<typeof setTimeout>;
+    /** Whether sync is in progress */
+    inProgress: boolean;
+    /** Target inbox address when we've initiated sync */
+    syncTarget?: string;
+}
+/** All sync control message payloads */
+type SyncControlPayload = SyncRequestPayload | SyncInfoPayload | SyncInitiatePayload | SyncManifestPayload | SyncDeltaPayload;
+/** Type guard for sync-request */
+declare function isSyncRequest(payload: SyncControlPayload): payload is SyncRequestPayload;
+/** Type guard for sync-info */
+declare function isSyncInfo(payload: SyncControlPayload): payload is SyncInfoPayload;
+/** Type guard for sync-initiate */
+declare function isSyncInitiate(payload: SyncControlPayload): payload is SyncInitiatePayload;
+/** Type guard for sync-manifest */
+declare function isSyncManifest(payload: SyncControlPayload): payload is SyncManifestPayload;
+/** Type guard for sync-delta */
+declare function isSyncDelta(payload: SyncControlPayload): payload is SyncDeltaPayload;
+
+/**
+ * StorageAdapter interface
+ *
+ * Platform-agnostic storage interface that can be implemented by:
+ * - IndexedDB (desktop/web)
+ * - MMKV (React Native mobile)
+ */
+
+interface GetMessagesParams {
+    spaceId: string;
+    channelId: string;
+    cursor?: number;
+    direction?: 'forward' | 'backward';
+    limit?: number;
+}
+interface GetMessagesResult {
+    messages: Message[];
+    nextCursor: number | null;
+    prevCursor: number | null;
+}
+interface StorageAdapter {
+    init(): Promise<void>;
+    getSpaces(): Promise<Space[]>;
+    getSpace(spaceId: string): Promise<Space | null>;
+    saveSpace(space: Space): Promise<void>;
+    deleteSpace(spaceId: string): Promise<void>;
+    getChannels(spaceId: string): Promise<Channel[]>;
+    getMessages(params: GetMessagesParams): Promise<GetMessagesResult>;
+    getMessage(params: {
+        spaceId: string;
+        channelId: string;
+        messageId: string;
+    }): Promise<Message | undefined>;
+    saveMessage(message: Message, lastMessageTimestamp: number, address: string, conversationType: string, icon: string, displayName: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    getConversations(params: {
+        type: 'direct' | 'group';
+        cursor?: number;
+        limit?: number;
+    }): Promise<{
+        conversations: Conversation[];
+        nextCursor: number | null;
+    }>;
+    getConversation(conversationId: string): Promise<Conversation | undefined>;
+    saveConversation(conversation: Conversation): Promise<void>;
+    deleteConversation(conversationId: string): Promise<void>;
+    getUserConfig(address: string): Promise<UserConfig | undefined>;
+    saveUserConfig(userConfig: UserConfig): Promise<void>;
+    getSpaceMembers(spaceId: string): Promise<SpaceMember[]>;
+    getSpaceMember(spaceId: string, address: string): Promise<SpaceMember | undefined>;
+    saveSpaceMember(spaceId: string, member: SpaceMember): Promise<void>;
+    getLastSyncTime(key: string): Promise<number | undefined>;
+    setLastSyncTime(key: string, time: number): Promise<void>;
+    /**
+     * Get message digests for efficient sync comparison.
+     * If not implemented, returns undefined and SyncService computes from messages.
+     */
+    getMessageDigests?(spaceId: string, channelId: string): Promise<MessageDigest[] | undefined>;
+    /**
+     * Get messages by IDs for delta sync.
+     * If not implemented, returns undefined and caller fetches individually.
+     */
+    getMessagesByIds?(spaceId: string, channelId: string, ids: string[]): Promise<Message[] | undefined>;
+    /**
+     * Get member digests for efficient sync comparison.
+     * If not implemented, returns undefined and SyncService computes from members.
+     */
+    getMemberDigests?(spaceId: string): Promise<MemberDigest[] | undefined>;
+    /**
+     * Get deleted message tombstones for sync.
+     */
+    getTombstones?(spaceId: string, channelId: string): Promise<DeletedMessageTombstone[]>;
+    /**
+     * Save deleted message tombstone.
+     */
+    saveTombstone?(tombstone: DeletedMessageTombstone): Promise<void>;
+    /**
+     * Clean up old tombstones.
+     */
+    cleanupTombstones?(maxAgeMs: number): Promise<void>;
+}
+
+/**
+ * QuorumApiClient interface
+ *
+ * Platform-agnostic API client that can be implemented differently
+ * for mobile (fetch) and desktop (Electron IPC or fetch)
+ */
+
+interface SendMessageParams {
+    spaceId: string;
+    channelId: string;
+    text: string;
+    repliesToMessageId?: string;
+}
+interface AddReactionParams {
+    spaceId: string;
+    channelId: string;
+    messageId: string;
+    reaction: string;
+}
+interface RemoveReactionParams {
+    spaceId: string;
+    channelId: string;
+    messageId: string;
+    reaction: string;
+}
+interface EditMessageParams {
+    spaceId: string;
+    channelId: string;
+    messageId: string;
+    text: string;
+}
+interface DeleteMessageParams {
+    spaceId: string;
+    channelId: string;
+    messageId: string;
+}
+interface SendDirectMessageParams {
+    conversationId: string;
+    text: string;
+    repliesToMessageId?: string;
+}
+interface QuorumApiClient {
+    fetchSpaces(): Promise<Space[]>;
+    fetchSpace(spaceId: string): Promise<Space>;
+    joinSpace(inviteCode: string): Promise<Space>;
+    fetchMessages(params: {
+        spaceId: string;
+        channelId: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        messages: Message[];
+        nextPageToken?: string;
+    }>;
+    sendMessage(params: SendMessageParams): Promise<Message>;
+    editMessage(params: EditMessageParams): Promise<Message>;
+    deleteMessage(params: DeleteMessageParams): Promise<void>;
+    addReaction(params: AddReactionParams): Promise<void>;
+    removeReaction(params: RemoveReactionParams): Promise<void>;
+    fetchConversations(): Promise<Conversation[]>;
+    createConversation(params: {
+        address: string;
+    }): Promise<Conversation>;
+    sendDirectMessage(params: SendDirectMessageParams): Promise<Message>;
+    fetchDirectMessages(params: {
+        conversationId: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        messages: Message[];
+        nextPageToken?: string;
+    }>;
+    pinMessage(params: {
+        spaceId: string;
+        channelId: string;
+        messageId: string;
+    }): Promise<void>;
+    unpinMessage(params: {
+        spaceId: string;
+        channelId: string;
+        messageId: string;
+    }): Promise<void>;
+}
+
+/**
+ * API error classes
+ */
+/** API error codes */
+declare enum ApiErrorCode {
+    NETWORK_ERROR = "NETWORK_ERROR",
+    TIMEOUT = "TIMEOUT",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    BAD_REQUEST = "BAD_REQUEST",
+    NOT_FOUND = "NOT_FOUND",
+    CONFLICT = "CONFLICT",
+    RATE_LIMITED = "RATE_LIMITED",
+    SERVER_ERROR = "SERVER_ERROR",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    UNKNOWN = "UNKNOWN"
+}
+/** API error details */
+interface ApiErrorDetails {
+    code: ApiErrorCode;
+    message: string;
+    status?: number;
+    field?: string;
+    retryAfter?: number;
+    originalError?: Error;
+}
+/**
+ * Custom API error class
+ */
+declare class ApiError extends Error {
+    readonly code: ApiErrorCode;
+    readonly status?: number;
+    readonly field?: string;
+    readonly retryAfter?: number;
+    readonly originalError?: Error;
+    constructor(details: ApiErrorDetails);
+    /** Check if error is retryable */
+    get isRetryable(): boolean;
+    /** Check if error requires re-authentication */
+    get requiresAuth(): boolean;
+    /** Convert to JSON-serializable object */
+    toJSON(): ApiErrorDetails;
+}
+/**
+ * Create ApiError from HTTP response
+ */
+declare function createApiError(status: number, message?: string, field?: string): ApiError;
+/**
+ * Create ApiError from network error
+ */
+declare function createNetworkError(error: Error): ApiError;
+
+/**
+ * API endpoint definitions
+ */
+/** Base API configuration */
+interface ApiConfig {
+    baseUrl: string;
+    timeout?: number;
+}
+/** API endpoint builders */
+declare const endpoints: {
+    readonly spaces: {
+        readonly list: () => string;
+        readonly detail: (spaceId: string) => string;
+        readonly members: (spaceId: string) => string;
+        readonly join: (spaceId: string) => string;
+        readonly leave: (spaceId: string) => string;
+    };
+    readonly channels: {
+        readonly list: (spaceId: string) => string;
+        readonly detail: (spaceId: string, channelId: string) => string;
+    };
+    readonly messages: {
+        readonly list: (spaceId: string, channelId: string) => string;
+        readonly detail: (spaceId: string, channelId: string, messageId: string) => string;
+        readonly send: (spaceId: string, channelId: string) => string;
+        readonly react: (spaceId: string, channelId: string, messageId: string) => string;
+        readonly pin: (spaceId: string, channelId: string, messageId: string) => string;
+    };
+    readonly conversations: {
+        readonly list: () => string;
+        readonly detail: (conversationId: string) => string;
+        readonly messages: (conversationId: string) => string;
+    };
+    readonly user: {
+        readonly config: () => string;
+        readonly profile: () => string;
+        readonly notifications: () => string;
+    };
+    readonly search: {
+        readonly messages: (spaceId: string) => string;
+        readonly members: (spaceId: string) => string;
+    };
+};
+/** HTTP methods */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** Request options */
+interface RequestOptions {
+    method?: HttpMethod;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+/** Pagination parameters */
+interface PaginationParams {
+    cursor?: string;
+    limit?: number;
+}
+/** Message list parameters */
+interface MessageListParams extends PaginationParams {
+    before?: string;
+    after?: string;
+    around?: string;
+}
+
+/**
+ * Query key factories for React Query
+ *
+ * Consistent key structure across platforms for cache management
+ */
+declare const queryKeys: {
+    readonly spaces: {
+        readonly all: readonly ["spaces"];
+        readonly detail: (spaceId: string) => readonly ["spaces", string];
+        readonly members: (spaceId: string) => readonly ["spaces", string, "members"];
+        readonly member: (spaceId: string, address: string) => readonly ["spaces", string, "members", string];
+    };
+    readonly channels: {
+        readonly bySpace: (spaceId: string) => readonly ["channels", string];
+        readonly detail: (spaceId: string, channelId: string) => readonly ["channels", string, string];
+    };
+    readonly messages: {
+        readonly infinite: (spaceId: string, channelId: string) => readonly ["messages", "infinite", string, string];
+        readonly detail: (spaceId: string, channelId: string, messageId: string) => readonly ["messages", string, string, string];
+        readonly pinned: (spaceId: string, channelId: string) => readonly ["messages", "pinned", string, string];
+    };
+    readonly conversations: {
+        readonly all: (type: "direct" | "group") => readonly ["conversations", "direct" | "group"];
+        readonly detail: (conversationId: string) => readonly ["conversations", string];
+        readonly messages: (conversationId: string) => readonly ["conversations", string, "messages"];
+    };
+    readonly user: {
+        readonly config: (address: string) => readonly ["user", "config", string];
+        readonly profile: (address: string) => readonly ["user", "profile", string];
+    };
+    readonly bookmarks: {
+        readonly all: readonly ["bookmarks"];
+        readonly bySource: (sourceType: "channel" | "dm") => readonly ["bookmarks", "channel" | "dm"];
+        readonly bySpace: (spaceId: string) => readonly ["bookmarks", "space", string];
+        readonly check: (messageId: string) => readonly ["bookmarks", "check", string];
+    };
+};
+type SpacesKey = typeof queryKeys.spaces.all;
+type SpaceDetailKey = ReturnType<typeof queryKeys.spaces.detail>;
+type ChannelsKey = ReturnType<typeof queryKeys.channels.bySpace>;
+type MessagesInfiniteKey = ReturnType<typeof queryKeys.messages.infinite>;
+
+interface UseSpacesOptions {
+    storage: StorageAdapter;
+    enabled?: boolean;
+}
+declare function useSpaces({ storage, enabled }: UseSpacesOptions): _tanstack_react_query.UseQueryResult<Space[], Error>;
+interface UseSpaceOptions {
+    storage: StorageAdapter;
+    spaceId: string | undefined;
+    enabled?: boolean;
+}
+declare function useSpace({ storage, spaceId, enabled }: UseSpaceOptions): _tanstack_react_query.UseQueryResult<Space | null, Error>;
+declare function useSpaceMembers({ storage, spaceId, enabled, }: UseSpaceOptions): _tanstack_react_query.UseQueryResult<SpaceMember[], Error>;
+
+interface UseChannelsOptions {
+    storage: StorageAdapter;
+    spaceId: string | undefined;
+    enabled?: boolean;
+}
+declare function useChannels({ storage, spaceId, enabled }: UseChannelsOptions): _tanstack_react_query.UseQueryResult<Channel[], Error>;
+/**
+ * Helper to extract channels from a space's groups
+ */
+declare function flattenChannels(groups: {
+    channels: Channel[];
+}[]): Channel[];
+/**
+ * Find a channel by ID within groups
+ */
+declare function findChannel(groups: {
+    channels: Channel[];
+}[], channelId: string): Channel | undefined;
+
+interface UseMessagesOptions {
+    storage: StorageAdapter;
+    spaceId: string | undefined;
+    channelId: string | undefined;
+    enabled?: boolean;
+    limit?: number;
+}
+declare function useMessages({ storage, spaceId, channelId, enabled, limit, }: UseMessagesOptions): _tanstack_react_query.UseInfiniteQueryResult<_tanstack_query_core.InfiniteData<GetMessagesResult, unknown>, Error>;
+/**
+ * Flatten paginated messages into a single array
+ */
+declare function flattenMessages(pages: GetMessagesResult[] | undefined): Message[];
+/**
+ * Hook to invalidate message cache
+ */
+declare function useInvalidateMessages(): {
+    invalidateChannel: (spaceId: string, channelId: string) => void;
+    invalidateSpace: (spaceId: string) => void;
+};
+
+interface UseSendMessageOptions {
+    storage: StorageAdapter;
+    apiClient: QuorumApiClient;
+    currentUserId: string;
+}
+declare function useSendMessage({ storage, apiClient, currentUserId, }: UseSendMessageOptions): _tanstack_react_query.UseMutationResult<Message, Error, SendMessageParams, {
+    previousData: unknown;
+    optimisticMessage: Message;
+}>;
+
+interface UseReactionOptions {
+    storage: StorageAdapter;
+    apiClient: QuorumApiClient;
+    currentUserId: string;
+}
+declare function useAddReaction({ storage, apiClient, currentUserId, }: UseReactionOptions): _tanstack_react_query.UseMutationResult<void, Error, AddReactionParams, {
+    previousData: unknown;
+}>;
+declare function useRemoveReaction({ storage, apiClient, currentUserId, }: UseReactionOptions): _tanstack_react_query.UseMutationResult<void, Error, RemoveReactionParams, {
+    previousData: unknown;
+}>;
+
+interface UseEditMessageOptions {
+    storage: StorageAdapter;
+    apiClient: QuorumApiClient;
+}
+declare function useEditMessage({ storage, apiClient }: UseEditMessageOptions): _tanstack_react_query.UseMutationResult<Message, Error, EditMessageParams, {
+    previousData: unknown;
+}>;
+
+interface UseDeleteMessageOptions {
+    storage: StorageAdapter;
+    apiClient: QuorumApiClient;
+}
+declare function useDeleteMessage({ storage, apiClient }: UseDeleteMessageOptions): _tanstack_react_query.UseMutationResult<void, Error, DeleteMessageParams, {
+    previousData: unknown;
+}>;
+
+/**
+ * Message validation utilities
+ */
+
+/** Maximum message length */
+declare const MAX_MESSAGE_LENGTH = 4000;
+/** Maximum number of mentions per message */
+declare const MAX_MENTIONS = 50;
+/** Validation result */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validate message content before sending
+ */
+declare function validateMessageContent(content: string): ValidationResult;
+/**
+ * Validate a message object
+ */
+declare function validateMessage(message: Partial<Message>): ValidationResult;
+/**
+ * Sanitize message content for display
+ */
+declare function sanitizeContent(content: string): string;
+
+/**
+ * Mention parsing utilities
+ */
+
+/** Mention patterns */
+declare const MENTION_PATTERNS: {
+    user: RegExp;
+    role: RegExp;
+    channel: RegExp;
+    everyone: RegExp;
+    here: RegExp;
+};
+/** Parsed mention */
+interface ParsedMention {
+    type: 'user' | 'role' | 'channel' | 'everyone' | 'here';
+    id?: string;
+    raw: string;
+    start: number;
+    end: number;
+}
+/**
+ * Parse mentions from message text
+ */
+declare function parseMentions(text: string): ParsedMention[];
+/**
+ * Extract Mentions object from parsed mentions
+ */
+declare function extractMentions(text: string): Mentions;
+/**
+ * Format mention for display
+ */
+declare function formatMention(type: 'user' | 'role' | 'channel', id: string): string;
+
+/**
+ * Date and text formatting utilities
+ */
+/**
+ * Format timestamp to time string (e.g., "2:30 PM")
+ */
+declare function formatTime(timestamp: number): string;
+/**
+ * Format timestamp to date string (e.g., "Dec 24, 2025")
+ */
+declare function formatDate(timestamp: number): string;
+/**
+ * Format timestamp to full datetime string (e.g., "Dec 24, 2025 at 2:30 PM")
+ */
+declare function formatDateTime(timestamp: number): string;
+/**
+ * Format timestamp to relative time (e.g., "5 minutes ago", "Yesterday")
+ */
+declare function formatRelativeTime(timestamp: number): string;
+/**
+ * Format message date header (e.g., "Today", "Yesterday", "December 24, 2025")
+ */
+declare function formatMessageDate(timestamp: number): string;
+/**
+ * Check if two dates are the same day
+ */
+declare function isSameDay(d1: Date, d2: Date): boolean;
+/**
+ * Truncate text to a maximum length with ellipsis
+ */
+declare function truncateText(text: string, maxLength: number): string;
+/**
+ * Format file size (e.g., "1.5 MB")
+ */
+declare function formatFileSize(bytes: number): string;
+/**
+ * Format member count (e.g., "1.2K members")
+ */
+declare function formatMemberCount(count: number): string;
+
+/**
+ * Encoding utilities for hex and base64 conversions
+ *
+ * These are platform-agnostic utilities for converting between
+ * byte arrays and string representations.
+ */
+/**
+ * Convert a hex string to a byte array
+ * @param hex - Hexadecimal string (with or without 0x prefix)
+ * @returns Array of bytes
+ */
+declare function hexToBytes(hex: string): number[];
+/**
+ * Convert a byte array to a hex string
+ * @param bytes - Array of bytes (number[] or Uint8Array)
+ * @returns Hexadecimal string (lowercase, no prefix)
+ */
+declare function bytesToHex(bytes: number[] | Uint8Array): string;
+/**
+ * Convert a base64 string to a Uint8Array
+ * @param base64 - Base64-encoded string
+ * @returns Uint8Array of bytes
+ */
+declare function base64ToBytes(base64: string): Uint8Array;
+/**
+ * Convert a byte array to a base64 string
+ * @param bytes - Array of bytes (number[] or Uint8Array)
+ * @returns Base64-encoded string
+ */
+declare function bytesToBase64(bytes: number[] | Uint8Array): string;
+/**
+ * Convert a UTF-8 string to a byte array
+ * @param str - UTF-8 string
+ * @returns Array of bytes
+ */
+declare function stringToBytes(str: string): number[];
+/**
+ * Convert a byte array to a UTF-8 string
+ * @param bytes - Array of bytes (number[] or Uint8Array)
+ * @returns UTF-8 string
+ */
+declare function bytesToString(bytes: number[] | Uint8Array): string;
+/**
+ * Convert a number to an 8-byte big-endian array (int64)
+ * Used for timestamp serialization in signatures
+ *
+ * @param num - The number to convert (must be within safe integer range)
+ * @returns 8-byte Uint8Array in big-endian format
+ */
+declare function int64ToBytes(num: number): Uint8Array;
+
+/**
+ * Logger utility that respects build environment
+ *
+ * In development: logs to console
+ * In production: no-ops for performance
+ *
+ * Usage:
+ *   import { logger } from '@quorum/shared';
+ *   logger.log('[MyModule]', 'some message', data);
+ *   logger.warn('[MyModule]', 'warning message');
+ *   logger.error('[MyModule]', 'error message', error);
+ */
+type LogLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
+interface LoggerConfig {
+    enabled: boolean;
+    minLevel: LogLevel;
+}
+declare const logger: {
+    /**
+     * Configure the logger
+     */
+    configure(newConfig: Partial<LoggerConfig>): void;
+    /**
+     * Check if logging is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Enable logging (useful for debugging production issues)
+     */
+    enable(): void;
+    /**
+     * Disable logging
+     */
+    disable(): void;
+    /**
+     * Log at debug level
+     */
+    debug: (...args: unknown[]) => void;
+    /**
+     * Log at default level
+     */
+    log: (...args: unknown[]) => void;
+    /**
+     * Log at info level
+     */
+    info: (...args: unknown[]) => void;
+    /**
+     * Log at warn level
+     */
+    warn: (...args: unknown[]) => void;
+    /**
+     * Log at error level (always logs unless explicitly disabled)
+     */
+    error: (...args: unknown[]) => void;
+    /**
+     * Create a scoped logger with a prefix
+     */
+    scope(prefix: string): {
+        debug: (...args: unknown[]) => void;
+        log: (...args: unknown[]) => void;
+        info: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+};
+
+/**
+ * Crypto types and CryptoProvider interface
+ *
+ * Platform-agnostic cryptographic operations for E2E encryption.
+ * Implementations:
+ * - WASM (desktop/web): Uses channel-wasm bindings
+ * - Native (iOS/Android): Uses uniffi-generated bindings
+ */
+interface Ed448Keypair {
+    type: 'ed448';
+    public_key: number[];
+    private_key: number[];
+}
+interface X448Keypair {
+    type: 'x448';
+    public_key: number[];
+    private_key: number[];
+}
+type Keypair = Ed448Keypair | X448Keypair;
+interface MessageCiphertext {
+    ciphertext: string;
+    initialization_vector: string;
+    associated_data?: string;
+}
+interface P2PChannelEnvelope {
+    protocol_identifier: number;
+    message_header: MessageCiphertext;
+    message_body: MessageCiphertext;
+}
+interface SenderX3DHParams {
+    sending_identity_private_key: number[];
+    sending_ephemeral_private_key: number[];
+    receiving_identity_key: number[];
+    receiving_signed_pre_key: number[];
+    session_key_length: number;
+}
+interface ReceiverX3DHParams {
+    sending_identity_private_key: number[];
+    sending_signed_private_key: number[];
+    receiving_identity_key: number[];
+    receiving_ephemeral_key: number[];
+    session_key_length: number;
+}
+interface NewDoubleRatchetParams {
+    session_key: number[];
+    sending_header_key: number[];
+    next_receiving_header_key: number[];
+    is_sender: boolean;
+    sending_ephemeral_private_key: number[];
+    receiving_ephemeral_key: number[];
+}
+interface DoubleRatchetStateAndMessage {
+    ratchet_state: string;
+    message: number[];
+}
+interface DoubleRatchetStateAndEnvelope {
+    ratchet_state: string;
+    envelope: string;
+}
+interface PeerInfo {
+    public_key: number[];
+    identity_public_key: number[];
+    signed_pre_public_key: number[];
+}
+interface NewTripleRatchetParams {
+    peers: number[][];
+    peer_key: number[];
+    identity_key: number[];
+    signed_pre_key: number[];
+    threshold: number;
+    async_dkg_ratchet: boolean;
+}
+interface TripleRatchetStateAndMetadata {
+    ratchet_state: string;
+    metadata: Record<string, string>;
+}
+interface TripleRatchetStateAndMessage {
+    ratchet_state: string;
+    message: number[];
+}
+interface TripleRatchetStateAndEnvelope {
+    ratchet_state: string;
+    envelope: string;
+}
+/**
+ * InitializationEnvelope - Contains sender info for first message in a session
+ *
+ * This is the format BEFORE sealing. The ephemeral_public_key is NOT included here -
+ * it goes at the TOP LEVEL of the SealedMessage, and the SAME ephemeral key is used for both:
+ * 1. Sealing the envelope (inbox encryption)
+ * 2. X3DH session establishment
+ *
+ * After unsealing, the ephemeral_public_key is added back to create UnsealedEnvelope
+ * (see transport/websocket.ts)
+ */
+interface InitializationEnvelope {
+    /** Sender's user address */
+    user_address: string;
+    /** Sender's display name */
+    display_name?: string;
+    /** Sender's icon URL */
+    user_icon?: string;
+    /** Inbox address for sending replies */
+    return_inbox_address: string;
+    /** X448 encryption key for the return inbox (hex) */
+    return_inbox_encryption_key: string;
+    /** Ed448 public key for the return inbox (hex) */
+    return_inbox_public_key: string;
+    /** Ed448 private key for the return inbox (hex) - shared so recipient can sign replies */
+    return_inbox_private_key: string;
+    /** Sender's identity public key for X3DH (hex) */
+    identity_public_key: string;
+    /** Session/conversation tag (typically the return inbox address) */
+    tag: string;
+    /** The Double Ratchet encrypted message envelope */
+    message: string;
+    /** Message type (e.g., 'direct') */
+    type: string;
+}
+interface InboxMessageEncryptRequest {
+    inbox_public_key: number[];
+    ephemeral_private_key: number[];
+    plaintext: number[];
+}
+interface InboxMessageDecryptRequest {
+    inbox_private_key: number[];
+    ephemeral_public_key: number[];
+    ciphertext: MessageCiphertext;
+}
+/**
+ * CryptoProvider - Platform-agnostic interface for cryptographic operations
+ *
+ * This interface abstracts the underlying crypto implementation,
+ * allowing the same code to work with WASM (desktop) or native modules (mobile).
+ *
+ * All methods are async to support both synchronous WASM and async native bridges.
+ * State is serialized as JSON strings for cross-platform compatibility.
+ */
+interface CryptoProvider {
+    /**
+     * Generate an X448 keypair for encryption
+     */
+    generateX448(): Promise<X448Keypair>;
+    /**
+     * Generate an Ed448 keypair for signing
+     */
+    generateEd448(): Promise<Ed448Keypair>;
+    /**
+     * Derive public key from X448 private key
+     * @param privateKey Base64-encoded private key
+     * @returns Base64-encoded public key
+     */
+    getPublicKeyX448(privateKey: string): Promise<string>;
+    /**
+     * Derive public key from Ed448 private key
+     * @param privateKey Base64-encoded private key
+     * @returns Base64-encoded public key
+     */
+    getPublicKeyEd448(privateKey: string): Promise<string>;
+    /**
+     * Perform sender-side X3DH key agreement
+     * @returns Base64-encoded session key (96 bytes: 32 session + 32 sending header + 32 receiving header)
+     */
+    senderX3DH(params: SenderX3DHParams): Promise<string>;
+    /**
+     * Perform receiver-side X3DH key agreement
+     * @returns Base64-encoded session key (96 bytes)
+     */
+    receiverX3DH(params: ReceiverX3DHParams): Promise<string>;
+    /**
+     * Initialize a new double ratchet session
+     * @returns JSON-serialized ratchet state
+     */
+    newDoubleRatchet(params: NewDoubleRatchetParams): Promise<string>;
+    /**
+     * Encrypt a message using double ratchet
+     * @returns Updated state and encrypted envelope
+     */
+    doubleRatchetEncrypt(stateAndMessage: DoubleRatchetStateAndMessage): Promise<DoubleRatchetStateAndEnvelope>;
+    /**
+     * Decrypt a message using double ratchet
+     * @returns Updated state and decrypted message
+     */
+    doubleRatchetDecrypt(stateAndEnvelope: DoubleRatchetStateAndEnvelope): Promise<DoubleRatchetStateAndMessage>;
+    /**
+     * Initialize a new triple ratchet session for group messaging
+     * @returns Initial state and DKG metadata
+     */
+    newTripleRatchet(params: NewTripleRatchetParams): Promise<TripleRatchetStateAndMetadata>;
+    /**
+     * Triple ratchet DKG round 1 - Generate polynomial fragments
+     */
+    tripleRatchetInitRound1(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    /**
+     * Triple ratchet DKG round 2 - Receive fragments, compute ZK commitment
+     */
+    tripleRatchetInitRound2(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    /**
+     * Triple ratchet DKG round 3 - Receive commitments, compute ZK reveal
+     */
+    tripleRatchetInitRound3(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    /**
+     * Triple ratchet DKG round 4 - Verify proofs, reconstruct group key
+     */
+    tripleRatchetInitRound4(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    /**
+     * Encrypt a message for the group using triple ratchet
+     */
+    tripleRatchetEncrypt(stateAndMessage: TripleRatchetStateAndMessage): Promise<TripleRatchetStateAndEnvelope>;
+    /**
+     * Decrypt a group message using triple ratchet
+     */
+    tripleRatchetDecrypt(stateAndEnvelope: TripleRatchetStateAndEnvelope): Promise<TripleRatchetStateAndMessage>;
+    /**
+     * Handle group membership changes
+     */
+    tripleRatchetResize(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    /**
+     * Encrypt a message for an inbox (sealed sender / ECIES-style)
+     * @returns Base64-encoded sealed message
+     */
+    encryptInboxMessage(request: InboxMessageEncryptRequest): Promise<string>;
+    /**
+     * Decrypt a sealed inbox message
+     * @returns Decrypted plaintext as byte array
+     */
+    decryptInboxMessage(request: InboxMessageDecryptRequest): Promise<number[]>;
+}
+
+/**
+ * Encryption State Types and Storage Interface
+ *
+ * Platform-agnostic types for managing Double Ratchet encryption states.
+ * The actual storage implementation is platform-specific (MMKV for mobile, IndexedDB for desktop).
+ */
+/**
+ * DeviceKeys - Device's cryptographic keypairs for E2E encryption
+ * Used for X3DH key exchange and inbox message unsealing
+ */
+interface DeviceKeys {
+    /** X448 identity key for X3DH - private key */
+    identityPrivateKey: number[];
+    /** X448 identity key for X3DH - public key */
+    identityPublicKey: number[];
+    /** X448 signed pre-key for X3DH - private key */
+    preKeyPrivateKey: number[];
+    /** X448 signed pre-key for X3DH - public key */
+    preKeyPublicKey: number[];
+    /** X448 inbox encryption key for unsealing - private key */
+    inboxEncryptionPrivateKey: number[];
+    /** X448 inbox encryption key for unsealing - public key */
+    inboxEncryptionPublicKey: number[];
+}
+/**
+ * RecipientInfo - Recipient's public keys needed for encryption
+ * Used to establish X3DH session and seal messages
+ */
+interface RecipientInfo {
+    /** Recipient's address */
+    address: string;
+    /** X448 identity public key for X3DH */
+    identityKey: number[];
+    /** X448 signed pre-key for X3DH */
+    signedPreKey: number[];
+    /** Recipient's inbox address */
+    inboxAddress: string;
+    /** X448 public key for sealing envelopes to recipient's inbox */
+    inboxEncryptionKey?: number[];
+}
+/**
+ * EncryptedEnvelope - Result of encrypting a message
+ */
+interface EncryptedEnvelope {
+    /** The encrypted Double Ratchet envelope */
+    envelope: string;
+    /** Recipient's inbox address */
+    inboxAddress: string;
+    /** Ephemeral public key (only set for first message in new session) */
+    ephemeralPublicKey?: number[];
+    /** Ephemeral private key (only set for first message - needed for sealing) */
+    ephemeralPrivateKey?: number[];
+}
+/**
+ * KeyValueStorageProvider - Platform-agnostic key-value storage interface
+ *
+ * Implementations:
+ * - MMKV (React Native)
+ * - IndexedDB (Desktop/Web)
+ * - AsyncStorage (React Native fallback)
+ */
+interface KeyValueStorageProvider {
+    /**
+     * Get a string value by key
+     * @returns The value or null if not found
+     */
+    getString(key: string): string | null;
+    /**
+     * Set a string value
+     */
+    set(key: string, value: string): void;
+    /**
+     * Remove a key
+     */
+    remove(key: string): void;
+    /**
+     * Get all keys in storage
+     */
+    getAllKeys(): string[];
+    /**
+     * Clear all data from storage
+     */
+    clearAll(): void;
+}
+/**
+ * SendingInbox - Recipient's inbox info needed for sealing messages
+ * Matches desktop SDK's SendingInbox type
+ */
+interface SendingInbox {
+    /** Recipient's inbox address where we send to */
+    inbox_address: string;
+    /** Recipient's X448 public key for sealing (hex) */
+    inbox_encryption_key: string;
+    /** Recipient's Ed448 public key (hex) - empty until confirmed */
+    inbox_public_key: string;
+    /** Always empty - we don't have their private key */
+    inbox_private_key: string;
+}
+/**
+ * ReceivingInbox - Our inbox info for receiving replies
+ * Simplified version (full keypair stored separately in ConversationInboxKeypair)
+ */
+interface ReceivingInbox {
+    /** Our inbox address where we receive replies */
+    inbox_address: string;
+}
+/**
+ * EncryptionState - Double Ratchet state for a conversation+inbox pair
+ * Matches desktop's DoubleRatchetStateAndInboxKeys structure
+ */
+interface EncryptionState {
+    /** JSON-serialized ratchet state */
+    state: string;
+    /** When state was created/updated */
+    timestamp: number;
+    /** Conversation identifier */
+    conversationId: string;
+    /** Associated inbox ID (our receiving inbox) */
+    inboxId: string;
+    /** Whether we've sent an accept message */
+    sentAccept?: boolean;
+    /** Recipient's inbox info for sealing messages */
+    sendingInbox?: SendingInbox;
+    /** Session tag (usually our inbox address) */
+    tag?: string;
+    /**
+     * X3DH ephemeral public key (hex) used for session establishment.
+     * MUST be reused for all init envelopes until session is confirmed.
+     * This ensures the receiver can derive the same session key via X3DH.
+     */
+    x3dhEphemeralPublicKey?: string;
+    /**
+     * X3DH ephemeral private key (hex) used for session establishment.
+     * MUST be reused for sealing init envelopes until session is confirmed.
+     */
+    x3dhEphemeralPrivateKey?: string;
+}
+/**
+ * InboxMapping - Maps inbox address to conversation
+ */
+interface InboxMapping {
+    inboxId: string;
+    conversationId: string;
+}
+/**
+ * LatestState - Tracks the most recent state for a conversation
+ */
+interface LatestState {
+    conversationId: string;
+    inboxId: string;
+    timestamp: number;
+}
+/**
+ * ConversationInboxKeypair - Per-conversation inbox keypair for receiving replies
+ * Mirrors desktop's InboxKeyset structure with both Ed448 and X448 keys
+ */
+interface ConversationInboxKeypair {
+    conversationId: string;
+    inboxAddress: string;
+    /** X448 encryption public key (for sealing/unsealing messages) */
+    encryptionPublicKey: number[];
+    /** X448 encryption private key */
+    encryptionPrivateKey: number[];
+    /** Ed448 signing public key (for signing/verifying inbox messages) */
+    signingPublicKey?: number[];
+    /** Ed448 signing private key */
+    signingPrivateKey?: number[];
+}
+/**
+ * Storage key prefixes for encryption state data
+ */
+declare const ENCRYPTION_STORAGE_KEYS: {
+    /** enc_state:{conversationId}:{inboxId} */
+    readonly ENCRYPTION_STATE: "enc_state:";
+    /** inbox_map:{inboxId} */
+    readonly INBOX_MAPPING: "inbox_map:";
+    /** latest:{conversationId} */
+    readonly LATEST_STATE: "latest:";
+    /** conv_inboxes:{conversationId} -> inboxId[] */
+    readonly CONVERSATION_INBOXES: "conv_inboxes:";
+    /** conv_inbox_key:{conversationId} -> ConversationInboxKeypair */
+    readonly CONVERSATION_INBOX_KEY: "conv_inbox_key:";
+};
+/**
+ * EncryptionStateStorageInterface - Interface for managing encryption states
+ *
+ * This interface defines the contract for encryption state storage.
+ * Implementations use platform-specific storage backends.
+ */
+interface EncryptionStateStorageInterface {
+    getEncryptionState(conversationId: string, inboxId: string): EncryptionState | null;
+    getEncryptionStates(conversationId: string): EncryptionState[];
+    saveEncryptionState(state: EncryptionState, updateLatest?: boolean): void;
+    deleteEncryptionState(conversationId: string, inboxId: string): void;
+    deleteAllEncryptionStates(conversationId: string): void;
+    getInboxMapping(inboxId: string): InboxMapping | null;
+    saveInboxMapping(inboxId: string, conversationId: string): void;
+    deleteInboxMapping(inboxId: string): void;
+    getLatestState(conversationId: string): LatestState | null;
+    saveConversationInboxKeypair(keypair: ConversationInboxKeypair): void;
+    getConversationInboxKeypair(conversationId: string): ConversationInboxKeypair | null;
+    deleteConversationInboxKeypair(conversationId: string): void;
+    getConversationInboxKeypairByAddress(inboxAddress: string): ConversationInboxKeypair | null;
+    getAllConversationInboxAddresses(): string[];
+    clearAll(): void;
+    hasEncryptionState(conversationId: string): boolean;
+    getStatesByInboxId(inboxId: string): Array<{
+        conversationId: string;
+        state: EncryptionState;
+    }>;
+}
+
+/**
+ * WASM CryptoProvider implementation
+ *
+ * Wraps the channel-wasm WASM module to implement the CryptoProvider interface.
+ * Used by desktop/web applications.
+ *
+ * Note: This file imports from the WASM module dynamically to avoid bundling
+ * issues in environments that don't support WASM.
+ */
+
+/**
+ * Interface for the WASM module functions
+ * This matches the exports from channel-wasm
+ */
+interface ChannelWasmModule {
+    js_generate_x448(): string;
+    js_generate_ed448(): string;
+    js_get_pubkey_x448(key: string): string;
+    js_get_pubkey_ed448(key: string): string;
+    js_sign_ed448(key: string, message: string): string;
+    js_verify_ed448(publicKey: string, message: string, signature: string): string;
+    js_sender_x3dh(input: string): string;
+    js_receiver_x3dh(input: string): string;
+    js_new_double_ratchet(params: string): string;
+    js_double_ratchet_encrypt(params: string): string;
+    js_double_ratchet_decrypt(params: string): string;
+    js_new_triple_ratchet(params: string): string;
+    js_triple_ratchet_init_round_1(params: string): string;
+    js_triple_ratchet_init_round_2(params: string): string;
+    js_triple_ratchet_init_round_3(params: string): string;
+    js_triple_ratchet_init_round_4(params: string): string;
+    js_triple_ratchet_encrypt(params: string): string;
+    js_triple_ratchet_decrypt(params: string): string;
+    js_triple_ratchet_resize(params: string): string;
+    js_encrypt_inbox_message(input: string): string;
+    js_decrypt_inbox_message(input: string): string;
+}
+/**
+ * WasmCryptoProvider - Implements CryptoProvider using channel-wasm
+ */
+declare class WasmCryptoProvider implements CryptoProvider {
+    private wasm;
+    constructor(wasmModule: ChannelWasmModule);
+    generateX448(): Promise<X448Keypair>;
+    generateEd448(): Promise<Ed448Keypair>;
+    getPublicKeyX448(privateKey: string): Promise<string>;
+    getPublicKeyEd448(privateKey: string): Promise<string>;
+    senderX3DH(params: SenderX3DHParams): Promise<string>;
+    receiverX3DH(params: ReceiverX3DHParams): Promise<string>;
+    newDoubleRatchet(params: NewDoubleRatchetParams): Promise<string>;
+    doubleRatchetEncrypt(stateAndMessage: DoubleRatchetStateAndMessage): Promise<DoubleRatchetStateAndEnvelope>;
+    doubleRatchetDecrypt(stateAndEnvelope: DoubleRatchetStateAndEnvelope): Promise<DoubleRatchetStateAndMessage>;
+    newTripleRatchet(params: NewTripleRatchetParams): Promise<TripleRatchetStateAndMetadata>;
+    tripleRatchetInitRound1(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    tripleRatchetInitRound2(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    tripleRatchetInitRound3(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    tripleRatchetInitRound4(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    tripleRatchetEncrypt(stateAndMessage: TripleRatchetStateAndMessage): Promise<TripleRatchetStateAndEnvelope>;
+    tripleRatchetDecrypt(stateAndEnvelope: TripleRatchetStateAndEnvelope): Promise<TripleRatchetStateAndMessage>;
+    tripleRatchetResize(state: TripleRatchetStateAndMetadata): Promise<TripleRatchetStateAndMetadata>;
+    encryptInboxMessage(request: InboxMessageEncryptRequest): Promise<string>;
+    decryptInboxMessage(request: InboxMessageDecryptRequest): Promise<number[]>;
+}
+
+/**
+ * Signing types and SigningProvider interface
+ *
+ * Platform-agnostic message signing and verification.
+ * Uses Ed448 for all signing operations.
+ */
+/**
+ * SigningProvider - Platform-agnostic interface for cryptographic signing
+ *
+ * Implementations:
+ * - WASM (desktop/web): Uses channel-wasm js_sign_ed448/js_verify_ed448
+ * - Native (iOS/Android): Uses uniffi-generated bindings
+ */
+interface SigningProvider {
+    /**
+     * Sign a message using Ed448
+     * @param privateKey Base64-encoded Ed448 private key (56 bytes)
+     * @param message Base64-encoded message to sign
+     * @returns Base64-encoded signature (114 bytes)
+     */
+    signEd448(privateKey: string, message: string): Promise<string>;
+    /**
+     * Verify an Ed448 signature
+     * @param publicKey Base64-encoded Ed448 public key (57 bytes)
+     * @param message Base64-encoded original message
+     * @param signature Base64-encoded signature to verify
+     * @returns true if signature is valid, false otherwise
+     */
+    verifyEd448(publicKey: string, message: string, signature: string): Promise<boolean>;
+}
+/**
+ * Signed message structure
+ */
+interface SignedMessage {
+    /** The message content (may be encrypted) */
+    content: string;
+    /** Base64-encoded Ed448 signature */
+    signature: string;
+    /** Base64-encoded Ed448 public key of signer */
+    publicKey: string;
+    /** Timestamp when signed */
+    timestamp: number;
+}
+/**
+ * Verify a signed message structure
+ */
+declare function verifySignedMessage(provider: SigningProvider, message: SignedMessage): Promise<boolean>;
+/**
+ * Create a signed message
+ */
+declare function createSignedMessage(provider: SigningProvider, privateKey: string, publicKey: string, content: string): Promise<SignedMessage>;
+
+/**
+ * WASM SigningProvider implementation
+ *
+ * Wraps the channel-wasm WASM module to implement the SigningProvider interface.
+ * Used by desktop/web applications.
+ */
+
+/**
+ * WasmSigningProvider - Implements SigningProvider using channel-wasm
+ */
+declare class WasmSigningProvider implements SigningProvider {
+    private wasm;
+    constructor(wasmModule: ChannelWasmModule);
+    signEd448(privateKey: string, message: string): Promise<string>;
+    verifyEd448(publicKey: string, message: string, signature: string): Promise<boolean>;
+}
+
+/**
+ * Transport types and interfaces
+ *
+ * Platform-agnostic transport layer for HTTP and IPC communication.
+ */
+interface TransportConfig {
+    baseUrl: string;
+    timeout?: number;
+    defaultHeaders?: Record<string, string>;
+}
+interface TransportRequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface TransportResponse<T> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+}
+/**
+ * TransportClient - Platform-agnostic HTTP transport
+ *
+ * Implementations:
+ * - Fetch (mobile/web): Uses native fetch API
+ * - Electron IPC (desktop): Uses Electron IPC for main process requests
+ */
+interface TransportClient {
+    /**
+     * Make an HTTP request
+     */
+    request<T>(endpoint: string, options?: TransportRequestOptions): Promise<TransportResponse<T>>;
+    /**
+     * Configure the transport client
+     */
+    configure(config: TransportConfig): void;
+    /**
+     * Set authorization header for all requests
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Clear authorization
+     */
+    clearAuth(): void;
+}
+
+/**
+ * WebSocket client interface
+ *
+ * Platform-agnostic WebSocket connection management.
+ * Handles connection, reconnection, and message routing.
+ *
+ * IMPORTANT: This handles transport only. Encryption is handled separately
+ * by the CryptoProvider before/after message transmission.
+ */
+type WebSocketConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+/**
+ * Encrypted message received from WebSocket
+ * The content is a SealedMessage containing the encrypted envelope.
+ * All cryptographic material (ephemeral key, identity key) comes from the envelope itself.
+ */
+interface EncryptedWebSocketMessage {
+    /** The encrypted message content (JSON string of SealedMessage) */
+    encryptedContent: string;
+    /** The inbox address this message was sent to */
+    inboxAddress: string;
+    /** Server timestamp */
+    timestamp: number;
+}
+/**
+ * SealedMessage format from the network
+ * Contains an encrypted envelope that can be unsealed with device keys.
+ * The ephemeral_public_key is used along with the inbox private key to decrypt.
+ */
+interface SealedMessage {
+    /** The inbox address the message was sent to */
+    inbox_address: string;
+    /** Sender's ephemeral public key (used for decryption) */
+    ephemeral_public_key: string;
+    /** The encrypted envelope (contains identity key, message, return inbox info) */
+    envelope: string;
+    /** Optional inbox public key for verification */
+    inbox_public_key?: string;
+    /** Optional inbox signature for verification */
+    inbox_signature?: string;
+}
+/**
+ * UnsealedEnvelope - the decrypted content of a SealedMessage
+ * Contains all the data needed to establish a session and decrypt the message.
+ */
+interface UnsealedEnvelope {
+    /** Sender's user address */
+    user_address: string;
+    /** Sender's display name */
+    display_name?: string;
+    /** Sender's icon URL */
+    user_icon?: string;
+    /** Inbox address for sending replies */
+    return_inbox_address: string;
+    /** Encryption key for the return inbox */
+    return_inbox_encryption_key: string;
+    /** Public key for the return inbox */
+    return_inbox_public_key: string;
+    /** Private key for the return inbox (only for sender's own use) */
+    return_inbox_private_key: string;
+    /** Sender's identity public key (for X3DH) */
+    identity_public_key: string;
+    /** Session/conversation tag */
+    tag: string;
+    /** The encrypted/signed message content */
+    message: string;
+    /** Message type */
+    type: string;
+    /** The ephemeral public key used to seal this message */
+    ephemeral_public_key: string;
+}
+/**
+ * Outbound message to send via WebSocket
+ */
+interface OutboundWebSocketMessage {
+    /** Message type (e.g., 'message', 'listen', 'unlisten') */
+    type: string;
+    /** Message payload */
+    payload: unknown;
+}
+/**
+ * Listen/subscribe message for inbox addresses
+ */
+interface ListenMessage {
+    type: 'listen';
+    inbox_addresses: string[];
+}
+/**
+ * Unlisten/unsubscribe message
+ */
+interface UnlistenMessage {
+    type: 'unlisten';
+    inbox_addresses: string[];
+}
+interface WebSocketClientOptions {
+    /** WebSocket server URL */
+    url: string;
+    /** Interval between reconnection attempts (ms). Default: 1000 */
+    reconnectInterval?: number;
+    /** Maximum reconnection attempts. Default: Infinity */
+    maxReconnectAttempts?: number;
+    /** Queue processing interval (ms). Default: 1000 */
+    queueProcessInterval?: number;
+}
+type MessageHandler = (message: EncryptedWebSocketMessage) => Promise<void>;
+type StateChangeHandler = (state: WebSocketConnectionState) => void;
+type ErrorHandler = (error: Error) => void;
+/**
+ * WebSocketClient - Platform-agnostic WebSocket interface
+ *
+ * Features:
+ * - Automatic reconnection with configurable interval
+ * - Dual queue system (inbound/outbound)
+ * - Inbox address subscription management
+ * - Message handler registration
+ *
+ * Implementations:
+ * - Browser/Electron: Uses native WebSocket API
+ * - React Native: Uses React Native WebSocket
+ */
+interface WebSocketClient {
+    /**
+     * Current connection state
+     */
+    readonly state: WebSocketConnectionState;
+    /**
+     * Whether currently connected
+     */
+    readonly isConnected: boolean;
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Send a message (must be already serialized)
+     * Messages are queued if not connected and sent when connection is established
+     */
+    send(message: string): Promise<void>;
+    /**
+     * Enqueue an outbound message with async preparation
+     * Useful when message needs async work before sending
+     */
+    enqueueOutbound(prepareMessage: () => Promise<string[]>): void;
+    /**
+     * Subscribe to messages for inbox addresses
+     */
+    subscribe(inboxAddresses: string[]): Promise<void>;
+    /**
+     * Unsubscribe from inbox addresses
+     */
+    unsubscribe(inboxAddresses: string[]): Promise<void>;
+    /**
+     * Set the message handler for incoming messages
+     * Only one handler can be set at a time
+     */
+    setMessageHandler(handler: MessageHandler): void;
+    /**
+     * Set the resubscribe callback (called after reconnection)
+     */
+    setResubscribeHandler(handler: () => Promise<void>): void;
+    /**
+     * Add a connection state change listener
+     * @returns Unsubscribe function
+     */
+    onStateChange(handler: StateChangeHandler): () => void;
+    /**
+     * Add an error listener
+     * @returns Unsubscribe function
+     */
+    onError(handler: ErrorHandler): () => void;
+}
+/**
+ * Factory function to create a WebSocket client
+ */
+type CreateWebSocketClient = (options: WebSocketClientOptions) => WebSocketClient;
+
+/**
+ * Browser/Electron WebSocket client implementation
+ *
+ * Uses the native WebSocket API available in browsers and Electron.
+ * Implements automatic reconnection, dual queue system, and subscription management.
+ */
+
+/**
+ * BrowserWebSocketClient - WebSocket implementation for browser/Electron
+ *
+ * Features:
+ * - Automatic reconnection with configurable interval
+ * - Dual queue system (inbound messages, outbound message generators)
+ * - Inbox address subscription management
+ * - Periodic queue processing
+ */
+declare class BrowserWebSocketClient implements WebSocketClient {
+    private url;
+    private reconnectInterval;
+    private maxReconnectAttempts;
+    private queueProcessInterval;
+    private ws;
+    private _state;
+    private reconnectAttempts;
+    private shouldReconnect;
+    private inboundQueue;
+    private outboundQueue;
+    private isProcessing;
+    private processIntervalId;
+    private messageHandler;
+    private resubscribeHandler;
+    private stateChangeHandlers;
+    private errorHandlers;
+    constructor(options: WebSocketClientOptions);
+    get state(): WebSocketConnectionState;
+    get isConnected(): boolean;
+    private setState;
+    private emitError;
+    connect(): Promise<void>;
+    private doConnect;
+    disconnect(): void;
+    send(message: string): Promise<void>;
+    enqueueOutbound(prepareMessage: () => Promise<string[]>): void;
+    subscribe(inboxAddresses: string[]): Promise<void>;
+    unsubscribe(inboxAddresses: string[]): Promise<void>;
+    setMessageHandler(handler: MessageHandler): void;
+    setResubscribeHandler(handler: () => Promise<void>): void;
+    onStateChange(handler: StateChangeHandler): () => void;
+    onError(handler: ErrorHandler): () => void;
+    private startQueueProcessing;
+    private stopQueueProcessing;
+    private processQueues;
+}
+/**
+ * Factory function to create a browser WebSocket client
+ */
+declare function createBrowserWebSocketClient(options: WebSocketClientOptions): WebSocketClient;
+
+/**
+ * React Native WebSocket client implementation
+ *
+ * Uses the React Native WebSocket API which is similar to the browser's.
+ * Implements automatic reconnection, dual queue system, and subscription management.
+ *
+ * Note: This implementation is nearly identical to browser-websocket.ts
+ * but kept separate to allow for React Native-specific optimizations if needed.
+ */
+
+/**
+ * RNWebSocketClient - WebSocket implementation for React Native
+ *
+ * Features:
+ * - Automatic reconnection with configurable interval
+ * - Dual queue system (inbound messages, outbound message generators)
+ * - Inbox address subscription management
+ * - Periodic queue processing
+ */
+declare class RNWebSocketClient implements WebSocketClient {
+    private url;
+    private reconnectInterval;
+    private maxReconnectAttempts;
+    private queueProcessInterval;
+    private ws;
+    private _state;
+    private reconnectAttempts;
+    private shouldReconnect;
+    private inboundQueue;
+    private outboundQueue;
+    private isProcessing;
+    private processIntervalId;
+    private messageHandler;
+    private resubscribeHandler;
+    private stateChangeHandlers;
+    private errorHandlers;
+    constructor(options: WebSocketClientOptions);
+    get state(): WebSocketConnectionState;
+    get isConnected(): boolean;
+    private setState;
+    private emitError;
+    connect(): Promise<void>;
+    private doConnect;
+    disconnect(): void;
+    send(message: string): Promise<void>;
+    enqueueOutbound(prepareMessage: () => Promise<string[]>): void;
+    subscribe(inboxAddresses: string[]): Promise<void>;
+    unsubscribe(inboxAddresses: string[]): Promise<void>;
+    setMessageHandler(handler: MessageHandler): void;
+    setResubscribeHandler(handler: () => Promise<void>): void;
+    onStateChange(handler: StateChangeHandler): () => void;
+    onError(handler: ErrorHandler): () => void;
+    private startQueueProcessing;
+    private stopQueueProcessing;
+    private processQueues;
+}
+/**
+ * Factory function to create a React Native WebSocket client
+ */
+declare function createRNWebSocketClient(options: WebSocketClientOptions): WebSocketClient;
+
+/**
+ * Sync Utility Functions
+ *
+ * Hash computation, digest creation, and delta calculation for sync protocol.
+ */
+
+/** Maximum chunk size for message transmission (5MB) */
+declare const MAX_CHUNK_SIZE: number;
+/** Default sync request expiry (30 seconds) */
+declare const DEFAULT_SYNC_EXPIRY_MS = 30000;
+/** Aggressive sync timeout after receiving first response (1 second) */
+declare const AGGRESSIVE_SYNC_TIMEOUT_MS = 1000;
+/**
+ * Compute SHA-256 hash of a string
+ */
+declare function computeHash(data: string): string;
+/**
+ * Compute hash of message content for comparison.
+ * Uses canonical representation: senderId + type + content-specific fields
+ */
+declare function computeContentHash(message: Message): string;
+/**
+ * Compute hash of reaction state for a message
+ */
+declare function computeReactionHash(reactions: Reaction[]): string;
+/**
+ * Compute hash of member's mutable fields
+ */
+declare function computeMemberHash(member: SpaceMember): {
+    displayNameHash: string;
+    iconHash: string;
+};
+/**
+ * Compute manifest hash for quick comparison.
+ * Hash of sorted message IDs.
+ */
+declare function computeManifestHash(digests: MessageDigest[]): string;
+/**
+ * Create digest from message
+ */
+declare function createMessageDigest(message: Message): MessageDigest;
+/**
+ * Create reaction digest for a message
+ */
+declare function createReactionDigest(messageId: string, reactions: Reaction[]): ReactionDigest[];
+/**
+ * Create manifest from messages
+ */
+declare function createManifest(spaceId: string, channelId: string, messages: Message[]): SyncManifest;
+/**
+ * Create member digest
+ */
+declare function createMemberDigest(member: SpaceMember): MemberDigest;
+interface MessageDiffResult {
+    /** Message IDs we don't have */
+    missingIds: string[];
+    /** Message IDs we have but are outdated (content changed) */
+    outdatedIds: string[];
+    /** Message IDs we have but they don't (we should send to them) */
+    extraIds: string[];
+}
+/**
+ * Compare manifests and determine what messages differ
+ */
+declare function computeMessageDiff(ourManifest: SyncManifest, theirManifest: SyncManifest): MessageDiffResult;
+interface ReactionDiffResult {
+    /** Reactions to add: { messageId, emojiId, memberIds to add } */
+    toAdd: Array<{
+        messageId: string;
+        emojiId: string;
+        memberIds: string[];
+    }>;
+    /** Reactions to remove: { messageId, emojiId, memberIds to remove } */
+    toRemove: Array<{
+        messageId: string;
+        emojiId: string;
+        memberIds: string[];
+    }>;
+}
+/**
+ * Compare reaction digests and determine differences.
+ * This requires the full reaction data to compute actual member diffs.
+ */
+declare function computeReactionDiff(ourReactions: Map<string, Reaction[]>, // messageId -> reactions
+theirDigests: ReactionDigest[]): ReactionDiffResult;
+interface MemberDiffResult {
+    /** Member addresses we don't have */
+    missingAddresses: string[];
+    /** Member addresses where our data is outdated */
+    outdatedAddresses: string[];
+    /** Member addresses we have that they don't */
+    extraAddresses: string[];
+}
+/**
+ * Compare member digests and determine differences
+ */
+declare function computeMemberDiff(ourDigests: MemberDigest[], theirDigests: MemberDigest[]): MemberDiffResult;
+interface PeerDiffResult {
+    /** Peer IDs they have that we don't */
+    missingPeerIds: number[];
+    /** Peer IDs we have that they don't */
+    extraPeerIds: number[];
+}
+/**
+ * Compare peer ID sets
+ */
+declare function computePeerDiff(ourPeerIds: number[], theirPeerIds: number[]): PeerDiffResult;
+/**
+ * Build message delta from diff result and message lookup
+ */
+declare function buildMessageDelta(spaceId: string, channelId: string, diff: MessageDiffResult, messageMap: Map<string, Message>, tombstones: DeletedMessageTombstone[]): MessageDelta;
+/**
+ * Build reaction delta for messages
+ */
+declare function buildReactionDelta(spaceId: string, channelId: string, messageMap: Map<string, Message>, messageIds: string[]): ReactionDelta;
+/**
+ * Build member delta from diff result and member lookup
+ */
+declare function buildMemberDelta(spaceId: string, diff: MemberDiffResult, memberMap: Map<string, SpaceMember>): MemberDelta;
+/**
+ * Chunk messages for transmission to stay under size limit
+ */
+declare function chunkMessages(messages: Message[]): Message[][];
+/**
+ * Chunk members for transmission
+ */
+declare function chunkMembers(members: SpaceMember[]): SpaceMember[][];
+/**
+ * Create sync summary from messages and members
+ */
+declare function createSyncSummary(messages: Message[], memberCount: number): {
+    memberCount: number;
+    messageCount: number;
+    newestMessageTimestamp: number;
+    oldestMessageTimestamp: number;
+    manifestHash: string;
+};
+
+/**
+ * SyncService
+ *
+ * Platform-agnostic sync orchestration logic.
+ * Handles sync protocol without encryption (that's platform-specific).
+ *
+ * Usage:
+ * 1. Platform creates SyncService with storage adapter
+ * 2. Platform calls build* methods to create payloads
+ * 3. Platform handles encryption and transmission
+ * 4. Platform calls apply* methods to process received data
+ */
+
+interface SyncServiceConfig {
+    storage: StorageAdapter;
+    /** Maximum messages to include in sync (default: 1000) */
+    maxMessages?: number;
+    /** Sync request expiry in ms (default: 30000) */
+    requestExpiry?: number;
+    /** Callback when sync should be initiated */
+    onInitiateSync?: (spaceId: string, target: string) => void;
+    /** Cache TTL in ms (default: 5000) */
+    cacheTtl?: number;
+}
+declare class SyncService {
+    private storage;
+    private maxMessages;
+    private requestExpiry;
+    private onInitiateSync?;
+    /** Active sync sessions by spaceId */
+    private sessions;
+    /** Deleted message tombstones (caller must persist these) */
+    private tombstones;
+    /** Pre-computed sync payload cache per space:channel - always ready to use */
+    private payloadCache;
+    constructor(config: SyncServiceConfig);
+    /**
+     * Get cache key for space/channel
+     */
+    private getCacheKey;
+    /**
+     * Get or initialize the payload cache for a space/channel.
+     * If not cached, loads from storage and builds the payload once.
+     */
+    private getPayloadCache;
+    /**
+     * Build the payload cache from messages and members
+     */
+    private buildPayloadCache;
+    /**
+     * Rebuild derived fields (manifest, digests, summary) from the maps
+     */
+    private rebuildPayloadCache;
+    /**
+     * Invalidate cache for a space/channel (forces reload from storage on next access)
+     */
+    invalidateCache(spaceId: string, channelId?: string): void;
+    /**
+     * Update cache with a new/updated message (incremental update - no storage query)
+     */
+    updateCacheWithMessage(spaceId: string, channelId: string, message: Message): void;
+    /**
+     * Remove a message from cache (incremental update - no storage query)
+     */
+    removeCacheMessage(spaceId: string, channelId: string, messageId: string): void;
+    /**
+     * Update cache with a new/updated member (incremental update - no storage query)
+     */
+    updateCacheWithMember(spaceId: string, channelId: string, member: SpaceMember): void;
+    /**
+     * Check if cache exists for a space/channel
+     */
+    hasCachedPayload(spaceId: string, channelId: string): boolean;
+    /**
+     * Check if a sync session is active for a space
+     */
+    hasActiveSession(spaceId: string): boolean;
+    /**
+     * Check if sync is in progress for a space
+     */
+    isSyncInProgress(spaceId: string): boolean;
+    /**
+     * Mark sync as in progress
+     */
+    setSyncInProgress(spaceId: string, inProgress: boolean): void;
+    /**
+     * Set the sync target (who we're syncing with)
+     */
+    setSyncTarget(spaceId: string, targetInbox: string): void;
+    /**
+     * Get the sync target for a space
+     */
+    getSyncTarget(spaceId: string): string | undefined;
+    /**
+     * Build sync-request payload to broadcast via hub
+     */
+    buildSyncRequest(spaceId: string, channelId: string, inboxAddress: string): Promise<SyncRequestPayload>;
+    /**
+     * Schedule sync initiation after timeout
+     */
+    scheduleSyncInitiation(spaceId: string, callback: () => void, timeoutMs?: number): void;
+    /**
+     * Build sync-info response if we have useful data.
+     * Returns null if we have nothing to offer or are already in sync.
+     */
+    buildSyncInfo(spaceId: string, channelId: string, inboxAddress: string, theirSummary: SyncSummary): Promise<SyncInfoPayload | null>;
+    /**
+     * Add candidate from sync-info response
+     */
+    addCandidate(spaceId: string, candidate: SyncCandidate): void;
+    /**
+     * Select best candidate based on data availability
+     */
+    selectBestCandidate(spaceId: string): SyncCandidate | null;
+    /**
+     * Build sync-initiate payload for selected peer
+     */
+    buildSyncInitiate(spaceId: string, channelId: string, inboxAddress: string, peerIds: number[]): Promise<{
+        target: string;
+        payload: SyncInitiatePayload;
+    } | null>;
+    /**
+     * Build sync-manifest response to sync-initiate
+     */
+    buildSyncManifest(spaceId: string, channelId: string, peerIds: number[], inboxAddress: string): Promise<SyncManifestPayload>;
+    /**
+     * Build sync-delta payloads based on manifest comparison.
+     * May return multiple payloads for chunking.
+     */
+    buildSyncDelta(spaceId: string, channelId: string, theirManifest: SyncManifest, theirMemberDigests: MemberDigest[], theirPeerIds: number[], ourPeerEntries: Map<number, PeerEntry>): Promise<SyncDeltaPayload[]>;
+    /**
+     * Apply received message delta to local storage
+     */
+    applyMessageDelta(delta: MessageDelta): Promise<void>;
+    /**
+     * Apply received reaction delta to local storage.
+     * This updates the reactions on existing messages.
+     */
+    applyReactionDelta(delta: ReactionDelta): Promise<void>;
+    /**
+     * Apply received member delta to local storage
+     */
+    applyMemberDelta(delta: MemberDelta): Promise<void>;
+    /**
+     * Apply full sync delta
+     */
+    applySyncDelta(delta: SyncDeltaPayload): Promise<void>;
+    /**
+     * Record a deleted message tombstone
+     */
+    addTombstone(tombstone: DeletedMessageTombstone): void;
+    /**
+     * Get all tombstones (for persistence by caller)
+     */
+    getTombstones(): DeletedMessageTombstone[];
+    /**
+     * Load tombstones (from caller's persistence)
+     */
+    loadTombstones(tombstones: DeletedMessageTombstone[]): void;
+    /**
+     * Clean up old tombstones (older than 30 days)
+     */
+    cleanupTombstones(maxAgeMs?: number): void;
+    private getChannelMessages;
+    /**
+     * Clean up expired sessions
+     */
+    cleanupSessions(): void;
+    /**
+     * Cancel active sync for a space
+     */
+    cancelSync(spaceId: string): void;
+}
+
+export { AGGRESSIVE_SYNC_TIMEOUT_MS, type AddReactionParams, type ApiConfig, ApiError, ApiErrorCode, type ApiErrorDetails, BOOKMARKS_CONFIG, type Bookmark, BrowserWebSocketClient, type Channel, type ChannelWasmModule, type ChannelsKey, type Conversation, type ConversationInboxKeypair, type ConversationSource, type CreateWebSocketClient, type CryptoProvider, DEFAULT_SYNC_EXPIRY_MS, type DeleteConversationMessage, type DeleteMessageParams, type DeletedMessageTombstone, type DeviceKeys, type DoubleRatchetStateAndEnvelope, type DoubleRatchetStateAndMessage, ENCRYPTION_STORAGE_KEYS, type Ed448Keypair, type EditMessage, type EditMessageParams, type EmbedMessage, type Emoji, type EncryptedEnvelope, type EncryptedWebSocketMessage, type EncryptionState, type EncryptionStateStorageInterface, type ErrorHandler, type EventMessage, type FolderColor, type GetMessagesParams, type GetMessagesResult, type Group, type HttpMethod, type InboxMapping, type InboxMessageDecryptRequest, type InboxMessageEncryptRequest, type InitializationEnvelope, type JoinMessage, type KeyValueStorageProvider, type Keypair, type KickMessage, type LatestState, type LeaveMessage, type ListenMessage, MAX_CHUNK_SIZE, MAX_MENTIONS, MAX_MESSAGE_LENGTH, MENTION_PATTERNS, type MemberDelta, type MemberDiffResult, type MemberDigest, type Mentions, type Message, type MessageCiphertext, type MessageContent, type MessageDelta, type MessageDiffResult, type MessageDigest, type MessageHandler, type MessageListParams, type MessageSendStatus, type MessagesInfiniteKey, type MuteMessage, type NavItem, type NewDoubleRatchetParams, type NewTripleRatchetParams, type NotificationSettings, type OutboundWebSocketMessage, type P2PChannelEnvelope, type PaginationParams, type ParsedMention, type PeerDiffResult, type PeerEntry, type PeerInfo, type PeerMapDelta, type Permission, type PinMessage, type PostMessage, type QuorumApiClient, RNWebSocketClient, type Reaction, type ReactionDelta, type ReactionDiffResult, type ReactionDigest, type ReactionMessage, type ReceiverX3DHParams, type ReceivingInbox, type RecipientInfo, type RemoveMessage, type RemoveReactionMessage, type RemoveReactionParams, type RequestOptions, type Role, type SealedMessage, type SendDirectMessageParams, type SendMessageParams, type SenderX3DHParams, type SendingInbox, type SignedMessage, type SigningProvider, type Space, type SpaceDetailKey, type SpaceMember, type SpacesKey, type StateChangeHandler, type Sticker, type StickerMessage, type StorageAdapter, type SyncCandidate, type SyncControlPayload, type SyncDeltaPayload, type SyncInfoPayload, type SyncInitiatePayload, type SyncManifest, type SyncManifestPayload, type SyncRequestPayload, SyncService, type SyncServiceConfig, type SyncSession, type SyncSummary, type TransportClient, type TransportConfig, type TransportRequestOptions, type TransportResponse, type TripleRatchetStateAndEnvelope, type TripleRatchetStateAndMessage, type TripleRatchetStateAndMetadata, type UnlistenMessage, type UnsealedEnvelope, type UpdateProfileMessage, type UseChannelsOptions, type UseDeleteMessageOptions, type UseEditMessageOptions, type UseMessagesOptions, type UseReactionOptions, type UseSendMessageOptions, type UseSpaceOptions, type UseSpacesOptions, type UserConfig, type UserProfile, type ValidationResult, WasmCryptoProvider, WasmSigningProvider, type WebSocketClient, type WebSocketClientOptions, type WebSocketConnectionState, type X448Keypair, base64ToBytes, buildMemberDelta, buildMessageDelta, buildReactionDelta, bytesToBase64, bytesToHex, bytesToString, chunkMembers, chunkMessages, computeContentHash, computeHash, computeManifestHash, computeMemberDiff, computeMemberHash, computeMessageDiff, computePeerDiff, computeReactionDiff, computeReactionHash, createApiError, createBrowserWebSocketClient, createManifest, createMemberDigest, createMessageDigest, createNetworkError, createRNWebSocketClient, createReactionDigest, createSignedMessage, createSyncSummary, endpoints, extractMentions, findChannel, flattenChannels, flattenMessages, formatDate, formatDateTime, formatFileSize, formatMemberCount, formatMention, formatMessageDate, formatRelativeTime, formatTime, hexToBytes, int64ToBytes, isSameDay, isSyncDelta, isSyncInfo, isSyncInitiate, isSyncManifest, isSyncRequest, logger, parseMentions, queryKeys, sanitizeContent, stringToBytes, truncateText, useAddReaction, useChannels, useDeleteMessage, useEditMessage, useInvalidateMessages, useMessages, useRemoveReaction, useSendMessage, useSpace, useSpaceMembers, useSpaces, validateMessage, validateMessageContent, verifySignedMessage };