cs-element/dist/workers/plugins/AnalyticsPlugin.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

import { CSElementPlugin } from '../types/plugin-interfaces';
import { CSElement } from '../core/CSElement';
export interface PluginConfig {
    enabled?: boolean;
    [key: string]: any;
}
export interface PluginContext {
    element?: CSElement;
    operation?: string;
    args?: any[];
    metadata?: Record<string, any>;
    timestamp?: Date;
    userId?: string;
    sessionId?: string;
}
export interface PluginResult {
    success: boolean;
    data?: any;
    error?: string;
    metadata?: Record<string, any>;
}
export declare enum EventType {
    CREATE = "create",
    READ = "read",
    UPDATE = "update",
    DELETE = "delete",
    QUERY = "query",
    SERIALIZE = "serialize",
    CUSTOM = "custom"
}
export declare enum MetricType {
    COUNTER = "counter",
    GAUGE = "gauge",
    HISTOGRAM = "histogram",
    TIMER = "timer",
    RATE = "rate"
}
export declare enum AggregationType {
    SUM = "sum",
    AVERAGE = "average",
    MIN = "min",
    MAX = "max",
    COUNT = "count",
    PERCENTILE = "percentile"
}
export declare enum ReportFormat {
    JSON = "json",
    CSV = "csv",
    HTML = "html",
    PDF = "pdf",
    EXCEL = "excel"
}
export interface AnalyticsEvent {
    id: string;
    type: EventType;
    elementId?: string;
    userId?: string;
    sessionId?: string;
    timestamp: Date;
    duration?: number;
    success: boolean;
    error?: string;
    metadata: Record<string, any>;
    tags: string[];
    category?: string;
    source?: string;
    userAgent?: string;
    ipAddress?: string;
}
export interface Metric {
    id: string;
    name: string;
    type: MetricType;
    value: number;
    timestamp: Date;
    tags: Record<string, string>;
    description?: string;
    unit?: string;
}
export interface Dimension {
    name: string;
    value: string;
    type: 'string' | 'number' | 'boolean' | 'date';
}
export interface AnalyticsQuery {
    eventTypes?: EventType[];
    dateRange?: {
        start: Date;
        end: Date;
    };
    filters?: Record<string, any>;
    groupBy?: string[];
    aggregation?: AggregationType;
    limit?: number;
    offset?: number;
    sortBy?: string;
    sortOrder?: 'asc' | 'desc';
}
export interface AnalyticsReport {
    id: string;
    name: string;
    description?: string;
    query: AnalyticsQuery;
    format: ReportFormat;
    createdAt: Date;
    updatedAt: Date;
    data: any[];
    summary: Record<string, any>;
    metadata: Record<string, any>;
}
export interface Dashboard {
    id: string;
    name: string;
    description?: string;
    widgets: Widget[];
    layout: DashboardLayout;
    filters: Record<string, any>;
    refreshInterval?: number;
    isPublic: boolean;
    createdAt: Date;
    updatedAt: Date;
}
export interface Widget {
    id: string;
    type: 'chart' | 'table' | 'metric' | 'text';
    title: string;
    query: AnalyticsQuery;
    config: Record<string, any>;
    position: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
}
export interface DashboardLayout {
    columns: number;
    rows: number;
    gap: number;
    responsive: boolean;
}
export interface UserBehavior {
    userId: string;
    sessionId: string;
    startTime: Date;
    endTime?: Date;
    events: AnalyticsEvent[];
    elementsAccessed: string[];
    operationsPerformed: Record<EventType, number>;
    timeSpentByElement: Record<string, number>;
    errorCount: number;
    successRate: number;
}
export interface PerformanceMetrics {
    averageResponseTime: number;
    throughput: number;
    errorRate: number;
    memoryUsage: number;
    cpuUsage: number;
    operationsPerSecond: Record<EventType, number>;
    slowestOperations: Array<{
        operation: string;
        duration: number;
        timestamp: Date;
    }>;
    peakUsageTime: Date;
}
export interface AnalyticsPluginConfig extends PluginConfig {
    enableRealTimeTracking: boolean;
    enableUserBehaviorTracking: boolean;
    enablePerformanceTracking: boolean;
    enableCustomEvents: boolean;
    samplingRate: number;
    maxEventsInMemory: number;
    retentionPeriod: number;
    batchSize: number;
    flushInterval: number;
    exportFormats: ReportFormat[];
    anonymizeUserData: boolean;
    excludeEvents: EventType[];
    includeMetadata: boolean;
    enableGeolocation: boolean;
}
export interface AnalyticsStats {
    totalEvents: number;
    eventsToday: number;
    eventsThisWeek: number;
    eventsThisMonth: number;
    eventsByType: Record<EventType, number>;
    uniqueUsers: number;
    uniqueSessions: number;
    averageSessionDuration: number;
    topElements: Array<{
        elementId: string;
        accessCount: number;
    }>;
    topOperations: Array<{
        operation: EventType;
        count: number;
    }>;
    errorRate: number;
    lastFlush?: Date;
    memoryUsage: number;
}
export declare class AnalyticsPlugin implements CSElementPlugin {
    readonly name = "AnalyticsPlugin";
    readonly version = "1.0.0";
    readonly description = "\u041F\u043B\u0430\u0433\u0438\u043D \u0434\u043B\u044F \u0441\u0431\u043E\u0440\u0430 \u0430\u043D\u0430\u043B\u0438\u0442\u0438\u043A\u0438 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u044F \u0438 \u043E\u0442\u0441\u043B\u0435\u0436\u0438\u0432\u0430\u043D\u0438\u044F \u0441\u043E\u0431\u044B\u0442\u0438\u0439";
    private config;
    private events;
    private metrics;
    private reports;
    private dashboards;
    private userBehaviors;
    private performanceMetrics;
    private stats;
    private flushTimer?;
    private sessionStartTimes;
    constructor(config?: Partial<AnalyticsPluginConfig>);
    install(CSElementClass: typeof CSElement): void;
    initialize(): Promise<void>;
    destroy(): Promise<void>;
    getConfig(): AnalyticsPluginConfig;
    updateConfig(newConfig: Partial<AnalyticsPluginConfig>): void;
    beforeCreate(element: CSElement, context: PluginContext): Promise<PluginResult>;
    afterCreate(element: CSElement, context: PluginContext): Promise<PluginResult>;
    beforeRead(element: CSElement, context: PluginContext): Promise<PluginResult>;
    beforeUpdate(element: CSElement, context: PluginContext): Promise<PluginResult>;
    beforeDelete(element: CSElement, context: PluginContext): Promise<PluginResult>;
    onError(error: Error, context: PluginContext): Promise<PluginResult>;
    trackEvent(eventData: Partial<AnalyticsEvent>, context: PluginContext): Promise<void>;
    trackCustomEvent(name: string, data: Record<string, any>, context: PluginContext): Promise<void>;
    recordMetric(name: string, value: number, type?: MetricType, tags?: Record<string, string>): void;
    query(query: AnalyticsQuery): Promise<AnalyticsEvent[]>;
    generateReport(name: string, query: AnalyticsQuery, format?: ReportFormat): Promise<AnalyticsReport>;
    exportReport(reportId: string, format?: ReportFormat): Promise<string>;
    createDashboard(dashboardData: Omit<Dashboard, 'id' | 'createdAt' | 'updatedAt'>): Dashboard;
    getDashboard(id: string): Dashboard | undefined;
    updateDashboard(id: string, updates: Partial<Dashboard>): boolean;
    deleteDashboard(id: string): boolean;
    getUserBehavior(userId: string): UserBehavior | undefined;
    analyzeUserBehavior(userId: string): Promise<Record<string, any>>;
    getPerformanceMetrics(): PerformanceMetrics;
    generatePerformanceReport(): Promise<Record<string, any>>;
    private withPerformanceTracking;
    private recordPerformanceMetric;
    private updateUserBehavior;
    private shouldSampleEvent;
    private updateRealTimeMetrics;
    private flushEvents;
    private cleanupOldData;
    private updateStats;
    private calculateSummary;
    private calculateTopElements;
    private calculateTopOperations;
    private getMostAccessedElements;
    private calculateAverageTimePerElement;
    private findPeakActivityTime;
    private calculateEventDistribution;
    private convertToCSV;
    private convertToHTML;
    private getNestedValue;
    private groupBy;
    private estimateMemoryUsage;
    private hashUserId;
    private hashIpAddress;
    private generateId;
    getStats(): AnalyticsStats;
    getAllEvents(): AnalyticsEvent[];
    getAllMetrics(): Metric[];
    getAllReports(): AnalyticsReport[];
    getAllDashboards(): Dashboard[];
    getAllUserBehaviors(): UserBehavior[];
}
//# sourceMappingURL=AnalyticsPlugin.d.ts.map