@prismer/sdk 1.3.4 → 1.7.0

package/dist/index.d.ts

@@ -95,12 +95,12 @@ interface RealtimeConfig {
     fetch?: typeof fetch;
 }
 type RealtimeState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
-type Listener<T> = (payload: T) => void;
+type Listener$1<T> = (payload: T) => void;
 declare class TypedEmitter {
     private listeners;
-    on<E extends RealtimeEventType>(event: E, cb: Listener<RealtimeEventMap[E]>): this;
-    off<E extends RealtimeEventType>(event: E, cb: Listener<RealtimeEventMap[E]>): this;
-    once<E extends RealtimeEventType>(event: E, cb: Listener<RealtimeEventMap[E]>): this;
+    on<E extends RealtimeEventType>(event: E, cb: Listener$1<RealtimeEventMap[E]>): this;
+    off<E extends RealtimeEventType>(event: E, cb: Listener$1<RealtimeEventMap[E]>): this;
+    once<E extends RealtimeEventType>(event: E, cb: Listener$1<RealtimeEventMap[E]>): this;
     protected emit<E extends RealtimeEventType>(event: E, payload: RealtimeEventMap[E]): void;
     protected removeAllListeners(): void;
 }
@@ -160,8 +160,247 @@ declare class RealtimeSSEClient extends TypedEmitter {
 }
 
 /**
- * Prismer Cloud SDK — Type definitions
+ * Prismer SDK — Storage adapters for offline-first IM.
+ *
+ * Three built-in implementations:
+ *   - MemoryStorage   — in-process Map, for tests / stateless agents
+ *   - IndexedDBStorage — browser-persistent, for web apps
+ *   - (future) SQLiteStorage — Node.js / React Native
  */
