import { EventEmitter } from 'events';
import { type Lock } from '../../shell/client/mailbox-lock';
import type { CommandContext, CommandContextState, ExecOptions, ExecResponse } from '../../shell/commands/types';
import type { ConnectionId, Logger, MailboxPath, ModSeq } from '../../types/common';
import type { AuthOptions, ConnectionOptions } from '../../types/connection';
import type { MailboxInfo, MailboxListEntry } from '../../types/mailbox';
import type { CommandAttribute } from '../../types/protocol';
export type IMAPClientOptions = ConnectionOptions & {
    readonly id?: string;
};
export type IMAPClientEvents = {
    close: [];
    error: [Error];
    exists: [{
        path: MailboxPath;
        count: number;
        prevCount: number;
    }];
    expunge: [{
        path: MailboxPath;
        seq: number;
        vanished: boolean;
    }];
    flags: [{
        path: MailboxPath;
        seq: number;
        uid?: number;
        flags: Set<string>;
        modseq?: ModSeq;
    }];
    log: [object];
    mailboxClose: [MailboxInfo];
    mailboxOpen: [MailboxInfo];
};
export declare class IMAPClient extends EventEmitter implements CommandContext, AsyncDisposable {
    readonly id: ConnectionId;
    private readonly options;
    private readonly listenerTracker;
    private readonly timerManager;
    private readonly stateMachine;
    private readonly commandQueue;
    private responseRouter;
    private readonly mailboxLock;
    private socketManager;
    private imapStream;
    private disposed;
    private greeting;
    private _capabilities;
    private readonly _enabled;
    private readonly _authCapabilities;
    private _mailbox;
    private readonly _folders;
    private _expectCapabilityUpdate;
    private readonly _log;
    constructor(options: IMAPClientOptions);
    get log(): Logger;
    get capabilities(): ReadonlySet<string>;
    get enabled(): ReadonlySet<string>;
    get authCapabilities(): ReadonlyMap<string, boolean>;
    get servername(): string;
    get state(): CommandContextState;
    get mailbox(): MailboxInfo | null;
    get folders(): ReadonlyMap<MailboxPath, MailboxListEntry>;
    get expectCapabilityUpdate(): boolean;
    get isDisposed(): boolean;
    get isCompressed(): boolean;
    enableCompression: () => void;
    setCapabilities: (capabilities: Set<string>) => void;
    addEnabled: (extension: string) => void;
    setAuthCapability: (method: string, success: boolean) => void;
    setExpectCapabilityUpdate: (expect: boolean) => void;
    setMailbox: (mailbox: MailboxInfo | null) => void;
    setFolder: (path: MailboxPath, folder: MailboxListEntry) => void;
    emitMailboxOpen: (mailbox: MailboxInfo) => void;
    emitMailboxClose: (mailbox: MailboxInfo) => void;
    emitExists: (info: {
        path: MailboxPath;
        count: number;
        prevCount: number;
    }) => void;
    emitExpunge: (info: {
        path: MailboxPath;
        seq: number;
        vanished: boolean;
    }) => void;
    emitFlags: (info: {
        path: MailboxPath;
        seq: number;
        uid?: number;
        flags: Set<string>;
        modseq?: ModSeq;
    }) => void;
    connect(): Promise<void>;
    authenticate(auth: AuthOptions): Promise<string>;
    private enableExtensions;
    exec(command: string, attributes?: readonly CommandAttribute[], options?: ExecOptions): Promise<ExecResponse>;
    write: (data: string | Buffer) => void;
    run: <T>(command: string, ...args: unknown[]) => Promise<T>;
    getMailboxLock(path: MailboxPath): Promise<Lock>;
    logout(): Promise<void>;
    close(): Promise<void>;
    dispose(): void;
    [Symbol.asyncDispose](): Promise<void>;
    private setupSocketListeners;
    private setupStreamListeners;
    private handleStreamData;
    private waitForGreeting;
    private parseGreetingCapabilities;
    private handleGlobalUntagged;
    private handleCapabilityResponse;
    private handleExistsResponse;
    private handleExpungeResponse;
    private handleFetchResponse;
}
export declare const createIMAPClient: (options: IMAPClientOptions) => IMAPClient;
//# sourceMappingURL=index.d.ts.map