@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/opsserver/handlers/stats.handler.js

@@ -0,0 +1,233 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+export class StatsHandler {
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Server Statistics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getServerStatistics', async (dataArg, toolsArg) => {
+            const stats = await this.collectServerStats();
+            return {
+                stats: {
+                    uptime: stats.uptime,
+                    startTime: Date.now() - (stats.uptime * 1000),
+                    memoryUsage: stats.memoryUsage,
+                    cpuUsage: stats.cpuUsage,
+                    activeConnections: stats.activeConnections,
+                    totalConnections: stats.totalConnections,
+                },
+                history: dataArg.includeHistory ? stats.history : undefined,
+            };
+        }));
+        // Email Statistics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getEmailStatistics', async (dataArg, toolsArg) => {
+            const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+            if (!emailServer) {
+                return {
+                    stats: {
+                        sent: 0,
+                        received: 0,
+                        bounced: 0,
+                        queued: 0,
+                        failed: 0,
+                        averageDeliveryTime: 0,
+                        deliveryRate: 0,
+                        bounceRate: 0,
+                    },
+                };
+            }
+            const stats = await this.collectEmailStats();
+            return {
+                stats: {
+                    sent: stats.sentToday,
+                    received: stats.receivedToday,
+                    bounced: Math.floor(stats.sentToday * stats.bounceRate / 100),
+                    queued: stats.queueSize,
+                    failed: 0,
+                    averageDeliveryTime: 0,
+                    deliveryRate: stats.deliveryRate,
+                    bounceRate: stats.bounceRate,
+                },
+                domainBreakdown: dataArg.includeDetails ? stats.domainBreakdown : undefined,
+            };
+        }));
+        // DNS Statistics Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getDnsStatistics', async (dataArg, toolsArg) => {
+            const dnsServer = this.opsServerRef.dcRouterRef.dnsServer;
+            if (!dnsServer) {
+                return {
+                    stats: {
+                        totalQueries: 0,
+                        cacheHits: 0,
+                        cacheMisses: 0,
+                        cacheHitRate: 0,
+                        activeDomains: 0,
+                        averageResponseTime: 0,
+                        queryTypes: {},
+                    },
+                };
+            }
+            const stats = await this.collectDnsStats();
+            return {
+                stats: {
+                    totalQueries: stats.totalQueries,
+                    cacheHits: stats.cacheHits,
+                    cacheMisses: stats.cacheMisses,
+                    cacheHitRate: stats.cacheHitRate,
+                    activeDomains: stats.topDomains.length,
+                    averageResponseTime: 0,
+                    queryTypes: stats.queryTypes,
+                },
+                domainBreakdown: dataArg.includeQueryTypes ? stats.domainBreakdown : undefined,
+            };
+        }));
+        // Queue Status Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getQueueStatus', async (dataArg, toolsArg) => {
+            const emailServer = this.opsServerRef.dcRouterRef.emailServer;
+            const queues = [];
+            if (emailServer) {
+                const status = await this.getQueueStatus();
+                queues.push({
+                    name: dataArg.queueName || 'default',
+                    size: status.pending,
+                    processing: status.active,
+                    failed: status.failed,
+                    retrying: status.retrying,
+                    averageProcessingTime: 0,
+                });
+            }
+            return {
+                queues,
+                totalItems: queues.reduce((sum, q) => sum + q.size + q.processing + q.failed + q.retrying, 0),
+            };
+        }));
+        // Health Status Handler
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getHealthStatus', async (dataArg, toolsArg) => {
+            const health = await this.checkHealthStatus();
+            return {
+                health: {
+                    healthy: health.healthy,
+                    uptime: process.uptime(),
+                    services: health.services.reduce((acc, service) => {
+                        acc[service.name] = {
+                            status: service.status,
+                            message: service.message,
+                            lastCheck: Date.now(),
+                        };
+                        return acc;
+                    }, {}),
+                    version: '2.12.0', // TODO: Get from package.json
+                },
+            };
+        }));
+    }
+    async collectServerStats() {
+        const uptime = process.uptime();
+        const memUsage = process.memoryUsage();
+        const totalMem = plugins.os.totalmem();
+        const freeMem = plugins.os.freemem();
+        const usedMem = totalMem - freeMem;
+        // Get CPU usage (simplified - in production would use proper monitoring)
+        const cpuUsage = plugins.os.loadavg()[0] * 100 / plugins.os.cpus().length;
+        // TODO: Implement proper request tracking
+        const requestsPerSecond = 0;
+        const activeConnections = 0;
+        const totalConnections = 0;
+        return {
+            uptime,
+            cpuUsage: {
+                user: cpuUsage * 0.7, // Approximate user CPU
+                system: cpuUsage * 0.3, // Approximate system CPU
+            },
+            memoryUsage: {
+                heapUsed: memUsage.heapUsed,
+                heapTotal: memUsage.heapTotal,
+                external: memUsage.external,
+                rss: memUsage.rss,
+            },
+            requestsPerSecond,
+            activeConnections,
+            totalConnections,
+            history: [], // TODO: Implement history tracking
+        };
+    }
+    async collectEmailStats() {
+        // TODO: Implement actual email statistics collection
+        return {
+            sentToday: 0,
+            receivedToday: 0,
+            bounceRate: 0,
+            deliveryRate: 100,
+            queueSize: 0,
+        };
+    }
+    async collectDnsStats() {
+        // TODO: Implement actual DNS statistics collection
+        return {
+            queriesPerSecond: 0,
+            totalQueries: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            cacheHitRate: 0,
+            topDomains: [],
+            queryTypes: {},
+        };
+    }
+    async getQueueStatus() {
+        // TODO: Implement actual queue status collection
+        return {
+            pending: 0,
+            active: 0,
+            failed: 0,
+            retrying: 0,
+            items: [],
+        };
+    }
+    async checkHealthStatus() {
+        const services = [];
+        // Check HTTP Proxy
+        if (this.opsServerRef.dcRouterRef.smartProxy) {
+            services.push({
+                name: 'HTTP/HTTPS Proxy',
+                status: 'healthy',
+            });
+        }
+        // Check Email Server
+        if (this.opsServerRef.dcRouterRef.emailServer) {
+            services.push({
+                name: 'Email Server',
+                status: 'healthy',
+            });
+        }
+        // Check DNS Server
+        if (this.opsServerRef.dcRouterRef.dnsServer) {
+            services.push({
+                name: 'DNS Server',
+                status: 'healthy',
+            });
+        }
+        // Check OpsServer
+        services.push({
+            name: 'OpsServer',
+            status: 'healthy',
+        });
+        const healthy = services.every(s => s.status === 'healthy');
+        return {
+            healthy,
+            services,
+            checks: [
+                {
+                    name: 'Memory Usage',
+                    passed: process.memoryUsage().heapUsed < (plugins.os.totalmem() * 0.9),
+                    message: 'Memory usage within limits',
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stats.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/stats.handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts/opsserver/helpers/guards.d.ts

@@ -0,0 +1,25 @@
+import * as plugins from '../../plugins.js';
+import type { AdminHandler } from '../handlers/admin.handler.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+/**
+ * Helper function to use identity guards in handlers
+ *
+ * @example
+ * // In a handler:
+ * await passGuards(toolsArg, this.opsServerRef.adminHandler.validIdentityGuard, dataArg);
+ */
+export declare function passGuards<T extends {
+    identity?: any;
+}>(toolsArg: any, guard: plugins.smartguard.Guard<T>, dataArg: T): Promise<void>;
+/**
+ * Helper to check admin identity in handlers
+ */
+export declare function requireAdminIdentity<T extends {
+    identity?: interfaces.data.IIdentity;
+}>(adminHandler: AdminHandler, dataArg: T): Promise<void>;
+/**
+ * Helper to check valid identity in handlers
+ */
+export declare function requireValidIdentity<T extends {
+    identity?: interfaces.data.IIdentity;
+}>(adminHandler: AdminHandler, dataArg: T): Promise<void>;

package/dist_ts/ts/opsserver/helpers/guards.js

@@ -0,0 +1,41 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+/**
+ * Helper function to use identity guards in handlers
+ *
+ * @example
+ * // In a handler:
+ * await passGuards(toolsArg, this.opsServerRef.adminHandler.validIdentityGuard, dataArg);
+ */
+export async function passGuards(toolsArg, guard, dataArg) {
+    const result = await guard.exec(dataArg);
+    if (!result) {
+        const failedHint = await guard.getFailedHint(dataArg);
+        throw new plugins.typedrequest.TypedResponseError(failedHint || 'Guard check failed');
+    }
+}
+/**
+ * Helper to check admin identity in handlers
+ */
+export async function requireAdminIdentity(adminHandler, dataArg) {
+    if (!dataArg.identity) {
+        throw new plugins.typedrequest.TypedResponseError('No identity provided');
+    }
+    const passed = await adminHandler.adminIdentityGuard.exec({ identity: dataArg.identity });
+    if (!passed) {
+        throw new plugins.typedrequest.TypedResponseError('Admin access required');
+    }
+}
+/**
+ * Helper to check valid identity in handlers
+ */
+export async function requireValidIdentity(adminHandler, dataArg) {
+    if (!dataArg.identity) {
+        throw new plugins.typedrequest.TypedResponseError('No identity provided');
+    }
+    const passed = await adminHandler.validIdentityGuard.exec({ identity: dataArg.identity });
+    if (!passed) {
+        throw new plugins.typedrequest.TypedResponseError('Valid identity required');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VhcmRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvb3Bzc2VydmVyL2hlbHBlcnMvZ3VhcmRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RDs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLFVBQVUsQ0FDOUIsUUFBYSxFQUNiLEtBQWtDLEVBQ2xDLE9BQVU7SUFFVixNQUFNLE1BQU0sR0FBRyxNQUFNLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDekMsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxVQUFVLEdBQUcsTUFBTSxLQUFLLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3RELE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLFVBQVUsSUFBSSxvQkFBb0IsQ0FBQyxDQUFDO0lBQ3hGLENBQUM7QUFDSCxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLG9CQUFvQixDQUN4QyxZQUEwQixFQUMxQixPQUFVO0lBRVYsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN0QixNQUFNLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzVFLENBQUM7SUFFRCxNQUFNLE1BQU0sR0FBRyxNQUFNLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEVBQUUsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDMUYsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQUMsdUJBQXVCLENBQUMsQ0FBQztJQUM3RSxDQUFDO0FBQ0gsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxvQkFBb0IsQ0FDeEMsWUFBMEIsRUFDMUIsT0FBVTtJQUVWLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDdEIsTUFBTSxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUM1RSxDQUFDO0lBRUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxZQUFZLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzFGLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNaLE1BQU0sSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDL0UsQ0FBQztBQUNILENBQUMifQ==

package/dist_ts/ts/opsserver/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.opsserver.js';

package/dist_ts/ts/opsserver/index.js

@@ -0,0 +1,2 @@
+export * from './classes.opsserver.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9vcHNzZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQyJ9

package/dist_ts/ts/paths.d.ts

@@ -0,0 +1,14 @@
+export declare const baseDir: string;
+export declare const packageDir: string;
+export declare const distServe: string;
+export declare const dataDir: string;
+export declare const keysDir: string;
+export declare const dnsRecordsDir: string;
+export declare const sentEmailsDir: string;
+export declare const receivedEmailsDir: string;
+export declare const failedEmailsDir: string;
+export declare const logsDir: string;
+export declare const emailTemplatesDir: string;
+export declare const MtaAttachmentsDir: string;
+export declare const configPath: string;
+export declare function ensureDirectories(): void;

package/dist_ts/ts/paths.js

@@ -0,0 +1,39 @@
+import * as plugins from './plugins.js';
+// Base directories
+export const baseDir = process.cwd();
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+export const distServe = plugins.path.join(packageDir, './dist_serve');
+// Configure data directory with environment variable or default to .nogit/data
+const DEFAULT_DATA_PATH = '.nogit/data';
+export const dataDir = process.env.DATA_DIR
+    ? process.env.DATA_DIR
+    : plugins.path.join(baseDir, DEFAULT_DATA_PATH);
+// MTA directories 
+export const keysDir = plugins.path.join(dataDir, 'keys');
+export const dnsRecordsDir = plugins.path.join(dataDir, 'dns');
+export const sentEmailsDir = plugins.path.join(dataDir, 'emails', 'sent');
+export const receivedEmailsDir = plugins.path.join(dataDir, 'emails', 'received');
+export const failedEmailsDir = plugins.path.join(dataDir, 'emails', 'failed'); // For failed emails
+export const logsDir = plugins.path.join(dataDir, 'logs'); // For logs
+// Email template directories
+export const emailTemplatesDir = plugins.path.join(dataDir, 'templates', 'email');
+export const MtaAttachmentsDir = plugins.path.join(dataDir, 'attachments'); // For email attachments
+// Configuration path
+export const configPath = process.env.CONFIG_PATH
+    ? process.env.CONFIG_PATH
+    : plugins.path.join(baseDir, 'config.json');
+// Create directories if they don't exist
+export function ensureDirectories() {
+    // Ensure data directories
+    plugins.smartfile.fs.ensureDirSync(dataDir);
+    plugins.smartfile.fs.ensureDirSync(keysDir);
+    plugins.smartfile.fs.ensureDirSync(dnsRecordsDir);
+    plugins.smartfile.fs.ensureDirSync(sentEmailsDir);
+    plugins.smartfile.fs.ensureDirSync(receivedEmailsDir);
+    plugins.smartfile.fs.ensureDirSync(failedEmailsDir);
+    plugins.smartfile.fs.ensureDirSync(logsDir);
+    // Ensure email template directories
+    plugins.smartfile.fs.ensureDirSync(emailTemplatesDir);
+    plugins.smartfile.fs.ensureDirSync(MtaAttachmentsDir);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/plugins.d.ts

@@ -0,0 +1,46 @@
+import * as dns from 'dns';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import * as http from 'http';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import * as tls from 'tls';
+import * as util from 'util';
+export { dns, fs, crypto, http, net, os, path, tls, util, };
+import * as servezoneInterfaces from '@serve.zone/interfaces';
+export { servezoneInterfaces };
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+import * as typedsocket from '@api.global/typedsocket';
+export { typedrequest, typedserver, typedsocket, };
+import * as projectinfo from '@push.rocks/projectinfo';
+import * as qenv from '@push.rocks/qenv';
+import * as smartacme from '@push.rocks/smartacme';
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartdns from '@push.rocks/smartdns';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartguard from '@push.rocks/smartguard';
+import * as smartjwt from '@push.rocks/smartjwt';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartmail from '@push.rocks/smartmail';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartproxy from '@push.rocks/smartproxy';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartrule from '@push.rocks/smartrule';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartunique from '@push.rocks/smartunique';
+export { projectinfo, qenv, smartacme, smartdata, smartdns, smartfile, smartguard, smartjwt, smartlog, smartmail, smartnetwork, smartpath, smartproxy, smartpromise, smartrequest, smartrule, smartrx, smartunique };
+export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+export { cloudflare, };
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+import * as mailauth from 'mailauth';
+import { dkimSign } from 'mailauth/lib/dkim/sign.js';
+import mailparser from 'mailparser';
+import * as uuid from 'uuid';
+import * as ip from 'ip';
+export { mailauth, dkimSign, mailparser, uuid, ip, };

package/dist_ts/ts/plugins.js

@@ -0,0 +1,53 @@
+// node native
+import * as dns from 'dns';
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import * as http from 'http';
+import * as net from 'net';
+import * as os from 'os';
+import * as path from 'path';
+import * as tls from 'tls';
+import * as util from 'util';
+export { dns, fs, crypto, http, net, os, path, tls, util, };
+// @serve.zone scope
+import * as servezoneInterfaces from '@serve.zone/interfaces';
+export { servezoneInterfaces };
+// @api.global scope
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+import * as typedsocket from '@api.global/typedsocket';
+export { typedrequest, typedserver, typedsocket, };
+// @push.rocks scope
+import * as projectinfo from '@push.rocks/projectinfo';
+import * as qenv from '@push.rocks/qenv';
+import * as smartacme from '@push.rocks/smartacme';
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartdns from '@push.rocks/smartdns';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartguard from '@push.rocks/smartguard';
+import * as smartjwt from '@push.rocks/smartjwt';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartmail from '@push.rocks/smartmail';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartproxy from '@push.rocks/smartproxy';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartrule from '@push.rocks/smartrule';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartunique from '@push.rocks/smartunique';
+export { projectinfo, qenv, smartacme, smartdata, smartdns, smartfile, smartguard, smartjwt, smartlog, smartmail, smartnetwork, smartpath, smartproxy, smartpromise, smartrequest, smartrule, smartrx, smartunique };
+// apiclient.xyz scope
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+export { cloudflare, };
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+// third party
+import * as mailauth from 'mailauth';
+import { dkimSign } from 'mailauth/lib/dkim/sign.js';
+import mailparser from 'mailparser';
+import * as uuid from 'uuid';
+import * as ip from 'ip';
+export { mailauth, dkimSign, mailparser, uuid, ip, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/security/classes.contentscanner.d.ts

@@ -0,0 +1,160 @@
+import { Email } from '../mail/core/classes.email.js';
+/**
+ * Scan result information
+ */
+export interface IScanResult {
+    isClean: boolean;
+    threatType?: string;
+    threatDetails?: string;
+    threatScore: number;
+    scannedElements: string[];
+    timestamp: number;
+}
+/**
+ * Options for content scanner configuration
+ */
+export interface IContentScannerOptions {
+    maxCacheSize?: number;
+    cacheTTL?: number;
+    scanSubject?: boolean;
+    scanBody?: boolean;
+    scanAttachments?: boolean;
+    maxAttachmentSizeToScan?: number;
+    scanAttachmentNames?: boolean;
+    blockExecutables?: boolean;
+    blockMacros?: boolean;
+    customRules?: Array<{
+        pattern: string | RegExp;
+        type: string;
+        score: number;
+        description: string;
+    }>;
+    minThreatScore?: number;
+    highThreatScore?: number;
+}
+/**
+ * Threat categories
+ */
+export declare enum ThreatCategory {
+    SPAM = "spam",
+    PHISHING = "phishing",
+    MALWARE = "malware",
+    EXECUTABLE = "executable",
+    SUSPICIOUS_LINK = "suspicious_link",
+    MALICIOUS_MACRO = "malicious_macro",
+    XSS = "xss",
+    SENSITIVE_DATA = "sensitive_data",
+    BLACKLISTED_CONTENT = "blacklisted_content",
+    CUSTOM_RULE = "custom_rule"
+}
+/**
+ * Content Scanner for detecting malicious email content
+ */
+export declare class ContentScanner {
+    private static instance;
+    private scanCache;
+    private options;
+    private static readonly MALICIOUS_PATTERNS;
+    private static readonly EXECUTABLE_EXTENSIONS;
+    private static readonly MACRO_DOCUMENT_EXTENSIONS;
+    /**
+     * Default options for the content scanner
+     */
+    private static readonly DEFAULT_OPTIONS;
+    /**
+     * Constructor for the ContentScanner
+     * @param options Configuration options
+     */
+    constructor(options?: IContentScannerOptions);
+    /**
+     * Get the singleton instance of the scanner
+     * @param options Configuration options
+     * @returns Singleton scanner instance
+     */
+    static getInstance(options?: IContentScannerOptions): ContentScanner;
+    /**
+     * Scan an email for malicious content
+     * @param email The email to scan
+     * @returns Scan result
+     */
+    scanEmail(email: Email): Promise<IScanResult>;
+    /**
+     * Generate a cache key from an email
+     * @param email The email to generate a key for
+     * @returns Cache key
+     */
+    private generateCacheKey;
+    /**
+     * Scan email subject for threats
+     * @param subject The subject to scan
+     * @param result The scan result to update
+     */
+    private scanSubject;
+    /**
+     * Scan plain text content for threats
+     * @param text The text content to scan
+     * @param result The scan result to update
+     */
+    private scanTextContent;
+    /**
+     * Scan HTML content for threats
+     * @param html The HTML content to scan
+     * @param result The scan result to update
+     */
+    private scanHtmlContent;
+    /**
+     * Scan an attachment for threats
+     * @param attachment The attachment to scan
+     * @param result The scan result to update
+     */
+    private scanAttachment;
+    /**
+     * Extract links from HTML content
+     * @param html HTML content
+     * @returns Array of extracted links
+     */
+    private extractLinksFromHtml;
+    /**
+     * Extract plain text from HTML
+     * @param html HTML content
+     * @returns Extracted text
+     */
+    private extractTextFromHtml;
+    /**
+     * Extract text from a binary buffer for scanning
+     * @param buffer Binary content
+     * @returns Extracted text (may be partial)
+     */
+    private extractTextFromBuffer;
+    /**
+     * Check if an Office document likely contains macros
+     * This is a simplified check - real implementation would use specialized libraries
+     * @param attachment The attachment to check
+     * @returns Whether the file likely contains macros
+     */
+    private likelyContainsMacros;
+    /**
+     * Map a pattern category to a threat type
+     * @param category The pattern category
+     * @returns The corresponding threat type
+     */
+    private mapCategoryToThreatType;
+    /**
+     * Log a high threat finding to the security logger
+     * @param email The email containing the threat
+     * @param result The scan result
+     */
+    private logHighThreatFound;
+    /**
+     * Log a threat finding to the security logger
+     * @param email The email containing the threat
+     * @param result The scan result
+     */
+    private logThreatFound;
+    /**
+     * Get threat level description based on score
+     * @param score Threat score
+     * @returns Threat level description
+     */
+    static getThreatLevel(score: number): 'none' | 'low' | 'medium' | 'high';
+}