@jagilber-org/index-server 1.19.1

package/dist/dashboard/export/exporters/csvExporter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CSV and Excel format exporters for the DataExporter system.
+ */
+/**
+ * Write data to a CSV file, optionally compressing afterwards.
+ */
+export declare function exportCSV(data: unknown[], outputPath: string, compress: boolean): Promise<void>;
+/**
+ * Export data as Excel (simplified — delegates to CSV with a .csv extension).
+ */
+export declare function exportExcel(data: unknown[], outputPath: string, compress: boolean): Promise<void>;

package/dist/dashboard/export/exporters/csvExporter.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * CSV and Excel format exporters for the DataExporter system.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportCSV = exportCSV;
+exports.exportExcel = exportExcel;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Write data to a CSV file, optionally compressing afterwards.
+ */
+async function exportCSV(data, outputPath, compress) {
+    if (!data.length) {
+        await fs_1.default.promises.writeFile(outputPath, '', 'utf8');
+        return;
+    }
+    await fs_1.default.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+    const headers = Object.keys(data[0]);
+    const csvRows = [
+        headers.join(','),
+        ...data.map(row => {
+            const rowRecord = row;
+            return headers.map(header => {
+                const value = rowRecord[header];
+                const stringValue = String(value || '');
+                return stringValue.includes(',') || stringValue.includes('"')
+                    ? `"${stringValue.replace(/"/g, '""')}"`
+                    : stringValue;
+            }).join(',');
+        })
+    ];
+    await fs_1.default.promises.writeFile(outputPath, csvRows.join('\n'), 'utf8');
+    if (compress) {
+        console.log(`Compressing file: ${outputPath}`);
+    }
+}
+/**
+ * Export data as Excel (simplified — delegates to CSV with a .csv extension).
+ */
+async function exportExcel(data, outputPath, compress) {
+    await exportCSV(data, outputPath.replace('.excel', '.csv'), compress);
+}

package/dist/dashboard/export/exporters/exportTypes.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Shared types for the DataExporter and format-specific exporter modules.
+ */
+export interface ExportConfig {
+    id: string;
+    name: string;
+    format: 'json' | 'csv' | 'excel' | 'pdf' | 'xml';
+    dataSource: 'metrics' | 'analytics' | 'security' | 'feedback' | 'instructions' | 'custom';
+    filters: ExportFilter[];
+    columns: ExportColumn[];
+    schedule?: ExportSchedule;
+    template?: string;
+    compression: boolean;
+    encryption: boolean;
+    destination: ExportDestination;
+}
+export interface ExportFilter {
+    field: string;
+    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'between' | 'in' | 'not_in';
+    value: unknown;
+    values?: unknown[];
+}
+export interface ExportColumn {
+    field: string;
+    header: string;
+    type: 'string' | 'number' | 'date' | 'boolean' | 'json';
+    format?: string;
+    aggregation?: 'sum' | 'avg' | 'count' | 'min' | 'max' | 'group';
+}
+export interface ExportSchedule {
+    enabled: boolean;
+    frequency: 'hourly' | 'daily' | 'weekly' | 'monthly' | 'custom';
+    interval: number;
+    time?: string;
+    dayOfWeek?: number;
+    dayOfMonth?: number;
+    timezone: string;
+    lastRun?: number;
+    nextRun?: number;
+}
+export interface ExportDestination {
+    type: 'local' | 'email' | 'ftp' | 'sftp' | 's3' | 'azure_blob' | 'webhook';
+    config: Record<string, unknown>;
+}
+export interface ExportJob {
+    id: string;
+    configId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    progress: number;
+    recordsProcessed: number;
+    totalRecords: number;
+    startTime: number;
+    endTime?: number;
+    error?: string;
+    outputPath?: string;
+    fileSize?: number;
+}
+export interface ReportTemplate {
+    id: string;
+    name: string;
+    description: string;
+    type: 'dashboard_summary' | 'security_report' | 'performance_analysis' | 'custom';
+    sections: ReportSection[];
+    formatting: ReportFormatting;
+}
+export interface ReportSection {
+    id: string;
+    title: string;
+    type: 'text' | 'table' | 'chart' | 'metrics' | 'raw_data';
+    dataSource: string;
+    config: Record<string, unknown>;
+    order: number;
+}
+export interface ReportFormatting {
+    pageSize: 'A4' | 'Letter' | 'Legal' | 'A3';
+    orientation: 'portrait' | 'landscape';
+    margins: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    fontSize: number;
+    fontFamily: string;
+    includeHeader: boolean;
+    includeFooter: boolean;
+    headerText?: string;
+    footerText?: string;
+}

