@push.rocks/smartmta 5.1.3 → 5.2.0

package/dist_ts/mail/routing/classes.email.action.executor.js

@@ -0,0 +1,137 @@
+import { logger } from '../../logger.js';
+import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
+import { Email } from '../core/classes.email.js';
+import { BounceManager } from '../core/classes.bouncemanager.js';
+import { UnifiedDeliveryQueue } from '../delivery/classes.delivery.queue.js';
+/**
+ * Executes email routing actions (forward, process, deliver, reject)
+ */
+export class EmailActionExecutor {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async executeAction(action, email, context) {
+        switch (action.type) {
+            case 'forward':
+                await this.handleForwardAction(action, email, context);
+                break;
+            case 'process':
+                await this.handleProcessAction(action, email, context);
+                break;
+            case 'deliver':
+                await this.handleDeliverAction(action, email, context);
+                break;
+            case 'reject':
+                await this.handleRejectAction(action, email, context);
+                break;
+            default:
+                throw new Error(`Unknown action type: ${action.type}`);
+        }
+    }
+    async handleForwardAction(action, email, context) {
+        if (!action.forward) {
+            throw new Error('Forward action requires forward configuration');
+        }
+        const { host, port = 25, auth, addHeaders } = action.forward;
+        logger.log('info', `Forwarding email to ${host}:${port}`);
+        // Add forwarding headers
+        if (addHeaders) {
+            for (const [key, value] of Object.entries(addHeaders)) {
+                email.headers[key] = value;
+            }
+        }
+        // Add standard forwarding headers
+        email.headers['X-Forwarded-For'] = context.session.remoteAddress || 'unknown';
+        email.headers['X-Forwarded-To'] = email.to.join(', ');
+        email.headers['X-Forwarded-Date'] = new Date().toISOString();
+        try {
+            // Send email via Rust SMTP client
+            await this.deps.sendOutboundEmail(host, port, email, {
+                auth: auth,
+            });
+            logger.log('info', `Successfully forwarded email to ${host}:${port}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.INFO,
+                type: SecurityEventType.EMAIL_FORWARDING,
+                message: 'Email forwarded successfully',
+                ipAddress: context.session.remoteAddress,
+                details: {
+                    sessionId: context.session.id,
+                    routeName: context.session.matchedRoute?.name,
+                    targetHost: host,
+                    targetPort: port,
+                    recipients: email.to
+                },
+                success: true
+            });
+        }
+        catch (error) {
+            logger.log('error', `Failed to forward email: ${error.message}`);
+            SecurityLogger.getInstance().logEvent({
+                level: SecurityLogLevel.ERROR,
+                type: SecurityEventType.EMAIL_FORWARDING,
+                message: 'Email forwarding failed',
+                ipAddress: context.session.remoteAddress,
+                details: {
+                    sessionId: context.session.id,
+                    routeName: context.session.matchedRoute?.name,
+                    targetHost: host,
+                    targetPort: port,
+                    error: error.message
+                },
+                success: false
+            });
+            // Handle as bounce
+            for (const recipient of email.getAllRecipients()) {
+                await this.deps.bounceManager.processSmtpFailure(recipient, error.message, {
+                    sender: email.from,
+                    originalEmailId: email.headers['Message-ID']
+                });
+            }
+            throw error;
+        }
+    }
+    async handleProcessAction(action, email, context) {
+        logger.log('info', `Processing email with action options`);
+        // Apply scanning if requested
+        if (action.process?.scan) {
+            logger.log('info', 'Content scanning requested');
+        }
+        // Queue for delivery
+        const queue = action.process?.queue || 'normal';
+        await this.deps.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute);
+        logger.log('info', `Email queued for delivery in ${queue} queue`);
+    }
+    async handleDeliverAction(_action, email, context) {
+        logger.log('info', `Delivering email locally`);
+        // Queue for local delivery
+        await this.deps.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute);
+        logger.log('info', 'Email queued for local delivery');
+    }
+    async handleRejectAction(action, _email, context) {
+        const code = action.reject?.code || 550;
+        const message = action.reject?.message || 'Message rejected';
+        logger.log('info', `Rejecting email with code ${code}: ${message}`);
+        SecurityLogger.getInstance().logEvent({
+            level: SecurityLogLevel.WARN,
+            type: SecurityEventType.EMAIL_PROCESSING,
+            message: 'Email rejected by routing rule',
+            ipAddress: context.session.remoteAddress,
+            details: {
+                sessionId: context.session.id,
+                routeName: context.session.matchedRoute?.name,
+                rejectCode: code,
+                rejectMessage: message,
+                from: _email.from,
+                to: _email.to
+            },
+            success: false
+        });
+        // Throw error with SMTP code and message
+        const error = new Error(message);
+        error.responseCode = code;
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5lbWFpbC5hY3Rpb24uZXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9tYWlsL3JvdXRpbmcvY2xhc3Nlcy5lbWFpbC5hY3Rpb24uZXhlY3V0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3pDLE9BQU8sRUFDTCxjQUFjLEVBQ2QsZ0JBQWdCLEVBQ2hCLGlCQUFpQixFQUNsQixNQUFNLHlCQUF5QixDQUFDO0FBRWpDLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNqRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDakUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFpQjdFOztHQUVHO0FBQ0gsTUFBTSxPQUFPLG1CQUFtQjtJQUNWO0lBQXBCLFlBQW9CLElBQXlCO1FBQXpCLFNBQUksR0FBSixJQUFJLENBQXFCO0lBQUcsQ0FBQztJQUVqRCxLQUFLLENBQUMsYUFBYSxDQUFDLE1BQW9CLEVBQUUsS0FBWSxFQUFFLE9BQXNCO1FBQzVFLFFBQVEsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3BCLEtBQUssU0FBUztnQkFDWixNQUFNLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUN2RCxNQUFNO1lBQ1IsS0FBSyxTQUFTO2dCQUNaLE1BQU0sSUFBSSxDQUFDLG1CQUFtQixDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7Z0JBQ3ZELE1BQU07WUFDUixLQUFLLFNBQVM7Z0JBQ1osTUFBTSxJQUFJLENBQUMsbUJBQW1CLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxPQUFPLENBQUMsQ0FBQztnQkFDdkQsTUFBTTtZQUNSLEtBQUssUUFBUTtnQkFDWCxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUN0RCxNQUFNO1lBQ1I7Z0JBQ0UsTUFBTSxJQUFJLEtBQUssQ0FBQyx3QkFBeUIsTUFBYyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7UUFDcEUsQ0FBQztJQUNILENBQUM7SUFFTyxLQUFLLENBQUMsbUJBQW1CLENBQUMsTUFBb0IsRUFBRSxLQUFZLEVBQUUsT0FBc0I7UUFDMUYsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNwQixNQUFNLElBQUksS0FBSyxDQUFDLCtDQUErQyxDQUFDLENBQUM7UUFDbkUsQ0FBQztRQUVELE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxHQUFHLEVBQUUsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQztRQUU3RCxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSx1QkFBdUIsSUFBSSxJQUFJLElBQUksRUFBRSxDQUFDLENBQUM7UUFFMUQseUJBQXlCO1FBQ3pCLElBQUksVUFBVSxFQUFFLENBQUM7WUFDZixLQUFLLE1BQU0sQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDO2dCQUN0RCxLQUFLLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQztZQUM3QixDQUFDO1FBQ0gsQ0FBQztRQUVELGtDQUFrQztRQUNsQyxLQUFLLENBQUMsT0FBTyxDQUFDLGlCQUFpQixDQUFDLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxhQUFhLElBQUksU0FBUyxDQUFDO1FBQzlFLEtBQUssQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxLQUFLLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN0RCxLQUFLLENBQUMsT0FBTyxDQUFDLGtCQUFrQixDQUFDLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUU3RCxJQUFJLENBQUM7WUFDSCxrQ0FBa0M7WUFDbEMsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFO2dCQUNuRCxJQUFJLEVBQUUsSUFBa0Q7YUFDekQsQ0FBQyxDQUFDO1lBRUgsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsbUNBQW1DLElBQUksSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBRXRFLGNBQWMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUM7Z0JBQ3BDLEtBQUssRUFBRSxnQkFBZ0IsQ0FBQyxJQUFJO2dCQUM1QixJQUFJLEVBQUUsaUJBQWlCLENBQUMsZ0JBQWdCO2dCQUN4QyxPQUFPLEVBQUUsOEJBQThCO2dCQUN2QyxTQUFTLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxhQUFhO2dCQUN4QyxPQUFPLEVBQUU7b0JBQ1AsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRTtvQkFDN0IsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLElBQUk7b0JBQzdDLFVBQVUsRUFBRSxJQUFJO29CQUNoQixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsVUFBVSxFQUFFLEtBQUssQ0FBQyxFQUFFO2lCQUNyQjtnQkFDRCxPQUFPLEVBQUUsSUFBSTthQUNkLENBQUMsQ0FBQztRQUNMLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsTUFBTSxDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsNEJBQTRCLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1lBRWpFLGNBQWMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxRQUFRLENBQUM7Z0JBQ3BDLEtBQUssRUFBRSxnQkFBZ0IsQ0FBQyxLQUFLO2dCQUM3QixJQUFJLEVBQUUsaUJBQWlCLENBQUMsZ0JBQWdCO2dCQUN4QyxPQUFPLEVBQUUseUJBQXlCO2dCQUNsQyxTQUFTLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxhQUFhO2dCQUN4QyxPQUFPLEVBQUU7b0JBQ1AsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRTtvQkFDN0IsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLElBQUk7b0JBQzdDLFVBQVUsRUFBRSxJQUFJO29CQUNoQixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsS0FBSyxFQUFFLEtBQUssQ0FBQyxPQUFPO2lCQUNyQjtnQkFDRCxPQUFPLEVBQUUsS0FBSzthQUNmLENBQUMsQ0FBQztZQUVILG1CQUFtQjtZQUNuQixLQUFLLE1BQU0sU0FBUyxJQUFJLEtBQUssQ0FBQyxnQkFBZ0IsRUFBRSxFQUFFLENBQUM7Z0JBQ2pELE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsa0JBQWtCLENBQUMsU0FBUyxFQUFFLEtBQUssQ0FBQyxPQUFPLEVBQUU7b0JBQ3pFLE1BQU0sRUFBRSxLQUFLLENBQUMsSUFBSTtvQkFDbEIsZUFBZSxFQUFFLEtBQUssQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFXO2lCQUN2RCxDQUFDLENBQUM7WUFDTCxDQUFDO1lBQ0QsTUFBTSxLQUFLLENBQUM7UUFDZCxDQUFDO0lBQ0gsQ0FBQztJQUVPLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxNQUFvQixFQUFFLEtBQVksRUFBRSxPQUFzQjtRQUMxRixNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxzQ0FBc0MsQ0FBQyxDQUFDO1FBRTNELDhCQUE4QjtRQUM5QixJQUFJLE1BQU0sQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7WUFDekIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsNEJBQTRCLENBQUMsQ0FBQztRQUNuRCxDQUFDO1FBRUQscUJBQXFCO1FBQ3JCLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxPQUFPLEVBQUUsS0FBSyxJQUFJLFFBQVEsQ0FBQztRQUNoRCxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsWUFBYSxDQUFDLENBQUM7UUFFdkYsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsZ0NBQWdDLEtBQUssUUFBUSxDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUVPLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxPQUFxQixFQUFFLEtBQVksRUFBRSxPQUFzQjtRQUMzRixNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSwwQkFBMEIsQ0FBQyxDQUFDO1FBRS9DLDJCQUEyQjtRQUMzQixNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsWUFBYSxDQUFDLENBQUM7UUFFbkYsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsaUNBQWlDLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRU8sS0FBSyxDQUFDLGtCQUFrQixDQUFDLE1BQW9CLEVBQUUsTUFBYSxFQUFFLE9BQXNCO1FBQzFGLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxNQUFNLEVBQUUsSUFBSSxJQUFJLEdBQUcsQ0FBQztRQUN4QyxNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLE9BQU8sSUFBSSxrQkFBa0IsQ0FBQztRQUU3RCxNQUFNLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSw2QkFBNkIsSUFBSSxLQUFLLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFFcEUsY0FBYyxDQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsQ0FBQztZQUNwQyxLQUFLLEVBQUUsZ0JBQWdCLENBQUMsSUFBSTtZQUM1QixJQUFJLEVBQUUsaUJBQWlCLENBQUMsZ0JBQWdCO1lBQ3hDLE9BQU8sRUFBRSxnQ0FBZ0M7WUFDekMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsYUFBYTtZQUN4QyxPQUFPLEVBQUU7Z0JBQ1AsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRTtnQkFDN0IsU0FBUyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLElBQUk7Z0JBQzdDLFVBQVUsRUFBRSxJQUFJO2dCQUNoQixhQUFhLEVBQUUsT0FBTztnQkFDdEIsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJO2dCQUNqQixFQUFFLEVBQUUsTUFBTSxDQUFDLEVBQUU7YUFDZDtZQUNELE9BQU8sRUFBRSxLQUFLO1NBQ2YsQ0FBQyxDQUFDO1FBRUgseUNBQXlDO1FBQ3pDLE1BQU0sS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2hDLEtBQWEsQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDO1FBQ25DLE1BQU0sS0FBSyxDQUFDO0lBQ2QsQ0FBQztDQUNGIn0=

package/dist_ts/mail/routing/classes.email.router.d.ts

@@ -0,0 +1,171 @@
+import { EventEmitter } from 'node:events';
+import type { IEmailRoute, IEmailContext } from './interfaces.js';
+/**
+ * Email router that evaluates routes and determines actions
+ */
+export declare class EmailRouter extends EventEmitter {
+    private routes;
+    private patternCache;
+    private storageManager?;
+    private persistChanges;
+    /**
+     * Create a new email router
+     * @param routes Array of email routes
+     * @param options Router options
+     */
+    constructor(routes: IEmailRoute[], options?: {
+        storageManager?: any;
+        persistChanges?: boolean;
+    });
+    /**
+     * Sort routes by priority (higher priority first)
+     * @param routes Routes to sort
+     * @returns Sorted routes
+     */
+    private sortRoutesByPriority;
+    /**
+     * Get all configured routes
+     * @returns Array of routes
+     */
+    getRoutes(): IEmailRoute[];
+    /**
+     * Update routes
+     * @param routes New routes
+     * @param persist Whether to persist changes (defaults to persistChanges setting)
+     */
+    updateRoutes(routes: IEmailRoute[], persist?: boolean): Promise<void>;
+    /**
+     * Set routes (alias for updateRoutes)
+     * @param routes New routes
+     * @param persist Whether to persist changes
+     */
+    setRoutes(routes: IEmailRoute[], persist?: boolean): Promise<void>;
+    /**
+     * Clear the pattern cache
+     */
+    clearCache(): void;
+    /**
+     * Evaluate routes and find the first match
+     * @param context Email context
+     * @returns Matched route or null
+     */
+    evaluateRoutes(context: IEmailContext): Promise<IEmailRoute | null>;
+    /**
+     * Check if a route matches the context
+     * @param route Route to check
+     * @param context Email context
+     * @returns True if route matches
+     */
+    private matchesRoute;
+    /**
+     * Check if email recipients match patterns
+     * @param email Email to check
+     * @param patterns Patterns to match
+     * @returns True if any recipient matches
+     */
+    private matchesRecipients;
+    /**
+     * Check if email sender matches patterns
+     * @param email Email to check
+     * @param patterns Patterns to match
+     * @returns True if sender matches
+     */
+    private matchesSenders;
+    /**
+     * Check if client IP matches patterns
+     * @param context Email context
+     * @param patterns IP patterns to match
+     * @returns True if IP matches
+     */
+    private matchesClientIp;
+    /**
+     * Check if email headers match patterns
+     * @param email Email to check
+     * @param headerPatterns Header patterns to match
+     * @returns True if headers match
+     */
+    private matchesHeaders;
+    /**
+     * Check if email size matches range
+     * @param email Email to check
+     * @param sizeRange Size range to match
+     * @returns True if size is in range
+     */
+    private matchesSize;
+    /**
+     * Check if email subject matches pattern
+     * @param email Email to check
+     * @param pattern Pattern to match
+     * @returns True if subject matches
+     */
+    private matchesSubject;
+    /**
+     * Check if a string matches a glob pattern
+     * @param str String to check
+     * @param pattern Glob pattern
+     * @returns True if matches
+     */
+    private matchesPattern;
+    /**
+     * Convert glob pattern to RegExp
+     * @param pattern Glob pattern
+     * @returns Regular expression
+     */
+    private globToRegExp;
+    /**
+     * Check if IP is in CIDR range
+     * @param ip IP address to check
+     * @param cidr CIDR notation (e.g., '192.168.0.0/16')
+     * @returns True if IP is in range
+     */
+    private ipInCidr;
+    /**
+     * Convert IP address to number
+     * @param ip IP address
+     * @returns Number representation
+     */
+    private ipToNumber;
+    /**
+     * Calculate approximate email size in bytes
+     * @param email Email to measure
+     * @returns Size in bytes
+     */
+    private calculateEmailSize;
+    /**
+     * Save current routes to storage
+     */
+    saveRoutes(): Promise<void>;
+    /**
+     * Load routes from storage
+     * @param options Load options
+     */
+    loadRoutes(options?: {
+        merge?: boolean;
+        replace?: boolean;
+    }): Promise<IEmailRoute[]>;
+    /**
+     * Add a route
+     * @param route Route to add
+     * @param persist Whether to persist changes
+     */
+    addRoute(route: IEmailRoute, persist?: boolean): Promise<void>;
+    /**
+     * Remove a route by name
+     * @param name Route name
+     * @param persist Whether to persist changes
+     */
+    removeRoute(name: string, persist?: boolean): Promise<void>;
+    /**
+     * Update a route
+     * @param name Route name
+     * @param route Updated route data
+     * @param persist Whether to persist changes
+     */
+    updateRoute(name: string, route: IEmailRoute, persist?: boolean): Promise<void>;
+    /**
+     * Get a route by name
+     * @param name Route name
+     * @returns Route or undefined
+     */
+    getRoute(name: string): IEmailRoute | undefined;
+}