@bobfrankston/iflow-direct 0.1.1

package/bridge-transport.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Bridge transport for IMAP — uses msgapi.tcp from the native shell.
+ * Works in any msgapi host: msga (MAUI), msger (Rust/wry), msgview (Electron).
+ *
+ * The native shell provides:
+ *   msgapi.tcp.connect(host, port, tls) → streamId
+ *   msgapi.tcp.write(streamId, data)
+ *   msgapi.tcp.onData(streamId, callback)
+ *   msgapi.tcp.upgradeTLS(streamId, servername)
+ *   msgapi.tcp.close(streamId)
+ *
+ * TLS is handled natively — JS never sees raw TLS handshake.
+ */
+import type { ImapTransport } from "./transport.js";
+export declare class BridgeTransport implements ImapTransport {
+    private streamId;
+    private dataHandler;
+    private closeHandler;
+    private errorHandler;
+    private _connected;
+    get connected(): boolean;
+    connect(host: string, port: number, tls: boolean, _servername?: string): Promise<void>;
+    upgradeTLS(servername?: string): Promise<void>;
+    write(data: string | Uint8Array): Promise<void>;
+    onData(handler: (data: string) => void): void;
+    onClose(handler: (hadError: boolean) => void): void;
+    onError(handler: (err: Error) => void): void;
+    close(): void;
+}
+//# sourceMappingURL=bridge-transport.d.ts.map

package/bridge-transport.js

@@ -0,0 +1,60 @@
+/**
+ * Bridge transport for IMAP — uses msgapi.tcp from the native shell.
+ * Works in any msgapi host: msga (MAUI), msger (Rust/wry), msgview (Electron).
+ *
+ * The native shell provides:
+ *   msgapi.tcp.connect(host, port, tls) → streamId
+ *   msgapi.tcp.write(streamId, data)
+ *   msgapi.tcp.onData(streamId, callback)
+ *   msgapi.tcp.upgradeTLS(streamId, servername)
+ *   msgapi.tcp.close(streamId)
+ *
+ * TLS is handled natively — JS never sees raw TLS handshake.
+ */
+export class BridgeTransport {
+    streamId = null;
+    dataHandler = null;
+    closeHandler = null;
+    errorHandler = null;
+    _connected = false;
+    get connected() { return this._connected; }
+    async connect(host, port, tls, _servername) {
+        this.streamId = await msgapi.tcp.connect(host, port, tls);
+        this._connected = true;
+        msgapi.tcp.onData(this.streamId, (data) => {
+            if (this.dataHandler)
+                this.dataHandler(data);
+        });
+        msgapi.tcp.onClose(this.streamId, (hadError) => {
+            this._connected = false;
+            if (this.closeHandler)
+                this.closeHandler(hadError);
+        });
+        msgapi.tcp.onError(this.streamId, (message) => {
+            if (this.errorHandler)
+                this.errorHandler(new Error(message));
+        });
+    }
+    async upgradeTLS(servername) {
+        if (this.streamId == null)
+            throw new Error("Not connected");
+        await msgapi.tcp.upgradeTLS(this.streamId, servername || "");
+    }
+    async write(data) {
+        if (this.streamId == null)
+            throw new Error("Not connected");
+        const str = typeof data === "string" ? data : new TextDecoder().decode(data);
+        await msgapi.tcp.write(this.streamId, str);
+    }
+    onData(handler) { this.dataHandler = handler; }
+    onClose(handler) { this.closeHandler = handler; }
+    onError(handler) { this.errorHandler = handler; }
+    close() {
+        this._connected = false;
+        if (this.streamId != null) {
+            msgapi.tcp.close(this.streamId);
+            this.streamId = null;
+        }
+    }
+}
+//# sourceMappingURL=bridge-transport.js.map

package/credentials.json

@@ -0,0 +1,9 @@
+{
+    "installed": {
+        "client_id": "884213380682-hcso64dcqmk4p98vsc7br2e6gvn7iv2u.apps.googleusercontent.com",
+        "client_secret": "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",
+        "token_uri": "https://oauth2.googleapis.com/token",
+        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+        "redirect_uris": ["http://localhost:9326"]
+    }
+}