package/dist/dashboard/export/exporters/exportTypes.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Shared types for the DataExporter and format-specific exporter modules.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dashboard/export/exporters/jsonExporter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * JSON format exporter for the DataExporter system.
+ */
+/**
+ * Write data to a JSON file, optionally compressing afterwards.
+ */
+export declare function exportJSON(data: unknown[], outputPath: string, compress: boolean): Promise<void>;

package/dist/dashboard/export/exporters/jsonExporter.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * JSON format exporter for the DataExporter system.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportJSON = exportJSON;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Write data to a JSON file, optionally compressing afterwards.
+ */
+async function exportJSON(data, outputPath, compress) {
+    await fs_1.default.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+    const jsonData = JSON.stringify(data, null, 2);
+    await fs_1.default.promises.writeFile(outputPath, jsonData, 'utf8');
+    if (compress) {
+        console.log(`Compressing file: ${outputPath}`);
+    }
+}

package/dist/dashboard/export/exporters/xmlExporter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * XML and PDF (HTML) format exporters for the DataExporter system.
+ * Handles structured document output including template-based report rendering.
+ */
+import type { ReportTemplate } from './exportTypes.js';
+/**
+ * Write data to an XML file, optionally compressing afterwards.
+ */
+export declare function exportXML(data: unknown[], outputPath: string, compress: boolean): Promise<void>;
+/**
+ * Write data as a PDF-placeholder HTML file.
+ * When a resolved ReportTemplate is provided the output uses the full template;
+ * otherwise a simple tabular layout is generated.
+ */
+export declare function exportPDF(data: unknown[], outputPath: string, template?: ReportTemplate): Promise<void>;
+export declare function generateReportHTML(template: ReportTemplate, data: unknown[]): string;
+export declare function generateSimplePDFContent(data: unknown[]): string;

