@k-msg/analytics 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,1048 +1,18 @@
-import { EventEmitter } from 'events';
-
-interface AnalyticsConfig {
-    enableRealTimeTracking: boolean;
-    retentionDays: number;
-    aggregationIntervals: ('minute' | 'hour' | 'day' | 'week' | 'month')[];
-    enabledMetrics: MetricType[];
-}
-declare enum MetricType {
-    MESSAGE_SENT = "message_sent",
-    MESSAGE_DELIVERED = "message_delivered",
-    MESSAGE_FAILED = "message_failed",
-    MESSAGE_CLICKED = "message_clicked",
-    TEMPLATE_USAGE = "template_usage",
-    PROVIDER_PERFORMANCE = "provider_performance",
-    CHANNEL_USAGE = "channel_usage",
-    ERROR_RATE = "error_rate",
-    DELIVERY_RATE = "delivery_rate",
-    CLICK_RATE = "click_rate"
-}
-interface MetricData {
-    id: string;
-    type: MetricType;
-    timestamp: Date;
-    value: number;
-    dimensions: Record<string, string>;
-    metadata?: Record<string, any>;
-}
-interface AggregatedMetric {
-    type: MetricType;
-    interval: 'minute' | 'hour' | 'day' | 'week' | 'month';
-    timestamp: Date;
-    dimensions: Record<string, string>;
-    aggregations: {
-        count: number;
-        sum: number;
-        avg: number;
-        min: number;
-        max: number;
-    };
-}
-interface AnalyticsReport {
-    id: string;
-    name: string;
-    description?: string;
-    dateRange: {
-        start: Date;
-        end: Date;
-    };
-    filters: Record<string, any>;
-    metrics: ReportMetric[];
-    generatedAt: Date;
-    format: 'json' | 'csv' | 'pdf';
-}
-interface ReportMetric {
-    type: MetricType;
-    value: number;
-    change?: number;
-    trend?: 'up' | 'down' | 'stable';
-    breakdown?: Record<string, number>;
-}
-interface InsightData {
-    id: string;
-    type: 'anomaly' | 'trend' | 'recommendation';
-    title: string;
-    description: string;
-    severity: 'low' | 'medium' | 'high' | 'critical';
-    metric: MetricType;
-    dimensions: Record<string, string>;
-    value: number;
-    expectedValue?: number;
-    confidence: number;
-    actionable: boolean;
-    recommendations?: string[];
-    detectedAt: Date;
-}
-interface AnalyticsQuery {
-    metrics: MetricType[];
-    dateRange: {
-        start: Date;
-        end: Date;
-    };
-    interval?: 'minute' | 'hour' | 'day' | 'week' | 'month';
-    filters?: Record<string, any>;
-    groupBy?: string[];
-    orderBy?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    }[];
-    limit?: number;
-    offset?: number;
-}
-interface AnalyticsResult {
-    query: AnalyticsQuery;
-    data: AggregatedMetric[];
-    summary: {
-        totalRecords: number;
-        dateRange: {
-            start: Date;
-            end: Date;
-        };
-        executionTime: number;
-    };
-    insights?: InsightData[];
-}
-
-declare class AnalyticsService {
-    private config;
-    private metricsCollector;
-    private reportGenerator;
-    private insightEngine;
-    private metrics;
-    private aggregatedMetrics;
-    constructor(config: AnalyticsConfig);
-    /**
-     * 메트릭 데이터 수집
-     */
-    collectMetric(metric: MetricData): Promise<void>;
-    /**
-     * 분석 쿼리 실행
-     */
-    query(query: AnalyticsQuery): Promise<AnalyticsResult>;
-    /**
-     * 실시간 메트릭 스트림
-     */
-    streamMetrics(types: MetricType[]): AsyncGenerator<MetricData>;
-    /**
-     * 대시보드 데이터 조회
-     */
-    getDashboardData(timeRange: {
-        start: Date;
-        end: Date;
-    }): Promise<{
-        timeRange: {
-            start: Date;
-            end: Date;
-        };
-        kpis: {
-            totalMessages: number;
-            deliveryRate: number;
-            errorRate: number;
-            clickRate: number;
-        };
-        metrics: AggregatedMetric[];
-        insights: InsightData[] | undefined;
-        trends: {};
-    }>;
-    /**
-     * 이상 탐지
-     */
-    detectAnomalies(metricType: MetricType, timeRange: {
-        start: Date;
-        end: Date;
-    }): Promise<InsightData[]>;
-    private processRealTimeMetric;
-    private validateQuery;
-    private executeQuery;
-    private performAggregation;
-    private generateInsights;
-    private getOptimalInterval;
-    private calculateKPIs;
-    private calculateTrends;
-    private sumMetrics;
-    private calculateRate;
-    private generateCacheKey;
-    private startAggregationTasks;
-    private scheduleAggregation;
-    private getScheduleInterval;
-    private runAggregation;
-    private notifyAnomalies;
-}
-
-declare class MetricsCollector {
-    private config;
-    private buffer;
-    private batchSize;
-    private flushInterval;
-    private storage;
-    constructor(config: AnalyticsConfig);
-    /**
-     * 메트릭 수집
-     */
-    collect(metric: MetricData): Promise<void>;
-    /**
-     * 여러 메트릭 일괄 수집
-     */
-    collectBatch(metrics: MetricData[]): Promise<void>;
-    /**
-     * 최근 메트릭 조회
-     */
-    getRecentMetrics(types: MetricType[], durationMs: number): Promise<MetricData[]>;
-    /**
-     * 메트릭 통계 조회
-     */
-    getMetricStats(type: MetricType, timeRange: {
-        start: Date;
-        end: Date;
-    }): Promise<{
-        count: number;
-        sum: number;
-        avg: number;
-        min: number;
-        max: number;
-    }>;
-    /**
-     * 메트릭 카운터 증가
-     */
-    incrementCounter(type: MetricType, dimensions: Record<string, string>, value?: number): Promise<void>;
-    /**
-     * 메트릭 게이지 값 설정
-     */
-    setGauge(type: MetricType, dimensions: Record<string, string>, value: number): Promise<void>;
-    /**
-     * 메트릭 히스토그램 기록
-     */
-    recordHistogram(type: MetricType, dimensions: Record<string, string>, value: number): Promise<void>;
-    /**
-     * 메트릭 버퍼 플러시
-     */
-    flush(): Promise<void>;
-    /**
-     * 메트릭 정리 (보존 기간 초과)
-     */
-    cleanup(): Promise<void>;
-    private validateMetric;
-    private persistMetrics;
-    private startBatchProcessor;
-    private generateMetricId;
-}
-
-declare class ReportGenerator {
-    private config;
-    constructor(config: AnalyticsConfig);
-    /**
-     * 일일 요약 보고서 생성
-     */
-    generateDailySummary(date: Date): Promise<AnalyticsReport>;
-    /**
-     * 주간 보고서 생성
-     */
-    generateWeeklyReport(weekStartDate: Date): Promise<AnalyticsReport>;
-    /**
-     * 월간 보고서 생성
-     */
-    generateMonthlyReport(year: number, month: number): Promise<AnalyticsReport>;
-    /**
-     * 프로바이더별 성능 보고서
-     */
-    generateProviderReport(providerId: string, dateRange: {
-        start: Date;
-        end: Date;
-    }): Promise<AnalyticsReport>;
-    /**
-     * 템플릿 사용량 보고서
-     */
-    generateTemplateUsageReport(dateRange: {
-        start: Date;
-        end: Date;
-    }): Promise<AnalyticsReport>;
-    /**
-     * 커스텀 보고서 생성
-     */
-    generateCustomReport(name: string, dateRange: {
-        start: Date;
-        end: Date;
-    }, filters: Record<string, any>, metricTypes: MetricType[]): Promise<AnalyticsReport>;
-    /**
-     * 보고서를 CSV 형식으로 내보내기
-     */
-    exportToCSV(report: AnalyticsReport): Promise<string>;
-    /**
-     * 보고서를 JSON 형식으로 내보내기
-     */
-    exportToJSON(report: AnalyticsReport): Promise<string>;
-    private generateReport;
-    private calculateDailyMetrics;
-    private calculateWeeklyMetrics;
-    private calculateMonthlyMetrics;
-    private calculateProviderMetrics;
-    private calculateTemplateMetrics;
-    private calculateCustomMetrics;
-    private getMetricValue;
-    private getProviderPerformance;
-    private getTemplateUsage;
-    private calculateChange;
-    private calculateTrend;
-    private getMetricPriority;
-    private validateReport;
-}
-
-declare class InsightEngine {
-    private config;
-    private anomalyThresholds;
-    private historicalData;
-    constructor(config: AnalyticsConfig);
-    /**
-     * 실시간 이상 탐지
-     */
-    detectRealTimeAnomalies(metric: MetricData): Promise<InsightData[]>;
-    /**
-     * 시계열 이상 탐지
-     */
-    detectAnomalies(metricType: MetricType, timeRange: {
-        start: Date;
-        end: Date;
-    }): Promise<InsightData[]>;
-    /**
-     * 인사이트 생성
-     */
-    generateInsights(query: AnalyticsQuery, data: AggregatedMetric[]): Promise<InsightData[]>;
-    /**
-     * 트렌드 예측
-     */
-    predictTrends(metricType: MetricType, forecastDays: number): Promise<{
-        date: Date;
-        predicted: number;
-        confidence: number;
-    }[]>;
-    private initializeBaselines;
-    private detectTrendChange;
-    private detectSeasonalAnomalies;
-    private detectPatternAnomalies;
-    private detectThresholdAnomalies;
-    private generatePerformanceInsights;
-    private generateTrendInsights;
-    private generateComparisonInsights;
-    private generateRecommendationInsights;
-    private calculateSeverity;
-    private calculateConfidence;
-    private generateRecommendations;
-    private calculateTrend;
-}
-
 /**
- * Time Series Data Aggregator
- * 시계열 데이터 집계 및 다운샘플링
- */
-
-interface TimeWindow {
-    start: Date;
-    end: Date;
-    interval: 'minute' | 'hour' | 'day' | 'week' | 'month';
-}
-interface AggregationOptions {
-    fillGaps: boolean;
-    fillValue: number;
-    timezone?: string;
-}
-declare class TimeSeriesAggregator {
-    private timezone;
-    constructor(timezone?: string);
-    /**
-     * 시계열 데이터를 지정된 간격으로 집계
-     */
-    aggregate(metrics: MetricData[], interval: 'minute' | 'hour' | 'day' | 'week' | 'month', options?: AggregationOptions): Promise<AggregatedMetric[]>;
-    /**
-     * 롤링 윈도우 집계
-     */
-    aggregateRolling(metrics: MetricData[], windowSize: number, // 분 단위
-    step?: number): Promise<AggregatedMetric[]>;
-    /**
-     * 계절성 분해 (간단한 이동평균 기반)
-     */
-    decomposeSeasonality(metrics: AggregatedMetric[], seasonLength?: number): Promise<{
-        trend: AggregatedMetric[];
-        seasonal: AggregatedMetric[];
-        residual: AggregatedMetric[];
-    }>;
-    /**
-     * 다운샘플링 (고해상도 → 저해상도)
-     */
-    downsample(metrics: AggregatedMetric[], targetInterval: 'minute' | 'hour' | 'day' | 'week' | 'month'): Promise<AggregatedMetric[]>;
-    private groupByType;
-    private groupByDimensions;
-    private aggregateByInterval;
-    private groupByTimeInterval;
-    private getTimeIntervalKey;
-    private fillTimeGaps;
-    private calculateAggregations;
-    private aggregateWindow;
-    private calculateMovingAverage;
-    private calculateSeasonalComponent;
-    private calculateResidual;
-}
-
-/**
- * Metric Aggregator
- * 메트릭별 특화 집계 로직
- */
-
-interface AggregationRule {
-    metricType: MetricType;
-    aggregationType: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'rate' | 'percentile';
-    dimensions: string[];
-    conditions?: Array<{
-        field: string;
-        operator: 'equals' | 'not_equals' | 'gt' | 'lt' | 'contains';
-        value: any;
-    }>;
-    percentile?: number;
-}
-interface AggregatorConfig {
-    rules: AggregationRule[];
-    batchSize: number;
-    flushInterval: number;
-}
-declare class MetricAggregator {
-    private config;
-    private buffer;
-    private aggregationCache;
-    constructor(config: AggregatorConfig);
-    /**
-     * 메트릭 추가 및 실시간 집계
-     */
-    addMetric(metric: MetricData): Promise<void>;
-    /**
-     * 배치 메트릭 처리
-     */
-    addMetrics(metrics: MetricData[]): Promise<void>;
-    /**
-     * 규칙 기반 집계 실행
-     */
-    aggregateByRules(metrics: MetricData[]): Promise<AggregatedMetric[]>;
-    /**
-     * 커스텀 집계 (동적 규칙)
-     */
-    aggregateCustom(metrics: MetricData[], groupBy: string[], aggregationType: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'rate', filters?: Record<string, any>): Promise<AggregatedMetric[]>;
-    /**
-     * 비율 계산 (예: 전환율, 오류율)
-     */
-    calculateRates(numeratorMetrics: MetricData[], denominatorMetrics: MetricData[], groupBy?: string[]): Promise<AggregatedMetric[]>;
-    /**
-     * 백분위수 계산
-     */
-    calculatePercentiles(metrics: MetricData[], percentiles: number[], groupBy?: string[]): Promise<AggregatedMetric[]>;
-    /**
-     * 슬라이딩 윈도우 집계
-     */
-    aggregateSlidingWindow(metrics: MetricData[], windowSizeMs: number, stepMs: number, aggregationType: 'sum' | 'avg' | 'min' | 'max' | 'count'): Promise<AggregatedMetric[]>;
-    /**
-     * 메트릭 정규화
-     */
-    normalizeMetrics(metrics: AggregatedMetric[], method: 'minmax' | 'zscore' | 'robust'): Promise<AggregatedMetric[]>;
-    private getBufferKey;
-    private flushBuffer;
-    private filterMetricsByRule;
-    private applyAggregationRule;
-    private groupMetrics;
-    private createGroupKey;
-    private getFieldValue;
-    private evaluateCondition;
-    private performAggregation;
-    private applyFilters;
-    private calculatePercentile;
-    private minMaxNormalize;
-    private zScoreNormalize;
-    private robustNormalize;
-    private calculateMAD;
-    private startPeriodicFlush;
-}
-
-/**
- * Event Collector
- * 실시간 이벤트 수집 및 메트릭 변환
- */
-
-interface EventData {
-    id: string;
-    type: string;
-    timestamp: Date;
-    source: string;
-    payload: Record<string, any>;
-    context?: {
-        userId?: string;
-        sessionId?: string;
-        requestId?: string;
-        userAgent?: string;
-        ipAddress?: string;
-    };
-}
-interface EventCollectorConfig {
-    bufferSize: number;
-    flushInterval: number;
-    enableDeduplication: boolean;
-    deduplicationWindow: number;
-    enableSampling: boolean;
-    samplingRate: number;
-}
-interface EventProcessor {
-    canProcess(event: EventData): boolean;
-    process(event: EventData): Promise<MetricData[]>;
-}
-declare class EventCollector extends EventEmitter {
-    private config;
-    private buffer;
-    private processors;
-    private recentEvents;
-    private metrics;
-    private defaultConfig;
-    constructor(config?: Partial<EventCollectorConfig>);
-    /**
-     * 이벤트 수집
-     */
-    collectEvent(event: EventData): Promise<void>;
-    /**
-     * 배치 이벤트 수집
-     */
-    collectEvents(events: EventData[]): Promise<void>;
-    /**
-     * 커스텀 이벤트 프로세서 등록
-     */
-    registerProcessor(name: string, processor: EventProcessor): void;
-    /**
-     * 이벤트 프로세서 제거
-     */
-    unregisterProcessor(name: string): boolean;
-    /**
-     * 수집된 메트릭 조회
-     */
-    getCollectedMetrics(since?: Date): MetricData[];
-    /**
-     * 실시간 메트릭 스트림
-     */
-    streamMetrics(): AsyncGenerator<MetricData[]>;
-    /**
-     * 이벤트 통계
-     */
-    getEventStats(): {
-        totalEvents: number;
-        eventsByType: Record<string, number>;
-        eventsBySource: Record<string, number>;
-        bufferSize: number;
-        metricsGenerated: number;
-    };
-    /**
-     * 버퍼 강제 플러시
-     */
-    flush(): Promise<void>;
-    private processEvent;
-    private validateEvent;
-    private isDuplicate;
-    private isHighPriorityEvent;
-    private initializeDefaultProcessors;
-    private startPeriodicFlush;
-    private startCleanup;
-}
-
-/**
- * Webhook Collector
- * 웹훅을 통한 외부 이벤트 수집
- */
-
-interface WebhookData {
-    id: string;
-    source: string;
-    timestamp: Date;
-    headers: Record<string, string>;
-    body: any;
-    signature?: string;
-}
-interface WebhookCollectorConfig {
-    enableSignatureValidation: boolean;
-    signatureHeader: string;
-    secretKey?: string;
-    allowedSources: string[];
-    maxPayloadSize: number;
-    rateLimitPerMinute: number;
-}
-interface WebhookTransformer {
-    canTransform(webhook: WebhookData): boolean;
-    transform(webhook: WebhookData): Promise<EventData[]>;
-}
-declare class WebhookCollector extends EventEmitter {
-    private config;
-    private transformers;
-    private requestCounts;
-    private processedWebhooks;
-    private defaultConfig;
-    constructor(config?: Partial<WebhookCollectorConfig>);
-    /**
-     * 웹훅 수신 처리
-     */
-    receiveWebhook(webhook: WebhookData): Promise<EventData[]>;
-    /**
-     * 웹훅 변환기 등록
-     */
-    registerTransformer(name: string, transformer: WebhookTransformer): void;
-    /**
-     * 웹훅 변환기 제거
-     */
-    unregisterTransformer(name: string): boolean;
-    /**
-     * 처리된 웹훅 조회
-     */
-    getProcessedWebhooks(since?: Date): WebhookData[];
-    /**
-     * 웹훅 통계
-     */
-    getWebhookStats(): {
-        totalProcessed: number;
-        bySource: Record<string, number>;
-        recentCount: number;
-        transformerCount: number;
-    };
-    private validateWebhook;
-    private validateSignature;
-    private generateSignature;
-    private checkRateLimit;
-    private transformWebhook;
-    private defaultTransform;
-    private initializeDefaultTransformers;
-    private startCleanup;
-}
-
-/**
- * Anomaly Detector
- * 이상 징후 탐지 및 분석
- */
-
-interface AnomalyDetectionConfig {
-    algorithms: AnomalyAlgorithm[];
-    sensitivity: 'low' | 'medium' | 'high';
-    minDataPoints: number;
-    confidenceThreshold: number;
-    enableSeasonalAdjustment: boolean;
-}
-interface AnomalyAlgorithm {
-    name: string;
-    type: 'statistical' | 'ml' | 'rule-based';
-    enabled: boolean;
-    config: Record<string, any>;
-}
-interface Anomaly {
-    id: string;
-    metricType: MetricType;
-    timestamp: Date;
-    value: number;
-    expectedValue: number;
-    deviation: number;
-    severity: 'low' | 'medium' | 'high' | 'critical';
-    confidence: number;
-    algorithm: string;
-    dimensions: Record<string, string>;
-    context?: {
-        trend: 'increasing' | 'decreasing' | 'stable';
-        seasonality: boolean;
-        historicalComparison: number;
-    };
-}
-declare class AnomalyDetector {
-    private config;
-    private historicalData;
-    private seasonalPatterns;
-    private baselines;
-    private defaultConfig;
-    constructor(config?: Partial<AnomalyDetectionConfig>);
-    /**
-     * 실시간 이상 탐지
-     */
-    detectRealTimeAnomalies(metric: MetricData): Promise<Anomaly[]>;
-    /**
-     * 배치 이상 탐지
-     */
-    detectBatchAnomalies(metrics: AggregatedMetric[], timeWindow?: {
-        start: Date;
-        end: Date;
-    }): Promise<Anomaly[]>;
-    /**
-     * 트렌드 변화 탐지
-     */
-    detectTrendChanges(metrics: AggregatedMetric[], windowSize?: number): Promise<InsightData[]>;
-    /**
-     * 베이스라인 업데이트
-     */
-    updateBaselines(metrics: AggregatedMetric[]): Promise<void>;
-    private runAlgorithm;
-    private zScoreDetection;
-    private iqrDetection;
-    private isolationForestDetection;
-    private thresholdDetection;
-    private calculateSeverity;
-    private calculateTrendSeverity;
-    private getMetricKey;
-    private updateHistoricalData;
-    private groupMetricsByTypeAndDimensions;
-    private adjustForSeasonality;
-    private calculateTrend;
-    private detectTrend;
-    private getSensitivityThreshold;
-    private calculateIsolationThreshold;
-    private calculateIsolationScore;
-    private deduplicateAndRankAnomalies;
-    private generateTrendRecommendations;
-}
-
-/**
- * Recommendation Engine
- * 데이터 기반 추천 시스템
- */
-
-interface RecommendationConfig {
-    rules: RecommendationRule[];
-    enableMachineLearning: boolean;
-    confidenceThreshold: number;
-    maxRecommendations: number;
-    categories: RecommendationCategory[];
-}
-interface RecommendationRule {
-    id: string;
-    name: string;
-    category: string;
-    priority: number;
-    conditions: RuleCondition[];
-    actions: RecommendationAction[];
-    enabled: boolean;
-}
-interface RuleCondition {
-    metric: MetricType;
-    operator: 'gt' | 'lt' | 'eq' | 'gte' | 'lte' | 'between' | 'trend';
-    value: number | [number, number];
-    timeWindow?: string;
-    dimensions?: Record<string, string>;
-}
-interface RecommendationAction {
-    type: 'optimization' | 'cost-saving' | 'performance' | 'reliability' | 'security';
-    title: string;
-    description: string;
-    impact: 'low' | 'medium' | 'high';
-    effort: 'low' | 'medium' | 'high';
-    steps: string[];
-    estimatedBenefit?: {
-        metric: MetricType;
-        improvement: number;
-        unit: string;
-    };
-}
-interface Recommendation {
-    id: string;
-    category: string;
-    priority: number;
-    title: string;
-    description: string;
-    rationale: string;
-    actions: RecommendationAction[];
-    confidence: number;
-    impact: 'low' | 'medium' | 'high';
-    effort: 'low' | 'medium' | 'high';
-    createdAt: Date;
-    validUntil?: Date;
-    metadata: {
-        ruleIds: string[];
-        triggeredBy: {
-            metrics: {
-                type: MetricType;
-                value: number;
-                timestamp: Date;
-            }[];
-            conditions: string[];
-        };
-        estimatedROI?: number;
-    };
-}
-interface RecommendationCategory {
-    id: string;
-    name: string;
-    description: string;
-    weight: number;
-}
-declare class RecommendationEngine {
-    private config;
-    private recommendations;
-    private ruleExecutionHistory;
-    private defaultConfig;
-    constructor(config?: Partial<RecommendationConfig>);
-    /**
-     * 메트릭 기반 추천 생성
-     */
-    generateRecommendations(metrics: AggregatedMetric[]): Promise<Recommendation[]>;
-    /**
-     * 특정 카테고리 추천 조회
-     */
-    getRecommendationsByCategory(category: string): Recommendation[];
-    /**
-     * 추천 실행 상태 업데이트
-     */
-    markRecommendationAsImplemented(recommendationId: string): boolean;
-    /**
-     * 추천 무시
-     */
-    dismissRecommendation(recommendationId: string, reason?: string): boolean;
-    /**
-     * 추천 통계
-     */
-    getRecommendationStats(): {
-        total: number;
-        byCategory: Record<string, number>;
-        byImpact: Record<string, number>;
-        byPriority: Record<string, number>;
-    };
-    private generateRuleBasedRecommendations;
-    private generatePatternBasedRecommendations;
-    private generateComparisonBasedRecommendations;
-    private generateMLBasedRecommendations;
-    private evaluateRuleConditions;
-    private evaluateCondition;
-    private createRecommendationFromRule;
-    private analyzeTimePatterns;
-    private generateTimeBasedRecommendations;
-    private analyzeChannelPatterns;
-    private generateChannelBasedRecommendations;
-    private analyzeErrorPatterns;
-    private generateErrorBasedRecommendations;
-    private compareProviderPerformance;
-    private generateProviderRecommendations;
-    private compareChannelEfficiency;
-    private generateChannelEfficiencyRecommendations;
-    private generateCapacityRecommendations;
-    private calculateRuleConfidence;
-    private calculateAggregateImpact;
-    private calculateAggregateEffort;
-    private generateRationale;
-    private recordRuleExecution;
-    private deduplicateAndPrioritize;
-    private initializeDefaultRules;
-}
-
-/**
- * Dashboard Report Generator
- * 실시간 대시보드 데이터 생성
- */
-
-interface DashboardConfig {
-    refreshInterval: number;
-    timeRange: {
-        default: string;
-        options: string[];
-    };
-    widgets: DashboardWidget[];
-    filters: DashboardFilter[];
-}
-interface DashboardWidget {
-    id: string;
-    type: 'metric' | 'chart' | 'table' | 'gauge' | 'heatmap' | 'trend';
-    title: string;
-    description?: string;
-    position: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    query: AnalyticsQuery;
-    visualization: VisualizationConfig;
-    refreshInterval?: number;
-}
-interface VisualizationConfig {
-    chartType?: 'line' | 'bar' | 'pie' | 'area' | 'scatter';
-    aggregation?: 'sum' | 'avg' | 'min' | 'max' | 'count';
-    groupBy?: string[];
-    colors?: string[];
-    yAxis?: {
-        min?: number;
-        max?: number;
-        label?: string;
-    };
-    xAxis?: {
-        label?: string;
-    };
-    showLegend?: boolean;
-    showGrid?: boolean;
-}
-interface DashboardFilter {
-    id: string;
-    name: string;
-    type: 'select' | 'date' | 'range' | 'multi-select';
-    field: string;
-    options?: Array<{
-        value: string;
-        label: string;
-    }>;
-    defaultValue?: any;
-}
-interface DashboardData {
-    timestamp: Date;
-    timeRange: {
-        start: Date;
-        end: Date;
-    };
-    kpis: KPIData[];
-    widgets: WidgetData[];
-    insights: InsightData[];
-    filters: Record<string, any>;
-}
-interface KPIData {
-    id: string;
-    name: string;
-    value: number;
-    previousValue?: number;
-    change?: number;
-    changePercent?: number;
-    trend: 'up' | 'down' | 'stable';
-    unit?: string;
-    target?: number;
-    status: 'good' | 'warning' | 'critical';
-}
-interface WidgetData {
-    id: string;
-    title: string;
-    type: string;
-    data: any;
-    lastUpdated: Date;
-    error?: string;
-}
-declare class DashboardGenerator {
-    private config;
-    private dataCache;
-    private defaultConfig;
-    constructor(config?: Partial<DashboardConfig>);
-    /**
-     * 대시보드 데이터 생성
-     */
-    generateDashboard(timeRange: {
-        start: Date;
-        end: Date;
-    }, filters?: Record<string, any>, metrics?: AggregatedMetric[]): Promise<DashboardData>;
-    /**
-     * 실시간 대시보드 스트림
-     */
-    streamDashboard(timeRange: {
-        start: Date;
-        end: Date;
-    }, filters?: Record<string, any>): AsyncGenerator<DashboardData>;
-    /**
-     * 특정 위젯 데이터 업데이트
-     */
-    updateWidget(widgetId: string, metrics: AggregatedMetric[], timeRange: {
-        start: Date;
-        end: Date;
-    }, filters?: Record<string, any>): Promise<WidgetData | null>;
-    /**
-     * 대시보드 구성 업데이트
-     */
-    updateConfig(config: Partial<DashboardConfig>): void;
-    /**
-     * 위젯 추가
-     */
-    addWidget(widget: DashboardWidget): void;
-    /**
-     * 위젯 제거
-     */
-    removeWidget(widgetId: string): boolean;
-    private calculateKPIs;
-    private generateWidgetData;
-    private generateSingleWidgetData;
-    private generateMetricWidgetData;
-    private generateChartWidgetData;
-    private generateGroupedChartData;
-    private generateTableWidgetData;
-    private generateGaugeWidgetData;
-    private generateHeatmapWidgetData;
-    private generateTrendWidgetData;
-    private filterMetrics;
-    private applyQueryFilters;
-    private calculatePreviousPeriodValue;
-    private getAggregatedValue;
-    private formatValue;
-    private getDefaultColor;
-    private initializeDefaultWidgets;
-}
-
-/**
- * Export Manager
- * 다양한 형식으로 데이터 내보내기
- */
-
-interface ExportConfig {
-    formats: ExportFormat[];
-    maxFileSize: number;
-    compressionEnabled: boolean;
-    watermark?: {
-        text: string;
-        position: 'top' | 'bottom';
-    };
-    scheduling?: {
-        enabled: boolean;
-        cron: string;
-        recipients: string[];
-    };
-}
-interface ExportFormat {
-    type: 'csv' | 'excel' | 'pdf' | 'json' | 'xml';
-    options?: Record<string, any>;
-    template?: string;
-}
-interface ExportResult {
-    id: string;
-    format: string;
-    fileName: string;
-    filePath: string;
-    fileSize: number;
-    createdAt: Date;
-    downloadUrl?: string;
-    expiresAt?: Date;
-}
-declare class ExportManager {
-    private config;
-    private exports;
-    private exportQueue;
-    private defaultConfig;
-    constructor(config?: Partial<ExportConfig>);
-    /**
-     * 분석 보고서 내보내기
-     */
-    exportReport(report: AnalyticsReport, format: ExportFormat, options?: any): Promise<ExportResult>;
-    /**
-     * 메트릭 데이터 내보내기
-     */
-    exportMetrics(metrics: AggregatedMetric[], format: ExportFormat, options?: any): Promise<ExportResult>;
-    /**
-     * 인사이트 데이터 내보내기
-     */
-    exportInsights(insights: InsightData[], format: ExportFormat, options?: any): Promise<ExportResult>;
-    /**
-     * 내보내기 상태 조회
-     */
-    getExportStatus(exportId: string): ExportResult | null;
-    /**
-     * 내보내기 목록 조회
-     */
-    listExports(limit?: number): ExportResult[];
-    /**
-     * 내보내기 삭제
-     */
-    deleteExport(exportId: string): boolean;
-    private exportToCSV;
-    private exportToExcel;
-    private exportToPDF;
-    private exportToJSON;
-    private exportToXML;
-    private exportMetricsToCSV;
-    private exportMetricsToJSON;
-    private exportInsightsToCSV;
-    private exportInsightsToJSON;
-    private exportInsightsToPDF;
-    private generateExportId;
-}
-
-export { type AggregatedMetric, type AggregationOptions, type AggregationRule, type AggregatorConfig, type AnalyticsConfig, type AnalyticsQuery, type AnalyticsReport, type AnalyticsResult, AnalyticsService, type Anomaly, type AnomalyAlgorithm, type AnomalyDetectionConfig, AnomalyDetector, type DashboardConfig, type DashboardData, DashboardGenerator, type DashboardWidget, EventCollector, type EventCollectorConfig, type EventData, type EventProcessor, type ExportConfig, type ExportFormat, ExportManager, type ExportResult, type InsightData, InsightEngine, type KPIData, MetricAggregator, type MetricData, MetricType, MetricsCollector, type Recommendation, type RecommendationConfig, RecommendationEngine, type RecommendationRule, ReportGenerator, type ReportMetric, TimeSeriesAggregator, type TimeWindow, WebhookCollector, type WebhookCollectorConfig, type WebhookData, type WidgetData };
+ * Analytics Engine
+ * 메시지 전송 통계 및 분석 기능 제공
+ */
+export type { AggregationOptions, AggregationRule, AggregatorConfig, TimeWindow, } from "./aggregators/index";
+export { MetricAggregator, TimeSeriesAggregator } from "./aggregators/index";
+export type { EventCollectorConfig, EventData, EventProcessor, WebhookCollectorConfig, WebhookData, } from "./collectors/index";
+export { EventCollector, WebhookCollector } from "./collectors/index";
+export type { Anomaly, AnomalyAlgorithm, AnomalyDetectionConfig, Recommendation, RecommendationConfig, RecommendationRule, } from "./insights/index";
+export { AnomalyDetector, RecommendationEngine } from "./insights/index";
+export type { DashboardConfig, DashboardData, DashboardWidget, ExportConfig, ExportFormat, ExportResult, KPIData, WidgetData, } from "./reports/index";
+export { DashboardGenerator, ExportManager } from "./reports/index";
+export { AnalyticsService } from "./services/analytics.service";
+export { InsightEngine } from "./services/insight.engine";
+export { MetricsCollector } from "./services/metrics.collector";
+export { ReportGenerator } from "./services/report.generator";
+export type { AggregatedMetric, AnalyticsConfig, AnalyticsQuery, AnalyticsReport, AnalyticsResult, InsightData, MetricData, ReportMetric, } from "./types/analytics.types";
+export { MetricType } from "./types/analytics.types";