package/gmail.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Gmail-specific IMAP support — Node-free version.
+ * OAuth token acquisition is the caller's responsibility.
+ * The caller provides a tokenProvider function that returns an access token.
+ */
+import type { ImapClientConfig, TokenProvider } from "./types.js";
+export interface GmailOAuthConfig {
+    username: string;
+    tokenProvider: TokenProvider;
+    verbose?: boolean;
+    rejectUnauthorized?: boolean;
+}
+/**
+ * Check if email address is Gmail
+ */
+export declare function isGmailUser(username: string): boolean;
+/**
+ * Check if a server is Gmail
+ */
+export declare function isGmailServer(server: string): boolean;
+/**
+ * Create Gmail IMAP config with caller-supplied token provider.
+ * The tokenProvider handles OAuth — this function just wires it up.
+ */
+export declare function createGmailConfig(config: GmailOAuthConfig): ImapClientConfig;
+/**
+ * Auto-configure IMAP client — detects Gmail and uses OAuth, otherwise uses password.
+ * For Gmail, caller must provide a tokenProvider.
+ */
+export declare function createAutoImapConfig(config: {
+    server: string;
+    port: number;
+    username: string;
+    password?: string;
+    tokenProvider?: TokenProvider;
+    verbose?: boolean;
+    rejectUnauthorized?: boolean;
+}): ImapClientConfig;
+//# sourceMappingURL=gmail.d.ts.map

package/gmail.js

@@ -0,0 +1,66 @@
+/**
+ * Gmail-specific IMAP support — Node-free version.
+ * OAuth token acquisition is the caller's responsibility.
+ * The caller provides a tokenProvider function that returns an access token.
+ */
+const GMAIL_SERVER = "imap.gmail.com";
+const GMAIL_PORT = 993;
+/**
+ * Check if email address is Gmail
+ */
+export function isGmailUser(username) {
+    return username.toLowerCase().endsWith("@gmail.com");
+}
+/**
+ * Check if a server is Gmail
+ */
+export function isGmailServer(server) {
+    return server.toLowerCase() === GMAIL_SERVER ||
+        server.toLowerCase().endsWith(".gmail.com");
+}
+/**
+ * Create Gmail IMAP config with caller-supplied token provider.
+ * The tokenProvider handles OAuth — this function just wires it up.
+ */
+export function createGmailConfig(config) {
+    if (!isGmailUser(config.username)) {
+        throw new Error(`Gmail OAuth only supports @gmail.com. Got: ${config.username}`);
+    }
+    return {
+        server: GMAIL_SERVER,
+        port: GMAIL_PORT,
+        username: config.username,
+        tokenProvider: config.tokenProvider,
+        verbose: config.verbose,
+        rejectUnauthorized: config.rejectUnauthorized,
+    };
+}
+/**
+ * Auto-configure IMAP client — detects Gmail and uses OAuth, otherwise uses password.
+ * For Gmail, caller must provide a tokenProvider.
+ */
+export function createAutoImapConfig(config) {
+    const isGmail = isGmailUser(config.username) || isGmailServer(config.server);
+    if (isGmail) {
+        if (!config.tokenProvider) {
+            throw new Error("Gmail requires a tokenProvider for OAuth. Pass a function that returns an access token.");
+        }
+        return createGmailConfig({
+            username: config.username,
+            tokenProvider: config.tokenProvider,
+            verbose: config.verbose,
+            rejectUnauthorized: config.rejectUnauthorized,
+        });
+    }
+    else {
+        return {
+            server: config.server,
+            port: config.port,
+            username: config.username,
+            password: config.password,
+            verbose: config.verbose,
+            rejectUnauthorized: config.rejectUnauthorized,
+        };
+    }
+}
+//# sourceMappingURL=gmail.js.map

