@serve.zone/dcrouter 2.12.4

package/dist_ts/security/classes.securitylogger.js

@@ -0,0 +1,232 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+/**
+ * Log level for security events
+ */
+export var SecurityLogLevel;
+(function (SecurityLogLevel) {
+    SecurityLogLevel["INFO"] = "info";
+    SecurityLogLevel["WARN"] = "warn";
+    SecurityLogLevel["ERROR"] = "error";
+    SecurityLogLevel["CRITICAL"] = "critical";
+})(SecurityLogLevel || (SecurityLogLevel = {}));
+/**
+ * Security event types for categorization
+ */
+export var SecurityEventType;
+(function (SecurityEventType) {
+    SecurityEventType["AUTHENTICATION"] = "authentication";
+    SecurityEventType["ACCESS_CONTROL"] = "access_control";
+    SecurityEventType["EMAIL_VALIDATION"] = "email_validation";
+    SecurityEventType["EMAIL_PROCESSING"] = "email_processing";
+    SecurityEventType["EMAIL_FORWARDING"] = "email_forwarding";
+    SecurityEventType["EMAIL_DELIVERY"] = "email_delivery";
+    SecurityEventType["DKIM"] = "dkim";
+    SecurityEventType["SPF"] = "spf";
+    SecurityEventType["DMARC"] = "dmarc";
+    SecurityEventType["RATE_LIMIT"] = "rate_limit";
+    SecurityEventType["RATE_LIMITING"] = "rate_limiting";
+    SecurityEventType["SPAM"] = "spam";
+    SecurityEventType["MALWARE"] = "malware";
+    SecurityEventType["CONNECTION"] = "connection";
+    SecurityEventType["DATA_EXPOSURE"] = "data_exposure";
+    SecurityEventType["CONFIGURATION"] = "configuration";
+    SecurityEventType["IP_REPUTATION"] = "ip_reputation";
+    SecurityEventType["REJECTED_CONNECTION"] = "rejected_connection";
+})(SecurityEventType || (SecurityEventType = {}));
+/**
+ * Security logger for enhanced security monitoring
+ */
+export class SecurityLogger {
+    constructor(options) {
+        this.securityEvents = [];
+        this.maxEventHistory = options?.maxEventHistory || 1000;
+        this.enableNotifications = options?.enableNotifications || false;
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance(options) {
+        if (!SecurityLogger.instance) {
+            SecurityLogger.instance = new SecurityLogger(options);
+        }
+        return SecurityLogger.instance;
+    }
+    /**
+     * Log a security event
+     * @param event The security event to log
+     */
+    logEvent(event) {
+        const fullEvent = {
+            ...event,
+            timestamp: Date.now()
+        };
+        // Store in memory buffer
+        this.securityEvents.push(fullEvent);
+        // Trim history if needed
+        if (this.securityEvents.length > this.maxEventHistory) {
+            this.securityEvents.shift();
+        }
+        // Log to regular logger with appropriate level
+        switch (event.level) {
+            case SecurityLogLevel.INFO:
+                logger.log('info', `[SECURITY:${event.type}] ${event.message}`, event.details);
+                break;
+            case SecurityLogLevel.WARN:
+                logger.log('warn', `[SECURITY:${event.type}] ${event.message}`, event.details);
+                break;
+            case SecurityLogLevel.ERROR:
+            case SecurityLogLevel.CRITICAL:
+                logger.log('error', `[SECURITY:${event.type}] ${event.message}`, event.details);
+                // Send notification for critical events if enabled
+                if (event.level === SecurityLogLevel.CRITICAL && this.enableNotifications) {
+                    this.sendNotification(fullEvent);
+                }
+                break;
+        }
+    }
+    /**
+     * Get recent security events
+     * @param limit Maximum number of events to return
+     * @param filter Filter for specific event types
+     * @returns Recent security events
+     */
+    getRecentEvents(limit = 100, filter) {
+        let filteredEvents = this.securityEvents;
+        // Apply filters
+        if (filter) {
+            if (filter.level) {
+                filteredEvents = filteredEvents.filter(event => event.level === filter.level);
+            }
+            if (filter.type) {
+                filteredEvents = filteredEvents.filter(event => event.type === filter.type);
+            }
+            if (filter.fromTimestamp) {
+                filteredEvents = filteredEvents.filter(event => event.timestamp >= filter.fromTimestamp);
+            }
+            if (filter.toTimestamp) {
+                filteredEvents = filteredEvents.filter(event => event.timestamp <= filter.toTimestamp);
+            }
+        }
+        // Return most recent events up to limit
+        return filteredEvents
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, limit);
+    }
+    /**
+     * Get events by security level
+     * @param level The security level to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events matching the level
+     */
+    getEventsByLevel(level, limit = 100) {
+        return this.getRecentEvents(limit, { level });
+    }
+    /**
+     * Get events by security type
+     * @param type The event type to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events matching the type
+     */
+    getEventsByType(type, limit = 100) {
+        return this.getRecentEvents(limit, { type });
+    }
+    /**
+     * Get security events for a specific IP address
+     * @param ipAddress The IP address to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events for the IP address
+     */
+    getEventsByIP(ipAddress, limit = 100) {
+        return this.securityEvents
+            .filter(event => event.ipAddress === ipAddress)
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, limit);
+    }
+    /**
+     * Get security events for a specific domain
+     * @param domain The domain to filter by
+     * @param limit Maximum number of events to return
+     * @returns Security events for the domain
+     */
+    getEventsByDomain(domain, limit = 100) {
+        return this.securityEvents
+            .filter(event => event.domain === domain)
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, limit);
+    }
+    /**
+     * Send a notification for critical security events
+     * @param event The security event to notify about
+     * @private
+     */
+    sendNotification(event) {
+        // In a production environment, this would integrate with a notification service
+        // For now, we'll just log that we would send a notification
+        logger.log('error', `[SECURITY NOTIFICATION] ${event.message}`, {
+            ...event,
+            notificationSent: true
+        });
+        // Future integration with alerting systems would go here
+    }
+    /**
+     * Clear event history
+     */
+    clearEvents() {
+        this.securityEvents = [];
+    }
+    /**
+     * Get statistical summary of security events
+     * @param timeWindow Optional time window in milliseconds
+     * @returns Summary of security events
+     */
+    getEventsSummary(timeWindow) {
+        // Filter by time window if provided
+        let events = this.securityEvents;
+        if (timeWindow) {
+            const cutoff = Date.now() - timeWindow;
+            events = events.filter(e => e.timestamp >= cutoff);
+        }
+        // Count by level
+        const byLevel = Object.values(SecurityLogLevel).reduce((acc, level) => {
+            acc[level] = events.filter(e => e.level === level).length;
+            return acc;
+        }, {});
+        // Count by type
+        const byType = Object.values(SecurityEventType).reduce((acc, type) => {
+            acc[type] = events.filter(e => e.type === type).length;
+            return acc;
+        }, {});
+        // Count by IP
+        const ipCounts = new Map();
+        events.forEach(e => {
+            if (e.ipAddress) {
+                ipCounts.set(e.ipAddress, (ipCounts.get(e.ipAddress) || 0) + 1);
+            }
+        });
+        // Count by domain
+        const domainCounts = new Map();
+        events.forEach(e => {
+            if (e.domain) {
+                domainCounts.set(e.domain, (domainCounts.get(e.domain) || 0) + 1);
+            }
+        });
+        // Sort and limit top entries
+        const topIPs = Array.from(ipCounts.entries())
+            .map(([ip, count]) => ({ ip, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+        const topDomains = Array.from(domainCounts.entries())
+            .map(([domain, count]) => ({ domain, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+        return {
+            total: events.length,
+            byLevel,
+            byType,
+            topIPs,
+            topDomains
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.securitylogger.js","sourceRoot":"","sources":["../../ts/security/classes.securitylogger.ts"],"names":[],"mappings":"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"}

package/dist_ts/security/index.d.ts

@@ -0,0 +1,3 @@
+export { SecurityLogger, SecurityLogLevel, SecurityEventType, type ISecurityEvent } from './classes.securitylogger.js';
+export { IPReputationChecker, ReputationThreshold, IPType, type IReputationResult, type IIPReputationOptions } from './classes.ipreputationchecker.js';
+export { ContentScanner, ThreatCategory, type IScanResult, type IContentScannerOptions } from './classes.contentscanner.js';

package/dist_ts/security/index.js

@@ -0,0 +1,4 @@
+export { SecurityLogger, SecurityLogLevel, SecurityEventType } from './classes.securitylogger.js';
+export { IPReputationChecker, ReputationThreshold, IPType } from './classes.ipreputationchecker.js';
+export { ContentScanner, ThreatCategory } from './classes.contentscanner.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9zZWN1cml0eS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsY0FBYyxFQUNkLGdCQUFnQixFQUNoQixpQkFBaUIsRUFFbEIsTUFBTSw2QkFBNkIsQ0FBQztBQUVyQyxPQUFPLEVBQ0wsbUJBQW1CLEVBQ25CLG1CQUFtQixFQUNuQixNQUFNLEVBR1AsTUFBTSxrQ0FBa0MsQ0FBQztBQUUxQyxPQUFPLEVBQ0wsY0FBYyxFQUNkLGNBQWMsRUFHZixNQUFNLDZCQUE2QixDQUFDIn0=

package/dist_ts/sms/classes.smsservice.d.ts

@@ -0,0 +1,15 @@
+import * as plugins from '../plugins.js';
+import type { ISmsConfig } from './config/sms.config.js';
+export declare class SmsService {
+    projectinfo: plugins.projectinfo.ProjectInfo;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    config: ISmsConfig;
+    constructor(options: ISmsConfig);
+    /**
+     * starts the financeflow instance
+     */
+    start(): Promise<void>;
+    sendSms(toNumber: number, fromName: string, messageText: string): Promise<void>;
+    sendVerificationCode(toNumber: number, fromName: string): Promise<number>;
+    stop(): Promise<void>;
+}

package/dist_ts/sms/classes.smsservice.js

@@ -0,0 +1,72 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import { logger } from '../logger.js';
+import { smsConfigSchema } from './config/sms.schema.js';
+import { ConfigValidator } from '../config/validator.js';
+export class SmsService {
+    constructor(options) {
+        this.typedrouter = new plugins.typedrequest.TypedRouter();
+        // Validate and apply defaults to configuration
+        const validationResult = ConfigValidator.validate(options, smsConfigSchema);
+        if (!validationResult.valid) {
+            logger.warn(`SMS service configuration has validation errors: ${validationResult.errors.join(', ')}`);
+        }
+        // Set configuration with defaults
+        this.config = validationResult.config;
+        // Add router to platform service
+    }
+    /**
+     * starts the financeflow instance
+     */
+    async start() {
+        logger.log('info', `starting sms service`);
+        this.projectinfo = new plugins.projectinfo.ProjectInfo(paths.packageDir);
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('sendSms', async (reqData) => {
+            await this.sendSms(reqData.toNumber, reqData.fromName, reqData.messageText);
+            return {
+                status: 'ok',
+            };
+        }));
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('sendVerificationCode', async (reqData) => {
+            const verificationCode = (await this.sendVerificationCode(reqData.toNumber, reqData.fromName)).toString();
+            return {
+                status: 'ok',
+                verificationCode,
+            };
+        }));
+    }
+    async sendSms(toNumber, fromName, messageText) {
+        // Use default sender if not specified
+        const sender = fromName || this.config.defaultSender || 'PlatformService';
+        const payload = {
+            sender,
+            message: messageText,
+            recipients: [{ msisdn: toNumber }],
+        };
+        const resp = await plugins.smartrequest.request('https://gatewayapi.com/rest/mtsms', {
+            method: 'POST',
+            requestBody: JSON.stringify(payload),
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${this.config.apiGatewayApiToken}:`).toString('base64')}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        const json = await resp.body;
+        logger.log('info', `sent an sms to ${toNumber} with text '${messageText}'`, {
+            eventType: 'sentSms',
+            sms: {
+                fromName: fromName,
+                toNumber: toNumber.toString(),
+                messageText: messageText,
+            },
+        });
+        console.log(JSON.stringify(json, null, 2));
+    }
+    async sendVerificationCode(toNumber, fromName) {
+        let verificationCode = Math.floor(100000 + Math.random() * 900000);
+        await this.sendSms(toNumber, fromName, `Your verification code: ${verificationCode}`);
+        return verificationCode;
+    }
+    async stop() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zbXNzZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvc21zL2NsYXNzZXMuc21zc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEtBQUssS0FBSyxNQUFNLGFBQWEsQ0FBQztBQUNyQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBR3RDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN6RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFekQsTUFBTSxPQUFPLFVBQVU7SUFLckIsWUFBWSxPQUFtQjtRQUh4QixnQkFBVyxHQUFHLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUkxRCwrQ0FBK0M7UUFDL0MsTUFBTSxnQkFBZ0IsR0FBRyxlQUFlLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxlQUFlLENBQUMsQ0FBQztRQUU1RSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDNUIsTUFBTSxDQUFDLElBQUksQ0FBQyxvREFBb0QsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDeEcsQ0FBQztRQUVELGtDQUFrQztRQUNsQyxJQUFJLENBQUMsTUFBTSxHQUFHLGdCQUFnQixDQUFDLE1BQU0sQ0FBQztRQUV0QyxpQ0FBaUM7SUFDbkMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLEtBQUs7UUFDaEIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsc0JBQXNCLENBQUMsQ0FBQztRQUMzQyxJQUFJLENBQUMsV0FBVyxHQUFHLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ3pFLElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUM5QixJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUNuQyxTQUFTLEVBQ1QsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLE1BQU0sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBQzVFLE9BQU87Z0JBQ0wsTUFBTSxFQUFFLElBQUk7YUFDYixDQUFDO1FBQ0osQ0FBQyxDQUNGLENBQ0YsQ0FBQztRQUNGLElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxDQUM5QixJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUNuQyxzQkFBc0IsRUFDdEIsS0FBSyxFQUFFLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLE1BQU0sZ0JBQWdCLEdBQUcsQ0FDdkIsTUFBTSxJQUFJLENBQUMsb0JBQW9CLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsUUFBUSxDQUFDLENBQ3BFLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDYixPQUFPO2dCQUNMLE1BQU0sRUFBRSxJQUFJO2dCQUNaLGdCQUFnQjthQUNqQixDQUFDO1FBQ0osQ0FBQyxDQUNGLENBQ0YsQ0FBQztJQUNKLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTyxDQUFDLFFBQWdCLEVBQUUsUUFBZ0IsRUFBRSxXQUFtQjtRQUMxRSxzQ0FBc0M7UUFDdEMsTUFBTSxNQUFNLEdBQUcsUUFBUSxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxJQUFJLGlCQUFpQixDQUFDO1FBRTFFLE1BQU0sT0FBTyxHQUFHO1lBQ2QsTUFBTTtZQUNOLE9BQU8sRUFBRSxXQUFXO1lBQ3BCLFVBQVUsRUFBRSxDQUFDLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxDQUFDO1NBQ25DLENBQUM7UUFFRixNQUFNLElBQUksR0FBRyxNQUFNLE9BQU8sQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLG1DQUFtQyxFQUFFO1lBQ25GLE1BQU0sRUFBRSxNQUFNO1lBQ2QsV0FBVyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDO1lBQ3BDLE9BQU8sRUFBRTtnQkFDUCxhQUFhLEVBQUUsU0FBUyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxrQkFBa0IsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxFQUFFO2dCQUM5RixjQUFjLEVBQUUsa0JBQWtCO2FBQ25DO1NBQ0YsQ0FBQyxDQUFDO1FBQ0gsTUFBTSxJQUFJLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQzdCLE1BQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLGtCQUFrQixRQUFRLGVBQWUsV0FBVyxHQUFHLEVBQUU7WUFDMUUsU0FBUyxFQUFFLFNBQVM7WUFDcEIsR0FBRyxFQUFFO2dCQUNILFFBQVEsRUFBRSxRQUFRO2dCQUNsQixRQUFRLEVBQUUsUUFBUSxDQUFDLFFBQVEsRUFBRTtnQkFDN0IsV0FBVyxFQUFFLFdBQVc7YUFDekI7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFFTSxLQUFLLENBQUMsb0JBQW9CLENBQUMsUUFBZ0IsRUFBRSxRQUFnQjtRQUNsRSxJQUFJLGdCQUFnQixHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUMsQ0FBQztRQUNuRSxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLFFBQVEsRUFBRSwyQkFBMkIsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDO1FBQ3RGLE9BQU8sZ0JBQWdCLENBQUM7SUFDMUIsQ0FBQztJQUVNLEtBQUssQ0FBQyxJQUFJLEtBQUksQ0FBQztDQUN2QiJ9

package/dist_ts/sms/config/sms.config.d.ts

@@ -0,0 +1,93 @@
+/**
+ * SMS service configuration interface
+ */
+export interface ISmsConfig {
+    /**
+     * API token for the gateway service
+     */
+    apiGatewayApiToken: string;
+    /**
+     * Default sender ID or phone number
+     */
+    defaultSender?: string;
+    /**
+     * SMS rate limiting
+     */
+    rateLimit?: {
+        /**
+         * Whether rate limiting is enabled
+         */
+        enabled?: boolean;
+        /**
+         * Maximum requests per period
+         */
+        maxPerPeriod?: number;
+        /**
+         * Period duration in milliseconds
+         */
+        periodMs?: number;
+        /**
+         * Whether to apply rate limit per key
+         */
+        perKey?: boolean;
+        /**
+         * Number of burst tokens
+         */
+        burstTokens?: number;
+        /**
+         * Maximum messages per recipient per day
+         */
+        maxPerRecipientPerDay?: number;
+    };
+    /**
+     * SMS provider configuration
+     */
+    provider?: {
+        /**
+         * Provider type
+         */
+        type?: 'gateway' | 'twilio' | 'other';
+        /**
+         * Provider-specific configuration
+         */
+        config?: Record<string, any>;
+        /**
+         * Fallback provider configuration
+         */
+        fallback?: {
+            /**
+             * Whether to use fallback provider
+             */
+            enabled?: boolean;
+            /**
+             * Provider type
+             */
+            type?: 'gateway' | 'twilio' | 'other';
+            /**
+             * Provider-specific configuration
+             */
+            config?: Record<string, any>;
+        };
+    };
+    /**
+     * Verification code settings
+     */
+    verification?: {
+        /**
+         * Code length
+         */
+        codeLength?: number;
+        /**
+         * Code expiration time in seconds
+         */
+        expirationSeconds?: number;
+        /**
+         * Maximum number of attempts
+         */
+        maxAttempts?: number;
+        /**
+         * Cooldown period in seconds
+         */
+        cooldownSeconds?: number;
+    };
+}

package/dist_ts/sms/config/sms.config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21zLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3Ntcy9jb25maWcvc21zLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist_ts/sms/config/sms.schema.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationSchema } from '../../config/validator.js';
+/**
+ * SMS service configuration schema
+ */
+export declare const smsConfigSchema: ValidationSchema;

package/dist_ts/sms/config/sms.schema.js

@@ -0,0 +1,121 @@
+/**
+ * SMS service configuration schema
+ */
+export const smsConfigSchema = {
+    apiGatewayApiToken: {
+        type: 'string',
+        required: true
+    },
+    defaultSender: {
+        type: 'string',
+        required: false
+    },
+    rateLimit: {
+        type: 'object',
+        required: false,
+        schema: {
+            enabled: {
+                type: 'boolean',
+                required: false,
+                default: true
+            },
+            maxPerPeriod: {
+                type: 'number',
+                required: false,
+                default: 100,
+                min: 1
+            },
+            periodMs: {
+                type: 'number',
+                required: false,
+                default: 60000, // 1 minute
+                min: 1000
+            },
+            perKey: {
+                type: 'boolean',
+                required: false,
+                default: true
+            },
+            burstTokens: {
+                type: 'number',
+                required: false,
+                default: 5,
+                min: 0
+            },
+            maxPerRecipientPerDay: {
+                type: 'number',
+                required: false,
+                default: 10,
+                min: 1
+            }
+        }
+    },
+    provider: {
+        type: 'object',
+        required: false,
+        schema: {
+            type: {
+                type: 'string',
+                required: false,
+                enum: ['gateway', 'twilio', 'other'],
+                default: 'gateway'
+            },
+            config: {
+                type: 'object',
+                required: false
+            },
+            fallback: {
+                type: 'object',
+                required: false,
+                schema: {
+                    enabled: {
+                        type: 'boolean',
+                        required: false,
+                        default: false
+                    },
+                    type: {
+                        type: 'string',
+                        required: false,
+                        enum: ['gateway', 'twilio', 'other']
+                    },
+                    config: {
+                        type: 'object',
+                        required: false
+                    }
+                }
+            }
+        }
+    },
+    verification: {
+        type: 'object',
+        required: false,
+        schema: {
+            codeLength: {
+                type: 'number',
+                required: false,
+                default: 6,
+                min: 4,
+                max: 10
+            },
+            expirationSeconds: {
+                type: 'number',
+                required: false,
+                default: 300, // 5 minutes
+                min: 60
+            },
+            maxAttempts: {
+                type: 'number',
+                required: false,
+                default: 3,
+                min: 1
+            },
+            cooldownSeconds: {
+                type: 'number',
+                required: false,
+                default: 60, // 1 minute
+                min: 0
+            }
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/sms/index.d.ts

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

package/dist_ts/sms/index.js

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

package/dist_ts/storage/classes.storagemanager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Storage configuration interface
+ */
+export interface IStorageConfig {
+    /** Filesystem path for storage */
+    fsPath?: string;
+    /** Custom read function */
+    readFunction?: (key: string) => Promise<string>;
+    /** Custom write function */
+    writeFunction?: (key: string, value: string) => Promise<void>;
+}
+/**
+ * Storage backend type
+ */
+export type StorageBackend = 'filesystem' | 'custom' | 'memory';
+/**
+ * Central storage manager for DcRouter
+ * Provides unified key-value storage with multiple backend support
+ */
+export declare class StorageManager {
+    private backend;
+    private memoryStore;
+    private config;
+    private fsBasePath?;
+    constructor(config?: IStorageConfig);
+    /**
+     * Show warning when using memory backend
+     */
+    private showMemoryWarning;
+    /**
+     * Ensure directory exists for filesystem backend
+     */
+    private ensureDirectory;
+    /**
+     * Validate and sanitize storage key
+     */
+    private validateKey;
+    /**
+     * Convert key to filesystem path
+     */
+    private keyToPath;
+    /**
+     * Internal filesystem read function
+     */
+    private fsRead;
+    /**
+     * Internal filesystem write function
+     */
+    private fsWrite;
+    /**
+     * Get value by key
+     */
+    get(key: string): Promise<string | null>;
+    /**
+     * Set value by key
+     */
+    set(key: string, value: string): Promise<void>;
+    /**
+     * Delete value by key
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * List keys by prefix
+     */
+    list(prefix?: string): Promise<string[]>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Get storage backend type
+     */
+    getBackend(): StorageBackend;
+    /**
+     * JSON helper: Get and parse JSON value
+     */
+    getJSON<T = any>(key: string): Promise<T | null>;
+    /**
+     * JSON helper: Set value as JSON
+     */
+    setJSON(key: string, value: any): Promise<void>;
+}