anon-identity/dist/agent/activity/activity-monitoring-service.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

import { ActivityLogger } from './activity-logger';
import { ActivityStreamManager } from './activity-stream-manager';
import { ActivityWebSocketServer } from './websocket-server';
import { ActivitySearchService } from './activity-search-service';
import { ActivityExporter, ExportOptions, ExportResult, ComplianceTemplate } from './activity-exporter';
import { ActivityArchivalService, ArchivalPolicy, ArchivalRule, GDPRComplianceInfo } from './activity-archival-service';
import { AgentActivity, ActivityLoggerConfig, ActivityQuery, ActivitySearchResult, ActivitySummary } from './types';
import { Server } from 'http';
export interface MonitoringServiceConfig extends ActivityLoggerConfig {
    websocket?: {
        enabled?: boolean;
        port?: number;
        path?: string;
        maxConnections?: number;
    };
    alerts?: {
        enabled?: boolean;
        errorRateThreshold?: number;
        volumeThreshold?: number;
        enableEmail?: boolean;
        enableWebhook?: boolean;
        webhookUrl?: string;
    };
}
export interface MonitoringStats {
    activities: {
        total: number;
        lastHour: number;
        errorRate: number;
    };
    agents: {
        active: number;
        totalSessions: number;
    };
    streaming: {
        connections: number;
        subscriptions: number;
        eventsPublished: number;
    };
    storage: {
        ipfsEnabled: boolean;
        indexEnabled: boolean;
        totalIndexed: number;
    };
}
/**
 * Comprehensive activity monitoring service that integrates all components
 */
export declare class ActivityMonitoringService {
    private logger;
    private streamManager?;
    private webSocketServer?;
    private searchService?;
    private exporter?;
    private archivalService?;
    private config;
    constructor(config?: MonitoringServiceConfig);
    /**
     * Start the monitoring service
     */
    start(httpServer?: Server): Promise<void>;
    /**
     * Stop the monitoring service
     */
    stop(): Promise<void>;
    /**
     * Log an activity
     */
    logActivity(activity: Partial<AgentActivity>): Promise<AgentActivity>;
    /**
     * Search activities
     */
    searchActivities(query: ActivityQuery): Promise<ActivitySearchResult>;
    /**
     * Get activity summary
     */
    getActivitySummary(agentDID: string, period: 'hour' | 'day' | 'week' | 'month' | 'year', startDate?: Date): Promise<ActivitySummary>;
    /**
     * Get recent activities for an agent
     */
    getRecentActivities(agentDID: string, limit?: number): Promise<AgentActivity[]>;
    /**
     * Subscribe to real-time activity stream
     */
    subscribeToActivities(filters: any, callback: (event: any) => void, metadata?: Record<string, any>): any;
    /**
     * Subscribe to agent activities
     */
    subscribeToAgent(agentDID: string, callback: (event: any) => void, metadata?: Record<string, any>): any;
    /**
     * Subscribe to critical events
     */
    subscribeToCriticalEvents(callback: (event: any) => void, metadata?: Record<string, any>): any;
    /**
     * Get comprehensive monitoring statistics
     */
    getMonitoringStats(): Promise<MonitoringStats>;
    /**
     * Get activity trends
     */
    getActivityTrends(agentDID: string, days?: number): Promise<Array<{
        date: string;
        count: number;
        byType: Record<string, number>;
        errorRate: number;
    }>>;
    /**
     * Compare multiple agents
     */
    compareAgents(agentDIDs: string[], period?: 'day' | 'week' | 'month'): Promise<Record<string, ActivitySummary>>;
    /**
     * Force flush all pending activities
     */
    flush(): Promise<void>;
    /**
     * Get the underlying logger instance
     */
    getLogger(): ActivityLogger;
    /**
     * Get the stream manager instance
     */
    getStreamManager(): ActivityStreamManager | undefined;
    /**
     * Get the WebSocket server instance
     */
    getWebSocketServer(): ActivityWebSocketServer | undefined;
    /**
     * Get the search service instance
     */
    getSearchService(): ActivitySearchService | undefined;
    /**
     * Export activities to various formats
     */
    exportActivities(query: ActivityQuery, options: ExportOptions): Promise<ExportResult>;
    /**
     * Generate compliance report
     */
    generateComplianceReport(agentDID: string, template: ComplianceTemplate, period: {
        start: Date;
        end: Date;
    }): Promise<ExportResult>;
    /**
     * Create audit proof for activities
     */
    createAuditProof(query: ActivityQuery, privateKey?: Uint8Array): Promise<any>;
    /**
     * Add archival policy
     */
    addArchivalPolicy(policy: ArchivalPolicy): void;
    /**
     * Add archival rule
     */
    addArchivalRule(rule: ArchivalRule): void;
    /**
     * Archive activities based on criteria
     */
    archiveActivities(query: ActivityQuery, policyId: string, options?: {
        deleteOriginals?: boolean;
        createProof?: boolean;
        encryptionKey?: Uint8Array;
    }): Promise<any>;
    /**
     * Handle GDPR data deletion request
     */
    handleGDPRDataDeletion(parentDID: string): Promise<{
        activitiesDeleted: number;
        archivesDeleted: number;
    }>;
    /**
     * Register GDPR compliance information
     */
    registerGDPRCompliance(parentDID: string, info: GDPRComplianceInfo): void;
    /**
     * Generate data retention report
     */
    generateRetentionReport(): Promise<any>;
    /**
     * Get the exporter instance
     */
    getExporter(): ActivityExporter | undefined;
    /**
     * Get the archival service instance
     */
    getArchivalService(): ActivityArchivalService | undefined;
    private initializeServices;
    private setupAlertMonitoring;
    private sendWebhookAlert;
    private sendEmailAlert;
}
//# sourceMappingURL=activity-monitoring-service.d.ts.map