package/imap-compat.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Compatibility wrapper — makes NativeImapClient look like the old ImapClient API.
+ * This allows mailx-imap to switch to the native client without rewriting all call sites.
+ * Each method opens the mailbox, does the operation, and returns. No persistent state.
+ */
+import { type NativeFolder } from "./imap-native.js";
+import type { ImapClientConfig } from "./types.js";
+import type { TransportFactory } from "./transport.js";
+/** Special folder detection result */
+export interface SpecialFolders {
+    inbox?: string;
+    sent?: string;
+    trash?: string;
+    drafts?: string;
+    spam?: string;
+    junk?: string;
+    archive?: string;
+}
+/**
+ * Compatibility IMAP client — wraps NativeImapClient with the old ImapClient API.
+ * Each method creates its own select/operation/close cycle.
+ */
+export declare class CompatImapClient {
+    private native;
+    private _connected;
+    constructor(config: ImapClientConfig, transportFactory: TransportFactory);
+    /** Connect and authenticate */
+    connect(): Promise<void>;
+    /** Ensure connected (lazy connect) */
+    private ensureConnected;
+    logout(): Promise<void>;
+    /** Get folder list */
+    getFolderList(): Promise<NativeFolder[]>;
+    /** Detect special folders from folder list */
+    getSpecialFolders(folders: NativeFolder[]): SpecialFolders;
+    /** Fetch messages since a UID in a mailbox */
+    fetchMessagesSinceUid(mailbox: string, sinceUid: number, options?: {
+        source?: boolean;
+    }): Promise<any[]>;
+    /** Fetch messages by date range */
+    fetchMessageByDate(mailbox: string, start: Date, end?: Date, options?: {
+        source?: boolean;
+    }): Promise<any[]>;
+    /** Fetch a single message by UID */
+    fetchMessageByUid(mailbox: string, uid: number, options?: {
+        source?: boolean;
+    }): Promise<any | null>;
+    /** Get message count via STATUS (does not require SELECT) */
+    getMessagesCount(mailbox: string): Promise<number>;
+    /** Get all UIDs in a mailbox */
+    getUids(mailbox: string): Promise<number[]>;
+    /** Fetch messages by UID range string (e.g. "100,200,300" or "100:200") */
+    fetchMessages(mailbox: string, uidRange: string, options?: {
+        source?: boolean;
+    }): Promise<any[]>;
+    /** Search messages in a mailbox */
+    searchMessages(mailbox: string, criteria: any): Promise<number[]>;
+    /** Search by header value — returns matching UIDs */
+    searchByHeader(mailbox: string, headerName: string, headerValue: string): Promise<number[]>;
+    /** Delete a message by UID */
+    deleteMessageByUid(mailbox: string, uid: number): Promise<void>;
+    /** Move a message between mailboxes (same server) */
+    moveMessage(msg: any, fromMailbox: string, toMailbox: string): Promise<void>;
+    /** Add flags to a message */
+    addFlags(mailbox: string, uid: number, flags: string[]): Promise<void>;
+    /** Remove flags from a message */
+    removeFlags(mailbox: string, uid: number, flags: string[]): Promise<void>;
+    /** Create a mailbox */
+    createmailbox(name: string): Promise<void>;
+    /** Append a message to a mailbox */
+    appendMessage(mailbox: string, message: string | Uint8Array, flags?: string[]): Promise<number | null>;
+    /** Watch a mailbox for new messages (IDLE) */
+    watchMailbox(mailbox: string, onNew: (count: number) => void): Promise<() => Promise<void>>;
+    /** Copy a message to another server (cross-account) */
+    moveMessageToServer(msg: any, fromMailbox: string, targetClient: CompatImapClient, toMailbox: string): Promise<void>;
+    /** Rename a mailbox (via native access) */
+    renameMailbox(from: string, to: string): Promise<void>;
+    /** Delete a mailbox */
+    deleteMailbox(name: string): Promise<void>;
+    /** Get flags for a UID — returns string[] for compatibility with old client */
+    getFlags(mailbox: string, uid: number): Promise<string[]>;
+}
+//# sourceMappingURL=imap-compat.d.ts.map

package/imap-compat.js

