zele 0.3.16 → 0.3.20

package/dist/imap-smtp-client.d.ts

@@ -0,0 +1,306 @@
+import { AuthError, ApiError, UnsupportedError, EmptyThreadError, NotFoundError } from './api-utils.js';
+import type { AccountId, ImapSmtpCredentials } from './auth.js';
+import type { ThreadListResult, ThreadResult, ParsedMessage, WatchEvent, Sender } from './gmail-client.js';
+export declare class ImapSmtpClient {
+    private imapCreds;
+    private smtpCreds;
+    private account;
+    private smtpTransporter;
+    constructor({ credentials, account }: {
+        credentials: ImapSmtpCredentials;
+        account: AccountId;
+    });
+    private createImapClient;
+    /**
+     * Resolve a zele folder name (inbox, sent, trash, etc.) to the actual IMAP
+     * mailbox path by checking RFC 6154 specialUse attributes first, then
+     * falling back to common mailbox name variants.
+     */
+    private resolveMailboxPath;
+    /** Run an IMAP operation with auto-connect/logout.
+     *  The entire callback is wrapped in imapBoundary so any IMAP error
+     *  (getMailboxLock, search, fetch, etc.) becomes an error value. */
+    private withImap;
+    private getSmtpTransporter;
+    listThreads({ query, folder, maxResults, labelIds, pageToken, }?: {
+        query?: string;
+        folder?: string;
+        maxResults?: number;
+        labelIds?: string[];
+        pageToken?: string;
+    }): Promise<ThreadListResult | AuthError | ApiError>;
+    getThread({ threadId }: {
+        threadId: string;
+    }): Promise<ThreadResult>;
+    getMessage({ messageId }: {
+        messageId: string;
+    }): Promise<ParsedMessage | AuthError | ApiError>;
+    getRawMessage({ messageId }: {
+        messageId: string;
+    }): Promise<string | NotFoundError | AuthError | ApiError>;
+    sendMessage({ to, subject, body, cc, bcc, inReplyTo, references, attachments, }: {
+        to: Array<{
+            name?: string;
+            email: string;
+        }>;
+        subject: string;
+        body: string;
+        cc?: Array<{
+            name?: string;
+            email: string;
+        }>;
+        bcc?: Array<{
+            name?: string;
+            email: string;
+        }>;
+        threadId?: string;
+        inReplyTo?: string;
+        references?: string;
+        attachments?: Array<{
+            filename: string;
+            mimeType: string;
+            content: Buffer;
+        }>;
+        fromEmail?: string;
+    }): Promise<{
+        id: string;
+        threadId: string;
+        labelIds: string[];
+    } | UnsupportedError | AuthError | ApiError>;
+    replyToThread({ threadId, body, replyAll, cc, fromEmail, }: {
+        threadId: string;
+        body: string;
+        replyAll?: boolean;
+        cc?: Array<{
+            email: string;
+        }>;
+        fromEmail?: string;
+    }): Promise<EmptyThreadError | UnsupportedError | AuthError | ApiError | {
+        id: string;
+        threadId: string;
+        labelIds: string[];
+    }>;
+    forwardThread({ threadId, to, body, fromEmail, }: {
+        threadId: string;
+        to: Array<{
+            email: string;
+        }>;
+        body?: string;
+        fromEmail?: string;
+    }): Promise<EmptyThreadError | UnsupportedError | AuthError | ApiError | {
+        id: string;
+        threadId: string;
+        labelIds: string[];
+    }>;
+    star({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    unstar({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    markAsRead({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    markAsUnread({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    trash({ threadId }: {
+        threadId: string;
+    }): Promise<void | AuthError | ApiError>;
+    untrash({ threadId }: {
+        threadId: string;
+    }): Promise<void | AuthError | ApiError>;
+    archive({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    markAsSpam({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    unmarkSpam({ threadIds }: {
+        threadIds: string[];
+    }): Promise<void | AuthError | ApiError>;
+    trashAllSpam(): Promise<{
+        count: number;
+    } | AuthError | ApiError>;
+    listLabels(): Promise<UnsupportedError>;
+    modifyLabels(_opts: {
+        threadIds: string[];
+        addLabelIds: string[];
+        removeLabelIds: string[];
+    }): Promise<UnsupportedError>;
+    getProfile(): Promise<{
+        emailAddress: string;
+        messagesTotal: number;
+        threadsTotal: number;
+        historyId: string;
+    } | AuthError | ApiError>;
+    getEmailAliases(): Promise<Array<{
+        email: string;
+        name?: string;
+        primary: boolean;
+    }> | AuthError | ApiError>;
+    getAttachment({ messageId, attachmentId }: {
+        messageId: string;
+        attachmentId: string;
+    }): Promise<string | NotFoundError | AuthError | ApiError>;
+    watchInbox({ folder, intervalMs, query, once, }?: {
+        folder?: string;
+        intervalMs?: number;
+        query?: string;
+        once?: boolean;
+    }): AsyncGenerator<WatchEvent>;
+    listDrafts({ query, maxResults, pageToken, }?: {
+        query?: string;
+        maxResults?: number;
+        pageToken?: string;
+    }): Promise<{
+        drafts: Array<{
+            id: string;
+            subject: string;
+            to: string[];
+            date: string;
+        }>;
+        nextPageToken: string | null;
+    } | AuthError | ApiError>;
+    createDraft({ to, subject, body, cc, bcc, threadId, fromEmail, }: {
+        to: Array<{
+            name?: string;
+            email: string;
+        }>;
+        subject: string;
+        body: string;
+        cc?: Array<{
+            name?: string;
+            email: string;
+        }>;
+        bcc?: Array<{
+            name?: string;
+            email: string;
+        }>;
+        threadId?: string;
+        fromEmail?: string;
+        attachments?: Array<{
+            filename: string;
+            mimeType: string;
+            content: Buffer;
+        }>;
+    }): Promise<{
+        id: string;
+        message: {
+            id: string;
+        };
+        threadId: string;
+    }>;
+    getDraft({ draftId }: {
+        draftId: string;
+    }): Promise<{
+        id: string;
+        message: ParsedMessage;
+        to: Sender[];
+        cc: Sender[];
+        bcc: Sender[];
+    }>;
+    sendDraft({ draftId }: {
+        draftId: string;
+    }): Promise<AuthError | ApiError | UnsupportedError | {
+        id: string;
+        threadId: string;
+        labelIds: string[];
+    }>;
+    deleteDraft({ draftId }: {
+        draftId: string;
+    }): Promise<void | AuthError | ApiError>;
+    /**
+     * Update an existing draft. IMAP has no native update — we delete the old
+     * draft and APPEND a new message to the Drafts folder.
+     */
+    updateDraft({ draftId, to, subject, body, cc, bcc, fromEmail, }: {
+        draftId: string;
+        to: Array<{
+            name?: string;
+            email: string;
+        }>;
+        subject: string;
+        body: string;
+        cc?: Array<{
+            name?: string;
+            email: string;
+        }>;
+        bcc?: Array<{
+            name?: string;
+            email: string;
+        }>;
+        threadId?: string;
+        fromEmail?: string;
+        attachments?: Array<{
+            filename: string;
+            mimeType: string;
+            content: Buffer;
+        }>;
+    }): Promise<AuthError | ApiError | {
+        id: string;
+        message: {
+            id: string;
+        };
+        threadId: string;
+    }>;
+    /**
+     * Create a draft reply to a thread. Resolves reply-to, reply-all CCs,
+     * and sets In-Reply-To/References headers, then appends to Drafts.
+     */
+    createDraftReply({ threadId, body, replyAll, cc, fromEmail, }: {
+        threadId: string;
+        body: string;
+        replyAll?: boolean;
+        cc?: Array<{
+            email: string;
+        }>;
+        fromEmail?: string;
+    }): Promise<EmptyThreadError | AuthError | ApiError | {
+        id: string;
+        message: {
+            id: string;
+        };
+        threadId: string;
+    }>;
+    /**
+     * Create a draft forwarding a thread. Builds the forwarded-message body
+     * and appends to Drafts folder.
+     */
+    createDraftForward({ threadId, to, body, fromEmail, }: {
+        threadId: string;
+        to: Array<{
+            email: string;
+        }>;
+        body?: string;
+        fromEmail?: string;
+    }): Promise<EmptyThreadError | AuthError | ApiError | {
+        id: string;
+        message: {
+            id: string;
+        };
+        threadId: string;
+    }>;
+    listFolders(): Promise<Array<{
+        name: string;
+        path: string;
+        specialUse?: string;
+        flags: string[];
+    }> | AuthError | ApiError>;
+    invalidateThreads(_threadIds: string[]): Promise<void>;
+    invalidateThread(_threadId: string): Promise<void>;
+    /** Modify IMAP flags on messages. Groups by folder for efficiency. */
+    private modifyFlags;
+    /** Check if a message has attachments from its bodyStructure. */
+    private hasAttachments;
+    /** Parse an imapflow FetchMessageObject into our ParsedMessage type. */
+    private parseImapMessage;
+    /** Extract body text from raw RFC 2822 source. */
+    private extractBodyFromSource;
+    private parseBody;
+    private parseMultipart;
+    private decodeTransferEncoding;
+    private getHeader;
+    /** Recursively collect attachment metadata from bodyStructure. */
+    private collectAttachments;
+}