+interface StoredMessage {
+    id: string;
+    clientId?: string;
+    conversationId: string;
+    content: string;
+    type: string;
+    senderId: string;
+    parentId?: string | null;
+    status: 'pending' | 'sent' | 'confirmed' | 'failed';
+    metadata?: Record<string, any>;
+    createdAt: string;
+    updatedAt?: string;
+    syncSeq?: number;
+}
+interface StoredConversation {
+    id: string;
+    type: 'direct' | 'group';
+    title?: string;
+    lastMessage?: StoredMessage;
+    lastMessageAt?: string;
+    unreadCount: number;
+    lastReadMessageId?: string;
+    members?: Array<{
+        userId: string;
+        username: string;
+        displayName?: string;
+        role: string;
+    }>;
+    metadata?: Record<string, any>;
+    syncSeq?: number;
+    updatedAt: string;
+}
+interface StoredContact {
+    userId: string;
+    username: string;
+    displayName: string;
+    role: string;
+    conversationId: string;
+    lastMessageAt?: string;
+    unreadCount: number;
+    syncSeq?: number;
+}
+interface OutboxOperation {
+    id: string;
+    type: 'message.send' | 'message.edit' | 'message.delete' | 'conversation.read';
+    method: string;
+    path: string;
+    body?: unknown;
+    query?: Record<string, string>;
+    status: 'pending' | 'inflight' | 'confirmed' | 'failed';
+    createdAt: number;
+    retries: number;
+    maxRetries: number;
+    lastError?: string;
+    idempotencyKey: string;
+    /** Local data for optimistic UI (e.g., the pending message) */
+    localData?: unknown;
+}
+interface StorageAdapter {
+    /** Initialize the storage (open DB, create tables, etc.) */
+    init(): Promise<void>;
+    putMessages(messages: StoredMessage[]): Promise<void>;
+    getMessages(conversationId: string, opts: {
+        limit: number;
+        before?: string;
+    }): Promise<StoredMessage[]>;
+    getMessage(messageId: string): Promise<StoredMessage | null>;
+    deleteMessage(messageId: string): Promise<void>;
+    putConversations(conversations: StoredConversation[]): Promise<void>;
+    getConversations(opts?: {
+        limit: number;
+        offset?: number;
+    }): Promise<StoredConversation[]>;
+    getConversation(id: string): Promise<StoredConversation | null>;
+    putContacts(contacts: StoredContact[]): Promise<void>;
+    getContacts(): Promise<StoredContact[]>;
+    getCursor(key: string): Promise<string | null>;
+    setCursor(key: string, value: string): Promise<void>;
+    enqueue(op: OutboxOperation): Promise<void>;
+    dequeueReady(limit: number): Promise<OutboxOperation[]>;
+    ack(opId: string): Promise<void>;
+    nack(opId: string, error: string, retries: number): Promise<void>;
+    getPendingCount(): Promise<number>;
+    clear(): Promise<void>;
+    /** Full-text search over message content. SQLiteStorage uses FTS5; others use basic contains. */
+    searchMessages?(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    /** Approximate storage size in bytes by category. */
+    getStorageSize?(): Promise<{
+        messages: number;
+        conversations: number;
+        total: number;
+    }>;
+    /** Delete oldest messages in a conversation, keeping the newest `keepCount`. Returns deleted count. */
+    clearOldMessages?(conversationId: string, keepCount: number): Promise<number>;
+}
+declare class MemoryStorage implements StorageAdapter {
+    private messages;
+    private conversations;
+    private contacts;
+    private cursors;
+    private outbox;
+    init(): Promise<void>;
+    putMessages(messages: StoredMessage[]): Promise<void>;
+    getMessages(conversationId: string, opts: {
+        limit: number;
+        before?: string;
+    }): Promise<StoredMessage[]>;
+    getMessage(messageId: string): Promise<StoredMessage | null>;
+    deleteMessage(messageId: string): Promise<void>;
+    putConversations(conversations: StoredConversation[]): Promise<void>;
+    getConversations(opts?: {
+        limit: number;
+        offset?: number;
+    }): Promise<StoredConversation[]>;
+    getConversation(id: string): Promise<StoredConversation | null>;
+    putContacts(contacts: StoredContact[]): Promise<void>;
+    getContacts(): Promise<StoredContact[]>;
+    getCursor(key: string): Promise<string | null>;
+    setCursor(key: string, value: string): Promise<void>;
+    enqueue(op: OutboxOperation): Promise<void>;
+    dequeueReady(limit: number): Promise<OutboxOperation[]>;
+    ack(opId: string): Promise<void>;
+    nack(opId: string, error: string, retries: number): Promise<void>;
+    getPendingCount(): Promise<number>;
+    searchMessages(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    getStorageSize(): Promise<{
+        messages: number;
+        conversations: number;
+        total: number;
+    }>;
+    clearOldMessages(conversationId: string, keepCount: number): Promise<number>;
+    clear(): Promise<void>;
+}
+declare class IndexedDBStorage implements StorageAdapter {
+    private dbName;
+    private version;
+    private db;
+    constructor(dbName?: string, version?: number);
+    init(): Promise<void>;
+    private tx;
+    private req;
+    putMessages(messages: StoredMessage[]): Promise<void>;
+    getMessages(conversationId: string, opts: {
+        limit: number;
+        before?: string;
+    }): Promise<StoredMessage[]>;
+    getMessage(messageId: string): Promise<StoredMessage | null>;
+    deleteMessage(messageId: string): Promise<void>;
+    putConversations(conversations: StoredConversation[]): Promise<void>;
+    getConversations(opts?: {
+        limit: number;
+        offset?: number;
+    }): Promise<StoredConversation[]>;
+    getConversation(id: string): Promise<StoredConversation | null>;
+    putContacts(contacts: StoredContact[]): Promise<void>;
+    getContacts(): Promise<StoredContact[]>;
+    getCursor(key: string): Promise<string | null>;
+    setCursor(key: string, value: string): Promise<void>;
+    enqueue(op: OutboxOperation): Promise<void>;
+    dequeueReady(limit: number): Promise<OutboxOperation[]>;
+    ack(opId: string): Promise<void>;
+    nack(opId: string, error: string, retries: number): Promise<void>;
+    getPendingCount(): Promise<number>;
+    searchMessages(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    getStorageSize(): Promise<{
+        messages: number;
+        conversations: number;
+        total: number;
+    }>;
+    clearOldMessages(conversationId: string, keepCount: number): Promise<number>;
+    clear(): Promise<void>;
+}
+/**
+ * SQLiteStorage uses `better-sqlite3` for synchronous, fast local persistence.
+ * Includes FTS5 full-text search for message content.
+ *
+ * Usage:
+ *   import { SQLiteStorage } from 'prismer/storage';
+ *   const storage = new SQLiteStorage('./my-app.db');
+ *   await storage.init();
+ */
+declare class SQLiteStorage implements StorageAdapter {
+    private db;
+    private dbPath;
+    constructor(dbPath?: string);
+    init(): Promise<void>;
+    private ensureDb;
+    putMessages(messages: StoredMessage[]): Promise<void>;
+    getMessages(conversationId: string, opts: {
+        limit: number;
+        before?: string;
+    }): Promise<StoredMessage[]>;
+    getMessage(messageId: string): Promise<StoredMessage | null>;
+    deleteMessage(messageId: string): Promise<void>;
+    private rowToMessage;
+    putConversations(conversations: StoredConversation[]): Promise<void>;
+    getConversations(opts?: {
+        limit: number;
+        offset?: number;
+    }): Promise<StoredConversation[]>;
+    getConversation(id: string): Promise<StoredConversation | null>;
+    private rowToConversation;
+    putContacts(contacts: StoredContact[]): Promise<void>;
+    getContacts(): Promise<StoredContact[]>;
+    getCursor(key: string): Promise<string | null>;
+    setCursor(key: string, value: string): Promise<void>;
+    enqueue(op: OutboxOperation): Promise<void>;
+    dequeueReady(limit: number): Promise<OutboxOperation[]>;
+    ack(opId: string): Promise<void>;
+    nack(opId: string, error: string, retries: number): Promise<void>;
+    getPendingCount(): Promise<number>;
+    searchMessages(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    getStorageSize(): Promise<{
+        messages: number;
+        conversations: number;
+        total: number;
+    }>;
+    clearOldMessages(conversationId: string, keepCount: number): Promise<number>;
+    clear(): Promise<void>;
+    private rowToOutbox;
+}
+
 type Environment = 'production';
 declare const ENVIRONMENTS: Record<Environment, string>;
 interface PrismerConfig {
@@ -177,6 +416,8 @@ interface PrismerConfig {
     fetch?: typeof fetch;
     /** Default X-IM-Agent header for IM requests (select which agent identity to use) */
     imAgent?: string;
+    /** Enable offline-first mode for IM with local persistence and sync */
+    offline?: OfflineConfig;
 }
 interface LoadOptions {
     inputType?: 'auto' | 'url' | 'urls' | 'query';
@@ -271,6 +512,7 @@ interface SaveOptions {
     url: string;
     hqcc: string;
     raw?: string;
+    visibility?: 'public' | 'private' | 'unlisted';
     meta?: Record<string, any>;
 }
 interface SaveBatchOptions {
@@ -280,14 +522,19 @@ interface SaveResult {
     success: boolean;
     status?: string;
     url?: string;
+    content_uri?: string;
+    visibility?: string;
     results?: Array<{
         url: string;
         status: string;
+        content_uri?: string;
     }>;
     summary?: {
         total: number;
         created: number;
-        exists: number;
+        updated?: number;
+        failed?: number;
+        exists?: number;
     };
     error?: {
         code: string;
@@ -555,6 +802,69 @@ interface IMDiscoverOptions {
     type?: string;
     capability?: string;
 }
+interface IMPresignOptions {
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+}
+interface IMPresignResult {
+    uploadId: string;
+    url: string;
+    fields: Record<string, string>;
+    expiresAt: string;
+}
+interface IMConfirmResult {
+    uploadId: string;
+    cdnUrl: string;
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+    sha256: string | null;
+    cost: number;
+}
+interface IMFileQuota {
+    used: number;
+    limit: number;
+    tier: string;
+    fileCount: number;
+}
+/** Input source for upload() — polymorphic across Node.js and browser */
+type FileInput = File | Blob | Buffer | Uint8Array | string;
+interface UploadOptions {
+    /** File name (required if input is Buffer/Uint8Array/Blob without name) */
+    fileName?: string;
+    /** MIME type (auto-detected from fileName extension if not provided) */
+    mimeType?: string;
+    /** Progress callback */
+    onProgress?: (uploaded: number, total: number) => void;
+}
+interface UploadResult {
+    uploadId: string;
+    cdnUrl: string;
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+    sha256: string | null;
+    cost: number;
+}
+interface SendFileOptions extends UploadOptions {
+    /** Message content (defaults to fileName) */
+    content?: string;
+    /** Parent message ID for threading */
+    parentId?: string;
+}
+interface SendFileResult {
+    upload: UploadResult;
+    message: any;
+}
+interface IMMultipartInitResult {
+    uploadId: string;
+    parts: Array<{
+        partNumber: number;
+        url: string;
+    }>;
+    expiresAt: string;
+}
 /** Generic IM API response wrapper */
 interface IMResult<T = any> {
     ok: boolean;
@@ -568,9 +878,373 @@ interface IMResult<T = any> {
         message: string;
     };
 }
+interface OfflineConfig {
+    /** Storage adapter implementation (IndexedDBStorage, MemoryStorage, SQLiteStorage) */
+    storage: StorageAdapter;
+    /** Auto-sync on reconnect (default: true) */
+    syncOnConnect?: boolean;
+    /** Max retries per outbox operation (default: 5) */
+    outboxRetryLimit?: number;
+    /** Outbox flush interval in ms (default: 1000) */
+    outboxFlushInterval?: number;
+    /** Conflict strategy: 'server' = server wins, 'client' = client wins (default: 'server') */
+    conflictStrategy?: 'server' | 'client';
+    /** Custom conflict resolver — called when server and local message diverge */
+    onConflict?: (local: StoredMessage, remote: {
+        type: string;
+        data: any;
+        seq: number;
+    }) => 'keep_local' | 'accept_remote' | StoredMessage;
+    /** Sync mode: 'push' = SSE continuous stream, 'poll' = periodic polling (default: 'push') */
+    syncMode?: 'push' | 'poll';
+    /** Enable multi-tab coordination via BroadcastChannel (default: true in browser, false in Node.js) */
+    multiTab?: boolean;
+    /** E2E encryption config */
+    e2e?: {
+        enabled: boolean;
+        /** User passphrase for master key derivation (PBKDF2) */
+        passphrase: string;
+    };
+    /** Storage quota config */
+    quota?: {
+        /** Max storage size in bytes (default: 500MB) */
+        maxStorageBytes?: number;
+        /** Warning threshold 0-1 (default: 0.9 = 90%) */
+        warningThreshold?: number;
+    };
+}
 /** Internal request function type */
 type RequestFn = <T>(method: string, path: string, body?: unknown, query?: Record<string, string>) => Promise<T>;
 
+/**
+ * Prismer SDK — Offline Manager, Outbox Queue, and Sync Engine.
+ *
+ * Orchestrates local persistence, optimistic writes, and incremental sync.
+ */
+
+interface SyncEvent {
+    seq: number;
+    type: string;
+    data: any;
+    conversationId?: string;
+    at: string;
+}
+interface SyncResult {
+    events: SyncEvent[];
+    cursor: number;
+    hasMore: boolean;
+}
+interface OfflineEventMap {
+    'sync.start': undefined;
+    'sync.progress': {
+        synced: number;
+        total: number;
+    };
+    'sync.complete': {
+        newMessages: number;
+        updatedConversations: number;
+    };
+    'sync.error': {
+        error: string;
+        willRetry: boolean;
+    };
+    'outbox.sending': {
+        opId: string;
+        type: string;
+    };
+    'outbox.confirmed': {
+        opId: string;
+        serverData: any;
+    };
+    'outbox.failed': {
+        opId: string;
+        error: string;
+        retriesLeft: number;
+    };
+    'message.local': StoredMessage;
+    'message.confirmed': {
+        clientId: string;
+        serverMessage: any;
+    };
+    'message.failed': {
+        clientId: string;
+        error: string;
+    };
+    'network.online': undefined;
+    'network.offline': undefined;
+    'presence.changed': {
+        userId: string;
+        status: string;
+        lastSeen?: string;
+    };
+    'quota.warning': {
+        used: number;
+        limit: number;
+        percentage: number;
+    };
+    'quota.exceeded': {
+        used: number;
+        limit: number;
+    };
+}
+type OfflineEventType = keyof OfflineEventMap;
+type Listener<T> = (payload: T) => void;
+declare class OfflineEmitter {
+    private listeners;
+    on<E extends OfflineEventType>(event: E, cb: Listener<OfflineEventMap[E]>): this;
+    off<E extends OfflineEventType>(event: E, cb: Listener<OfflineEventMap[E]>): this;
+    emit<E extends OfflineEventType>(event: E, payload: OfflineEventMap[E]): void;
+    removeAllListeners(): void;
+}
+declare class OfflineManager extends OfflineEmitter {
+    readonly storage: StorageAdapter;
+    private networkRequest;
+    private options;
+    private flushTimer;
+    private flushing;
+    private _isOnline;
+    private _syncState;
+    private sseSource;
+    private sseReconnectTimer;
+    private sseReconnectAttempts;
+    /** Presence cache for realtime presence events */
+    private presenceCache;
+    /** Auth token provider — set by PrismerClient for SSE auth */
+    tokenProvider?: () => string | undefined;
+    get isOnline(): boolean;
+    get syncState(): string;
+    constructor(storage: StorageAdapter, networkRequest: RequestFn, options?: Omit<OfflineConfig, 'storage'>);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    setOnline(online: boolean): void;
+    /**
+     * Dispatch an IM request. Write ops go through outbox; reads check local cache.
+     */
+    dispatch<T>(method: string, path: string, body?: unknown, query?: Record<string, string>): Promise<T>;
+    private dispatchWrite;
+    private startFlushTimer;
+    private stopFlushTimer;
+    flush(): Promise<void>;
+    get outboxSize(): Promise<number>;
+    sync(): Promise<void>;
+    private applySyncEvent;
+    /**
+     * Handle a realtime event (from WS/SSE) and store locally.
+     */
+    handleRealtimeEvent(type: string, payload: any): Promise<void>;
+    /**
+     * Get cached presence status for a user.
+     */
+    getPresence(userId: string): {
+        status: string;
+        lastSeen: string;
+    } | null;
+    /**
+     * Search messages in local storage.
+     */
+    searchMessages(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    /**
+     * Get storage size and quota info.
+     */
+    getQuotaStatus(): Promise<{
+        used: number;
+        limit: number;
+        percentage: number;
+        warning: boolean;
+        exceeded: boolean;
+    }>;
+    /**
+     * Clear old messages for a conversation (user-initiated quota management).
+     */
+    clearOldMessages(conversationId: string, keepCount: number): Promise<number>;
+    private readFromCache;
+    private cacheReadResult;
+    /**
+     * Start continuous sync via SSE (Server-Sent Events).
+     * Replaces polling with real-time push when syncMode is 'push'.
+     */
+    startContinuousSync(): Promise<void>;
+    /**
+     * Stop the SSE continuous sync connection.
+     */
+    stopContinuousSync(): void;
+    private scheduleSseReconnect;
+    /** Get the base URL for SSE connections (strip /api/im prefix). */
+    private getBaseUrl;
+    private checkQuota;
+}
+interface QueuedAttachment {
+    id: string;
+    conversationId: string;
+    file: {
+        name: string;
+        size: number;
+        type: string;
+    };
+    /** File data — stored in memory for MemoryStorage, in IndexedDB/SQLite for persistent */
+    data?: ArrayBuffer;
+    status: 'pending' | 'uploading' | 'uploaded' | 'failed';
+    progress: number;
+    messageClientId: string;
+    error?: string;
+    createdAt: number;
+}
+/**
+ * AttachmentQueue manages offline file uploads.
+ * Files are queued locally and uploaded when online, then a message
+ * is sent referencing the uploaded file.
+ */
+declare class AttachmentQueue {
+    private offline;
+    private networkRequest;
+    private queue;
+    private uploading;
+    constructor(offline: OfflineManager, networkRequest: RequestFn);
+    /**
+     * Queue a file attachment for offline upload.
+     * Returns the queued attachment with a local ID.
+     */
+    queueAttachment(conversationId: string, file: {
+        name: string;
+        size: number;
+        type: string;
+        data: ArrayBuffer;
+    }, messageContent?: string): Promise<QueuedAttachment>;
+    /** Process pending uploads. */
+    processQueue(): Promise<void>;
+    /** Get all queued attachments. */
+    getQueue(): QueuedAttachment[];
+    /** Retry a failed attachment upload. */
+    retry(attachmentId: string): Promise<void>;
+    /** Cancel and remove a queued attachment. */
+    cancel(attachmentId: string): Promise<void>;
+}
+
+/**
+ * Prismer SDK — Multi-Tab Coordination
+ *
+ * Uses BroadcastChannel API to coordinate multiple browser tabs.
+ * Protocol: "Last login wins" — the most recently opened tab becomes leader.
+ * Leader runs outbox flush + sync. Passive tabs receive events from leader.
+ *
+ * Fallback: In environments without BroadcastChannel (Node.js, old browsers),
+ * this is a no-op — single-tab/single-process behavior.
+ */
+
+/**
+ * TabCoordinator manages leadership election and event relay
+ * between multiple browser tabs sharing the same IndexedDB.
+ */
+declare class TabCoordinator {
+    private offline;
+    private channelName;
+    private channel;
+    private tabId;
+    private _isLeader;
+    private disposed;
+    get isLeader(): boolean;
+    constructor(offline: OfflineManager, channelName?: string);
+    /**
+     * Initialize tab coordination.
+     * Claims leadership immediately (last-login-wins).
+     */
+    init(): void;
+    /**
+     * Release leadership and clean up.
+     */
+    destroy(): void;
+    /**
+     * Relay a sync event to passive tabs.
+     * Called by the leader tab after processing a sync event.
+     */
+    relaySyncEvent(event: SyncEvent): void;
+    private claimLeadership;
+    private demoteToPassive;
+    private handleMessage;
+    private onBecomeLeader;
+    private onBecomePassive;
+    private broadcast;
+}
+
+/**
+ * Prismer SDK — E2E Encryption
+ *
+ * Industry-standard end-to-end encryption for IM messages.
+ *
+ * - Per-conversation symmetric key: AES-256-GCM
+ * - Key exchange: ECDH P-256
+ * - Master key derivation: PBKDF2-SHA256
+ * - Key storage: Encrypted with master key
+ * - Runtime: Web Crypto API (browser) / node:crypto (Node.js)
+ *
+ * The server only sees ciphertext — it cannot decrypt message content.
+ */
+/**
+ * E2EEncryption manages per-conversation symmetric keys and
+ * encrypts/decrypts message content using AES-256-GCM.
+ *
+ * Usage:
+ *   const e2e = new E2EEncryption();
+ *   await e2e.init('user-passphrase');
+ *   const ciphertext = await e2e.encrypt('conv-123', 'Hello!');
+ *   const plaintext = await e2e.decrypt('conv-123', ciphertext);
+ */
+declare class E2EEncryption {
+    private masterKey;
+    private keyPair;
+    private sessionKeys;
+    private salt;
+    /**
+     * Initialize encryption with user passphrase.
+     * Derives a master key via PBKDF2 and generates an ECDH key pair.
+     */
+    init(passphrase: string): Promise<void>;
+    /**
+     * Export public key for sharing with conversation peers.
+     */
+    exportPublicKey(): Promise<JsonWebKey>;
+    /**
+     * Derive a shared session key for a conversation using ECDH.
+     * Call this with each peer's public key.
+     */
+    deriveSessionKey(conversationId: string, peerPublicKey: JsonWebKey): Promise<void>;
+    /**
+     * Set a pre-shared session key for a conversation.
+     * Useful when the key is exchanged out-of-band or derived from a group key.
+     */
+    setSessionKey(conversationId: string, rawKey: ArrayBuffer): Promise<void>;
+    /**
+     * Generate a random session key for a conversation.
+     * Returns the raw key bytes for sharing with peers.
+     */
+    generateSessionKey(conversationId: string): Promise<ArrayBuffer>;
+    /**
+     * Encrypt plaintext for a conversation.
+     * Returns base64-encoded ciphertext with prepended IV.
+     */
+    encrypt(conversationId: string, plaintext: string): Promise<string>;
+    /**
+     * Decrypt ciphertext from a conversation.
+     * Expects base64-encoded data with prepended IV.
+     */
+    decrypt(conversationId: string, ciphertext: string): Promise<string>;
+    /**
+     * Check if a session key exists for a conversation.
+     */
+    hasSessionKey(conversationId: string): boolean;
+    /**
+     * Remove session key for a conversation.
+     */
+    removeSessionKey(conversationId: string): void;
+    /**
+     * Clear all keys and reset state.
+     */
+    destroy(): void;
+}
+
 /**
  * Prismer Cloud SDK for TypeScript/JavaScript
  *
@@ -705,6 +1379,55 @@ declare class WorkspaceClient {
     /** @mention autocomplete */
     mentionAutocomplete(conversationId: string, query?: string): Promise<IMResult<IMAutocompleteResult[]>>;
 }
+/** File upload management (presign → upload → confirm) */
+declare class FilesClient {
+    private _r;
+    private _baseUrl;
+    private _fetchFn;
+    private _getAuthHeaders;
+    constructor(_r: RequestFn, _baseUrl: string, _fetchFn: typeof fetch, _getAuthHeaders: () => Record<string, string>);
+    /** Get a presigned upload URL */
+    presign(options: IMPresignOptions): Promise<IMResult<IMPresignResult>>;
+    /** Confirm an uploaded file (triggers validation + CDN activation) */
+    confirm(uploadId: string): Promise<IMResult<IMConfirmResult>>;
+    /** Get storage quota */
+    quota(): Promise<IMResult<IMFileQuota>>;
+    /** Delete a file */
+    delete(uploadId: string): Promise<IMResult<void>>;
+    /** List allowed MIME types */
+    types(): Promise<IMResult<{
+        allowedMimeTypes: string[];
+    }>>;
+    /** Initialize a multipart upload (for files > 10 MB) */
+    initMultipart(opts: {
+        fileName: string;
+        fileSize: number;
+        mimeType: string;
+    }): Promise<IMResult<IMMultipartInitResult>>;
+    /** Complete a multipart upload */
+    completeMultipart(uploadId: string, parts: Array<{
+        partNumber: number;
+        etag: string;
+    }>): Promise<IMResult<IMConfirmResult>>;
+    /**
+     * Upload a file (full lifecycle: presign → upload → confirm).
+     *
+     * @param input - File, Blob, Buffer, Uint8Array, or file path (Node.js string)
+     * @param opts  - Optional fileName, mimeType, onProgress
+     * @returns Confirmed upload result with CDN URL
+     */
+    upload(input: FileInput, opts?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Upload a file and send it as a message in one call.
+     *
+     * @param conversationId - Target conversation
+     * @param input          - File input (same as upload())
+     * @param opts           - Upload options + optional message content/parentId
+     */
+    sendFile(conversationId: string, input: FileInput, opts?: SendFileOptions): Promise<SendFileResult>;
+    private _uploadSimple;
+    private _uploadMultipart;
+}
 /** Real-time connection factory (WebSocket & SSE) */
 declare class IMRealtimeClient {
     private _wsBase;
@@ -728,8 +1451,11 @@ declare class IMClient {
     readonly bindings: BindingsClient;
     readonly credits: CreditsClient;
     readonly workspace: WorkspaceClient;
+    readonly files: FilesClient;
     readonly realtime: IMRealtimeClient;
-    constructor(request: RequestFn, wsBase: string);
+    /** Offline manager (null if offline mode not enabled) */
+    readonly offline: OfflineManager | null;
+    constructor(request: RequestFn, wsBase: string, fetchFn: typeof fetch, getAuthHeaders: () => Record<string, string>, offlineManager?: OfflineManager | null);
     /** IM health check */
     health(): Promise<IMResult<void>>;
 }
@@ -739,14 +1465,19 @@ declare class PrismerClient {
     private readonly timeout;
     private readonly fetchFn;
     private readonly imAgent?;
+    private _offlineManager;
     /** IM API sub-client */
     readonly im: IMClient;
     constructor(config?: PrismerConfig);
+    /** Build auth headers for raw HTTP requests (used by file upload) */
+    private _getAuthHeaders;
     /**
      * Set or update the auth token (API key or IM JWT).
      * Useful after anonymous registration to set the returned JWT.
      */
     setToken(token: string): void;
+    /** Cleanup resources (offline manager, timers). Call when disposing the client. */
+    destroy(): Promise<void>;
     private _request;
     /** Load content from URL(s) or search query */
     load(input: string | string[], options?: LoadOptions): Promise<LoadResult>;
@@ -773,4 +1504,4 @@ declare class PrismerClient {
 
 declare function createClient(config: PrismerConfig): PrismerClient;
 
-export { AccountClient, type AuthenticatedPayload, type BatchSummary, type BatchUrlCost, BindingsClient, ContactsClient, ConversationsClient, CreditsClient, DirectClient, type DisconnectedPayload, ENVIRONMENTS, type Environment, type ErrorPayload, GroupsClient, type IMAgentCard, type IMAutocompleteResult, type IMBinding, type IMBindingData, IMClient, type IMContact, type IMConversation, type IMConversationsOptions, type IMCreateBindingOptions, type IMCreateGroupOptions, type IMCreditsData, type IMDiscoverAgent, type IMDiscoverOptions, type IMGroupData, type IMGroupMember, type IMMeData, type IMMessage, type IMMessageData, type IMPaginationOptions, IMRealtimeClient, type IMRegisterData, type IMRegisterOptions, type IMResult, type IMRouting, type IMSendOptions, type IMTokenData, type IMTransaction, type IMUser, type IMWorkspaceData, type IMWorkspaceInitGroupOptions, type IMWorkspaceInitOptions, type LoadOptions, type LoadResult, type LoadResultItem, type MessageNewPayload, MessagesClient, type ParseCost, type ParseCostBreakdown, type ParseDocument, type ParseDocumentImage, type ParseOptions, type ParseResult, type ParseUsage, type PongPayload, type PresenceChangedPayload, PrismerClient, type PrismerConfig, type QueryCost, type QuerySummary, type RankingFactors, type RealtimeCommand, type RealtimeConfig, type RealtimeEventMap, type RealtimeEventType, RealtimeSSEClient, type RealtimeState, RealtimeWSClient, type ReconnectingPayload, type RequestFn, type SaveBatchOptions, type SaveOptions, type SaveResult, type SingleUrlCost, type TypingIndicatorPayload, WorkspaceClient, createClient, PrismerClient as default };
+export { AccountClient, AttachmentQueue, type AuthenticatedPayload, type BatchSummary, type BatchUrlCost, BindingsClient, ContactsClient, ConversationsClient, CreditsClient, DirectClient, type DisconnectedPayload, E2EEncryption, ENVIRONMENTS, type Environment, type ErrorPayload, type FileInput, FilesClient, GroupsClient, type IMAgentCard, type IMAutocompleteResult, type IMBinding, type IMBindingData, IMClient, type IMConfirmResult, type IMContact, type IMConversation, type IMConversationsOptions, type IMCreateBindingOptions, type IMCreateGroupOptions, type IMCreditsData, type IMDiscoverAgent, type IMDiscoverOptions, type IMFileQuota, type IMGroupData, type IMGroupMember, type IMMeData, type IMMessage, type IMMessageData, type IMMultipartInitResult, type IMPaginationOptions, type IMPresignOptions, type IMPresignResult, IMRealtimeClient, type IMRegisterData, type IMRegisterOptions, type IMResult, type IMRouting, type IMSendOptions, type IMTokenData, type IMTransaction, type IMUser, type IMWorkspaceData, type IMWorkspaceInitGroupOptions, type IMWorkspaceInitOptions, IndexedDBStorage, type LoadOptions, type LoadResult, type LoadResultItem, MemoryStorage, type MessageNewPayload, MessagesClient, type OfflineConfig, type OfflineEventMap, type OfflineEventType, OfflineManager, type OutboxOperation, type ParseCost, type ParseCostBreakdown, type ParseDocument, type ParseDocumentImage, type ParseOptions, type ParseResult, type ParseUsage, type PongPayload, type PresenceChangedPayload, PrismerClient, type PrismerConfig, type QueryCost, type QuerySummary, type QueuedAttachment, type RankingFactors, type RealtimeCommand, type RealtimeConfig, type RealtimeEventMap, type RealtimeEventType, RealtimeSSEClient, type RealtimeState, RealtimeWSClient, type ReconnectingPayload, type RequestFn, SQLiteStorage, type SaveBatchOptions, type SaveOptions, type SaveResult, type SendFileOptions, type SendFileResult, type SingleUrlCost, type StorageAdapter, type StoredContact, type StoredConversation, type StoredMessage, type SyncEvent, type SyncResult, TabCoordinator, type TypingIndicatorPayload, type UploadOptions, type UploadResult, WorkspaceClient, createClient, PrismerClient as default };