package/dist/dashboard/export/exporters/xmlExporter.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * XML and PDF (HTML) format exporters for the DataExporter system.
+ * Handles structured document output including template-based report rendering.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportXML = exportXML;
+exports.exportPDF = exportPDF;
+exports.generateReportHTML = generateReportHTML;
+exports.generateSimplePDFContent = generateSimplePDFContent;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Write data to an XML file, optionally compressing afterwards.
+ */
+async function exportXML(data, outputPath, compress) {
+    await fs_1.default.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+    const xmlContent = convertToXML(data);
+    await fs_1.default.promises.writeFile(outputPath, xmlContent, 'utf8');
+    if (compress) {
+        console.log(`Compressing file: ${outputPath}`);
+    }
+}
+/**
+ * Write data as a PDF-placeholder HTML file.
+ * When a resolved ReportTemplate is provided the output uses the full template;
+ * otherwise a simple tabular layout is generated.
+ */
+async function exportPDF(data, outputPath, template) {
+    await fs_1.default.promises.mkdir(path_1.default.dirname(outputPath), { recursive: true });
+    const content = template
+        ? generateReportHTML(template, data)
+        : generateSimplePDFContent(data);
+    // In a real implementation a PDF library (puppeteer, pdfkit) would be used.
+    await fs_1.default.promises.writeFile(outputPath.replace('.pdf', '.html'), content, 'utf8');
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function convertToXML(data) {
+    const xmlRows = data.map(item => {
+        const itemRecord = item;
+        const xmlFields = Object.entries(itemRecord)
+            .map(([key, value]) => `    <${key}>${escapeXML(String(value))}</${key}>`)
+            .join('\n');
+        return `  <record>\n${xmlFields}\n  </record>`;
+    });
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<data>\n${xmlRows.join('\n')}\n</data>`;
+}
+function escapeXML(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function generateReportHTML(template, data) {
+    let html = `<!DOCTYPE html>
+<html>
+<head>
+    <title>${template.name}</title>
+    <meta charset="UTF-8">
+    <style>
+        body { font-family: ${template.formatting.fontFamily}; font-size: ${template.formatting.fontSize}px; }
+        .header { text-align: center; border-bottom: 1px solid #ccc; padding-bottom: 10px; margin-bottom: 20px; }
+        .footer { text-align: center; border-top: 1px solid #ccc; padding-top: 10px; margin-top: 20px; }
+        .section { margin-bottom: 30px; }
+        .section-title { font-size: 16px; font-weight: bold; margin-bottom: 10px; }
+        table { width: 100%; border-collapse: collapse; margin-bottom: 15px; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+        th { background-color: #f2f2f2; }
+    </style>
+</head>
+<body>`;
+    if (template.formatting.includeHeader) {
+        const headerText = replaceTemplateVariables(template.formatting.headerText || '');
+        html += `<div class="header">${headerText}</div>`;
+    }
+    const sortedSections = template.sections.sort((a, b) => a.order - b.order);
+    for (const section of sortedSections) {
+        html += `<div class="section">`;
+        html += `<div class="section-title">${section.title}</div>`;
+        switch (section.type) {
+            case 'table':
+                html += generateTableSection(data, section);
+                break;
+            case 'metrics':
+                html += generateMetricsSection(data, section);
+                break;
+            case 'text':
+                html += generateTextSection(data, section);
+                break;
+            default:
+                html += `<p>Section type "${section.type}" not implemented</p>`;
+        }
+        html += `</div>`;
+    }
+    if (template.formatting.includeFooter) {
+        const footerText = replaceTemplateVariables(template.formatting.footerText || '');
+        html += `<div class="footer">${footerText}</div>`;
+    }
+    html += `</body></html>`;
+    return html;
+}
+function generateSimplePDFContent(data) {
+    if (!data.length)
+        return '<html><body><p>No data to export</p></body></html>';
+    const headers = Object.keys(data[0]);
+    let html = `<!DOCTYPE html>
+<html>
+<head>
+    <title>Data Export</title>
+    <style>
+        body { font-family: Arial, sans-serif; }
+        table { width: 100%; border-collapse: collapse; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+        th { background-color: #f2f2f2; }
+    </style>
+</head>
+<body>
+    <h1>Data Export</h1>
+    <table>
+        <thead>
+            <tr>${headers.map(h => `<th>${h}</th>`).join('')}</tr>
+        </thead>
+        <tbody>`;
+    data.forEach(row => {
+        const rowRecord = row;
+        html += `<tr>${headers.map(h => `<td>${String(rowRecord[h] || '')}</td>`).join('')}</tr>`;
+    });
+    html += `        </tbody>
+    </table>
+</body>
+</html>`;
+    return html;
+}
+function generateTableSection(data, _section) {
+    if (!data.length)
+        return '<p>No data available</p>';
+    const headers = Object.keys(data[0]);
+    let html = '<table><thead><tr>';
+    headers.forEach(header => { html += `<th>${header}</th>`; });
+    html += '</tr></thead><tbody>';
+    data.forEach(row => {
+        const rowRecord = row;
+        html += '<tr>';
+        headers.forEach(header => { html += `<td>${String(rowRecord[header] || '')}</td>`; });
+        html += '</tr>';
+    });
+    html += '</tbody></table>';
+    return html;
+}
+function generateMetricsSection(data, _section) {
+    return `<div>
+        <p><strong>Total Records:</strong> ${data.length}</p>
+        <p><strong>Generated:</strong> ${new Date().toLocaleString()}</p>
+    </div>`;
+}
+function generateTextSection(data, section) {
+    return `<p>This is a ${section.dataSource} section with ${data.length} records.</p>`;
+}
+function replaceTemplateVariables(text) {
+    const now = new Date();
+    return text
+        .replace(/\{\{date\}\}/g, now.toLocaleDateString())
+        .replace(/\{\{time\}\}/g, now.toLocaleTimeString())
+        .replace(/\{\{datetime\}\}/g, now.toLocaleString())
+        .replace(/\{\{page\}\}/g, '1')
+        .replace(/\{\{totalPages\}\}/g, '1')
+        .replace(/\{\{dateRange\}\}/g, 'Last 7 days');
+}

package/dist/dashboard/integration/APIIntegration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * APIIntegration - Phase 4 API Integration & External Connectors
+ *
+ * Thin coordinator that composes three domain modules:
+ * - EndpointManager  (api.instructions.routes) — endpoint configuration & rate-limiting
+ * - UsageManager     (api.usage.routes)        — request execution & monitoring
+ * - FeedbackManager  (api.feedback.routes)     — webhooks & external connectors
+ */
+import type { APIEndpoint } from '../server/routes/api.instructions.routes.js';
+import type { APIRequest, APIResponse, APIMonitoringEvent } from '../server/routes/api.usage.routes.js';
+import type { WebhookConfig, ExternalConnector } from '../server/routes/api.feedback.routes.js';
+export type { APIEndpoint, APIRequest, APIResponse, APIMonitoringEvent, WebhookConfig, ExternalConnector };
+export declare class APIIntegration {
+    private readonly endpointMgr;
+    private readonly usageMgr;
+    private readonly feedbackMgr;
+    constructor();
+    private startBackgroundTasks;
+    executeRequest(endpointId: string, data?: unknown, overrides?: Partial<APIRequest>): Promise<APIResponse>;
+    createEndpoint(endpoint: Omit<APIEndpoint, 'id'>): string;
+    getEndpoint(id: string): APIEndpoint | undefined;
+    listEndpoints(): APIEndpoint[];
+    updateEndpoint(id: string, updates: Partial<APIEndpoint>): boolean;
+    deleteEndpoint(id: string): boolean;
+    getConfiguredEndpoints(): APIEndpoint[];
+    createWebhook(webhook: Omit<WebhookConfig, 'id'>): string;
+    triggerWebhook(id: string, event: string, data: unknown): Promise<boolean>;
+    createConnector(connector: Omit<ExternalConnector, 'id' | 'status' | 'metrics'>): string;
+    getConnectorStatus(id: string): ExternalConnector | undefined;
+    listConnectors(): ExternalConnector[];
+    onAPIEvent(callback: (event: APIMonitoringEvent) => void): void;
+    getAPIStatistics(): {
+        endpoints: number;
+        webhooks: number;
+        connectors: number;
+        activeConnections: number;
+        totalRequests: number;
+        errorRate: number;
+    };
+}
+export declare function getAPIIntegration(): APIIntegration;

package/dist/dashboard/integration/APIIntegration.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * APIIntegration - Phase 4 API Integration & External Connectors
+ *
+ * Thin coordinator that composes three domain modules:
+ * - EndpointManager  (api.instructions.routes) — endpoint configuration & rate-limiting
+ * - UsageManager     (api.usage.routes)        — request execution & monitoring
+ * - FeedbackManager  (api.feedback.routes)     — webhooks & external connectors
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIIntegration = void 0;
+exports.getAPIIntegration = getAPIIntegration;
+const api_instructions_routes_js_1 = require("../server/routes/api.instructions.routes.js");
+const api_usage_routes_js_1 = require("../server/routes/api.usage.routes.js");
+const api_feedback_routes_js_1 = require("../server/routes/api.feedback.routes.js");
+class APIIntegration {
+    endpointMgr;
+    usageMgr;
+    feedbackMgr;
+    constructor() {
+        this.endpointMgr = new api_instructions_routes_js_1.EndpointManager();
+        this.usageMgr = new api_usage_routes_js_1.UsageManager(this.endpointMgr);
+        this.feedbackMgr = new api_feedback_routes_js_1.FeedbackManager(this.usageMgr);
+        this.startBackgroundTasks();
+    }
+    startBackgroundTasks() {
+        setInterval(() => { this.usageMgr.processRequestQueues(); }, 100);
+        setInterval(() => { this.endpointMgr.cleanupCache(); }, 60000);
+        setInterval(() => { this.endpointMgr.resetRateLimiters(); }, 60000);
+        setInterval(() => { this.feedbackMgr.performHealthChecks(); }, 30000);
+    }
+    // ── Endpoint management ──────────────────────────────────────────────────────────
+    async executeRequest(endpointId, data, overrides) {
+        return this.usageMgr.executeRequest(endpointId, data, overrides);
+    }
+    createEndpoint(endpoint) {
+        return this.endpointMgr.createEndpoint(endpoint);
+    }
+    getEndpoint(id) {
+        return this.endpointMgr.getEndpoint(id);
+    }
+    listEndpoints() {
+        return this.endpointMgr.listEndpoints();
+    }
+    updateEndpoint(id, updates) {
+        return this.endpointMgr.updateEndpoint(id, updates);
+    }
+    deleteEndpoint(id) {
+        return this.endpointMgr.deleteEndpoint(id);
+    }
+    getConfiguredEndpoints() {
+        return this.endpointMgr.getConfiguredEndpoints();
+    }
+    // ── Webhook management ───────────────────────────────────────────────────────────
+    createWebhook(webhook) {
+        return this.feedbackMgr.createWebhook(webhook);
+    }
+    async triggerWebhook(id, event, data) {
+        return this.feedbackMgr.triggerWebhook(id, event, data);
+    }
+    // ── Connector management ─────────────────────────────────────────────────────────
+    createConnector(connector) {
+        return this.feedbackMgr.createConnector(connector);
+    }
+    getConnectorStatus(id) {
+        return this.feedbackMgr.getConnectorStatus(id);
+    }
+    listConnectors() {
+        return this.feedbackMgr.listConnectors();
+    }
+    // ── Monitoring ───────────────────────────────────────────────────────────────────
+    onAPIEvent(callback) {
+        this.usageMgr.onAPIEvent(callback);
+    }
+    getAPIStatistics() {
+        const stats = this.feedbackMgr.getStats();
+        return {
+            endpoints: this.endpointMgr.endpoints.size,
+            webhooks: stats.webhookCount,
+            connectors: stats.connectorCount,
+            activeConnections: stats.activeConnections,
+            totalRequests: stats.totalRequests,
+            errorRate: stats.totalRequests > 0 ? stats.totalErrors / stats.totalRequests : 0
+        };
+    }
+}
+exports.APIIntegration = APIIntegration;
+// Singleton instance
+let apiIntegration = null;
+function getAPIIntegration() {
+    if (!apiIntegration) {
+        apiIntegration = new APIIntegration();
+    }
+    return apiIntegration;
+}

package/dist/dashboard/security/SecurityMonitor.d.ts

@@ -0,0 +1,167 @@
+interface SecurityThreat {
+    id: string;
+    type: 'authentication_failure' | 'rate_limit_exceeded' | 'suspicious_activity' | 'data_breach_attempt' | 'injection_attack';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    source: string;
+    timestamp: number;
+    details: Record<string, unknown>;
+    status: 'active' | 'mitigated' | 'resolved';
+    actionTaken?: string;
+}
+interface PerformanceMetric {
+    id: string;
+    type: 'cpu' | 'memory' | 'disk' | 'network' | 'database' | 'api_latency';
+    value: number;
+    unit: string;
+    timestamp: number;
+    threshold: {
+        warning: number;
+        critical: number;
+    };
+    trend: 'increasing' | 'decreasing' | 'stable';
+}
+interface SystemHealth {
+    overall: 'healthy' | 'warning' | 'critical' | 'down';
+    services: Array<{
+        name: string;
+        status: 'up' | 'down' | 'degraded';
+        latency: number;
+        uptime: number;
+        lastCheck: number;
+    }>;
+    alerts: SecurityThreat[];
+    performance: PerformanceMetric[];
+}
+interface SecurityRule {
+    id: string;
+    name: string;
+    type: 'rate_limit' | 'ip_blocking' | 'pattern_detection' | 'anomaly_detection';
+    enabled: boolean;
+    config: Record<string, unknown>;
+    lastTriggered?: number;
+    triggerCount: number;
+}
+export declare class SecurityMonitor {
+    private threats;
+    private performanceMetrics;
+    private securityRules;
+    private monitoringInterval;
+    private alertCallbacks;
+    constructor();
+    /**
+     * Anonymize a real user identifier (IP, username, etc.) for PH-3 compliance.
+     * Returns the first 16 hex characters of the SHA-256 hash of the identifier.
+     * @param identifier - Raw user identifier to anonymize
+     * @returns Anonymized identifier string (not reversible)
+     */
+    private anonymize;
+    /**
+     * Initialize default security rules
+     */
+    private initializeSecurityRules;
+    /**
+     * Start continuous monitoring
+     */
+    private startMonitoring;
+    /**
+     * Stop monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Collect system performance metrics
+     */
+    private collectPerformanceMetrics;
+    /**
+     * Add performance metric and analyze trends
+     */
+    private addPerformanceMetric;
+    /**
+     * Calculate trend from values
+     */
+    private calculateTrend;
+    /**
+     * Check performance thresholds and create alerts
+     */
+    private checkPerformanceThresholds;
+    /**
+     * Analyze current security threats
+     */
+    private analyzeSecurityThreats;
+    /**
+     * Detect anomalous patterns in system activity
+     */
+    private detectAnomalousPatterns;
+    /**
+     * Check rate limiting violations
+     */
+    private checkRateLimits;
+    /**
+     * Validate authentication attempts
+     */
+    private validateAuthenticationAttempts;
+    /**
+     * Report a security threat
+     */
+    reportThreat(threat: SecurityThreat): void;
+    /**
+     * Log security event to audit trail
+     */
+    private logSecurityEvent;
+    /**
+     * Get current system health status
+     */
+    getSystemHealth(): SystemHealth;
+    /**
+     * Get service statuses
+     */
+    private getServiceStatuses;
+    /**
+     * Get recent performance metrics
+     */
+    private getRecentPerformanceMetrics;
+    /**
+     * Register alert callback
+     */
+    onThreatDetected(callback: (threat: SecurityThreat) => void): void;
+    /**
+     * Mitigate a threat
+     */
+    mitigateThreat(threatId: string, action: string): boolean;
+    /**
+     * Resolve a threat
+     */
+    resolveThreat(threatId: string): boolean;
+    /**
+     * Get list of active threats
+     */
+    getActiveThreats(): SecurityThreat[];
+    /**
+     * Clean up old data
+     */
+    private cleanupOldData;
+    private getCPUUsage;
+    private getAverageAPILatency;
+    private checkForSuspiciousPatterns;
+    private checkRateLimitViolation;
+    private checkAuthenticationAnomaly;
+    /**
+     * Get security rules configuration
+     */
+    getSecurityRules(): SecurityRule[];
+    /**
+     * Update security rule
+     */
+    updateSecurityRule(ruleId: string, updates: Partial<SecurityRule>): boolean;
+    /**
+     * Get threat statistics
+     */
+    getThreatStatistics(): {
+        total: number;
+        active: number;
+        resolved: number;
+        byType: Record<string, number>;
+        bySeverity: Record<string, number>;
+    };
+}
+export declare function getSecurityMonitor(): SecurityMonitor;
+export {};