@bobfrankston/mailx 1.0.179 → 1.0.180

package/packages/mailx-store-web/gmail-api-web.js

@@ -0,0 +1,231 @@
+/**
+ * Web-compatible Gmail API provider.
+ * Identical to packages/mailx-imap/providers/gmail-api.ts but uses
+ * atob() instead of Buffer.from() for base64 decoding (no Node.js deps).
+ *
+ * This file is a standalone copy — not imported from mailx-imap — because
+ * mailx-imap depends on Node.js modules (node:events, node:fs, mailparser, etc.)
+ * that aren't available in a WebView.
+ */
+const API = "https://gmail.googleapis.com/gmail/v1/users/me";
+/** Convert Gmail hex ID to integer UID (lower 48 bits) */
+function idToUid(id) {
+    const hex = id.length > 12 ? id.slice(-12) : id;
+    return parseInt(hex, 16);
+}
+/** Map Gmail label to IMAP-style specialUse */
+function labelSpecialUse(label) {
+    switch (label.id) {
+        case "INBOX": return "inbox";
+        case "SENT": return "sent";
+        case "DRAFT": return "drafts";
+        case "TRASH": return "trash";
+        case "SPAM": return "junk";
+        default: return "";
+    }
+}
+function getHeader(headers, name) {
+    return headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value || "";
+}
+function parseAddress(raw) {
+    const match = raw.match(/^"?([^"<]*?)"?\s*<([^>]+)>/);
+    if (match)
+        return { name: match[1].trim(), address: match[2].trim() };
+    return { address: raw.trim() };
+}
+function parseAddressList(raw) {
+    if (!raw)
+        return [];
+    return raw.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/).map(s => parseAddress(s.trim())).filter(a => a.address);
+}
+export class GmailApiWebProvider {
+    tokenProvider;
+    constructor(tokenProvider) {
+        this.tokenProvider = tokenProvider;
+    }
+    async apiFetch(path, options = {}) {
+        const token = await this.tokenProvider();
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const res = await globalThis.fetch(`${API}${path}`, {
+                ...options,
+                headers: {
+                    "Authorization": `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    ...options.headers,
+                },
+            });
+            if (res.status === 429) {
+                const delay = (attempt + 1) * 2000;
+                console.log(`[gmail] Rate limited, waiting ${delay / 1000}s...`);
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+            if (!res.ok) {
+                const err = await res.text().catch(() => "");
+                throw new Error(`Gmail API ${res.status}: ${err.substring(0, 200)}`);
+            }
+            return res.json();
+        }
+        throw new Error("Gmail API: rate limited after 3 retries");
+    }
+    async listFolders() {
+        const data = await this.apiFetch("/labels");
+        const labels = data.labels || [];
+        const folders = [];
+        for (const label of labels) {
+            if (["UNREAD", "STARRED", "IMPORTANT", "CATEGORY_PERSONAL",
+                "CATEGORY_SOCIAL", "CATEGORY_PROMOTIONS", "CATEGORY_UPDATES",
+                "CATEGORY_FORUMS", "CHAT"].includes(label.id))
+                continue;
+            const specialUse = labelSpecialUse(label);
+            const path = label.name || label.id;
+            const name = path.includes("/") ? path.split("/").pop() : path;
+            folders.push({
+                path, name, delimiter: "/", specialUse,
+                flags: label.type === "system" ? ["\\Noselect"] : [],
+            });
+        }
+        return folders;
+    }
+    async listMessageIds(query, maxResults = 500) {
+        const ids = [];
+        let pageToken = "";
+        while (true) {
+            const params = new URLSearchParams({ q: query, maxResults: String(Math.min(maxResults - ids.length, 500)) });
+            if (pageToken)
+                params.set("pageToken", pageToken);
+            const data = await this.apiFetch(`/messages?${params}`);
+            for (const msg of data.messages || []) {
+                ids.push(msg.id);
+            }
+            if (!data.nextPageToken || ids.length >= maxResults)
+                break;
+            pageToken = data.nextPageToken;
+        }
+        return ids;
+    }
+    async batchFetch(ids, options = {}, onChunk) {
+        const all = [];
+        const chunkSize = options.source ? 10 : 50;
+        const format = options.source ? "raw" : "metadata";
+        for (let i = 0; i < ids.length; i += chunkSize) {
+            const chunk = ids.slice(i, i + chunkSize);
+            const messages = [];
+            for (const id of chunk) {
+                const params = new URLSearchParams({ format });
+                if (format === "metadata") {
+                    for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
+                        params.append("metadataHeaders", h);
+                    }
+                }
+                messages.push(await this.apiFetch(`/messages/${id}?${params}`));
+            }
+            const parsed = messages.map(msg => this.parseMessage(msg, options));
+            all.push(...parsed);
+            if (onChunk)
+                onChunk(parsed);
+        }
+        return all;
+    }
+    parseMessage(msg, options = {}) {
+        const labels = msg.labelIds || [];
+        const headers = msg.payload?.headers || [];
+        let source = "";
+        if (options.source && msg.raw) {
+            // URL-safe base64 → standard base64 → decoded string
+            const base64 = msg.raw.replace(/-/g, "+").replace(/_/g, "/");
+            try {
+                source = atob(base64);
+            }
+            catch {
+                // Handle padding issues
+                const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+                source = atob(padded);
+            }
+        }
+        const fromRaw = getHeader(headers, "From");
+        const toRaw = getHeader(headers, "To");
+        const ccRaw = getHeader(headers, "Cc");
+        const dateRaw = getHeader(headers, "Date") || "";
+        const subject = getHeader(headers, "Subject") || msg.snippet || "";
+        const messageId = getHeader(headers, "Message-ID") || "";
+        return {
+            uid: idToUid(msg.id),
+            messageId,
+            providerId: msg.id,
+            date: dateRaw ? new Date(dateRaw) : (msg.internalDate ? new Date(Number(msg.internalDate)) : null),
+            subject,
+            from: parseAddressList(fromRaw),
+            to: parseAddressList(toRaw),
+            cc: parseAddressList(ccRaw),
+            seen: !labels.includes("UNREAD"),
+            flagged: labels.includes("STARRED"),
+            answered: false,
+            draft: labels.includes("DRAFT"),
+            size: msg.sizeEstimate || 0,
+            source,
+        };
+    }
+    async fetchSince(folder, sinceUid, options = {}) {
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 200);
+        const messages = await this.batchFetch(ids, options);
+        return messages.filter(m => m.uid > sinceUid);
+    }
+    async fetchByDate(folder, since, before, options = {}, onChunk) {
+        const afterDate = this.formatDate(since);
+        const beforeDate = this.formatDate(before);
+        const query = `in:${this.folderToLabel(folder)} after:${afterDate} before:${beforeDate}`;
+        const ids = await this.listMessageIds(query);
+        return this.batchFetch(ids, options, onChunk);
+    }
+    async fetchByUids(folder, uids, options = {}) {
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query);
+        const uidSet = new Set(uids);
+        const matchingIds = ids.filter(id => uidSet.has(idToUid(id)));
+        return this.batchFetch(matchingIds, options);
+    }
+    async fetchOne(folder, uid, options = {}) {
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 1000);
+        const id = ids.find(id => idToUid(id) === uid);
+        if (!id)
+            return null;
+        const format = options.source ? "raw" : "metadata";
+        const params = new URLSearchParams({ format });
+        if (format === "metadata") {
+            for (const h of ["From", "To", "Cc", "Subject", "Message-ID", "Date"]) {
+                params.append("metadataHeaders", h);
+            }
+        }
+        const msg = await this.apiFetch(`/messages/${id}?${params}`);
+        return this.parseMessage(msg, options);
+    }
+    async getUids(folder) {
+        const query = `in:${this.folderToLabel(folder)}`;
+        const ids = await this.listMessageIds(query, 10000);
+        return ids.map(idToUid);
+    }
+    async close() { }
+    folderToLabel(path) {
+        const lower = path.toLowerCase();
+        if (lower === "inbox")
+            return "inbox";
+        if (lower === "sent" || lower === "[gmail]/sent mail")
+            return "sent";
+        if (lower === "drafts" || lower === "[gmail]/drafts")
+            return "drafts";
+        if (lower === "trash" || lower === "[gmail]/trash")
+            return "trash";
+        if (lower === "spam" || lower === "[gmail]/spam" || lower === "junk email")
+            return "spam";
+        if (lower === "archive" || lower === "[gmail]/all mail")
+            return "all";
+        return `"${path}"`;
+    }
+    formatDate(d) {
+        return `${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/${String(d.getDate()).padStart(2, "0")}`;
+    }
+}
+//# sourceMappingURL=gmail-api-web.js.map

package/packages/mailx-store-web/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @bobfrankston/mailx-store-web
+ * WebAssembly SQLite + IndexedDB storage for Android/browser.
+ * Drop-in replacement for @bobfrankston/mailx-store in non-Node environments.
+ */
+export { WebMailxDB } from "./db.js";
+export { WebMessageStore } from "./web-message-store.js";
+export { WebMailxService } from "./web-service.js";
+export { dispatch } from "./web-jsonrpc.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/mailx-store-web/index.js

@@ -0,0 +1,10 @@
+/**
+ * @bobfrankston/mailx-store-web
+ * WebAssembly SQLite + IndexedDB storage for Android/browser.
+ * Drop-in replacement for @bobfrankston/mailx-store in non-Node environments.
+ */
+export { WebMailxDB } from "./db.js";
+export { WebMessageStore } from "./web-message-store.js";
+export { WebMailxService } from "./web-service.js";
+export { dispatch } from "./web-jsonrpc.js";
+//# sourceMappingURL=index.js.map

package/packages/mailx-store-web/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@bobfrankston/mailx-store-web",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@bobfrankston/mailx-types": "file:../mailx-types",
+    "sql.js": "^1.14.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BobFrankston/mailx-store-web.git"
+  }
+}

package/packages/mailx-store-web/provider-types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Mail provider interface for web (browser/Android).
+ * Identical to @bobfrankston/mailx-imap/providers/types.ts.
+ * Duplicated here to avoid importing from mailx-imap (which depends on Node.js).
+ */
+export interface ProviderFolder {
+    path: string;
+    name: string;
+    delimiter: string;
+    specialUse: string;
+    flags: string[];
+}
+export interface ProviderMessage {
+    uid: number;
+    messageId: string;
+    providerId: string;
+    date: Date | null;
+    subject: string;
+    from: {
+        name?: string;
+        address?: string;
+    }[];
+    to: {
+        name?: string;
+        address?: string;
+    }[];
+    cc: {
+        name?: string;
+        address?: string;
+    }[];
+    seen: boolean;
+    flagged: boolean;
+    answered: boolean;
+    draft: boolean;
+    size: number;
+    source: string;
+}
+export interface FetchOptions {
+    source?: boolean;
+}
+export interface MailProvider {
+    listFolders(): Promise<ProviderFolder[]>;
+    fetchSince(folder: string, sinceUid: number, options?: FetchOptions): Promise<ProviderMessage[]>;
+    fetchByDate(folder: string, since: Date, before: Date, options?: FetchOptions, onChunk?: (msgs: ProviderMessage[]) => void): Promise<ProviderMessage[]>;
+    fetchByUids(folder: string, uids: number[], options?: FetchOptions): Promise<ProviderMessage[]>;
+    fetchOne(folder: string, uid: number, options?: FetchOptions): Promise<ProviderMessage | null>;
+    getUids(folder: string): Promise<number[]>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=provider-types.d.ts.map

package/packages/mailx-store-web/provider-types.js

@@ -0,0 +1,7 @@
+/**
+ * Mail provider interface for web (browser/Android).
+ * Identical to @bobfrankston/mailx-imap/providers/types.ts.
+ * Duplicated here to avoid importing from mailx-imap (which depends on Node.js).
+ */
+export {};
+//# sourceMappingURL=provider-types.js.map

package/packages/mailx-store-web/sql.js.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal type declarations for sql.js (WebAssembly SQLite).
+ * Only the API surface used by WebMailxDB is typed.
+ */
+
+declare module "sql.js" {
+    interface SqlJsStatic {
+        Database: new (data?: ArrayLike<number>) => Database;
+    }
+
+    interface Database {
+        run(sql: string, params?: any[]): Database;
+        exec(sql: string, params?: any[]): QueryExecResult[];
+        export(): Uint8Array;
+        close(): void;
+    }
+
+    interface QueryExecResult {
+        columns: string[];
+        values: any[][];
+    }
+
+    function initSqlJs(config?: {
+        locateFile?: (file: string) => string;
+    }): Promise<SqlJsStatic>;
+
+    export default initSqlJs;
+    export type { Database, SqlJsStatic, QueryExecResult };
+}

package/packages/mailx-store-web/web-jsonrpc.d.ts

@@ -0,0 +1,20 @@
+/**
+ * JSON-RPC dispatcher for WebMailxService.
+ * Maps mailxapi action names to WebMailxService method calls.
+ * Same dispatch table as desktop jsonrpc.ts but adapted for async settings.
+ */
+type ServiceLike = Record<string, (...args: any[]) => any>;
+export interface RpcRequest {
+    _action: string;
+    _cbid: string;
+    [key: string]: any;
+}
+export interface RpcResponse {
+    _cbid: string;
+    result?: any;
+    error?: string;
+}
+/** Dispatch an incoming mailxapi call to the appropriate WebMailxService method */
+export declare function dispatch(svc: ServiceLike, req: RpcRequest): Promise<RpcResponse>;
+export {};
+//# sourceMappingURL=web-jsonrpc.d.ts.map

package/packages/mailx-store-web/web-jsonrpc.js

@@ -0,0 +1,94 @@
+/**
+ * JSON-RPC dispatcher for WebMailxService.
+ * Maps mailxapi action names to WebMailxService method calls.
+ * Same dispatch table as desktop jsonrpc.ts but adapted for async settings.
+ */
+/** Dispatch an incoming mailxapi call to the appropriate WebMailxService method */
+export async function dispatch(svc, req) {
+    const { _action, _cbid, ...params } = req;
+    try {
+        const result = await dispatchAction(svc, _action, params);
+        return { _cbid, result };
+    }
+    catch (e) {
+        return { _cbid, error: e.message || String(e) };
+    }
+}
+async function dispatchAction(svc, action, p) {
+    switch (action) {
+        case "getAccounts":
+            return svc.getAccounts();
+        case "getFolders":
+            return svc.getFolders(p.accountId);
+        case "getMessages":
+            return svc.getMessages(p.accountId, p.folderId, p.page, p.pageSize);
+        case "getUnifiedInbox":
+            return svc.getUnifiedInbox(p.page || 1, p.pageSize || 50);
+        case "getMessage":
+            return svc.getMessage(p.accountId, p.uid, p.allowRemote, p.folderId);
+        case "updateFlags":
+            await svc.updateFlags(p.accountId, p.uid, p.flags);
+            return { ok: true };
+        case "deleteMessage":
+            await svc.deleteMessage(p.accountId, p.uid);
+            return { ok: true };
+        case "deleteMessages":
+            await svc.deleteMessages(p.accountId, p.uids);
+            return { ok: true, count: p.uids.length };
+        case "undeleteMessage":
+            await svc.undeleteMessage(p.accountId, p.uid, p.folderId);
+            return { ok: true };
+        case "moveMessage":
+            await svc.moveMessage(p.accountId, p.uid, p.targetFolderId, p.targetAccountId);
+            return { ok: true };
+        case "moveMessages":
+            await svc.moveMessages(p.accountId, p.uids, p.targetFolderId);
+            return { ok: true, count: p.uids.length };
+        case "markFolderRead":
+            svc.markFolderRead(p.folderId);
+            return { ok: true };
+        case "sendMessage":
+            await svc.send(p);
+            return { ok: true };
+        case "saveDraft":
+            return svc.saveDraft(p.accountId, p.subject, p.bodyHtml, p.bodyText, p.to, p.cc, p.previousDraftUid, p.draftId);
+        case "deleteDraft":
+            await svc.deleteDraft(p.accountId, p.draftUid);
+            return { ok: true };
+        case "syncAll":
+            await svc.syncAll();
+            return { ok: true };
+        case "syncAccount":
+            await svc.syncAccount(p.accountId);
+            return { ok: true };
+        case "getSyncPending":
+            return svc.getSyncPending();
+        case "reauthenticate":
+            return { ok: await svc.reauthenticate(p.accountId) };
+        case "searchMessages":
+            return svc.search(p.query, p.page, p.pageSize, p.scope, p.accountId, p.folderId);
+        case "searchContacts":
+            return svc.searchContacts(p.query);
+        case "getSettings":
+            return svc.getSettings();
+        case "saveSettingsData":
+            await svc.saveSettingsData(p);
+            return { ok: true };
+        case "allowRemoteContent":
+            await svc.allowRemoteContent(p.type, p.value);
+            return { ok: true };
+        case "getVersion":
+            return { version: "1.0.0-android", theme: "system", storage: svc.getStorageInfo(), platform: "android" };
+        case "getAutocompleteSettings":
+            return svc.getAutocompleteSettings();
+        case "saveAutocompleteSettings":
+            await svc.saveAutocompleteSettings(p);
+            return { ok: true };
+        case "resetStore":
+            await svc.resetStore();
+            return { ok: true };
+        default:
+            throw new Error(`Unknown action: ${action}`);
+    }
+}
+//# sourceMappingURL=web-jsonrpc.js.map

package/packages/mailx-store-web/web-message-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * IndexedDB-based message body storage for Android/browser.
+ * Mirrors FileMessageStore API from @bobfrankston/mailx-store.
+ * Stores RFC 2822 message bodies as blobs keyed by accountId/folderId/uid.
+ */
+export declare class WebMessageStore {
+    private dbPromise;
+    constructor();
+    putMessage(accountId: string, folderId: number, uid: number, raw: Uint8Array | ArrayBuffer): Promise<string>;
+    getMessage(accountId: string, folderId: number, uid: number): Promise<Uint8Array | null>;
+    deleteMessage(accountId: string, folderId: number, uid: number): Promise<void>;
+    hasMessage(accountId: string, folderId: number, uid: number): Promise<boolean>;
+    /** Clear all stored bodies — used for "Reset Store" */
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=web-message-store.d.ts.map

package/packages/mailx-store-web/web-message-store.js

@@ -0,0 +1,89 @@
+/**
+ * IndexedDB-based message body storage for Android/browser.
+ * Mirrors FileMessageStore API from @bobfrankston/mailx-store.
+ * Stores RFC 2822 message bodies as blobs keyed by accountId/folderId/uid.
+ */
+const DB_NAME = "mailx-bodies";
+const DB_VERSION = 1;
+const STORE_NAME = "messages";
+function openDb() {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                db.createObjectStore(STORE_NAME);
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+function makeKey(accountId, folderId, uid) {
+    return `${accountId}/${folderId}/${uid}`;
+}
+export class WebMessageStore {
+    dbPromise;
+    constructor() {
+        this.dbPromise = openDb();
+    }
+    async putMessage(accountId, folderId, uid, raw) {
+        const db = await this.dbPromise;
+        const key = makeKey(accountId, folderId, uid);
+        const data = raw instanceof Uint8Array ? raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength) : raw;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, "readwrite");
+            tx.objectStore(STORE_NAME).put(data, key);
+            tx.oncomplete = () => resolve(key);
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async getMessage(accountId, folderId, uid) {
+        const db = await this.dbPromise;
+        const key = makeKey(accountId, folderId, uid);
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, "readonly");
+            const req = tx.objectStore(STORE_NAME).get(key);
+            req.onsuccess = () => {
+                if (req.result) {
+                    resolve(new Uint8Array(req.result));
+                }
+                else {
+                    resolve(null);
+                }
+            };
+            req.onerror = () => reject(req.error);
+        });
+    }
+    async deleteMessage(accountId, folderId, uid) {
+        const db = await this.dbPromise;
+        const key = makeKey(accountId, folderId, uid);
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, "readwrite");
+            tx.objectStore(STORE_NAME).delete(key);
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async hasMessage(accountId, folderId, uid) {
+        const db = await this.dbPromise;
+        const key = makeKey(accountId, folderId, uid);
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, "readonly");
+            const req = tx.objectStore(STORE_NAME).count(IDBKeyRange.only(key));
+            req.onsuccess = () => resolve(req.result > 0);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    /** Clear all stored bodies — used for "Reset Store" */
+    async clear() {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(STORE_NAME, "readwrite");
+            tx.objectStore(STORE_NAME).clear();
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+}
+//# sourceMappingURL=web-message-store.js.map

package/packages/mailx-store-web/web-service.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Web-compatible MailxService for Android/browser.
+ * Replaces @bobfrankston/mailx-service which depends on Node.js (fs, dns, mailparser).
+ *
+ * Key differences from desktop:
+ * - Uses WebMailxDB (wa-sqlite) instead of MailxDB (node:sqlite)
+ * - Uses WebMessageStore (IndexedDB) instead of FileMessageStore (filesystem)
+ * - Uses postal-mime or manual header parsing instead of mailparser's simpleParser
+ * - Settings via IndexedDB + GDrive API instead of filesystem
+ * - No dns.resolveMx — provider detection is static (Gmail/Outlook/Yahoo/iCloud)
+ */
+import type { WebMailxDB } from "./db.js";
+import type { WebMessageStore } from "./web-message-store.js";
+import type { Folder, AutocompleteSettings } from "@bobfrankston/mailx-types";
+export declare function sanitizeHtml(html: string): {
+    html: string;
+    hasRemoteContent: boolean;
+};
+export interface WebSyncManager {
+    syncAll(): Promise<void>;
+    syncFolders(accountId: string): Promise<Folder[]>;
+    syncFolder(accountId: string, folderId: number): Promise<void>;
+    fetchMessageBody(accountId: string, folderId: number, uid: number): Promise<Uint8Array | null>;
+    updateFlagsLocal(accountId: string, uid: number, folderId: number, flags: string[]): Promise<void>;
+    trashMessage(accountId: string, folderId: number, uid: number): Promise<void>;
+    trashMessages(accountId: string, messages: {
+        uid: number;
+        folderId: number;
+    }[]): Promise<void>;
+    moveMessage(accountId: string, uid: number, folderId: number, targetFolderId: number): Promise<void>;
+    moveMessages(accountId: string, messages: {
+        uid: number;
+        folderId: number;
+    }[], targetFolderId: number): Promise<void>;
+    moveMessageCrossAccount(accountId: string, uid: number, folderId: number, targetAccountId: string, targetFolderId: number): Promise<void>;
+    undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
+    queueOutgoingLocal(accountId: string, rawMessage: string): void;
+    saveDraft(accountId: string, raw: string, previousDraftUid?: number, draftId?: string): Promise<number | null>;
+    deleteDraft(accountId: string, draftUid: number): Promise<void>;
+    reauthenticate(accountId: string): Promise<boolean>;
+    searchOnServer(accountId: string, folderPath: string, criteria: any): Promise<number[]>;
+    syncAllContacts(): Promise<void>;
+    addAccount(account: any): Promise<void>;
+    on(event: string, handler: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}
+export declare class WebMailxService {
+    private db;
+    private bodyStore;
+    private syncManager;
+    constructor(db: WebMailxDB, bodyStore: WebMessageStore, syncManager: WebSyncManager);
+    getAccounts(): Promise<any[]>;
+    getFolders(accountId: string): Folder[];
+    getUnifiedInbox(page?: number, pageSize?: number): any;
+    getMessages(accountId: string, folderId: number, page?: number, pageSize?: number, sort?: string, sortDir?: string, search?: string): any;
+    getMessage(accountId: string, uid: number, allowRemote?: boolean, folderId?: number): Promise<any>;
+    updateFlags(accountId: string, uid: number, flags: string[]): Promise<void>;
+    allowRemoteContent(type: "sender" | "domain" | "recipient", value: string): Promise<void>;
+    search(q: string, page?: number, pageSize?: number, scope?: string, accountId?: string, folderId?: number): Promise<any>;
+    getSyncPending(): {
+        pending: number;
+    };
+    syncAll(): Promise<void>;
+    syncAccount(accountId: string): Promise<void>;
+    reauthenticate(accountId: string): Promise<boolean>;
+    send(msg: any): Promise<void>;
+    deleteMessage(accountId: string, uid: number): Promise<void>;
+    deleteMessages(accountId: string, uids: number[]): Promise<void>;
+    moveMessage(accountId: string, uid: number, targetFolderId: number, targetAccountId?: string): Promise<void>;
+    moveMessages(accountId: string, uids: number[], targetFolderId: number): Promise<void>;
+    undeleteMessage(accountId: string, uid: number, folderId: number): Promise<void>;
+    saveDraft(accountId: string, subject: string, bodyHtml: string, bodyText: string, to?: string, cc?: string, previousDraftUid?: number, draftId?: string): Promise<{
+        uid: number | null;
+        draftId: string;
+    }>;
+    deleteDraft(accountId: string, draftUid: number): Promise<void>;
+    searchContacts(query: string): any[];
+    getSettings(): Promise<any>;
+    saveSettingsData(settings: any): Promise<void>;
+    getStorageInfo(): {
+        provider: string;
+        mode: string;
+    };
+    markFolderRead(folderId: number): void;
+    getAutocompleteSettings(): Promise<AutocompleteSettings>;
+    saveAutocompleteSettings(settings: AutocompleteSettings): Promise<void>;
+    autocomplete(_req: any): Promise<{
+        suggestion: string;
+    }>;
+    resetStore(): Promise<void>;
+}
+//# sourceMappingURL=web-service.d.ts.map