@@ -0,0 +1,254 @@
+/**
+ * Compatibility wrapper — makes NativeImapClient look like the old ImapClient API.
+ * This allows mailx-imap to switch to the native client without rewriting all call sites.
+ * Each method opens the mailbox, does the operation, and returns. No persistent state.
+ */
+import { NativeImapClient } from "./imap-native.js";
+/** Convert NativeFetchedMessage to the old FetchedMessage shape used by mailx-imap */
+function toCompatMessage(msg) {
+    return {
+        uid: msg.uid,
+        seq: msg.seq,
+        flags: msg.flags,
+        seen: msg.seen,
+        flagged: msg.flagged,
+        answered: msg.answered,
+        draft: msg.draft,
+        date: msg.date,
+        subject: msg.subject,
+        messageId: msg.messageId,
+        from: msg.from,
+        to: msg.to,
+        cc: msg.cc,
+        bcc: msg.bcc,
+        sender: msg.sender,
+        replyTo: msg.replyTo,
+        inReplyTo: msg.inReplyTo,
+        size: msg.size,
+        source: msg.source,
+        headers: msg.headers,
+        // Compatibility: old FetchedMessage had envelope sub-object, but mailx-imap accesses directly
+        envelope: {
+            date: msg.date,
+            subject: msg.subject,
+            messageId: msg.messageId,
+            from: msg.from,
+            to: msg.to,
+            cc: msg.cc,
+            bcc: msg.bcc,
+            sender: msg.sender,
+            replyTo: msg.replyTo,
+            inReplyTo: msg.inReplyTo,
+        }
+    };
+}
+/**
+ * Compatibility IMAP client — wraps NativeImapClient with the old ImapClient API.
+ * Each method creates its own select/operation/close cycle.
+ */
+export class CompatImapClient {
+    native;
+    _connected = false;
+    constructor(config, transportFactory) {
+        this.native = new NativeImapClient(config, transportFactory);
+    }
+    /** Connect and authenticate */
+    async connect() {
+        await this.native.connect();
+        this._connected = true;
+    }
+    /** Ensure connected (lazy connect) */
+    async ensureConnected() {
+        if (!this._connected)
+            await this.connect();
+    }
+    async logout() {
+        this._connected = false;
+        await this.native.logout();
+    }
+    /** Get folder list */
+    async getFolderList() {
+        await this.ensureConnected();
+        return this.native.listFolders();
+    }
+    /** Detect special folders from folder list */
+    getSpecialFolders(folders) {
+        const result = {};
+        for (const f of folders) {
+            const lower = f.path.toLowerCase();
+            const flags = f.flags.map(fl => fl.toLowerCase());
+            if (flags.includes("\\inbox") || lower === "inbox")
+                result.inbox = f.path;
+            else if (flags.includes("\\sent") || lower === "sent" || lower.includes("sent"))
+                result.sent = f.path;
+            else if (flags.includes("\\trash") || lower === "trash" || lower.includes("trash"))
+                result.trash = f.path;
+            else if (flags.includes("\\drafts") || lower === "drafts" || lower.includes("draft"))
+                result.drafts = f.path;
+            else if (flags.includes("\\junk") || flags.includes("\\spam") || lower === "spam" || lower === "junk") {
+                result.junk = f.path;
+                result.spam = f.path;
+            }
+            else if (flags.includes("\\archive") || lower === "archive")
+                result.archive = f.path;
+        }
+        return result;
+    }
+    /** Fetch messages since a UID in a mailbox */
+    async fetchMessagesSinceUid(mailbox, sinceUid, options) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const msgs = await this.native.fetchSinceUid(sinceUid, options);
+        await this.native.closeMailbox();
+        return msgs.map(toCompatMessage);
+    }
+    /** Fetch messages by date range */
+    async fetchMessageByDate(mailbox, start, end, options) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const msgs = await this.native.fetchByDate(start, end, options);
+        await this.native.closeMailbox();
+        return msgs.map(toCompatMessage);
+    }
+    /** Fetch a single message by UID */
+    async fetchMessageByUid(mailbox, uid, options) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const msg = await this.native.fetchMessage(uid, options);
+        await this.native.closeMailbox();
+        return msg ? toCompatMessage(msg) : null;
+    }
+    /** Get message count via STATUS (does not require SELECT) */
+    async getMessagesCount(mailbox) {
+        await this.ensureConnected();
+        return this.native.getMessageCount(mailbox);
+    }
+    /** Get all UIDs in a mailbox */
+    async getUids(mailbox) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const uids = await this.native.getUids();
+        await this.native.closeMailbox();
+        return uids;
+    }
+    /** Fetch messages by UID range string (e.g. "100,200,300" or "100:200") */
+    async fetchMessages(mailbox, uidRange, options) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const msgs = await this.native.fetchMessages(uidRange, options);
+        await this.native.closeMailbox();
+        return msgs.map(toCompatMessage);
+    }
+    /** Search messages in a mailbox */
+    async searchMessages(mailbox, criteria) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        // Convert object criteria to IMAP search string
+        const parts = [];
+        if (criteria.from)
+            parts.push(`FROM "${criteria.from}"`);
+        if (criteria.to)
+            parts.push(`TO "${criteria.to}"`);
+        if (criteria.subject)
+            parts.push(`SUBJECT "${criteria.subject}"`);
+        if (criteria.body)
+            parts.push(`BODY "${criteria.body}"`);
+        if (criteria.since)
+            parts.push(`SINCE ${formatDate(criteria.since)}`);
+        if (criteria.before)
+            parts.push(`BEFORE ${formatDate(criteria.before)}`);
+        const searchStr = parts.length > 0 ? parts.join(" ") : "ALL";
+        const uids = await this.native.search(searchStr);
+        await this.native.closeMailbox();
+        return uids;
+    }
+    /** Search by header value — returns matching UIDs */
+    async searchByHeader(mailbox, headerName, headerValue) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const uids = await this.native.search(`HEADER ${headerName} "${headerValue}"`);
+        await this.native.closeMailbox();
+        return uids;
+    }
+    /** Delete a message by UID */
+    async deleteMessageByUid(mailbox, uid) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        await this.native.deleteMessage(uid);
+        await this.native.closeMailbox();
+    }
+    /** Move a message between mailboxes (same server) */
+    async moveMessage(msg, fromMailbox, toMailbox) {
+        await this.ensureConnected();
+        await this.native.select(fromMailbox);
+        await this.native.moveMessage(msg.uid, toMailbox);
+        await this.native.closeMailbox();
+    }
+    /** Add flags to a message */
+    async addFlags(mailbox, uid, flags) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        await this.native.addFlags(uid, flags);
+        await this.native.closeMailbox();
+    }
+    /** Remove flags from a message */
+    async removeFlags(mailbox, uid, flags) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        await this.native.removeFlags(uid, flags);
+        await this.native.closeMailbox();
+    }
+    /** Create a mailbox */
+    async createmailbox(name) {
+        await this.ensureConnected();
+        await this.native.createMailbox(name);
+    }
+    /** Append a message to a mailbox */
+    async appendMessage(mailbox, message, flags = []) {
+        await this.ensureConnected();
+        const data = typeof message === "string" ? message : new TextDecoder().decode(message);
+        return this.native.appendMessage(mailbox, data, flags);
+    }
+    /** Watch a mailbox for new messages (IDLE) */
+    async watchMailbox(mailbox, onNew) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        return this.native.startIdle(onNew);
+    }
+    /** Copy a message to another server (cross-account) */
+    async moveMessageToServer(msg, fromMailbox, targetClient, toMailbox) {
+        // Fetch source, append to target, delete from source
+        await this.ensureConnected();
+        await this.native.select(fromMailbox);
+        const fetched = await this.native.fetchMessage(msg.uid, { source: true });
+        if (!fetched || !fetched.source)
+            throw new Error(`Message UID ${msg.uid} not found`);
+        await targetClient.ensureConnected();
+        await targetClient.native.appendMessage(toMailbox, fetched.source, [...fetched.flags]);
+        await this.native.deleteMessage(msg.uid);
+        await this.native.closeMailbox();
+    }
+    /** Rename a mailbox (via native access) */
+    async renameMailbox(from, to) {
+        await this.ensureConnected();
+        await this.native.renameMailbox(from, to);
+    }
+    /** Delete a mailbox */
+    async deleteMailbox(name) {
+        await this.ensureConnected();
+        await this.native.deleteMailbox(name);
+    }
+    /** Get flags for a UID — returns string[] for compatibility with old client */
+    async getFlags(mailbox, uid) {
+        await this.ensureConnected();
+        await this.native.select(mailbox);
+        const msg = await this.native.fetchMessage(uid, { source: false });
+        await this.native.closeMailbox();
+        return msg?.flags ? [...msg.flags] : [];
+    }
+}
+function formatDate(d) {
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    return `${d.getDate()}-${months[d.getMonth()]}-${d.getFullYear()}`;
+}
+//# sourceMappingURL=imap-compat.js.map

