@astralibx/email-account-manager 2.0.0

package/dist/index.d.mts

@@ -0,0 +1,1049 @@
+import { Router } from 'express';
+import * as mongoose from 'mongoose';
+import { Connection, Model, HydratedDocument, Schema, Types } from 'mongoose';
+import { Redis } from 'ioredis';
+import { LogAdapter, AlxError } from '@astralibx/core';
+export { LogAdapter } from '@astralibx/core';
+import { Job } from 'bullmq';
+
+interface WarmupPhase {
+    days: [number, number];
+    dailyLimit: number;
+    delayMinMs: number;
+    delayMaxMs: number;
+}
+interface EmailAccountManagerConfig {
+    db: {
+        connection: Connection;
+        collectionPrefix?: string;
+    };
+    redis: {
+        connection: Redis;
+        keyPrefix?: string;
+    };
+    logger?: LogAdapter;
+    options?: {
+        warmup?: {
+            defaultSchedule: WarmupPhase[];
+        };
+        healthDefaults?: {
+            minScore?: number;
+            maxBounceRate?: number;
+            maxConsecutiveErrors?: number;
+        };
+        ses?: {
+            enabled: boolean;
+            validateSignature?: boolean;
+            allowedTopicArns?: string[];
+        };
+        unsubscribe?: {
+            builtin?: {
+                enabled: boolean;
+                secret: string;
+                baseUrl: string;
+                tokenExpiryDays?: number;
+            };
+            generateUrl?: (email: string, accountId: string) => string;
+        };
+        queues?: {
+            sendQueueName?: string;
+            approvalQueueName?: string;
+        };
+    };
+    hooks?: {
+        onAccountDisabled?: (info: {
+            accountId: string;
+            reason: string;
+        }) => void;
+        onWarmupComplete?: (info: {
+            accountId: string;
+            email: string;
+        }) => void;
+        onHealthDegraded?: (info: {
+            accountId: string;
+            healthScore: number;
+        }) => void;
+        onSend?: (info: {
+            accountId: string;
+            email: string;
+            messageId?: string;
+        }) => void;
+        onSendError?: (info: {
+            accountId: string;
+            email: string;
+            error: string;
+        }) => void;
+        onBounce?: (info: {
+            accountId: string;
+            email: string;
+            bounceType: string;
+            provider: string;
+        }) => void;
+        onUnsubscribe?: (info: {
+            email: string;
+            accountId?: string;
+        }) => void;
+        onDelivery?: (info: {
+            accountId: string;
+            email: string;
+        }) => void;
+        onComplaint?: (info: {
+            accountId: string;
+            email: string;
+        }) => void;
+        onOpen?: (info: {
+            accountId: string;
+            email: string;
+            timestamp: Date;
+        }) => void;
+        onClick?: (info: {
+            accountId: string;
+            email: string;
+            link: string;
+        }) => void;
+        onDraftCreated?: (info: {
+            draftId: string;
+            to: string;
+            subject: string;
+        }) => void;
+        onDraftApproved?: (info: {
+            draftId: string;
+            to: string;
+            scheduledAt?: Date;
+        }) => void;
+        onDraftRejected?: (info: {
+            draftId: string;
+            to: string;
+            reason?: string;
+        }) => void;
+    };
+}
+
+interface DevModeSettings {
+    enabled: boolean;
+    testEmails: string[];
+}
+interface ImapSettings {
+    enabled: boolean;
+    pollIntervalMs: number;
+    searchSince: 'last_check' | 'last_24h' | 'last_7d';
+    bounceSenders: string[];
+}
+interface SesSettings {
+    configurationSet?: string;
+    trackOpens: boolean;
+    trackClicks: boolean;
+}
+interface ApprovalSendWindow {
+    timezone: string;
+    startHour: number;
+    endHour: number;
+}
+interface ApprovalSettings {
+    enabled: boolean;
+    defaultMode: 'manual' | 'auto';
+    autoApproveDelayMs: number;
+    sendWindow: ApprovalSendWindow;
+    spreadStrategy: 'random' | 'even';
+    maxSpreadMinutes: number;
+}
+interface UnsubscribePageSettings {
+    companyName: string;
+    logoUrl?: string;
+    accentColor?: string;
+}
+interface QueueSettings {
+    sendConcurrency: number;
+    sendAttempts: number;
+    sendBackoffMs: number;
+    approvalConcurrency: number;
+    approvalAttempts: number;
+    approvalBackoffMs: number;
+}
+interface GlobalSettings {
+    _id: 'global';
+    timezone: string;
+    devMode: DevModeSettings;
+    imap: ImapSettings;
+    ses: SesSettings;
+    approval: ApprovalSettings;
+    unsubscribePage: UnsubscribePageSettings;
+    queues: QueueSettings;
+    updatedAt: Date;
+}
+type UpdateGlobalSettingsInput = Partial<Omit<GlobalSettings, '_id' | 'updatedAt'>>;
+
+interface IGlobalSettings extends Omit<GlobalSettings, '_id'> {
+    _id: string;
+}
+type GlobalSettingsDocument = HydratedDocument<IGlobalSettings>;
+interface GlobalSettingsStatics {
+    getSettings(): Promise<GlobalSettingsDocument>;
+    updateSettings(partial: Partial<Omit<GlobalSettings, '_id' | 'updatedAt'>>): Promise<GlobalSettingsDocument>;
+}
+type GlobalSettingsModel = Model<IGlobalSettings> & GlobalSettingsStatics;
+interface CreateGlobalSettingsSchemaOptions {
+    collectionName?: string;
+}
+declare function createGlobalSettingsSchema(options?: CreateGlobalSettingsSchemaOptions): Schema<IGlobalSettings, Model<IGlobalSettings, any, any, any, mongoose.Document<unknown, any, IGlobalSettings, any, {}> & IGlobalSettings & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IGlobalSettings, mongoose.Document<unknown, {}, mongoose.FlatRecord<IGlobalSettings>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IGlobalSettings> & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}>;
+
+declare class SettingsService {
+    private GlobalSettings;
+    private logger;
+    private cache;
+    constructor(GlobalSettings: GlobalSettingsModel, logger: LogAdapter);
+    get(): Promise<GlobalSettings>;
+    update(partial: UpdateGlobalSettingsInput): Promise<GlobalSettings>;
+    updateSection(section: string, data: unknown): Promise<GlobalSettings>;
+    invalidateCache(): void;
+}
+
+declare const ACCOUNT_PROVIDER: {
+    readonly Gmail: "gmail";
+    readonly Ses: "ses";
+};
+type AccountProvider = (typeof ACCOUNT_PROVIDER)[keyof typeof ACCOUNT_PROVIDER];
+declare const ACCOUNT_STATUS: {
+    readonly Active: "active";
+    readonly Disabled: "disabled";
+    readonly QuotaExceeded: "quota_exceeded";
+    readonly Error: "error";
+    readonly Warmup: "warmup";
+};
+type AccountStatus = (typeof ACCOUNT_STATUS)[keyof typeof ACCOUNT_STATUS];
+declare const IDENTIFIER_STATUS: {
+    readonly Active: "active";
+    readonly Bounced: "bounced";
+    readonly Unsubscribed: "unsubscribed";
+    readonly Blocked: "blocked";
+    readonly Invalid: "invalid";
+};
+type IdentifierStatus = (typeof IDENTIFIER_STATUS)[keyof typeof IDENTIFIER_STATUS];
+declare const BOUNCE_TYPE: {
+    readonly Hard: "hard";
+    readonly Soft: "soft";
+    readonly InboxFull: "inbox_full";
+    readonly InvalidEmail: "invalid_email";
+};
+type BounceType = (typeof BOUNCE_TYPE)[keyof typeof BOUNCE_TYPE];
+declare const DRAFT_STATUS: {
+    readonly Pending: "pending";
+    readonly Approved: "approved";
+    readonly Rejected: "rejected";
+    readonly Queued: "queued";
+    readonly Sent: "sent";
+    readonly Failed: "failed";
+};
+type DraftStatus = (typeof DRAFT_STATUS)[keyof typeof DRAFT_STATUS];
+declare const EMAIL_EVENT_TYPE: {
+    readonly Sent: "sent";
+    readonly Failed: "failed";
+    readonly Delivered: "delivered";
+    readonly Bounced: "bounced";
+    readonly Complained: "complained";
+    readonly Opened: "opened";
+    readonly Clicked: "clicked";
+    readonly Unsubscribed: "unsubscribed";
+};
+type EmailEventType = (typeof EMAIL_EVENT_TYPE)[keyof typeof EMAIL_EVENT_TYPE];
+declare const SES_BOUNCE_TYPE: {
+    readonly Permanent: "Permanent";
+    readonly Transient: "Transient";
+    readonly Undetermined: "Undetermined";
+};
+type SesBounceType = (typeof SES_BOUNCE_TYPE)[keyof typeof SES_BOUNCE_TYPE];
+declare const SES_COMPLAINT_TYPE: {
+    readonly Abuse: "abuse";
+    readonly AuthFailure: "auth-failure";
+    readonly Fraud: "fraud";
+    readonly NotSpam: "not-spam";
+    readonly Other: "other";
+    readonly Virus: "virus";
+};
+type SesComplaintType = (typeof SES_COMPLAINT_TYPE)[keyof typeof SES_COMPLAINT_TYPE];
+declare const SNS_MESSAGE_TYPE: {
+    readonly Notification: "Notification";
+    readonly SubscriptionConfirmation: "SubscriptionConfirmation";
+    readonly UnsubscribeConfirmation: "UnsubscribeConfirmation";
+};
+type SnsMessageType = (typeof SNS_MESSAGE_TYPE)[keyof typeof SNS_MESSAGE_TYPE];
+declare const SES_NOTIFICATION_TYPE: {
+    readonly Bounce: "Bounce";
+    readonly Complaint: "Complaint";
+    readonly Delivery: "Delivery";
+    readonly Send: "Send";
+    readonly Open: "Open";
+    readonly Click: "Click";
+};
+type SesNotificationType = (typeof SES_NOTIFICATION_TYPE)[keyof typeof SES_NOTIFICATION_TYPE];
+
+interface IEmailIdentifier {
+    email: string;
+    status: IdentifierStatus;
+    sentCount: number;
+    bounceCount: number;
+    lastSentAt?: Date;
+    lastBouncedAt?: Date;
+    bounceType?: BounceType;
+    unsubscribedAt?: Date;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type EmailIdentifierDocument = HydratedDocument<IEmailIdentifier>;
+interface EmailIdentifierStatics {
+    findOrCreate(email: string): Promise<{
+        identifier: EmailIdentifierDocument;
+        created: boolean;
+    }>;
+    markBounced(email: string, bounceType: BounceType): Promise<EmailIdentifierDocument | null>;
+    markUnsubscribed(email: string): Promise<EmailIdentifierDocument | null>;
+    incrementSentCount(email: string): Promise<EmailIdentifierDocument | null>;
+    findByEmail(email: string): Promise<EmailIdentifierDocument | null>;
+}
+type EmailIdentifierModel = Model<IEmailIdentifier> & EmailIdentifierStatics;
+interface CreateEmailIdentifierSchemaOptions {
+    collectionName?: string;
+}
+declare function createEmailIdentifierSchema(options?: CreateEmailIdentifierSchemaOptions): Schema<IEmailIdentifier, Model<IEmailIdentifier, any, any, any, mongoose.Document<unknown, any, IEmailIdentifier, any, {}> & IEmailIdentifier & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailIdentifier, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailIdentifier>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailIdentifier> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+declare class IdentifierService {
+    private EmailIdentifier;
+    private logger;
+    private hooks?;
+    constructor(EmailIdentifier: EmailIdentifierModel, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    findOrCreate(email: string): Promise<EmailIdentifierDocument>;
+    findByEmail(email: string): Promise<EmailIdentifierDocument | null>;
+    markBounced(email: string, bounceType: BounceType): Promise<void>;
+    markUnsubscribed(email: string): Promise<void>;
+    updateStatus(email: string, status: IdentifierStatus): Promise<void>;
+    incrementSentCount(email: string): Promise<void>;
+    merge(sourceEmail: string, targetEmail: string): Promise<void>;
+    list(filters?: {
+        status?: string;
+    }, page?: number, limit?: number): Promise<{
+        items: EmailIdentifierDocument[];
+        total: number;
+    }>;
+}
+
+interface SmtpConfig {
+    host: string;
+    port: number;
+    user: string;
+    pass: string;
+}
+interface ImapConfig {
+    host: string;
+    port: number;
+    user: string;
+    pass: string;
+}
+interface SesConfig {
+    region: string;
+    configurationSet?: string;
+}
+interface HealthThresholds {
+    minScore: number;
+    maxBounceRate: number;
+    maxConsecutiveErrors: number;
+}
+interface AccountHealthData {
+    score: number;
+    consecutiveErrors: number;
+    bounceCount: number;
+    thresholds: HealthThresholds;
+}
+interface AccountWarmupData {
+    enabled: boolean;
+    startedAt?: Date;
+    completedAt?: Date;
+    currentDay: number;
+    schedule: WarmupPhase[];
+}
+interface AccountLimits {
+    dailyMax: number;
+}
+interface EmailAccount {
+    _id: string;
+    email: string;
+    senderName: string;
+    provider: AccountProvider;
+    status: AccountStatus;
+    smtp: SmtpConfig;
+    imap?: ImapConfig;
+    ses?: SesConfig;
+    limits: AccountLimits;
+    health: AccountHealthData;
+    warmup: AccountWarmupData;
+    totalEmailsSent: number;
+    lastSuccessfulSendAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateEmailAccountInput {
+    email: string;
+    senderName: string;
+    provider: AccountProvider;
+    smtp: SmtpConfig;
+    imap?: ImapConfig;
+    ses?: SesConfig;
+    limits?: Partial<AccountLimits>;
+    warmup?: {
+        schedule?: WarmupPhase[];
+    };
+    health?: {
+        thresholds?: Partial<HealthThresholds>;
+    };
+}
+interface UpdateEmailAccountInput {
+    senderName?: string;
+    status?: AccountStatus;
+    smtp?: Partial<SmtpConfig>;
+    imap?: Partial<ImapConfig>;
+    ses?: Partial<SesConfig>;
+    limits?: Partial<AccountLimits>;
+    warmup?: Partial<AccountWarmupData>;
+    health?: {
+        thresholds?: Partial<HealthThresholds>;
+    };
+}
+interface AccountCapacity {
+    accountId: string;
+    email: string;
+    provider: AccountProvider;
+    dailyMax: number;
+    sentToday: number;
+    remaining: number;
+    usagePercent: number;
+}
+interface AccountHealth {
+    accountId: string;
+    email: string;
+    score: number;
+    consecutiveErrors: number;
+    bounceCount: number;
+    thresholds: HealthThresholds;
+    status: AccountStatus;
+}
+
+interface IEmailAccount {
+    email: string;
+    senderName: string;
+    provider: AccountProvider;
+    status: AccountStatus;
+    smtp: {
+        host: string;
+        port: number;
+        user: string;
+        pass: string;
+    };
+    imap?: {
+        host: string;
+        port: number;
+        user: string;
+        pass: string;
+    };
+    ses?: {
+        region: string;
+        configurationSet?: string;
+    };
+    limits: {
+        dailyMax: number;
+    };
+    health: {
+        score: number;
+        consecutiveErrors: number;
+        bounceCount: number;
+        thresholds: {
+            minScore: number;
+            maxBounceRate: number;
+            maxConsecutiveErrors: number;
+        };
+    };
+    warmup: {
+        enabled: boolean;
+        startedAt?: Date;
+        completedAt?: Date;
+        currentDay: number;
+        schedule: WarmupPhase[];
+    };
+    totalEmailsSent: number;
+    lastSuccessfulSendAt?: Date;
+    lastImapCheckAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type EmailAccountDocument = HydratedDocument<IEmailAccount>;
+interface EmailAccountStatics {
+    findActive(): Promise<EmailAccountDocument[]>;
+    findByProvider(provider: AccountProvider): Promise<EmailAccountDocument[]>;
+    findByEmail(email: string): Promise<EmailAccountDocument | null>;
+    getBestAvailable(): Promise<EmailAccountDocument | null>;
+}
+type EmailAccountModel = Model<IEmailAccount> & EmailAccountStatics;
+interface CreateEmailAccountSchemaOptions {
+    collectionName?: string;
+}
+declare function createEmailAccountSchema(options?: CreateEmailAccountSchemaOptions): Schema<IEmailAccount, Model<IEmailAccount, any, any, any, mongoose.Document<unknown, any, IEmailAccount, any, {}> & IEmailAccount & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailAccount, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailAccount>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailAccount> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+interface IEmailDailyStats {
+    accountId: Types.ObjectId;
+    date: string;
+    sent: number;
+    failed: number;
+    bounced: number;
+    delivered: number;
+    complained: number;
+    opened: number;
+    clicked: number;
+    unsubscribed: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type EmailDailyStatsDocument = HydratedDocument<IEmailDailyStats>;
+interface EmailDailyStatsStatics {
+    incrementStat(accountId: string, field: string, count?: number, date?: string): Promise<EmailDailyStatsDocument>;
+    getForAccount(accountId: string, days?: number): Promise<EmailDailyStatsDocument[]>;
+    getForDate(date: string): Promise<EmailDailyStatsDocument[]>;
+}
+type EmailDailyStatsModel = Model<IEmailDailyStats> & EmailDailyStatsStatics;
+interface CreateEmailDailyStatsSchemaOptions {
+    collectionName?: string;
+}
+declare function createEmailDailyStatsSchema(options?: CreateEmailDailyStatsSchemaOptions): Schema<IEmailDailyStats, Model<IEmailDailyStats, any, any, any, mongoose.Document<unknown, any, IEmailDailyStats, any, {}> & IEmailDailyStats & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailDailyStats, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailDailyStats>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailDailyStats> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+declare class HealthTracker {
+    private EmailAccount;
+    private EmailDailyStats;
+    private settings;
+    private logger;
+    private hooks?;
+    constructor(EmailAccount: EmailAccountModel, EmailDailyStats: EmailDailyStatsModel, settings: SettingsService, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    recordSuccess(accountId: string): Promise<void>;
+    recordError(accountId: string, error: string): Promise<void>;
+    recordBounce(accountId: string, email: string, bounceType: BounceType): Promise<void>;
+    getHealth(accountId: string): Promise<AccountHealth | null>;
+    getAllHealth(): Promise<AccountHealth[]>;
+    private toAccountHealth;
+    private getTodayDateString;
+    private incrementDailyStat;
+}
+
+interface WarmupStatus {
+    accountId: string;
+    email: string;
+    enabled: boolean;
+    currentDay: number;
+    startedAt?: Date;
+    completedAt?: Date;
+    currentPhase: WarmupPhase | null;
+    dailyLimit: number;
+    delayRange: {
+        min: number;
+        max: number;
+    };
+}
+declare class WarmupManager {
+    private EmailAccount;
+    private config;
+    private logger;
+    private hooks?;
+    constructor(EmailAccount: EmailAccountModel, config: EmailAccountManagerConfig, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    startWarmup(accountId: string): Promise<void>;
+    completeWarmup(accountId: string): Promise<void>;
+    resetWarmup(accountId: string): Promise<void>;
+    getCurrentPhase(accountId: string): Promise<WarmupPhase | null>;
+    getRecommendedDelay(accountId: string): Promise<number>;
+    getDailyLimit(accountId: string): Promise<number>;
+    advanceDay(accountId: string): Promise<void>;
+    getStatus(accountId: string): Promise<WarmupStatus | null>;
+    updateSchedule(accountId: string, schedule: WarmupPhase[]): Promise<void>;
+    private findPhaseForDay;
+    private getMaxDay;
+}
+
+declare class CapacityManager {
+    private EmailAccount;
+    private EmailDailyStats;
+    private warmupManager;
+    private settings;
+    private logger;
+    constructor(EmailAccount: EmailAccountModel, EmailDailyStats: EmailDailyStatsModel, warmupManager: WarmupManager, settings: SettingsService, logger: LogAdapter);
+    getBestAccount(): Promise<EmailAccountDocument | null>;
+    getAccountCapacity(accountId: string): Promise<AccountCapacity>;
+    getAllCapacity(): Promise<{
+        accounts: AccountCapacity[];
+        totalRemaining: number;
+    }>;
+    private getSentToday;
+    private getDailyLimit;
+    private getTodayDateString;
+}
+
+declare class UnsubscribeService {
+    private EmailIdentifier;
+    private config;
+    private logger;
+    private hooks?;
+    constructor(EmailIdentifier: EmailIdentifierModel, config: EmailAccountManagerConfig, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    generateUrl(email: string, accountId?: string): string;
+    generateToken(email: string): string;
+    verifyToken(email: string, token: string): boolean;
+    handleUnsubscribe(email: string, token: string): Promise<{
+        success: boolean;
+        error?: string;
+        email?: string;
+    }>;
+    getConfirmationHtml(email: string, success: boolean): string;
+}
+
+interface QueueStats {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+}
+interface SendJobData {
+    accountId: string;
+    to: string;
+    subject: string;
+    html: string;
+    text: string;
+    unsubscribeUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ApprovalJobData {
+    draftId: string;
+    scheduledAt?: string;
+}
+declare class QueueService {
+    private redis;
+    private config;
+    private settings;
+    private logger;
+    private sendQueue;
+    private approvalQueue;
+    private sendWorker;
+    private approvalWorker;
+    constructor(redis: Redis, config: EmailAccountManagerConfig, settings: SettingsService, logger: LogAdapter);
+    init(processors: {
+        sendProcessor: (job: Job) => Promise<void>;
+        approvalProcessor: (job: Job) => Promise<void>;
+    }): Promise<void>;
+    enqueueSend(data: SendJobData): Promise<string>;
+    enqueueApproval(data: ApprovalJobData): Promise<string>;
+    getStats(): Promise<{
+        send: QueueStats;
+        approval: QueueStats;
+    }>;
+    pause(queue: 'send' | 'approval'): Promise<void>;
+    resume(queue: 'send' | 'approval'): Promise<void>;
+    close(): Promise<void>;
+}
+
+interface SmtpSendParams {
+    accountId?: string;
+    to: string;
+    subject: string;
+    html: string;
+    text?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SmtpSendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+    draftId?: string;
+}
+declare class SmtpService {
+    private EmailAccount;
+    private capacityManager;
+    private healthTracker;
+    private identifierService;
+    private unsubscribeService;
+    private queueService;
+    private settings;
+    private config;
+    private logger;
+    private hooks?;
+    private devRoundRobinIndex;
+    private transporterPool;
+    constructor(EmailAccount: EmailAccountModel, capacityManager: CapacityManager, healthTracker: HealthTracker, identifierService: IdentifierService, unsubscribeService: UnsubscribeService, queueService: QueueService, settings: SettingsService, config: EmailAccountManagerConfig, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    send(params: SmtpSendParams): Promise<SmtpSendResult>;
+    testConnection(accountId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    executeSend(accountId: string, to: string, subject: string, html: string, text: string, unsubscribeUrl?: string): Promise<SmtpSendResult>;
+    closeAll(): void;
+    private getOrCreateTransporter;
+    private createTransporter;
+}
+
+interface EmailDraft {
+    _id: string;
+    to: string;
+    subject: string;
+    htmlBody: string;
+    textBody?: string;
+    accountId: string;
+    status: DraftStatus;
+    approvedAt?: Date;
+    rejectedAt?: Date;
+    rejectionReason?: string;
+    sentAt?: Date;
+    scheduledAt?: Date;
+    failureReason?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateDraftInput {
+    to: string;
+    subject: string;
+    htmlBody: string;
+    textBody?: string;
+    accountId: string;
+    scheduledAt?: Date;
+    metadata?: Record<string, unknown>;
+}
+
+interface IEmailDraft {
+    to: string;
+    subject: string;
+    htmlBody: string;
+    textBody?: string;
+    accountId: Types.ObjectId;
+    status: DraftStatus;
+    approvedAt?: Date;
+    rejectedAt?: Date;
+    rejectionReason?: string;
+    sentAt?: Date;
+    scheduledAt?: Date;
+    failureReason?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type EmailDraftDocument = HydratedDocument<IEmailDraft>;
+interface EmailDraftStatics {
+    findPending(limit?: number): Promise<EmailDraftDocument[]>;
+    findByStatus(status: DraftStatus, limit?: number): Promise<EmailDraftDocument[]>;
+    countByStatus(): Promise<Record<string, number>>;
+}
+type EmailDraftModel = Model<IEmailDraft> & EmailDraftStatics;
+interface CreateEmailDraftSchemaOptions {
+    collectionName?: string;
+}
+declare function createEmailDraftSchema(options?: CreateEmailDraftSchemaOptions): Schema<IEmailDraft, Model<IEmailDraft, any, any, any, mongoose.Document<unknown, any, IEmailDraft, any, {}> & IEmailDraft & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IEmailDraft, mongoose.Document<unknown, {}, mongoose.FlatRecord<IEmailDraft>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<IEmailDraft> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+
+declare class ApprovalService {
+    private EmailDraft;
+    private queueService;
+    private settings;
+    private logger;
+    private hooks?;
+    constructor(EmailDraft: EmailDraftModel, queueService: QueueService, settings: SettingsService, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    createDraft(input: CreateDraftInput): Promise<EmailDraftDocument>;
+    approve(draftId: string): Promise<void>;
+    reject(draftId: string, reason?: string): Promise<void>;
+    bulkApprove(draftIds: string[]): Promise<void>;
+    bulkReject(draftIds: string[], reason?: string): Promise<void>;
+    sendNow(draftId: string): Promise<void>;
+    updateContent(draftId: string, content: {
+        subject?: string;
+        htmlBody?: string;
+        textBody?: string;
+    }): Promise<EmailDraftDocument>;
+    getDrafts(filters?: {
+        status?: string;
+    }, page?: number, limit?: number): Promise<{
+        items: EmailDraftDocument[];
+        total: number;
+    }>;
+    getDraftById(draftId: string): Promise<EmailDraftDocument | null>;
+    countByStatus(): Promise<Record<string, number>>;
+    private calculateScheduledTime;
+}
+
+declare class ImapBounceChecker {
+    private EmailAccount;
+    private healthTracker;
+    private identifierService;
+    private settings;
+    private logger;
+    private hooks?;
+    private polling;
+    constructor(EmailAccount: EmailAccountModel, healthTracker: HealthTracker, identifierService: IdentifierService, settings: SettingsService, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    start(): Promise<void>;
+    stop(): void;
+    checkNow(): Promise<void>;
+    checkAccount(accountId: string): Promise<{
+        bouncesFound: number;
+    }>;
+    private classifyBounce;
+    private getSearchDate;
+}
+
+interface EmailIdentifier {
+    _id: string;
+    email: string;
+    status: IdentifierStatus;
+    sentCount: number;
+    bounceCount: number;
+    lastSentAt?: Date;
+    lastBouncedAt?: Date;
+    bounceType?: BounceType;
+    unsubscribedAt?: Date;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateIdentifierInput {
+    email: string;
+    status?: IdentifierStatus;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateIdentifierInput {
+    status?: IdentifierStatus;
+    bounceType?: BounceType;
+    metadata?: Record<string, unknown>;
+}
+
+interface EmailEvent {
+    type: EmailEventType;
+    accountId: string;
+    email: string;
+    provider: AccountProvider;
+    bounceType?: BounceType;
+    link?: string;
+    timestamp: Date;
+    metadata?: Record<string, unknown>;
+}
+interface SnsMessage {
+    Type: SnsMessageType;
+    MessageId: string;
+    TopicArn: string;
+    Subject?: string;
+    Message: string;
+    Timestamp: string;
+    SignatureVersion: string;
+    Signature: string;
+    SigningCertURL: string;
+    SubscribeURL?: string;
+    UnsubscribeURL?: string;
+    Token?: string;
+}
+interface SesBounceRecipient {
+    emailAddress: string;
+    action?: string;
+    status?: string;
+    diagnosticCode?: string;
+}
+interface SesComplaintRecipient {
+    emailAddress: string;
+}
+interface SesMailPayload {
+    messageId: string;
+    timestamp: string;
+    source: string;
+    sourceArn?: string;
+    sendingAccountId?: string;
+    destination: string[];
+    headersTruncated?: boolean;
+    headers?: Array<{
+        name: string;
+        value: string;
+    }>;
+    commonHeaders?: {
+        from?: string[];
+        to?: string[];
+        subject?: string;
+        messageId?: string;
+    };
+}
+interface SesBounce {
+    bounceType: SesBounceType;
+    bounceSubType: string;
+    bouncedRecipients: SesBounceRecipient[];
+    timestamp: string;
+    feedbackId?: string;
+    remoteMtaIp?: string;
+    reportingMTA?: string;
+}
+interface SesComplaint {
+    complainedRecipients: SesComplaintRecipient[];
+    timestamp: string;
+    complaintFeedbackType?: SesComplaintType;
+    feedbackId?: string;
+    userAgent?: string;
+    arrivalDate?: string;
+}
+interface SesDelivery {
+    timestamp: string;
+    processingTimeMillis: number;
+    recipients: string[];
+    smtpResponse: string;
+    reportingMTA?: string;
+}
+interface SesOpen {
+    ipAddress: string;
+    timestamp: string;
+    userAgent: string;
+}
+interface SesClick {
+    ipAddress: string;
+    timestamp: string;
+    userAgent: string;
+    link: string;
+    linkTags?: Record<string, string[]>;
+}
+interface SesNotification {
+    notificationType: SesNotificationType;
+    mail: SesMailPayload;
+    bounce?: SesBounce;
+    complaint?: SesComplaint;
+    delivery?: SesDelivery;
+    open?: SesOpen;
+    click?: SesClick;
+}
+
+declare class AlxAccountError extends AlxError {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+declare class ConfigValidationError extends AlxAccountError {
+    readonly field: string;
+    constructor(message: string, field: string);
+}
+declare class AccountDisabledError extends AlxAccountError {
+    readonly accountId: string;
+    readonly reason: string;
+    constructor(accountId: string, reason: string);
+}
+declare class NoAvailableAccountError extends AlxAccountError {
+    constructor();
+}
+declare class SmtpConnectionError extends AlxAccountError {
+    readonly accountId: string;
+    readonly originalError: Error;
+    constructor(accountId: string, originalError: Error);
+}
+declare class InvalidTokenError extends AlxAccountError {
+    readonly tokenType: 'unsubscribe';
+    constructor(tokenType: 'unsubscribe');
+}
+declare class QuotaExceededError extends AlxAccountError {
+    readonly accountId: string;
+    readonly dailyMax: number;
+    readonly currentSent: number;
+    constructor(accountId: string, dailyMax: number, currentSent: number);
+}
+declare class SnsSignatureError extends AlxAccountError {
+    constructor();
+}
+declare class AccountNotFoundError extends AlxAccountError {
+    readonly accountId: string;
+    constructor(accountId: string);
+}
+declare class DraftNotFoundError extends AlxAccountError {
+    readonly draftId: string;
+    constructor(draftId: string);
+}
+
+declare function validateConfig(raw: unknown): void;
+
+interface WebhookProcessResult {
+    processed: boolean;
+    type?: string;
+    error?: string;
+}
+declare class SesWebhookHandler {
+    private healthTracker;
+    private identifierService;
+    private EmailAccount;
+    private config;
+    private logger;
+    private hooks?;
+    constructor(healthTracker: HealthTracker, identifierService: IdentifierService, EmailAccount: EmailAccountModel, config: EmailAccountManagerConfig, logger: LogAdapter, hooks?: EmailAccountManagerConfig['hooks']);
+    handleSnsMessage(body: unknown): Promise<WebhookProcessResult>;
+    private handleSubscriptionConfirmation;
+    private processNotification;
+    private processBounce;
+    private processComplaint;
+    private validateSignature;
+    private fetchCertificate;
+    private parseBody;
+    private findAccountIdBySource;
+}
+
+interface EmailAccountManager {
+    routes: Router;
+    webhookRoutes: {
+        ses: Router;
+    };
+    unsubscribeRoutes: Router;
+    accounts: {
+        model: any;
+        create: (data: any) => Promise<any>;
+        findById: (id: string) => Promise<any>;
+        update: (id: string, data: any) => Promise<any>;
+        remove: (id: string) => Promise<any>;
+    };
+    capacity: CapacityManager;
+    health: HealthTracker;
+    warmup: WarmupManager;
+    smtp: SmtpService;
+    imap: ImapBounceChecker;
+    approval: ApprovalService;
+    unsubscribe: UnsubscribeService;
+    identifiers: IdentifierService;
+    queues: QueueService;
+    settings: SettingsService;
+    destroy(): Promise<void>;
+}
+declare function createEmailAccountManager(config: EmailAccountManagerConfig): EmailAccountManager;
+
+export { ACCOUNT_PROVIDER, ACCOUNT_STATUS, type AccountCapacity, AccountDisabledError, type AccountHealth, type AccountHealthData, type AccountLimits, AccountNotFoundError, type AccountProvider, type AccountStatus, type AccountWarmupData, AlxAccountError, type ApprovalJobData, type ApprovalSendWindow, ApprovalService, type ApprovalSettings, BOUNCE_TYPE, type BounceType, CapacityManager, ConfigValidationError, type CreateDraftInput, type CreateEmailAccountInput, type CreateEmailAccountSchemaOptions, type CreateEmailDailyStatsSchemaOptions, type CreateEmailDraftSchemaOptions, type CreateEmailIdentifierSchemaOptions, type CreateGlobalSettingsSchemaOptions, type CreateIdentifierInput, DRAFT_STATUS, type DevModeSettings, DraftNotFoundError, type DraftStatus, EMAIL_EVENT_TYPE, type EmailAccount, type EmailAccountDocument, type EmailAccountManager, type EmailAccountManagerConfig, type EmailAccountModel, type EmailAccountStatics, type EmailDailyStatsDocument, type EmailDailyStatsModel, type EmailDailyStatsStatics, type EmailDraft, type EmailDraftDocument, type EmailDraftModel, type EmailDraftStatics, type EmailEvent, type EmailEventType, type EmailIdentifier, type EmailIdentifierDocument, type EmailIdentifierModel, type EmailIdentifierStatics, type GlobalSettings, type GlobalSettingsDocument, type GlobalSettingsModel, type GlobalSettingsStatics, type HealthThresholds, HealthTracker, IDENTIFIER_STATUS, type IEmailAccount, type IEmailDailyStats, type IEmailDraft, type IEmailIdentifier, type IGlobalSettings, IdentifierService, type IdentifierStatus, ImapBounceChecker, type ImapConfig, type ImapSettings, InvalidTokenError, NoAvailableAccountError, QueueService, type QueueSettings, type QueueStats, QuotaExceededError, SES_BOUNCE_TYPE, SES_COMPLAINT_TYPE, SES_NOTIFICATION_TYPE, SNS_MESSAGE_TYPE, type SendJobData, type SesBounce, type SesBounceRecipient, type SesBounceType, type SesClick, type SesComplaint, type SesComplaintRecipient, type SesComplaintType, type SesConfig, type SesDelivery, type SesMailPayload, type SesNotification, type SesNotificationType, type SesOpen, type SesSettings, SesWebhookHandler, SettingsService, type SmtpConfig, SmtpConnectionError, type SmtpSendParams, type SmtpSendResult, SmtpService, type SnsMessage, type SnsMessageType, SnsSignatureError, type UnsubscribePageSettings, UnsubscribeService, type UpdateEmailAccountInput, type UpdateGlobalSettingsInput, type UpdateIdentifierInput, WarmupManager, type WarmupPhase, type WarmupStatus, type WebhookProcessResult, createEmailAccountManager, createEmailAccountSchema, createEmailDailyStatsSchema, createEmailDraftSchema, createEmailIdentifierSchema, createGlobalSettingsSchema, validateConfig };