@bobfrankston/mailx 1.0.179 → 1.0.180

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

@@ -0,0 +1,508 @@
+/**
+ * WebAssembly SQLite metadata index for mailx (Android/browser).
+ * API-compatible with @bobfrankston/mailx-store's MailxDB.
+ * Uses sql.js (SQLite compiled to WebAssembly) for in-browser SQLite.
+ *
+ * Database is persisted to IndexedDB on every write operation.
+ * Bodies are stored in IndexedDB via WebMessageStore (not filesystem).
+ */
+import initSqlJs from "sql.js";
+const SCHEMA = `
+    CREATE TABLE IF NOT EXISTS accounts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL,
+        config_json TEXT NOT NULL,
+        last_sync INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS folders (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        account_id TEXT NOT NULL REFERENCES accounts(id),
+        path TEXT NOT NULL,
+        name TEXT NOT NULL,
+        special_use TEXT,
+        delimiter TEXT DEFAULT '/',
+        total_count INTEGER DEFAULT 0,
+        unread_count INTEGER DEFAULT 0,
+        uidvalidity INTEGER DEFAULT 0,
+        highest_modseq TEXT DEFAULT '0',
+        UNIQUE(account_id, path)
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        account_id TEXT NOT NULL,
+        folder_id INTEGER NOT NULL REFERENCES folders(id),
+        uid INTEGER NOT NULL,
+        message_id TEXT,
+        in_reply_to TEXT,
+        refs TEXT,
+        date INTEGER NOT NULL,
+        subject TEXT DEFAULT '',
+        from_address TEXT DEFAULT '',
+        from_name TEXT DEFAULT '',
+        to_json TEXT DEFAULT '[]',
+        cc_json TEXT DEFAULT '[]',
+        flags_json TEXT DEFAULT '[]',
+        size INTEGER DEFAULT 0,
+        has_attachments INTEGER DEFAULT 0,
+        preview TEXT DEFAULT '',
+        body_path TEXT,
+        cached_at INTEGER NOT NULL,
+        UNIQUE(account_id, folder_id, uid)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_folder_date
+        ON messages(account_id, folder_id, date DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_message_id
+        ON messages(message_id);
+
+    CREATE TABLE IF NOT EXISTS queue (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL,
+        send_after INTEGER NOT NULL,
+        attempts INTEGER DEFAULT 0,
+        last_attempt INTEGER DEFAULT 0,
+        error TEXT,
+        from_account TEXT NOT NULL,
+        to_json TEXT NOT NULL,
+        cc_json TEXT DEFAULT '[]',
+        bcc_json TEXT DEFAULT '[]',
+        subject TEXT DEFAULT '',
+        body_html TEXT DEFAULT '',
+        body_text TEXT DEFAULT '',
+        in_reply_to TEXT,
+        refs TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS contacts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source TEXT NOT NULL DEFAULT 'sent',
+        google_id TEXT,
+        name TEXT DEFAULT '',
+        email TEXT NOT NULL,
+        organization TEXT DEFAULT '',
+        last_used INTEGER DEFAULT 0,
+        use_count INTEGER DEFAULT 0,
+        updated_at INTEGER NOT NULL,
+        UNIQUE(email)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_contacts_email ON contacts(email);
+    CREATE INDEX IF NOT EXISTS idx_contacts_name ON contacts(name);
+
+    CREATE TABLE IF NOT EXISTS sync_actions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        account_id TEXT NOT NULL,
+        action TEXT NOT NULL,
+        uid INTEGER,
+        folder_id INTEGER,
+        target_folder_id INTEGER,
+        flags_json TEXT,
+        raw_message TEXT,
+        created_at INTEGER NOT NULL,
+        attempts INTEGER DEFAULT 0,
+        last_error TEXT,
+        UNIQUE(account_id, action, uid, folder_id)
+    );
+`;
+const IDB_NAME = "mailx-sqldb";
+const IDB_STORE = "database";
+const IDB_KEY = "mailx.db";
+// ── IndexedDB persistence ──
+function openIdb() {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(IDB_NAME, 1);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            if (!db.objectStoreNames.contains(IDB_STORE)) {
+                db.createObjectStore(IDB_STORE);
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+async function loadDbFromIdb() {
+    const idb = await openIdb();
+    return new Promise((resolve, reject) => {
+        const tx = idb.transaction(IDB_STORE, "readonly");
+        const req = tx.objectStore(IDB_STORE).get(IDB_KEY);
+        req.onsuccess = () => resolve(req.result ? new Uint8Array(req.result) : null);
+        req.onerror = () => reject(req.error);
+    });
+}
+async function saveDbToIdb(data) {
+    const idb = await openIdb();
+    return new Promise((resolve, reject) => {
+        const tx = idb.transaction(IDB_STORE, "readwrite");
+        tx.objectStore(IDB_STORE).put(data.buffer, IDB_KEY);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+async function clearIdb() {
+    const idb = await openIdb();
+    return new Promise((resolve, reject) => {
+        const tx = idb.transaction(IDB_STORE, "readwrite");
+        tx.objectStore(IDB_STORE).delete(IDB_KEY);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+// ── Helper: convert sql.js result to array of objects ──
+function resultToRows(result) {
+    if (!result || result.length === 0)
+        return [];
+    const { columns, values } = result[0];
+    return values.map((row) => {
+        const obj = {};
+        columns.forEach((col, i) => { obj[col] = row[i]; });
+        return obj;
+    });
+}
+export class WebMailxDB {
+    db = null;
+    ready;
+    saveTimer = null;
+    constructor(dbName = "mailx") {
+        this.ready = this.init(dbName);
+    }
+    async init(_dbName) {
+        const SQL = await initSqlJs({
+            locateFile: (file) => `https://sql.js.org/dist/${file}`
+        });
+        // Try to load existing DB from IndexedDB
+        const existing = await loadDbFromIdb();
+        if (existing) {
+            this.db = new SQL.Database(existing);
+        }
+        else {
+            this.db = new SQL.Database();
+        }
+        this.db.run("PRAGMA foreign_keys = ON");
+        this.db.run(SCHEMA);
+        this.scheduleSave();
+    }
+    /** Wait for DB initialization */
+    async waitReady() {
+        await this.ready;
+    }
+    /** Persist DB to IndexedDB (debounced — batches rapid writes) */
+    scheduleSave() {
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(async () => {
+            this.saveTimer = null;
+            if (this.db) {
+                const data = this.db.export();
+                await saveDbToIdb(data);
+            }
+        }, 1000);
+    }
+    /** Force immediate persist */
+    async flush() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        if (this.db) {
+            const data = this.db.export();
+            await saveDbToIdb(data);
+        }
+    }
+    close() {
+        if (this.db) {
+            this.flush();
+            this.db.close();
+            this.db = null;
+        }
+    }
+    run(sql, params) {
+        this.db.run(sql, params);
+        this.scheduleSave();
+    }
+    get(sql, params) {
+        const result = this.db.exec(sql, params);
+        const rows = resultToRows(result);
+        return rows[0] || null;
+    }
+    all(sql, params) {
+        const result = this.db.exec(sql, params);
+        return resultToRows(result);
+    }
+    lastId() {
+        const row = this.get("SELECT last_insert_rowid() as id");
+        return row?.id || 0;
+    }
+    // ── Accounts ──
+    upsertAccount(id, name, email, configJson) {
+        this.run(`INSERT INTO accounts (id, name, email, config_json)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET name=?, email=?, config_json=?`, [id, name, email, configJson, name, email, configJson]);
+    }
+    getAccounts() {
+        return this.all("SELECT id, name, email, last_sync as lastSync FROM accounts");
+    }
+    getAccountConfigs() {
+        return this.all("SELECT id, name, email, config_json as configJson FROM accounts");
+    }
+    updateLastSync(accountId, timestamp) {
+        this.run("UPDATE accounts SET last_sync = ? WHERE id = ?", [timestamp, accountId]);
+    }
+    // ── Folders ──
+    upsertFolder(accountId, folderPath, name, specialUse, delimiter) {
+        const existing = this.get("SELECT id FROM folders WHERE account_id = ? AND path = ?", [accountId, folderPath]);
+        if (existing) {
+            this.run("UPDATE folders SET name = ?, special_use = ?, delimiter = ? WHERE id = ?", [name, specialUse, delimiter, existing.id]);
+            return existing.id;
+        }
+        this.run("INSERT INTO folders (account_id, path, name, special_use, delimiter) VALUES (?, ?, ?, ?, ?)", [accountId, folderPath, name, specialUse, delimiter]);
+        return this.lastId();
+    }
+    getFolders(accountId) {
+        const rows = this.all("SELECT * FROM folders WHERE account_id = ? ORDER BY path", [accountId]);
+        return rows.map(r => ({
+            id: r.id, accountId: r.account_id, path: r.path, name: r.name,
+            specialUse: r.special_use, delimiter: r.delimiter,
+            totalCount: r.total_count, unreadCount: r.unread_count,
+            children: []
+        }));
+    }
+    deleteFolder(folderId) {
+        this.run("DELETE FROM messages WHERE folder_id = ?", [folderId]);
+        this.run("DELETE FROM folders WHERE id = ?", [folderId]);
+    }
+    markFolderRead(folderId) {
+        this.run(`UPDATE messages SET flags_json = REPLACE(flags_json, '[]', '["\\\\Seen"]')
+             WHERE folder_id = ? AND flags_json NOT LIKE '%\\\\Seen%'`, [folderId]);
+        this.recalcFolderCounts(folderId);
+    }
+    deleteAllMessages(accountId, folderId) {
+        this.run("DELETE FROM messages WHERE account_id = ? AND folder_id = ?", [accountId, folderId]);
+        this.recalcFolderCounts(folderId);
+    }
+    updateFolderCounts(folderId, total, unread) {
+        this.run("UPDATE folders SET total_count = ?, unread_count = ? WHERE id = ?", [total, unread, folderId]);
+    }
+    updateFolderSync(folderId, uidvalidity, highestModseq) {
+        this.run("UPDATE folders SET uidvalidity = ?, highest_modseq = ? WHERE id = ?", [uidvalidity, highestModseq, folderId]);
+    }
+    getFolderSync(folderId) {
+        const row = this.get("SELECT uidvalidity, highest_modseq as highestModseq FROM folders WHERE id = ?", [folderId]);
+        return row || { uidvalidity: 0, highestModseq: "0" };
+    }
+    // ── Messages ──
+    upsertMessage(msg) {
+        const existing = this.get("SELECT id FROM messages WHERE account_id = ? AND folder_id = ? AND uid = ?", [msg.accountId, msg.folderId, msg.uid]);
+        if (existing) {
+            this.run(`UPDATE messages SET flags_json = ?, preview = ?, body_path = ?, cached_at = ? WHERE id = ?`, [JSON.stringify(msg.flags), msg.preview, msg.bodyPath, Date.now(), existing.id]);
+            return existing.id;
+        }
+        this.run(`INSERT INTO messages (
+                account_id, folder_id, uid, message_id, in_reply_to, refs,
+                date, subject, from_address, from_name, to_json, cc_json,
+                flags_json, size, has_attachments, preview, body_path, cached_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            msg.accountId, msg.folderId, msg.uid, msg.messageId,
+            msg.inReplyTo, JSON.stringify(msg.references),
+            msg.date, msg.subject, msg.from.address, msg.from.name,
+            JSON.stringify(msg.to), JSON.stringify(msg.cc),
+            JSON.stringify(msg.flags), msg.size, msg.hasAttachments ? 1 : 0,
+            msg.preview, msg.bodyPath, Date.now()
+        ]);
+        return this.lastId();
+    }
+    getMessages(query) {
+        const page = query.page || 1;
+        const pageSize = query.pageSize || 50;
+        const offset = (page - 1) * pageSize;
+        const sortCol = query.sort === "from" ? "from_name" : query.sort === "subject" ? "subject" : "date";
+        const sortDir = query.sortDir || "desc";
+        let where = "account_id = ? AND folder_id = ?";
+        const params = [query.accountId, query.folderId];
+        if (query.search) {
+            where += " AND (subject LIKE ? OR from_name LIKE ? OR from_address LIKE ?)";
+            const term = `%${query.search}%`;
+            params.push(term, term, term);
+        }
+        const countRow = this.get(`SELECT COUNT(*) as cnt FROM messages WHERE ${where}`, params);
+        const total = countRow?.cnt || 0;
+        const rows = this.all(`SELECT * FROM messages WHERE ${where} ORDER BY ${sortCol} ${sortDir} LIMIT ? OFFSET ?`, [...params, pageSize, offset]);
+        return { items: rows.map(r => this.rowToEnvelope(r)), total, page, pageSize };
+    }
+    getUnifiedInbox(page = 1, pageSize = 50) {
+        const offset = (page - 1) * pageSize;
+        const inboxRows = this.all("SELECT id FROM folders WHERE special_use = 'inbox'");
+        if (inboxRows.length === 0)
+            return { items: [], total: 0, page, pageSize };
+        const ids = inboxRows.map(r => r.id);
+        const placeholders = ids.map(() => "?").join(",");
+        const countRow = this.get(`SELECT COUNT(*) as cnt FROM messages WHERE folder_id IN (${placeholders})`, ids);
+        const total = countRow?.cnt || 0;
+        const rows = this.all(`SELECT * FROM messages WHERE folder_id IN (${placeholders}) ORDER BY date DESC LIMIT ? OFFSET ?`, [...ids, pageSize, offset]);
+        return { items: rows.map(r => this.rowToEnvelope(r)), total, page, pageSize };
+    }
+    getMessageByUid(accountId, uid, folderId) {
+        const sql = folderId != null
+            ? "SELECT * FROM messages WHERE account_id = ? AND uid = ? AND folder_id = ?"
+            : "SELECT * FROM messages WHERE account_id = ? AND uid = ?";
+        const params = folderId != null ? [accountId, uid, folderId] : [accountId, uid];
+        const r = this.get(sql, params);
+        if (!r)
+            return null;
+        return this.rowToEnvelope(r);
+    }
+    getMessageBodyPath(accountId, uid) {
+        const r = this.get("SELECT body_path FROM messages WHERE account_id = ? AND uid = ?", [accountId, uid]);
+        return r?.body_path || "";
+    }
+    updateMessageFlags(accountId, uid, flags) {
+        this.run("UPDATE messages SET flags_json = ? WHERE account_id = ? AND uid = ?", [JSON.stringify(flags), accountId, uid]);
+    }
+    updateBodyPath(accountId, uid, bodyPath) {
+        this.run("UPDATE messages SET body_path = ? WHERE account_id = ? AND uid = ?", [bodyPath, accountId, uid]);
+    }
+    getMessagesWithoutBody(accountId, limit = 50) {
+        return this.all("SELECT uid, folder_id as folderId FROM messages WHERE account_id = ? AND (body_path IS NULL OR body_path = '') ORDER BY date DESC LIMIT ?", [accountId, limit]);
+    }
+    getHighestUid(accountId, folderId) {
+        const r = this.get("SELECT MAX(uid) as maxUid FROM messages WHERE account_id = ? AND folder_id = ?", [accountId, folderId]);
+        return r?.maxUid || 0;
+    }
+    getOldestDate(accountId, folderId) {
+        const r = this.get("SELECT MIN(date) as minDate FROM messages WHERE account_id = ? AND folder_id = ?", [accountId, folderId]);
+        return r?.minDate || 0;
+    }
+    getMessageCount(accountId, folderId) {
+        const r = this.get("SELECT count(*) as cnt FROM messages WHERE account_id = ? AND folder_id = ?", [accountId, folderId]);
+        return r?.cnt || 0;
+    }
+    getUidsForFolder(accountId, folderId) {
+        return this.all("SELECT uid FROM messages WHERE account_id = ? AND folder_id = ?", [accountId, folderId]).map(r => r.uid);
+    }
+    deleteMessage(accountId, uid) {
+        const msg = this.get("SELECT folder_id FROM messages WHERE account_id = ? AND uid = ?", [accountId, uid]);
+        this.run("DELETE FROM messages WHERE account_id = ? AND uid = ?", [accountId, uid]);
+        if (msg)
+            this.recalcFolderCounts(msg.folder_id);
+    }
+    recalcFolderCounts(folderId) {
+        const counts = this.get(`SELECT COUNT(*) as total,
+                    SUM(CASE WHEN flags_json NOT LIKE '%\\\\Seen%' THEN 1 ELSE 0 END) as unread
+             FROM messages WHERE folder_id = ?`, [folderId]);
+        this.updateFolderCounts(folderId, counts?.total || 0, counts?.unread || 0);
+    }
+    beginTransaction() { this.db.run("BEGIN"); }
+    commitTransaction() { this.db.run("COMMIT"); this.scheduleSave(); }
+    rollbackTransaction() { this.db.run("ROLLBACK"); }
+    // ── Contacts ──
+    recordSentAddress(name, email) {
+        const now = Date.now();
+        const existing = this.get("SELECT id FROM contacts WHERE email = ?", [email]);
+        if (existing) {
+            this.run("UPDATE contacts SET name = CASE WHEN ? != '' THEN ? ELSE name END, last_used = ?, use_count = use_count + 1, updated_at = ? WHERE email = ?", [name, name, now, now, email]);
+        }
+        else {
+            this.run("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('sent', ?, ?, ?, 1, ?)", [name, email, now, now]);
+        }
+    }
+    seedContactsFromMessages() {
+        const now = Date.now();
+        const rows = this.all(`SELECT from_name, from_address, COUNT(*) as cnt, MAX(date) as last
+             FROM messages WHERE from_address != '' GROUP BY from_address`);
+        let added = 0;
+        for (const r of rows) {
+            const existing = this.get("SELECT id FROM contacts WHERE email = ?", [r.from_address]);
+            if (!existing) {
+                this.run("INSERT INTO contacts (source, name, email, last_used, use_count, updated_at) VALUES ('received', ?, ?, ?, ?, ?)", [r.from_name || "", r.from_address, r.last, r.cnt, now]);
+                added++;
+            }
+        }
+        return added;
+    }
+    searchContacts(query, limit = 10) {
+        const q = `%${query}%`;
+        return this.all(`SELECT name, email, source, use_count as useCount FROM contacts
+             WHERE email LIKE ? OR name LIKE ?
+             ORDER BY use_count DESC, last_used DESC LIMIT ?`, [q, q, limit]);
+    }
+    // ── Search ──
+    searchMessages(query, page = 1, pageSize = 50, accountId, folderId) {
+        const offset = (page - 1) * pageSize;
+        const term = `%${query}%`;
+        let where = "(subject LIKE ? OR from_name LIKE ? OR from_address LIKE ? OR preview LIKE ?)";
+        const params = [term, term, term, term];
+        if (accountId && folderId) {
+            where += " AND account_id = ? AND folder_id = ?";
+            params.push(accountId, folderId);
+        }
+        else if (accountId) {
+            where += " AND account_id = ?";
+            params.push(accountId);
+        }
+        const countRow = this.get(`SELECT COUNT(*) as cnt FROM messages WHERE ${where}`, params);
+        const total = countRow?.cnt || 0;
+        const rows = this.all(`SELECT * FROM messages WHERE ${where} ORDER BY date DESC LIMIT ? OFFSET ?`, [...params, pageSize, offset]);
+        return { items: rows.map(r => this.rowToEnvelope(r)), total, page, pageSize };
+    }
+    // ── Sync Actions ──
+    queueSyncAction(accountId, action, uid, folderId, extra) {
+        try {
+            this.run(`INSERT OR REPLACE INTO sync_actions (account_id, action, uid, folder_id, target_folder_id, flags_json, raw_message, created_at)
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [accountId, action, uid, folderId,
+                extra?.targetFolderId || null,
+                extra?.flags ? JSON.stringify(extra.flags) : null,
+                extra?.rawMessage || null,
+                Date.now()]);
+        }
+        catch { /* UNIQUE constraint */ }
+    }
+    getPendingSyncActions(accountId) {
+        const rows = this.all("SELECT * FROM sync_actions WHERE account_id = ? ORDER BY created_at", [accountId]);
+        return rows.map(r => ({
+            id: r.id, action: r.action, uid: r.uid, folderId: r.folder_id,
+            targetFolderId: r.target_folder_id,
+            flags: r.flags_json ? JSON.parse(r.flags_json) : [],
+            rawMessage: r.raw_message, attempts: r.attempts,
+        }));
+    }
+    completeSyncAction(id) { this.run("DELETE FROM sync_actions WHERE id = ?", [id]); }
+    failSyncAction(id, error) {
+        this.run("UPDATE sync_actions SET attempts = attempts + 1, last_error = ? WHERE id = ?", [error, id]);
+    }
+    getPendingSyncCount(accountId) {
+        const r = this.get("SELECT COUNT(*) as cnt FROM sync_actions WHERE account_id = ?", [accountId]);
+        return r?.cnt || 0;
+    }
+    getTotalPendingSyncCount() {
+        const r = this.get("SELECT COUNT(*) as cnt FROM sync_actions");
+        return r?.cnt || 0;
+    }
+    /** Reset the entire database */
+    async resetStore() {
+        this.run("DELETE FROM sync_actions");
+        this.run("DELETE FROM contacts");
+        this.run("DELETE FROM messages");
+        this.run("DELETE FROM folders");
+        this.run("DELETE FROM accounts");
+        this.run("DELETE FROM queue");
+        await clearIdb();
+    }
+    // ── Helpers ──
+    rowToEnvelope(r) {
+        return {
+            id: r.id, accountId: r.account_id, folderId: r.folder_id,
+            uid: r.uid, messageId: r.message_id || "", inReplyTo: r.in_reply_to || "",
+            references: JSON.parse(r.refs || "[]"), date: r.date, subject: r.subject,
+            from: { name: r.from_name, address: r.from_address },
+            to: JSON.parse(r.to_json), cc: JSON.parse(r.cc_json),
+            flags: JSON.parse(r.flags_json), size: r.size,
+            hasAttachments: !!r.has_attachments, preview: r.preview
+        };
+    }
+}
+//# sourceMappingURL=db.js.map

package/packages/mailx-store-web/gmail-api-web.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+import type { MailProvider, ProviderFolder, ProviderMessage, FetchOptions } from "./provider-types.js";
+export declare class GmailApiWebProvider implements MailProvider {
+    private tokenProvider;
+    constructor(tokenProvider: () => Promise<string>);
+    private apiFetch;
+    listFolders(): Promise<ProviderFolder[]>;
+    private listMessageIds;
+    private batchFetch;
+    private parseMessage;
+    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>;
+    private folderToLabel;
+    private formatDate;
+}
+//# sourceMappingURL=gmail-api-web.d.ts.map