package/imap-native.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Native IMAP client — transport-agnostic.
+ * Uses ImapTransport for I/O, imap-protocol for parsing.
+ * Works with NodeTransport (desktop) or BridgeTransport (Android).
+ *
+ * This is a NEW client alongside the existing ImapClient (which wraps imapflow).
+ * Existing callers are not affected.
+ */
+import type { TransportFactory } from "./transport.js";
+import * as proto from "./imap-protocol.js";
+import type { ImapClientConfig } from "./types.js";
+export interface NativeFetchedMessage {
+    seq: number;
+    uid: number;
+    flags: Set<string>;
+    date: Date | null;
+    subject: string;
+    messageId: string;
+    from: proto.AddressData[];
+    to: proto.AddressData[];
+    cc: proto.AddressData[];
+    bcc: proto.AddressData[];
+    sender: proto.AddressData[];
+    replyTo: proto.AddressData[];
+    inReplyTo: string;
+    size: number;
+    source: string;
+    headers: string;
+    seen: boolean;
+    flagged: boolean;
+    answered: boolean;
+    draft: boolean;
+}
+export interface NativeFolder {
+    path: string;
+    delimiter: string;
+    flags: string[];
+}
+export interface MailboxInfo {
+    exists: number;
+    recent: number;
+    uidNext: number;
+    uidValidity: number;
+    flags: string[];
+    permanentFlags: string[];
+}
+export declare class NativeImapClient {
+    private transport;
+    private transportFactory;
+    private config;
+    private buffer;
+    private pendingCommand;
+    private capabilities;
+    private _connected;
+    private idleTag;
+    private idleCallback;
+    private verbose;
+    private selectedMailbox;
+    private mailboxInfo;
+    private greetingResolve;
+    /** Callback for waitForContinuation — set when waiting for "+" response */
+    private continuationResolve;
+    constructor(config: ImapClientConfig, transportFactory: TransportFactory);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    private readGreeting;
+    private authenticate;
+    private starttls;
+    capability(): Promise<Set<string>>;
+    private parseCapabilities;
+    logout(): Promise<void>;
+    select(mailbox: string): Promise<MailboxInfo>;
+    examine(mailbox: string): Promise<MailboxInfo>;
+    /** Close the currently selected mailbox */
+    closeMailbox(): Promise<void>;
+    listFolders(): Promise<NativeFolder[]>;
+    getStatus(mailbox: string): Promise<proto.StatusData>;
+    createMailbox(mailbox: string): Promise<void>;
+    deleteMailbox(mailbox: string): Promise<void>;
+    renameMailbox(from: string, to: string): Promise<void>;
+    /** Fetch messages by UID range */
+    fetchMessages(range: string, options?: {
+        source?: boolean;
+        headers?: boolean;
+    }): Promise<NativeFetchedMessage[]>;
+    /** Fetch messages since a UID */
+    fetchSinceUid(sinceUid: number, options?: {
+        source?: boolean;
+    }, onChunk?: (msgs: NativeFetchedMessage[]) => void): Promise<NativeFetchedMessage[]>;
+    /** Fetch messages by date range. Optional onChunk callback receives each batch as it arrives. */
+    fetchByDate(since: Date, before?: Date, options?: {
+        source?: boolean;
+    }, onChunk?: (msgs: NativeFetchedMessage[]) => void): Promise<NativeFetchedMessage[]>;
+    /** Fetch a single message by UID */
+    fetchMessage(uid: number, options?: {
+        source?: boolean;
+    }): Promise<NativeFetchedMessage | null>;
+    /** Get all UIDs in the current mailbox */
+    getUids(): Promise<number[]>;
+    /** UID SEARCH */
+    search(criteria: string): Promise<number[]>;
+    /** Set flags on a message */
+    addFlags(uid: number, flags: string[]): Promise<void>;
+    /** Remove flags from a message */
+    removeFlags(uid: number, flags: string[]): Promise<void>;
+    /** Copy a message to another mailbox */
+    copyMessage(uid: number, destination: string): Promise<void>;
+    /** Move a message to another mailbox (MOVE or COPY+DELETE) */
+    moveMessage(uid: number, destination: string): Promise<void>;
+    /** Delete a message by UID (flag + expunge) */
+    deleteMessage(uid: number): Promise<void>;
+    /** Expunge deleted messages */
+    expunge(): Promise<void>;
+    /** Append a message to a mailbox */
+    appendMessage(mailbox: string, message: string | Uint8Array, flags?: string[]): Promise<number | null>;
+    startIdle(onNewMail: (count: number) => void): Promise<() => Promise<void>>;
+    getMessageCount(mailbox: string): Promise<number>;
+    /** Inactivity timeout — how long to wait with NO data before declaring the connection dead.
+     *  This is NOT a wall-clock timeout. Timer resets every time data arrives from the server.
+     *  A large FETCH returning data continuously will never timeout. */
+    private inactivityTimeout;
+    /** Fetch chunk sizes — start small for quick first paint, ramp up for throughput */
+    private static INITIAL_CHUNK_SIZE;
+    private static MAX_CHUNK_SIZE;
+    /** Active command timer — reset by handleData on every data arrival */
+    private commandTimer;
+    private sendCommand;
+    private waitForContinuation;
+    private waitForTagged;
+    private handleData;
+    private processBuffer;
+    private handleUntaggedResponse;
+    private parseFetchResponses;
+}
+//# sourceMappingURL=imap-native.d.ts.map