@k-msg/analytics 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -1,4497 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AnalyticsService: () => AnalyticsService,
-  AnomalyDetector: () => AnomalyDetector,
-  DashboardGenerator: () => DashboardGenerator,
-  EventCollector: () => EventCollector,
-  ExportManager: () => ExportManager,
-  InsightEngine: () => InsightEngine,
-  MetricAggregator: () => MetricAggregator,
-  MetricType: () => MetricType,
-  MetricsCollector: () => MetricsCollector,
-  RecommendationEngine: () => RecommendationEngine,
-  ReportGenerator: () => ReportGenerator,
-  TimeSeriesAggregator: () => TimeSeriesAggregator,
-  WebhookCollector: () => WebhookCollector
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/services/metrics.collector.ts
-var MetricsCollector = class {
-  config;
-  buffer = [];
-  batchSize = 1e3;
-  flushInterval = 5e3;
-  // 5초
-  storage = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-    this.startBatchProcessor();
-  }
-  /**
-   * 메트릭 수집
-   */
-  async collect(metric) {
-    this.validateMetric(metric);
-    this.buffer.push(metric);
-    if (this.buffer.length >= this.batchSize) {
-      await this.flush();
-    }
-  }
-  /**
-   * 여러 메트릭 일괄 수집
-   */
-  async collectBatch(metrics) {
-    for (const metric of metrics) {
-      await this.collect(metric);
-    }
-  }
-  /**
-   * 최근 메트릭 조회
-   */
-  async getRecentMetrics(types, durationMs) {
-    const cutoff = new Date(Date.now() - durationMs);
-    const recent = [];
-    for (const type of types) {
-      const typeKey = type.toString();
-      const metrics = this.storage.get(typeKey) || [];
-      const recentMetrics = metrics.filter((m) => m.timestamp >= cutoff);
-      recent.push(...recentMetrics);
-    }
-    return recent.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-  }
-  /**
-   * 메트릭 통계 조회
-   */
-  async getMetricStats(type, timeRange) {
-    const typeKey = type.toString();
-    const metrics = this.storage.get(typeKey) || [];
-    const filtered = metrics.filter(
-      (m) => m.timestamp >= timeRange.start && m.timestamp <= timeRange.end
-    );
-    if (filtered.length === 0) {
-      return {
-        count: 0,
-        sum: 0,
-        avg: 0,
-        min: 0,
-        max: 0
-      };
-    }
-    const values = filtered.map((m) => m.value);
-    const sum = values.reduce((acc, val) => acc + val, 0);
-    return {
-      count: filtered.length,
-      sum,
-      avg: sum / filtered.length,
-      min: Math.min(...values),
-      max: Math.max(...values)
-    };
-  }
-  /**
-   * 메트릭 카운터 증가
-   */
-  async incrementCounter(type, dimensions, value = 1) {
-    const metric = {
-      id: this.generateMetricId(),
-      type,
-      timestamp: /* @__PURE__ */ new Date(),
-      value,
-      dimensions
-    };
-    await this.collect(metric);
-  }
-  /**
-   * 메트릭 게이지 값 설정
-   */
-  async setGauge(type, dimensions, value) {
-    const metric = {
-      id: this.generateMetricId(),
-      type,
-      timestamp: /* @__PURE__ */ new Date(),
-      value,
-      dimensions
-    };
-    await this.collect(metric);
-  }
-  /**
-   * 메트릭 히스토그램 기록
-   */
-  async recordHistogram(type, dimensions, value) {
-    const metric = {
-      id: this.generateMetricId(),
-      type,
-      timestamp: /* @__PURE__ */ new Date(),
-      value,
-      dimensions,
-      metadata: {
-        metricClass: "histogram"
-      }
-    };
-    await this.collect(metric);
-  }
-  /**
-   * 메트릭 버퍼 플러시
-   */
-  async flush() {
-    if (this.buffer.length === 0) {
-      return;
-    }
-    const metrics = [...this.buffer];
-    this.buffer = [];
-    try {
-      await this.persistMetrics(metrics);
-    } catch (error) {
-      console.error("Failed to persist metrics:", error);
-      this.buffer.unshift(...metrics);
-      throw error;
-    }
-  }
-  /**
-   * 메트릭 정리 (보존 기간 초과)
-   */
-  async cleanup() {
-    const cutoff = new Date(Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1e3);
-    for (const [typeKey, metrics] of this.storage.entries()) {
-      const filtered = metrics.filter((m) => m.timestamp >= cutoff);
-      this.storage.set(typeKey, filtered);
-    }
-  }
-  validateMetric(metric) {
-    if (!metric.id) {
-      throw new Error("Metric ID is required");
-    }
-    if (!metric.type) {
-      throw new Error("Metric type is required");
-    }
-    if (typeof metric.value !== "number" || isNaN(metric.value)) {
-      throw new Error("Metric value must be a valid number");
-    }
-    if (!metric.timestamp || !(metric.timestamp instanceof Date)) {
-      throw new Error("Invalid metric timestamp");
-    }
-    if (!metric.dimensions || typeof metric.dimensions !== "object") {
-      throw new Error("Metric dimensions must be an object");
-    }
-  }
-  async persistMetrics(metrics) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const typeKey = metric.type.toString();
-      if (!grouped.has(typeKey)) {
-        grouped.set(typeKey, []);
-      }
-      grouped.get(typeKey).push(metric);
-    }
-    for (const [typeKey, typeMetrics] of grouped.entries()) {
-      const existing = this.storage.get(typeKey) || [];
-      existing.push(...typeMetrics);
-      existing.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-      if (existing.length > 1e4) {
-        existing.splice(1e4);
-      }
-      this.storage.set(typeKey, existing);
-    }
-    console.log(`Persisted ${metrics.length} metrics`);
-  }
-  startBatchProcessor() {
-    setInterval(async () => {
-      try {
-        await this.flush();
-      } catch (error) {
-        console.error("Batch processing failed:", error);
-      }
-    }, this.flushInterval);
-    setInterval(async () => {
-      try {
-        await this.cleanup();
-      } catch (error) {
-        console.error("Cleanup failed:", error);
-      }
-    }, 24 * 60 * 60 * 1e3);
-  }
-  generateMetricId() {
-    return `metric_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-};
-
-// src/types/analytics.types.ts
-var import_zod = require("zod");
-var MetricType = /* @__PURE__ */ ((MetricType2) => {
-  MetricType2["MESSAGE_SENT"] = "message_sent";
-  MetricType2["MESSAGE_DELIVERED"] = "message_delivered";
-  MetricType2["MESSAGE_FAILED"] = "message_failed";
-  MetricType2["MESSAGE_CLICKED"] = "message_clicked";
-  MetricType2["TEMPLATE_USAGE"] = "template_usage";
-  MetricType2["PROVIDER_PERFORMANCE"] = "provider_performance";
-  MetricType2["CHANNEL_USAGE"] = "channel_usage";
-  MetricType2["ERROR_RATE"] = "error_rate";
-  MetricType2["DELIVERY_RATE"] = "delivery_rate";
-  MetricType2["CLICK_RATE"] = "click_rate";
-  return MetricType2;
-})(MetricType || {});
-var MetricDataSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  type: import_zod.z.nativeEnum(MetricType),
-  timestamp: import_zod.z.date(),
-  value: import_zod.z.number(),
-  dimensions: import_zod.z.record(import_zod.z.string(), import_zod.z.string()),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional()
-});
-var AnalyticsQuerySchema = import_zod.z.object({
-  metrics: import_zod.z.array(import_zod.z.nativeEnum(MetricType)),
-  dateRange: import_zod.z.object({
-    start: import_zod.z.date(),
-    end: import_zod.z.date()
-  }),
-  interval: import_zod.z.enum(["minute", "hour", "day", "week", "month"]).optional(),
-  filters: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
-  groupBy: import_zod.z.array(import_zod.z.string()).optional(),
-  orderBy: import_zod.z.array(import_zod.z.object({
-    field: import_zod.z.string(),
-    direction: import_zod.z.enum(["asc", "desc"])
-  })).optional(),
-  limit: import_zod.z.number().min(1).max(1e4).optional(),
-  offset: import_zod.z.number().min(0).optional()
-});
-var InsightDataSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  type: import_zod.z.enum(["anomaly", "trend", "recommendation"]),
-  title: import_zod.z.string(),
-  description: import_zod.z.string(),
-  severity: import_zod.z.enum(["low", "medium", "high", "critical"]),
-  metric: import_zod.z.nativeEnum(MetricType),
-  dimensions: import_zod.z.record(import_zod.z.string(), import_zod.z.string()),
-  value: import_zod.z.number(),
-  expectedValue: import_zod.z.number().optional(),
-  confidence: import_zod.z.number().min(0).max(1),
-  actionable: import_zod.z.boolean(),
-  recommendations: import_zod.z.array(import_zod.z.string()).optional(),
-  detectedAt: import_zod.z.date()
-});
-
-// src/services/report.generator.ts
-var ReportGenerator = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * 일일 요약 보고서 생성
-   */
-  async generateDailySummary(date) {
-    const startOfDay = new Date(date);
-    startOfDay.setHours(0, 0, 0, 0);
-    const endOfDay = new Date(date);
-    endOfDay.setHours(23, 59, 59, 999);
-    const previousDay = new Date(startOfDay);
-    previousDay.setDate(previousDay.getDate() - 1);
-    return this.generateReport({
-      id: `daily_${date.toISOString().split("T")[0]}`,
-      name: `Daily Summary - ${date.toISOString().split("T")[0]}`,
-      description: "Daily messaging performance summary",
-      dateRange: { start: startOfDay, end: endOfDay },
-      filters: {},
-      metrics: await this.calculateDailyMetrics(startOfDay, endOfDay, previousDay),
-      generatedAt: /* @__PURE__ */ new Date(),
-      format: "json"
-    });
-  }
-  /**
-   * 주간 보고서 생성
-   */
-  async generateWeeklyReport(weekStartDate) {
-    const weekEnd = new Date(weekStartDate);
-    weekEnd.setDate(weekEnd.getDate() + 6);
-    const previousWeekStart = new Date(weekStartDate);
-    previousWeekStart.setDate(previousWeekStart.getDate() - 7);
-    return this.generateReport({
-      id: `weekly_${weekStartDate.toISOString().split("T")[0]}`,
-      name: `Weekly Report - Week of ${weekStartDate.toISOString().split("T")[0]}`,
-      description: "Weekly messaging performance analysis",
-      dateRange: { start: weekStartDate, end: weekEnd },
-      filters: {},
-      metrics: await this.calculateWeeklyMetrics(weekStartDate, weekEnd, previousWeekStart),
-      generatedAt: /* @__PURE__ */ new Date(),
-      format: "json"
-    });
-  }
-  /**
-   * 월간 보고서 생성
-   */
-  async generateMonthlyReport(year, month) {
-    const monthStart = new Date(year, month - 1, 1);
-    const monthEnd = new Date(year, month, 0);
-    const previousMonthStart = new Date(year, month - 2, 1);
-    const previousMonthEnd = new Date(year, month - 1, 0);
-    return this.generateReport({
-      id: `monthly_${year}_${month.toString().padStart(2, "0")}`,
-      name: `Monthly Report - ${year}-${month.toString().padStart(2, "0")}`,
-      description: "Monthly messaging performance analysis",
-      dateRange: { start: monthStart, end: monthEnd },
-      filters: {},
-      metrics: await this.calculateMonthlyMetrics(monthStart, monthEnd, previousMonthStart, previousMonthEnd),
-      generatedAt: /* @__PURE__ */ new Date(),
-      format: "json"
-    });
-  }
-  /**
-   * 프로바이더별 성능 보고서
-   */
-  async generateProviderReport(providerId, dateRange) {
-    return this.generateReport({
-      id: `provider_${providerId}_${dateRange.start.toISOString().split("T")[0]}`,
-      name: `Provider Performance - ${providerId}`,
-      description: `Performance analysis for provider ${providerId}`,
-      dateRange,
-      filters: { provider: providerId },
-      metrics: await this.calculateProviderMetrics(providerId, dateRange),
-      generatedAt: /* @__PURE__ */ new Date(),
-      format: "json"
-    });
-  }
-  /**
-   * 템플릿 사용량 보고서
-   */
-  async generateTemplateUsageReport(dateRange) {
-    return this.generateReport({
-      id: `template_usage_${dateRange.start.toISOString().split("T")[0]}`,
-      name: "Template Usage Report",
-      description: "Analysis of template usage and performance",
-      dateRange,
-      filters: {},
-      metrics: await this.calculateTemplateMetrics(dateRange),
-      generatedAt: /* @__PURE__ */ new Date(),
-      format: "json"
-    });
-  }
-  /**
-   * 커스텀 보고서 생성
-   */
-  async generateCustomReport(name, dateRange, filters, metricTypes) {
-    return this.generateReport({
-      id: `custom_${Date.now()}`,
-      name,
-      description: "Custom analytics report",
-      dateRange,
-      filters,
-      metrics: await this.calculateCustomMetrics(dateRange, filters, metricTypes),
-      generatedAt: /* @__PURE__ */ new Date(),
-      format: "json"
-    });
-  }
-  /**
-   * 보고서를 CSV 형식으로 내보내기
-   */
-  async exportToCSV(report) {
-    const headers = ["Metric Type", "Value", "Change (%)", "Trend"];
-    const rows = report.metrics.map((metric) => [
-      metric.type.toString(),
-      metric.value.toString(),
-      metric.change?.toFixed(2) || "0",
-      metric.trend || "stable"
-    ]);
-    const csvContent = [headers, ...rows].map((row) => row.map((cell) => `"${cell}"`).join(",")).join("\n");
-    return csvContent;
-  }
-  /**
-   * 보고서를 JSON 형식으로 내보내기
-   */
-  async exportToJSON(report) {
-    return JSON.stringify(report, null, 2);
-  }
-  async generateReport(reportData) {
-    this.validateReport(reportData);
-    reportData.metrics.sort((a, b) => {
-      const priority = this.getMetricPriority(a.type) - this.getMetricPriority(b.type);
-      return priority;
-    });
-    return reportData;
-  }
-  async calculateDailyMetrics(startDate, endDate, previousDate) {
-    const metrics = [];
-    const totalSent = await this.getMetricValue("message_sent" /* MESSAGE_SENT */, startDate, endDate);
-    const totalDelivered = await this.getMetricValue("message_delivered" /* MESSAGE_DELIVERED */, startDate, endDate);
-    const totalFailed = await this.getMetricValue("message_failed" /* MESSAGE_FAILED */, startDate, endDate);
-    const totalClicked = await this.getMetricValue("message_clicked" /* MESSAGE_CLICKED */, startDate, endDate);
-    const previousStart = new Date(previousDate);
-    const previousEnd = new Date(previousDate);
-    previousEnd.setHours(23, 59, 59, 999);
-    const prevSent = await this.getMetricValue("message_sent" /* MESSAGE_SENT */, previousStart, previousEnd);
-    metrics.push({
-      type: "message_sent" /* MESSAGE_SENT */,
-      value: totalSent,
-      change: this.calculateChange(totalSent, prevSent),
-      trend: this.calculateTrend(totalSent, prevSent)
-    });
-    if (totalSent > 0) {
-      const deliveryRate = totalDelivered / totalSent * 100;
-      const errorRate = totalFailed / totalSent * 100;
-      metrics.push({
-        type: "delivery_rate" /* DELIVERY_RATE */,
-        value: deliveryRate,
-        change: 0,
-        // TODO: 이전 기간과 비교
-        trend: "stable"
-      });
-      metrics.push({
-        type: "error_rate" /* ERROR_RATE */,
-        value: errorRate,
-        change: 0,
-        // TODO: 이전 기간과 비교
-        trend: "stable"
-      });
-    }
-    if (totalDelivered > 0) {
-      const clickRate = totalClicked / totalDelivered * 100;
-      metrics.push({
-        type: "click_rate" /* CLICK_RATE */,
-        value: clickRate,
-        change: 0,
-        // TODO: 이전 기간과 비교
-        trend: "stable"
-      });
-    }
-    return metrics;
-  }
-  async calculateWeeklyMetrics(weekStart, weekEnd, previousWeekStart) {
-    return this.calculateDailyMetrics(weekStart, weekEnd, previousWeekStart);
-  }
-  async calculateMonthlyMetrics(monthStart, monthEnd, previousMonthStart, previousMonthEnd) {
-    return this.calculateDailyMetrics(monthStart, monthEnd, previousMonthStart);
-  }
-  async calculateProviderMetrics(providerId, dateRange) {
-    const metrics = [];
-    const performance = await this.getProviderPerformance(providerId, dateRange);
-    metrics.push({
-      type: "provider_performance" /* PROVIDER_PERFORMANCE */,
-      value: performance.averageResponseTime,
-      breakdown: {
-        "Success Rate": performance.successRate,
-        "Error Rate": performance.errorRate,
-        "Avg Response Time": performance.averageResponseTime
-      }
-    });
-    return metrics;
-  }
-  async calculateTemplateMetrics(dateRange) {
-    const metrics = [];
-    const templateUsage = await this.getTemplateUsage(dateRange);
-    metrics.push({
-      type: "template_usage" /* TEMPLATE_USAGE */,
-      value: templateUsage.totalUsage,
-      breakdown: templateUsage.byTemplate
-    });
-    return metrics;
-  }
-  async calculateCustomMetrics(dateRange, filters, metricTypes) {
-    const metrics = [];
-    for (const type of metricTypes) {
-      const value = await this.getMetricValue(type, dateRange.start, dateRange.end, filters);
-      metrics.push({
-        type,
-        value,
-        change: 0,
-        // TODO: 이전 기간과 비교
-        trend: "stable"
-      });
-    }
-    return metrics;
-  }
-  async getMetricValue(type, start, end, filters) {
-    return Math.floor(Math.random() * 1e4);
-  }
-  async getProviderPerformance(providerId, dateRange) {
-    return {
-      successRate: 95.5,
-      errorRate: 4.5,
-      averageResponseTime: 250
-      // ms
-    };
-  }
-  async getTemplateUsage(dateRange) {
-    return {
-      totalUsage: 5e3,
-      byTemplate: {
-        "auth_otp": 2e3,
-        "welcome": 1500,
-        "notification": 1e3,
-        "others": 500
-      }
-    };
-  }
-  calculateChange(current, previous) {
-    if (previous === 0) return current > 0 ? 100 : 0;
-    return (current - previous) / previous * 100;
-  }
-  calculateTrend(current, previous) {
-    const change = this.calculateChange(current, previous);
-    if (Math.abs(change) < 5) return "stable";
-    return change > 0 ? "up" : "down";
-  }
-  getMetricPriority(type) {
-    const priorities = {
-      ["message_sent" /* MESSAGE_SENT */]: 1,
-      ["delivery_rate" /* DELIVERY_RATE */]: 2,
-      ["error_rate" /* ERROR_RATE */]: 3,
-      ["click_rate" /* CLICK_RATE */]: 4,
-      ["message_delivered" /* MESSAGE_DELIVERED */]: 5,
-      ["message_failed" /* MESSAGE_FAILED */]: 6,
-      ["message_clicked" /* MESSAGE_CLICKED */]: 7,
-      ["template_usage" /* TEMPLATE_USAGE */]: 8,
-      ["provider_performance" /* PROVIDER_PERFORMANCE */]: 9,
-      ["channel_usage" /* CHANNEL_USAGE */]: 10
-    };
-    return priorities[type] || 99;
-  }
-  validateReport(report) {
-    if (!report.id) {
-      throw new Error("Report ID is required");
-    }
-    if (!report.name) {
-      throw new Error("Report name is required");
-    }
-    if (!report.dateRange || !report.dateRange.start || !report.dateRange.end) {
-      throw new Error("Valid date range is required");
-    }
-    if (report.dateRange.start >= report.dateRange.end) {
-      throw new Error("Invalid date range: start must be before end");
-    }
-  }
-};
-
-// src/services/insight.engine.ts
-var InsightEngine = class {
-  config;
-  anomalyThresholds = /* @__PURE__ */ new Map();
-  historicalData = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-    this.initializeBaselines();
-  }
-  /**
-   * 실시간 이상 탐지
-   */
-  async detectRealTimeAnomalies(metric) {
-    const insights = [];
-    const threshold = this.anomalyThresholds.get(metric.type);
-    if (!threshold) {
-      return insights;
-    }
-    if (metric.value > threshold.max || metric.value < threshold.min) {
-      insights.push({
-        id: `anomaly_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        type: "anomaly",
-        title: `${metric.type} Anomaly Detected`,
-        description: `Value ${metric.value} is outside normal range [${threshold.min}, ${threshold.max}]`,
-        severity: this.calculateSeverity(metric.value, threshold),
-        metric: metric.type,
-        dimensions: metric.dimensions,
-        value: metric.value,
-        expectedValue: (threshold.min + threshold.max) / 2,
-        confidence: this.calculateConfidence(metric.value, threshold),
-        actionable: true,
-        recommendations: this.generateRecommendations(metric),
-        detectedAt: /* @__PURE__ */ new Date()
-      });
-    }
-    const recentTrend = await this.detectTrendChange(metric);
-    if (recentTrend) {
-      insights.push(recentTrend);
-    }
-    return insights;
-  }
-  /**
-   * 시계열 이상 탐지
-   */
-  async detectAnomalies(metricType, timeRange) {
-    const insights = [];
-    const seasonalAnomalies = await this.detectSeasonalAnomalies(metricType, timeRange);
-    insights.push(...seasonalAnomalies);
-    const patternAnomalies = await this.detectPatternAnomalies(metricType, timeRange);
-    insights.push(...patternAnomalies);
-    const thresholdAnomalies = await this.detectThresholdAnomalies(metricType, timeRange);
-    insights.push(...thresholdAnomalies);
-    return insights;
-  }
-  /**
-   * 인사이트 생성
-   */
-  async generateInsights(query, data) {
-    const insights = [];
-    const performanceInsights = await this.generatePerformanceInsights(data);
-    insights.push(...performanceInsights);
-    const trendInsights = await this.generateTrendInsights(data);
-    insights.push(...trendInsights);
-    const comparisonInsights = await this.generateComparisonInsights(data);
-    insights.push(...comparisonInsights);
-    const recommendationInsights = await this.generateRecommendationInsights(data);
-    insights.push(...recommendationInsights);
-    return insights.sort((a, b) => {
-      const severityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
-      return severityOrder[b.severity] - severityOrder[a.severity];
-    });
-  }
-  /**
-   * 트렌드 예측
-   */
-  async predictTrends(metricType, forecastDays) {
-    const historical = this.historicalData.get(metricType) || [];
-    if (historical.length < 7) {
-      return [];
-    }
-    const predictions = [];
-    const lastValue = historical[historical.length - 1];
-    const trend = this.calculateTrend(historical);
-    for (let i = 1; i <= forecastDays; i++) {
-      const predictedValue = lastValue + trend * i;
-      const confidence = Math.max(0.1, 1 - i * 0.1);
-      predictions.push({
-        date: new Date(Date.now() + i * 24 * 60 * 60 * 1e3),
-        predicted: Math.max(0, predictedValue),
-        confidence
-      });
-    }
-    return predictions;
-  }
-  async initializeBaselines() {
-    this.anomalyThresholds.set("message_sent" /* MESSAGE_SENT */, { min: 0, max: 1e4, stdDev: 500 });
-    this.anomalyThresholds.set("message_delivered" /* MESSAGE_DELIVERED */, { min: 0, max: 1e4, stdDev: 500 });
-    this.anomalyThresholds.set("message_failed" /* MESSAGE_FAILED */, { min: 0, max: 1e3, stdDev: 100 });
-    this.anomalyThresholds.set("delivery_rate" /* DELIVERY_RATE */, { min: 85, max: 99, stdDev: 5 });
-    this.anomalyThresholds.set("error_rate" /* ERROR_RATE */, { min: 0, max: 15, stdDev: 3 });
-  }
-  async detectTrendChange(metric) {
-    const history = this.historicalData.get(metric.type) || [];
-    history.push(metric.value);
-    if (history.length > 5) {
-      history.shift();
-    }
-    this.historicalData.set(metric.type, history);
-    if (history.length < 3) {
-      return null;
-    }
-    const recentChange = (history[history.length - 1] - history[history.length - 2]) / history[history.length - 2];
-    if (Math.abs(recentChange) > 0.5) {
-      return {
-        id: `trend_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        type: "trend",
-        title: `Sudden ${recentChange > 0 ? "Increase" : "Decrease"} in ${metric.type}`,
-        description: `${metric.type} changed by ${(recentChange * 100).toFixed(1)}% in the last period`,
-        severity: Math.abs(recentChange) > 0.8 ? "high" : "medium",
-        metric: metric.type,
-        dimensions: metric.dimensions,
-        value: metric.value,
-        expectedValue: history[history.length - 2],
-        confidence: 0.8,
-        actionable: true,
-        recommendations: [`Monitor ${metric.type} closely`, "Check for system changes or external factors"],
-        detectedAt: /* @__PURE__ */ new Date()
-      };
-    }
-    return null;
-  }
-  async detectSeasonalAnomalies(metricType, timeRange) {
-    const insights = [];
-    const isWeekend = timeRange.start.getDay() === 0 || timeRange.start.getDay() === 6;
-    const currentHour = timeRange.start.getHours();
-    if (!isWeekend && (currentHour < 6 || currentHour > 22)) {
-      insights.push({
-        id: `seasonal_${Date.now()}`,
-        type: "anomaly",
-        title: "Unusual Activity During Off-Hours",
-        description: `High ${metricType} activity detected during off-business hours`,
-        severity: "medium",
-        metric: metricType,
-        dimensions: { timeframe: "off_hours" },
-        value: 0,
-        // 실제 값으로 대체
-        confidence: 0.7,
-        actionable: true,
-        recommendations: ["Check for automated systems or bulk operations", "Verify if this is expected behavior"],
-        detectedAt: /* @__PURE__ */ new Date()
-      });
-    }
-    return insights;
-  }
-  async detectPatternAnomalies(metricType, timeRange) {
-    return [];
-  }
-  async detectThresholdAnomalies(metricType, timeRange) {
-    return [];
-  }
-  async generatePerformanceInsights(data) {
-    const insights = [];
-    const deliveryMetrics = data.filter((d) => d.type === "delivery_rate" /* DELIVERY_RATE */);
-    for (const metric of deliveryMetrics) {
-      if (metric.aggregations.avg < 90) {
-        insights.push({
-          id: `performance_delivery_${Date.now()}`,
-          type: "recommendation",
-          title: "Low Delivery Rate Detected",
-          description: `Delivery rate of ${metric.aggregations.avg.toFixed(1)}% is below optimal threshold`,
-          severity: metric.aggregations.avg < 80 ? "high" : "medium",
-          metric: "delivery_rate" /* DELIVERY_RATE */,
-          dimensions: metric.dimensions,
-          value: metric.aggregations.avg,
-          expectedValue: 95,
-          confidence: 0.9,
-          actionable: true,
-          recommendations: [
-            "Check provider API status",
-            "Review template approval status",
-            "Verify recipient phone numbers",
-            "Consider switching to backup provider"
-          ],
-          detectedAt: /* @__PURE__ */ new Date()
-        });
-      }
-    }
-    return insights;
-  }
-  async generateTrendInsights(data) {
-    const insights = [];
-    const sentMetrics = data.filter((d) => d.type === "message_sent" /* MESSAGE_SENT */).sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    if (sentMetrics.length >= 3) {
-      const trend = this.calculateTrend(sentMetrics.map((m) => m.aggregations.sum));
-      if (Math.abs(trend) > 100) {
-        insights.push({
-          id: `trend_sent_${Date.now()}`,
-          type: "trend",
-          title: `${trend > 0 ? "Increasing" : "Decreasing"} Message Volume`,
-          description: `Message volume is ${trend > 0 ? "increasing" : "decreasing"} by approximately ${Math.abs(trend).toFixed(0)} messages per day`,
-          severity: "low",
-          metric: "message_sent" /* MESSAGE_SENT */,
-          dimensions: {},
-          value: sentMetrics[sentMetrics.length - 1].aggregations.sum,
-          confidence: 0.7,
-          actionable: trend < -500,
-          // 급격한 감소시에만 액션 필요
-          recommendations: trend < -500 ? [
-            "Investigate cause of volume decrease",
-            "Check for system issues or campaign changes"
-          ] : void 0,
-          detectedAt: /* @__PURE__ */ new Date()
-        });
-      }
-    }
-    return insights;
-  }
-  async generateComparisonInsights(data) {
-    const insights = [];
-    const providerPerformance = /* @__PURE__ */ new Map();
-    for (const metric of data) {
-      const provider = metric.dimensions.provider;
-      if (!provider) continue;
-      if (!providerPerformance.has(provider)) {
-        providerPerformance.set(provider, { delivered: 0, sent: 0 });
-      }
-      const stats = providerPerformance.get(provider);
-      if (metric.type === "message_sent" /* MESSAGE_SENT */) {
-        stats.sent += metric.aggregations.sum;
-      } else if (metric.type === "message_delivered" /* MESSAGE_DELIVERED */) {
-        stats.delivered += metric.aggregations.sum;
-      }
-    }
-    const providers = Array.from(providerPerformance.entries());
-    if (providers.length > 1) {
-      const rates = providers.map(([provider, stats]) => ({
-        provider,
-        rate: stats.sent > 0 ? stats.delivered / stats.sent * 100 : 0,
-        volume: stats.sent
-      }));
-      const avgRate = rates.reduce((sum, r) => sum + r.rate, 0) / rates.length;
-      const underperforming = rates.filter((r) => r.rate < avgRate - 10);
-      for (const provider of underperforming) {
-        insights.push({
-          id: `comparison_provider_${provider.provider}_${Date.now()}`,
-          type: "recommendation",
-          title: `Provider ${provider.provider} Underperforming`,
-          description: `${provider.provider} delivery rate (${provider.rate.toFixed(1)}%) is significantly below average (${avgRate.toFixed(1)}%)`,
-          severity: provider.rate < avgRate - 20 ? "high" : "medium",
-          metric: "provider_performance" /* PROVIDER_PERFORMANCE */,
-          dimensions: { provider: provider.provider },
-          value: provider.rate,
-          expectedValue: avgRate,
-          confidence: 0.8,
-          actionable: true,
-          recommendations: [
-            `Contact ${provider.provider} support team`,
-            "Consider reducing traffic to this provider",
-            "Check provider-specific settings and configurations"
-          ],
-          detectedAt: /* @__PURE__ */ new Date()
-        });
-      }
-    }
-    return insights;
-  }
-  async generateRecommendationInsights(data) {
-    const insights = [];
-    const channelUsage = /* @__PURE__ */ new Map();
-    for (const metric of data) {
-      if (metric.type === "channel_usage" /* CHANNEL_USAGE */) {
-        const channel = metric.dimensions.channel;
-        if (channel) {
-          channelUsage.set(channel, (channelUsage.get(channel) || 0) + metric.aggregations.sum);
-        }
-      }
-    }
-    const totalUsage = Array.from(channelUsage.values()).reduce((sum, usage) => sum + usage, 0);
-    if (totalUsage > 0) {
-      const smsUsage = channelUsage.get("sms") || 0;
-      const alimtalkUsage = channelUsage.get("alimtalk") || 0;
-      if (smsUsage / totalUsage > 0.3 && alimtalkUsage > 0) {
-        insights.push({
-          id: `recommendation_channel_${Date.now()}`,
-          type: "recommendation",
-          title: "Consider Switching to AlimTalk",
-          description: `${(smsUsage / totalUsage * 100).toFixed(1)}% of messages are sent via SMS. AlimTalk could reduce costs`,
-          severity: "low",
-          metric: "channel_usage" /* CHANNEL_USAGE */,
-          dimensions: { optimization: "cost" },
-          value: smsUsage,
-          confidence: 0.8,
-          actionable: true,
-          recommendations: [
-            "Evaluate message types suitable for AlimTalk conversion",
-            "Create AlimTalk templates for common SMS use cases",
-            "Implement fallback logic for failed AlimTalk messages"
-          ],
-          detectedAt: /* @__PURE__ */ new Date()
-        });
-      }
-    }
-    return insights;
-  }
-  calculateSeverity(value, threshold) {
-    const distance = Math.min(
-      Math.abs(value - threshold.min) / threshold.stdDev,
-      Math.abs(value - threshold.max) / threshold.stdDev
-    );
-    if (distance > 3) return "critical";
-    if (distance > 2) return "high";
-    if (distance > 1) return "medium";
-    return "low";
-  }
-  calculateConfidence(value, threshold) {
-    const distance = Math.min(
-      Math.abs(value - threshold.min) / threshold.stdDev,
-      Math.abs(value - threshold.max) / threshold.stdDev
-    );
-    return Math.min(0.99, 0.5 + distance * 0.15);
-  }
-  generateRecommendations(metric) {
-    const recommendations = [];
-    switch (metric.type) {
-      case "message_failed" /* MESSAGE_FAILED */:
-        recommendations.push(
-          "Check provider API status and connectivity",
-          "Verify template approval status",
-          "Validate recipient phone numbers",
-          "Review message content for compliance"
-        );
-        break;
-      case "delivery_rate" /* DELIVERY_RATE */:
-        recommendations.push(
-          "Monitor provider performance metrics",
-          "Check for network connectivity issues",
-          "Verify recipient opt-in status"
-        );
-        break;
-      case "error_rate" /* ERROR_RATE */:
-        recommendations.push(
-          "Investigate error patterns and root causes",
-          "Implement retry mechanisms for transient failures",
-          "Consider switching to backup provider"
-        );
-        break;
-      default:
-        recommendations.push(
-          "Monitor the metric closely",
-          "Investigate potential causes",
-          "Check system health and performance"
-        );
-    }
-    return recommendations;
-  }
-  calculateTrend(values) {
-    if (values.length < 2) return 0;
-    const n = values.length;
-    const x = Array.from({ length: n }, (_, i) => i);
-    const sumX = x.reduce((a, b) => a + b, 0);
-    const sumY = values.reduce((a, b) => a + b, 0);
-    const sumXY = x.reduce((sum, xi, i) => sum + xi * values[i], 0);
-    const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
-    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-    return slope;
-  }
-};
-
-// src/services/analytics.service.ts
-var AnalyticsService = class {
-  config;
-  metricsCollector;
-  reportGenerator;
-  insightEngine;
-  metrics = /* @__PURE__ */ new Map();
-  aggregatedMetrics = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-    this.metricsCollector = new MetricsCollector(config);
-    this.reportGenerator = new ReportGenerator(config);
-    this.insightEngine = new InsightEngine(config);
-    this.startAggregationTasks();
-  }
-  /**
-   * 메트릭 데이터 수집
-   */
-  async collectMetric(metric) {
-    if (!this.config.enabledMetrics.includes(metric.type)) {
-      return;
-    }
-    await this.metricsCollector.collect(metric);
-    if (this.config.enableRealTimeTracking) {
-      await this.processRealTimeMetric(metric);
-    }
-  }
-  /**
-   * 분석 쿼리 실행
-   */
-  async query(query) {
-    const startTime = Date.now();
-    this.validateQuery(query);
-    const data = await this.executeQuery(query);
-    const insights = await this.generateInsights(query, data);
-    const executionTime = Date.now() - startTime;
-    return {
-      query,
-      data,
-      summary: {
-        totalRecords: data.length,
-        dateRange: query.dateRange,
-        executionTime
-      },
-      insights
-    };
-  }
-  /**
-   * 실시간 메트릭 스트림
-   */
-  async *streamMetrics(types) {
-    while (true) {
-      const metrics = await this.metricsCollector.getRecentMetrics(types, 1e3);
-      for (const metric of metrics) {
-        yield metric;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-    }
-  }
-  /**
-   * 대시보드 데이터 조회
-   */
-  async getDashboardData(timeRange) {
-    const now = /* @__PURE__ */ new Date();
-    const previousPeriod = {
-      start: new Date(timeRange.start.getTime() - (timeRange.end.getTime() - timeRange.start.getTime())),
-      end: timeRange.start
-    };
-    const currentData = await this.query({
-      metrics: this.config.enabledMetrics,
-      dateRange: timeRange,
-      interval: this.getOptimalInterval(timeRange),
-      groupBy: ["provider", "channel"]
-    });
-    const previousData = await this.query({
-      metrics: this.config.enabledMetrics,
-      dateRange: previousPeriod,
-      interval: this.getOptimalInterval(timeRange),
-      groupBy: ["provider", "channel"]
-    });
-    const kpis = this.calculateKPIs(currentData.data, previousData.data);
-    return {
-      timeRange,
-      kpis,
-      metrics: currentData.data,
-      insights: currentData.insights,
-      trends: this.calculateTrends(currentData.data, previousData.data)
-    };
-  }
-  /**
-   * 이상 탐지
-   */
-  async detectAnomalies(metricType, timeRange) {
-    return this.insightEngine.detectAnomalies(metricType, timeRange);
-  }
-  async processRealTimeMetric(metric) {
-    const anomalies = await this.insightEngine.detectRealTimeAnomalies(metric);
-    if (anomalies.length > 0) {
-      await this.notifyAnomalies(anomalies);
-    }
-  }
-  validateQuery(query) {
-    if (query.dateRange.start >= query.dateRange.end) {
-      throw new Error("Invalid date range: start must be before end");
-    }
-    const maxRangeMs = 90 * 24 * 60 * 60 * 1e3;
-    if (query.dateRange.end.getTime() - query.dateRange.start.getTime() > maxRangeMs) {
-      throw new Error("Date range too large: maximum 90 days");
-    }
-    if (query.limit && query.limit > 1e4) {
-      throw new Error("Limit too large: maximum 10000 records");
-    }
-  }
-  async executeQuery(query) {
-    const interval = query.interval || this.getOptimalInterval(query.dateRange);
-    const cacheKey = this.generateCacheKey(query);
-    if (this.aggregatedMetrics.has(cacheKey)) {
-      return this.aggregatedMetrics.get(cacheKey);
-    }
-    const aggregated = await this.performAggregation(query, interval);
-    this.aggregatedMetrics.set(cacheKey, aggregated);
-    return aggregated;
-  }
-  async performAggregation(query, interval) {
-    return [];
-  }
-  async generateInsights(query, data) {
-    return this.insightEngine.generateInsights(query, data);
-  }
-  getOptimalInterval(dateRange) {
-    const durationMs = dateRange.end.getTime() - dateRange.start.getTime();
-    const durationDays = durationMs / (24 * 60 * 60 * 1e3);
-    if (durationDays <= 1) return "minute";
-    if (durationDays <= 7) return "hour";
-    if (durationDays <= 30) return "day";
-    if (durationDays <= 90) return "week";
-    return "month";
-  }
-  calculateKPIs(current, previous) {
-    return {
-      totalMessages: this.sumMetrics(current, "message_sent"),
-      deliveryRate: this.calculateRate(current, "message_delivered", "message_sent"),
-      errorRate: this.calculateRate(current, "message_failed", "message_sent"),
-      clickRate: this.calculateRate(current, "message_clicked", "message_delivered")
-    };
-  }
-  calculateTrends(current, previous) {
-    return {};
-  }
-  sumMetrics(metrics, type) {
-    return metrics.filter((m) => m.type.toString() === type).reduce((sum, m) => sum + m.aggregations.sum, 0);
-  }
-  calculateRate(metrics, numerator, denominator) {
-    const num = this.sumMetrics(metrics, numerator);
-    const den = this.sumMetrics(metrics, denominator);
-    return den > 0 ? num / den * 100 : 0;
-  }
-  generateCacheKey(query) {
-    return JSON.stringify({
-      metrics: query.metrics.sort(),
-      dateRange: query.dateRange,
-      interval: query.interval,
-      filters: query.filters,
-      groupBy: query.groupBy?.sort()
-    });
-  }
-  startAggregationTasks() {
-    for (const interval of this.config.aggregationIntervals) {
-      this.scheduleAggregation(interval);
-    }
-  }
-  scheduleAggregation(interval) {
-    const scheduleMs = this.getScheduleInterval(interval);
-    setInterval(async () => {
-      try {
-        await this.runAggregation(interval);
-      } catch (error) {
-        console.error(`Aggregation failed for interval ${interval}:`, error);
-      }
-    }, scheduleMs);
-  }
-  getScheduleInterval(interval) {
-    switch (interval) {
-      case "minute":
-        return 60 * 1e3;
-      case "hour":
-        return 60 * 60 * 1e3;
-      case "day":
-        return 24 * 60 * 60 * 1e3;
-      case "week":
-        return 7 * 24 * 60 * 60 * 1e3;
-      case "month":
-        return 30 * 24 * 60 * 60 * 1e3;
-      default:
-        return 60 * 60 * 1e3;
-    }
-  }
-  async runAggregation(interval) {
-    console.log(`Running ${interval} aggregation...`);
-  }
-  async notifyAnomalies(anomalies) {
-    for (const anomaly of anomalies) {
-      if (anomaly.severity === "critical" || anomaly.severity === "high") {
-        console.warn("Anomaly detected:", anomaly);
-      }
-    }
-  }
-};
-
-// src/aggregators/time-series.aggregator.ts
-var TimeSeriesAggregator = class {
-  timezone;
-  constructor(timezone = "UTC") {
-    this.timezone = timezone;
-  }
-  /**
-   * 시계열 데이터를 지정된 간격으로 집계
-   */
-  async aggregate(metrics, interval, options = { fillGaps: false, fillValue: 0 }) {
-    if (metrics.length === 0) {
-      return [];
-    }
-    const groupedByType = this.groupByType(metrics);
-    const aggregated = [];
-    for (const [type, typeMetrics] of groupedByType.entries()) {
-      const groupedByDimensions = this.groupByDimensions(typeMetrics);
-      for (const [dimensionKey, dimensionMetrics] of groupedByDimensions.entries()) {
-        const typeAggregated = await this.aggregateByInterval(
-          dimensionMetrics,
-          type,
-          interval,
-          JSON.parse(dimensionKey),
-          options
-        );
-        aggregated.push(...typeAggregated);
-      }
-    }
-    return aggregated.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-  }
-  /**
-   * 롤링 윈도우 집계
-   */
-  async aggregateRolling(metrics, windowSize, step = windowSize) {
-    if (metrics.length === 0) {
-      return [];
-    }
-    const sortedMetrics = [...metrics].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    const startTime = sortedMetrics[0].timestamp;
-    const endTime = sortedMetrics[sortedMetrics.length - 1].timestamp;
-    const aggregated = [];
-    const windowMs = windowSize * 60 * 1e3;
-    const stepMs = step * 60 * 1e3;
-    let currentTime = startTime.getTime();
-    const endTimeMs = endTime.getTime();
-    while (currentTime <= endTimeMs) {
-      const windowStart = new Date(currentTime);
-      const windowEnd = new Date(currentTime + windowMs);
-      const windowMetrics = sortedMetrics.filter(
-        (m) => m.timestamp >= windowStart && m.timestamp < windowEnd
-      );
-      if (windowMetrics.length > 0) {
-        const windowAggregated = await this.aggregateWindow(windowMetrics, windowStart);
-        aggregated.push(...windowAggregated);
-      }
-      currentTime += stepMs;
-    }
-    return aggregated;
-  }
-  /**
-   * 계절성 분해 (간단한 이동평균 기반)
-   */
-  async decomposeSeasonality(metrics, seasonLength = 24) {
-    if (metrics.length < seasonLength * 2) {
-      return { trend: [], seasonal: [], residual: [] };
-    }
-    const sortedMetrics = [...metrics].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    const trend = this.calculateMovingAverage(sortedMetrics, seasonLength);
-    const seasonal = this.calculateSeasonalComponent(sortedMetrics, trend, seasonLength);
-    const residual = this.calculateResidual(sortedMetrics, trend, seasonal);
-    return { trend, seasonal, residual };
-  }
-  /**
-   * 다운샘플링 (고해상도 → 저해상도)
-   */
-  async downsample(metrics, targetInterval) {
-    const groupedByTime = this.groupByTimeInterval(metrics, targetInterval);
-    const downsampled = [];
-    for (const [timeKey, timeMetrics] of groupedByTime.entries()) {
-      const timestamp = new Date(timeKey);
-      const grouped = /* @__PURE__ */ new Map();
-      for (const metric of timeMetrics) {
-        const typeKey = metric.type.toString();
-        const dimensionKey = JSON.stringify(metric.dimensions);
-        if (!grouped.has(typeKey)) {
-          grouped.set(typeKey, /* @__PURE__ */ new Map());
-        }
-        if (!grouped.get(typeKey).has(dimensionKey)) {
-          grouped.get(typeKey).set(dimensionKey, []);
-        }
-        grouped.get(typeKey).get(dimensionKey).push(metric);
-      }
-      for (const [typeKey, typeGroups] of grouped.entries()) {
-        for (const [dimensionKey, dimensionMetrics] of typeGroups.entries()) {
-          const aggregations = this.calculateAggregations(dimensionMetrics.map((m) => m.aggregations.sum));
-          downsampled.push({
-            type: dimensionMetrics[0].type,
-            interval: targetInterval,
-            timestamp,
-            dimensions: JSON.parse(dimensionKey),
-            aggregations
-          });
-        }
-      }
-    }
-    return downsampled.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-  }
-  groupByType(metrics) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      if (!grouped.has(metric.type)) {
-        grouped.set(metric.type, []);
-      }
-      grouped.get(metric.type).push(metric);
-    }
-    return grouped;
-  }
-  groupByDimensions(metrics) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const key = JSON.stringify(metric.dimensions);
-      if (!grouped.has(key)) {
-        grouped.set(key, []);
-      }
-      grouped.get(key).push(metric);
-    }
-    return grouped;
-  }
-  async aggregateByInterval(metrics, type, interval, dimensions, options) {
-    const grouped = this.groupByTimeInterval(metrics, interval);
-    const aggregated = [];
-    if (options.fillGaps && grouped.size > 0) {
-      const timeKeys = Array.from(grouped.keys()).sort((a, b) => new Date(a).getTime() - new Date(b).getTime());
-      const filledGroups = this.fillTimeGaps(timeKeys, interval, options.fillValue);
-      for (const [timeKey, defaultValue] of filledGroups.entries()) {
-        if (!grouped.has(timeKey)) {
-          grouped.set(timeKey, [{
-            id: `filled_${Date.now()}`,
-            type,
-            timestamp: new Date(timeKey),
-            value: defaultValue,
-            dimensions
-          }]);
-        }
-      }
-    }
-    for (const [timeKey, timeMetrics] of grouped.entries()) {
-      const timestamp = new Date(timeKey);
-      const values = timeMetrics.map((m) => m.value);
-      const aggregations = this.calculateAggregations(values);
-      aggregated.push({
-        type,
-        interval,
-        timestamp,
-        dimensions,
-        aggregations
-      });
-    }
-    return aggregated;
-  }
-  groupByTimeInterval(metrics, interval) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const timeKey = this.getTimeIntervalKey(metric.timestamp, interval);
-      if (!grouped.has(timeKey)) {
-        grouped.set(timeKey, []);
-      }
-      grouped.get(timeKey).push(metric);
-    }
-    return grouped;
-  }
-  getTimeIntervalKey(timestamp, interval) {
-    const date = new Date(timestamp);
-    switch (interval) {
-      case "minute":
-        date.setSeconds(0, 0);
-        break;
-      case "hour":
-        date.setMinutes(0, 0, 0);
-        break;
-      case "day":
-        date.setHours(0, 0, 0, 0);
-        break;
-      case "week":
-        const dayOfWeek = date.getDay();
-        const diff = date.getDate() - dayOfWeek;
-        date.setDate(diff);
-        date.setHours(0, 0, 0, 0);
-        break;
-      case "month":
-        date.setDate(1);
-        date.setHours(0, 0, 0, 0);
-        break;
-    }
-    return date.toISOString();
-  }
-  fillTimeGaps(timeKeys, interval, fillValue) {
-    const filled = /* @__PURE__ */ new Map();
-    if (timeKeys.length < 2) {
-      return filled;
-    }
-    const start = new Date(timeKeys[0]);
-    const end = new Date(timeKeys[timeKeys.length - 1]);
-    let current = new Date(start);
-    while (current <= end) {
-      const key = current.toISOString();
-      filled.set(key, fillValue);
-      switch (interval) {
-        case "minute":
-          current.setMinutes(current.getMinutes() + 1);
-          break;
-        case "hour":
-          current.setHours(current.getHours() + 1);
-          break;
-        case "day":
-          current.setDate(current.getDate() + 1);
-          break;
-        case "week":
-          current.setDate(current.getDate() + 7);
-          break;
-        case "month":
-          current.setMonth(current.getMonth() + 1);
-          break;
-      }
-    }
-    return filled;
-  }
-  calculateAggregations(values) {
-    if (values.length === 0) {
-      return { count: 0, sum: 0, avg: 0, min: 0, max: 0 };
-    }
-    const sum = values.reduce((acc, val) => acc + val, 0);
-    const count = values.length;
-    const avg = sum / count;
-    const min = Math.min(...values);
-    const max = Math.max(...values);
-    return { count, sum, avg, min, max };
-  }
-  async aggregateWindow(metrics, windowStart) {
-    const grouped = this.groupByType(metrics);
-    const aggregated = [];
-    for (const [type, typeMetrics] of grouped.entries()) {
-      const dimensionGroups = this.groupByDimensions(typeMetrics);
-      for (const [dimensionKey, dimensionMetrics] of dimensionGroups.entries()) {
-        const values = dimensionMetrics.map((m) => m.value);
-        const aggregations = this.calculateAggregations(values);
-        aggregated.push({
-          type,
-          interval: "minute",
-          // 롤링 윈도우는 분 단위로 처리
-          timestamp: windowStart,
-          dimensions: JSON.parse(dimensionKey),
-          aggregations
-        });
-      }
-    }
-    return aggregated;
-  }
-  calculateMovingAverage(metrics, windowSize) {
-    const trend = [];
-    for (let i = Math.floor(windowSize / 2); i < metrics.length - Math.floor(windowSize / 2); i++) {
-      const window = metrics.slice(i - Math.floor(windowSize / 2), i + Math.floor(windowSize / 2) + 1);
-      const avgValue = window.reduce((sum, m) => sum + m.aggregations.avg, 0) / window.length;
-      trend.push({
-        ...metrics[i],
-        aggregations: {
-          ...metrics[i].aggregations,
-          avg: avgValue,
-          sum: avgValue * metrics[i].aggregations.count
-        }
-      });
-    }
-    return trend;
-  }
-  calculateSeasonalComponent(metrics, trend, seasonLength) {
-    const seasonal = [];
-    const seasonalPattern = new Array(seasonLength).fill(0);
-    const seasonalCounts = new Array(seasonLength).fill(0);
-    for (let i = 0; i < metrics.length; i++) {
-      const seasonIndex = i % seasonLength;
-      const trendValue = trend.find((t) => t.timestamp.getTime() === metrics[i].timestamp.getTime());
-      if (trendValue) {
-        seasonalPattern[seasonIndex] += metrics[i].aggregations.avg - trendValue.aggregations.avg;
-        seasonalCounts[seasonIndex]++;
-      }
-    }
-    for (let i = 0; i < seasonLength; i++) {
-      if (seasonalCounts[i] > 0) {
-        seasonalPattern[i] /= seasonalCounts[i];
-      }
-    }
-    for (let i = 0; i < metrics.length; i++) {
-      const seasonIndex = i % seasonLength;
-      seasonal.push({
-        ...metrics[i],
-        aggregations: {
-          ...metrics[i].aggregations,
-          avg: seasonalPattern[seasonIndex],
-          sum: seasonalPattern[seasonIndex] * metrics[i].aggregations.count
-        }
-      });
-    }
-    return seasonal;
-  }
-  calculateResidual(original, trend, seasonal) {
-    const residual = [];
-    for (let i = 0; i < original.length; i++) {
-      const trendValue = trend.find((t) => t.timestamp.getTime() === original[i].timestamp.getTime());
-      const seasonalValue = seasonal[i];
-      let residualValue = original[i].aggregations.avg;
-      if (trendValue) {
-        residualValue -= trendValue.aggregations.avg;
-      }
-      if (seasonalValue) {
-        residualValue -= seasonalValue.aggregations.avg;
-      }
-      residual.push({
-        ...original[i],
-        aggregations: {
-          ...original[i].aggregations,
-          avg: residualValue,
-          sum: residualValue * original[i].aggregations.count
-        }
-      });
-    }
-    return residual;
-  }
-};
-
-// src/aggregators/metric.aggregator.ts
-var MetricAggregator = class {
-  config;
-  buffer = /* @__PURE__ */ new Map();
-  aggregationCache = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.config = config;
-    this.startPeriodicFlush();
-  }
-  /**
-   * 메트릭 추가 및 실시간 집계
-   */
-  async addMetric(metric) {
-    const bufferKey = this.getBufferKey(metric);
-    if (!this.buffer.has(bufferKey)) {
-      this.buffer.set(bufferKey, []);
-    }
-    this.buffer.get(bufferKey).push(metric);
-    if (this.buffer.get(bufferKey).length >= this.config.batchSize) {
-      await this.flushBuffer(bufferKey);
-    }
-  }
-  /**
-   * 배치 메트릭 처리
-   */
-  async addMetrics(metrics) {
-    for (const metric of metrics) {
-      await this.addMetric(metric);
-    }
-  }
-  /**
-   * 규칙 기반 집계 실행
-   */
-  async aggregateByRules(metrics) {
-    const results = [];
-    for (const rule of this.config.rules) {
-      const applicableMetrics = this.filterMetricsByRule(metrics, rule);
-      if (applicableMetrics.length === 0) continue;
-      const aggregated = await this.applyAggregationRule(applicableMetrics, rule);
-      results.push(...aggregated);
-    }
-    return results;
-  }
-  /**
-   * 커스텀 집계 (동적 규칙)
-   */
-  async aggregateCustom(metrics, groupBy, aggregationType, filters) {
-    let filteredMetrics = metrics;
-    if (filters) {
-      filteredMetrics = this.applyFilters(metrics, filters);
-    }
-    const grouped = this.groupMetrics(filteredMetrics, groupBy);
-    const results = [];
-    for (const [groupKey, groupMetrics] of grouped.entries()) {
-      const dimensions = JSON.parse(groupKey);
-      const aggregated = await this.performAggregation(groupMetrics, aggregationType, dimensions);
-      results.push(...aggregated);
-    }
-    return results;
-  }
-  /**
-   * 비율 계산 (예: 전환율, 오류율)
-   */
-  async calculateRates(numeratorMetrics, denominatorMetrics, groupBy = []) {
-    const numGrouped = this.groupMetrics(numeratorMetrics, groupBy);
-    const denGrouped = this.groupMetrics(denominatorMetrics, groupBy);
-    const rates = [];
-    for (const [groupKey, numMetrics] of numGrouped.entries()) {
-      const denMetrics = denGrouped.get(groupKey) || [];
-      const dimensions = JSON.parse(groupKey);
-      const numSum = numMetrics.reduce((sum, m) => sum + m.value, 0);
-      const denSum = denMetrics.reduce((sum, m) => sum + m.value, 0);
-      const rate = denSum > 0 ? numSum / denSum * 100 : 0;
-      const latestTimestamp = new Date(Math.max(
-        ...numMetrics.map((m) => m.timestamp.getTime()),
-        ...denMetrics.map((m) => m.timestamp.getTime())
-      ));
-      rates.push({
-        type: numMetrics[0]?.type || "delivery_rate" /* DELIVERY_RATE */,
-        interval: "minute",
-        timestamp: latestTimestamp,
-        dimensions,
-        aggregations: {
-          count: numMetrics.length + denMetrics.length,
-          sum: rate,
-          avg: rate,
-          min: rate,
-          max: rate
-        }
-      });
-    }
-    return rates;
-  }
-  /**
-   * 백분위수 계산
-   */
-  async calculatePercentiles(metrics, percentiles, groupBy = []) {
-    const grouped = this.groupMetrics(metrics, groupBy);
-    const results = [];
-    for (const [groupKey, groupMetrics] of grouped.entries()) {
-      const dimensions = JSON.parse(groupKey);
-      const values = groupMetrics.map((m) => m.value).sort((a, b) => a - b);
-      for (const percentile of percentiles) {
-        const value = this.calculatePercentile(values, percentile);
-        results.push({
-          type: groupMetrics[0].type,
-          interval: "minute",
-          timestamp: /* @__PURE__ */ new Date(),
-          dimensions: { ...dimensions, percentile: percentile.toString() },
-          aggregations: {
-            count: values.length,
-            sum: value,
-            avg: value,
-            min: value,
-            max: value
-          }
-        });
-      }
-    }
-    return results;
-  }
-  /**
-   * 슬라이딩 윈도우 집계
-   */
-  async aggregateSlidingWindow(metrics, windowSizeMs, stepMs, aggregationType) {
-    const sortedMetrics = [...metrics].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    if (sortedMetrics.length === 0) return [];
-    const results = [];
-    const startTime = sortedMetrics[0].timestamp.getTime();
-    const endTime = sortedMetrics[sortedMetrics.length - 1].timestamp.getTime();
-    let currentTime = startTime;
-    while (currentTime <= endTime) {
-      const windowStart = new Date(currentTime);
-      const windowEnd = new Date(currentTime + windowSizeMs);
-      const windowMetrics = sortedMetrics.filter(
-        (m) => m.timestamp >= windowStart && m.timestamp < windowEnd
-      );
-      if (windowMetrics.length > 0) {
-        const aggregated = await this.performAggregation(windowMetrics, aggregationType, {});
-        results.push(...aggregated);
-      }
-      currentTime += stepMs;
-    }
-    return results;
-  }
-  /**
-   * 메트릭 정규화
-   */
-  async normalizeMetrics(metrics, method) {
-    const byType = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      if (!byType.has(metric.type)) {
-        byType.set(metric.type, []);
-      }
-      byType.get(metric.type).push(metric);
-    }
-    const normalized = [];
-    for (const [type, typeMetrics] of byType.entries()) {
-      const values = typeMetrics.map((m) => m.aggregations.avg);
-      let normalizedValues;
-      switch (method) {
-        case "minmax":
-          normalizedValues = this.minMaxNormalize(values);
-          break;
-        case "zscore":
-          normalizedValues = this.zScoreNormalize(values);
-          break;
-        case "robust":
-          normalizedValues = this.robustNormalize(values);
-          break;
-        default:
-          normalizedValues = values;
-      }
-      for (let i = 0; i < typeMetrics.length; i++) {
-        normalized.push({
-          ...typeMetrics[i],
-          aggregations: {
-            ...typeMetrics[i].aggregations,
-            avg: normalizedValues[i],
-            sum: normalizedValues[i] * typeMetrics[i].aggregations.count
-          }
-        });
-      }
-    }
-    return normalized;
-  }
-  getBufferKey(metric) {
-    return `${metric.type}_${JSON.stringify(metric.dimensions)}`;
-  }
-  async flushBuffer(bufferKey) {
-    const metrics = this.buffer.get(bufferKey);
-    if (!metrics || metrics.length === 0) return;
-    const aggregated = await this.aggregateByRules(metrics);
-    if (aggregated.length > 0) {
-      const cacheKey = `${bufferKey}_${Date.now()}`;
-      this.aggregationCache.set(cacheKey, aggregated);
-    }
-    this.buffer.set(bufferKey, []);
-  }
-  filterMetricsByRule(metrics, rule) {
-    let filtered = metrics.filter((m) => m.type === rule.metricType);
-    if (rule.conditions) {
-      filtered = filtered.filter((metric) => {
-        return rule.conditions.every((condition) => {
-          const value = this.getFieldValue(metric, condition.field);
-          return this.evaluateCondition(value, condition.operator, condition.value);
-        });
-      });
-    }
-    return filtered;
-  }
-  async applyAggregationRule(metrics, rule) {
-    const grouped = this.groupMetrics(metrics, rule.dimensions);
-    const results = [];
-    for (const [groupKey, groupMetrics] of grouped.entries()) {
-      const dimensions = JSON.parse(groupKey);
-      if (rule.aggregationType === "percentile") {
-        if (rule.percentile) {
-          const values = groupMetrics.map((m) => m.value).sort((a, b) => a - b);
-          const percentileValue = this.calculatePercentile(values, rule.percentile);
-          results.push({
-            type: rule.metricType,
-            interval: "minute",
-            timestamp: /* @__PURE__ */ new Date(),
-            dimensions,
-            aggregations: {
-              count: values.length,
-              sum: percentileValue,
-              avg: percentileValue,
-              min: percentileValue,
-              max: percentileValue
-            }
-          });
-        }
-      } else {
-        const aggregated = await this.performAggregation(groupMetrics, rule.aggregationType, dimensions);
-        results.push(...aggregated);
-      }
-    }
-    return results;
-  }
-  groupMetrics(metrics, groupBy) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const groupKey = this.createGroupKey(metric, groupBy);
-      if (!grouped.has(groupKey)) {
-        grouped.set(groupKey, []);
-      }
-      grouped.get(groupKey).push(metric);
-    }
-    return grouped;
-  }
-  createGroupKey(metric, groupBy) {
-    const groupDimensions = {};
-    for (const field of groupBy) {
-      groupDimensions[field] = this.getFieldValue(metric, field);
-    }
-    return JSON.stringify(groupDimensions);
-  }
-  getFieldValue(metric, field) {
-    if (field === "type") return metric.type.toString();
-    if (field === "timestamp") return metric.timestamp.toISOString();
-    return metric.dimensions[field] || "";
-  }
-  evaluateCondition(value, operator, expected) {
-    switch (operator) {
-      case "equals":
-        return value === expected;
-      case "not_equals":
-        return value !== expected;
-      case "gt":
-        return Number(value) > Number(expected);
-      case "lt":
-        return Number(value) < Number(expected);
-      case "contains":
-        return String(value).includes(String(expected));
-      default:
-        return false;
-    }
-  }
-  async performAggregation(metrics, aggregationType, dimensions) {
-    if (metrics.length === 0) return [];
-    const values = metrics.map((m) => m.value);
-    let aggregatedValue;
-    switch (aggregationType) {
-      case "sum":
-        aggregatedValue = values.reduce((sum, val) => sum + val, 0);
-        break;
-      case "avg":
-        aggregatedValue = values.reduce((sum, val) => sum + val, 0) / values.length;
-        break;
-      case "min":
-        aggregatedValue = Math.min(...values);
-        break;
-      case "max":
-        aggregatedValue = Math.max(...values);
-        break;
-      case "count":
-        aggregatedValue = values.length;
-        break;
-      case "rate":
-        aggregatedValue = 0;
-        break;
-      default:
-        aggregatedValue = 0;
-    }
-    return [{
-      type: metrics[0].type,
-      interval: "minute",
-      timestamp: /* @__PURE__ */ new Date(),
-      dimensions,
-      aggregations: {
-        count: values.length,
-        sum: aggregationType === "sum" ? aggregatedValue : values.reduce((sum, val) => sum + val, 0),
-        avg: aggregationType === "avg" ? aggregatedValue : aggregatedValue,
-        min: Math.min(...values),
-        max: Math.max(...values)
-      }
-    }];
-  }
-  applyFilters(metrics, filters) {
-    return metrics.filter((metric) => {
-      return Object.entries(filters).every(([key, value]) => {
-        const metricValue = this.getFieldValue(metric, key);
-        return Array.isArray(value) ? value.includes(metricValue) : metricValue === value;
-      });
-    });
-  }
-  calculatePercentile(values, percentile) {
-    if (values.length === 0) return 0;
-    const index = percentile / 100 * (values.length - 1);
-    const lower = Math.floor(index);
-    const upper = Math.ceil(index);
-    if (lower === upper) {
-      return values[lower];
-    }
-    const weight = index - lower;
-    return values[lower] * (1 - weight) + values[upper] * weight;
-  }
-  minMaxNormalize(values) {
-    const min = Math.min(...values);
-    const max = Math.max(...values);
-    const range = max - min;
-    return range === 0 ? values.map(() => 0) : values.map((v) => (v - min) / range);
-  }
-  zScoreNormalize(values) {
-    const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
-    const stdDev = Math.sqrt(values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length);
-    return stdDev === 0 ? values.map(() => 0) : values.map((v) => (v - mean) / stdDev);
-  }
-  robustNormalize(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const median = this.calculatePercentile(sorted, 50);
-    const mad = this.calculateMAD(sorted, median);
-    return mad === 0 ? values.map(() => 0) : values.map((v) => (v - median) / mad);
-  }
-  calculateMAD(values, median) {
-    const absDeviations = values.map((v) => Math.abs(v - median));
-    return this.calculatePercentile(absDeviations.sort((a, b) => a - b), 50);
-  }
-  startPeriodicFlush() {
-    setInterval(async () => {
-      for (const bufferKey of this.buffer.keys()) {
-        await this.flushBuffer(bufferKey);
-      }
-    }, this.config.flushInterval);
-  }
-};
-
-// src/collectors/event.collector.ts
-var import_events = require("events");
-var EventCollector = class extends import_events.EventEmitter {
-  config;
-  buffer = [];
-  processors = /* @__PURE__ */ new Map();
-  recentEvents = /* @__PURE__ */ new Map();
-  // 중복 제거용
-  metrics = [];
-  defaultConfig = {
-    bufferSize: 1e3,
-    flushInterval: 5e3,
-    enableDeduplication: true,
-    deduplicationWindow: 6e4,
-    // 1분
-    enableSampling: false,
-    samplingRate: 1
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeDefaultProcessors();
-    this.startPeriodicFlush();
-    this.startCleanup();
-  }
-  /**
-   * 이벤트 수집
-   */
-  async collectEvent(event) {
-    if (this.config.enableSampling && Math.random() > this.config.samplingRate) {
-      return;
-    }
-    if (this.config.enableDeduplication && this.isDuplicate(event)) {
-      return;
-    }
-    this.validateEvent(event);
-    this.buffer.push(event);
-    if (this.isHighPriorityEvent(event)) {
-      await this.processEvent(event);
-    }
-    if (this.buffer.length >= this.config.bufferSize) {
-      await this.flush();
-    }
-    this.emit("event:collected", event);
-  }
-  /**
-   * 배치 이벤트 수집
-   */
-  async collectEvents(events) {
-    for (const event of events) {
-      await this.collectEvent(event);
-    }
-  }
-  /**
-   * 커스텀 이벤트 프로세서 등록
-   */
-  registerProcessor(name, processor) {
-    this.processors.set(name, processor);
-    this.emit("processor:registered", { name, processor });
-  }
-  /**
-   * 이벤트 프로세서 제거
-   */
-  unregisterProcessor(name) {
-    const removed = this.processors.delete(name);
-    if (removed) {
-      this.emit("processor:unregistered", { name });
-    }
-    return removed;
-  }
-  /**
-   * 수집된 메트릭 조회
-   */
-  getCollectedMetrics(since) {
-    if (!since) {
-      return [...this.metrics];
-    }
-    return this.metrics.filter((m) => m.timestamp >= since);
-  }
-  /**
-   * 실시간 메트릭 스트림
-   */
-  async *streamMetrics() {
-    while (true) {
-      await new Promise((resolve) => setTimeout(resolve, this.config.flushInterval));
-      if (this.buffer.length > 0) {
-        await this.flush();
-      }
-      const recentMetrics = this.getCollectedMetrics(
-        new Date(Date.now() - this.config.flushInterval)
-      );
-      if (recentMetrics.length > 0) {
-        yield recentMetrics;
-      }
-    }
-  }
-  /**
-   * 이벤트 통계
-   */
-  getEventStats() {
-    const eventsByType = {};
-    const eventsBySource = {};
-    for (const event of this.buffer) {
-      eventsByType[event.type] = (eventsByType[event.type] || 0) + 1;
-      eventsBySource[event.source] = (eventsBySource[event.source] || 0) + 1;
-    }
-    return {
-      totalEvents: this.buffer.length,
-      eventsByType,
-      eventsBySource,
-      bufferSize: this.buffer.length,
-      metricsGenerated: this.metrics.length
-    };
-  }
-  /**
-   * 버퍼 강제 플러시
-   */
-  async flush() {
-    if (this.buffer.length === 0) {
-      return;
-    }
-    const events = [...this.buffer];
-    this.buffer = [];
-    try {
-      const allMetrics = [];
-      for (const event of events) {
-        const metrics = await this.processEvent(event);
-        allMetrics.push(...metrics);
-      }
-      this.metrics.push(...allMetrics);
-      if (this.metrics.length > 1e5) {
-        this.metrics = this.metrics.slice(-5e4);
-      }
-      this.emit("events:flushed", {
-        eventCount: events.length,
-        metricCount: allMetrics.length
-      });
-    } catch (error) {
-      this.buffer.unshift(...events);
-      this.emit("flush:error", error);
-      throw error;
-    }
-  }
-  async processEvent(event) {
-    const metrics = [];
-    for (const [name, processor] of this.processors.entries()) {
-      try {
-        if (processor.canProcess(event)) {
-          const processorMetrics = await processor.process(event);
-          metrics.push(...processorMetrics);
-        }
-      } catch (error) {
-        this.emit("processor:error", { processorName: name, event, error });
-      }
-    }
-    return metrics;
-  }
-  validateEvent(event) {
-    if (!event.id) {
-      throw new Error("Event ID is required");
-    }
-    if (!event.type) {
-      throw new Error("Event type is required");
-    }
-    if (!event.timestamp || !(event.timestamp instanceof Date)) {
-      throw new Error("Valid event timestamp is required");
-    }
-    if (!event.source) {
-      throw new Error("Event source is required");
-    }
-    if (!event.payload || typeof event.payload !== "object") {
-      throw new Error("Event payload must be an object");
-    }
-  }
-  isDuplicate(event) {
-    const now = Date.now();
-    const eventKey = `${event.id}_${event.type}_${event.source}`;
-    const lastSeen = this.recentEvents.get(eventKey);
-    if (lastSeen && now - lastSeen < this.config.deduplicationWindow) {
-      return true;
-    }
-    this.recentEvents.set(eventKey, now);
-    return false;
-  }
-  isHighPriorityEvent(event) {
-    const highPriorityTypes = [
-      "message.failed",
-      "system.error",
-      "security.alert",
-      "performance.degradation"
-    ];
-    return highPriorityTypes.includes(event.type);
-  }
-  initializeDefaultProcessors() {
-    this.registerProcessor("message-sent", {
-      canProcess: (event) => event.type === "message.sent",
-      process: async (event) => {
-        return [{
-          id: `metric_${event.id}`,
-          type: "message_sent" /* MESSAGE_SENT */,
-          timestamp: event.timestamp,
-          value: 1,
-          dimensions: {
-            provider: event.payload.provider || "unknown",
-            channel: event.payload.channel || "unknown",
-            template: event.payload.templateId || "none"
-          },
-          metadata: {
-            messageId: event.payload.messageId,
-            recipientCount: event.payload.recipientCount || 1
-          }
-        }];
-      }
-    });
-    this.registerProcessor("message-delivered", {
-      canProcess: (event) => event.type === "message.delivered",
-      process: async (event) => {
-        return [{
-          id: `metric_${event.id}`,
-          type: "message_delivered" /* MESSAGE_DELIVERED */,
-          timestamp: event.timestamp,
-          value: 1,
-          dimensions: {
-            provider: event.payload.provider || "unknown",
-            channel: event.payload.channel || "unknown"
-          },
-          metadata: {
-            messageId: event.payload.messageId,
-            deliveryTime: event.payload.deliveryTime
-          }
-        }];
-      }
-    });
-    this.registerProcessor("message-failed", {
-      canProcess: (event) => event.type === "message.failed",
-      process: async (event) => {
-        return [{
-          id: `metric_${event.id}`,
-          type: "message_failed" /* MESSAGE_FAILED */,
-          timestamp: event.timestamp,
-          value: 1,
-          dimensions: {
-            provider: event.payload.provider || "unknown",
-            channel: event.payload.channel || "unknown",
-            errorCode: event.payload.errorCode || "unknown"
-          },
-          metadata: {
-            messageId: event.payload.messageId,
-            errorMessage: event.payload.errorMessage,
-            errorType: event.payload.errorType
-          }
-        }];
-      }
-    });
-    this.registerProcessor("message-clicked", {
-      canProcess: (event) => event.type === "message.clicked" || event.type === "link.clicked",
-      process: async (event) => {
-        return [{
-          id: `metric_${event.id}`,
-          type: "message_clicked" /* MESSAGE_CLICKED */,
-          timestamp: event.timestamp,
-          value: 1,
-          dimensions: {
-            provider: event.payload.provider || "unknown",
-            channel: event.payload.channel || "unknown",
-            linkType: event.payload.linkType || "unknown"
-          },
-          metadata: {
-            messageId: event.payload.messageId,
-            linkUrl: event.payload.linkUrl,
-            userId: event.context?.userId
-          }
-        }];
-      }
-    });
-    this.registerProcessor("template-used", {
-      canProcess: (event) => event.type === "template.used",
-      process: async (event) => {
-        return [{
-          id: `metric_${event.id}`,
-          type: "template_usage" /* TEMPLATE_USAGE */,
-          timestamp: event.timestamp,
-          value: 1,
-          dimensions: {
-            templateId: event.payload.templateId || "unknown",
-            provider: event.payload.provider || "unknown",
-            channel: event.payload.channel || "unknown"
-          },
-          metadata: {
-            templateName: event.payload.templateName,
-            version: event.payload.version
-          }
-        }];
-      }
-    });
-    this.registerProcessor("channel-used", {
-      canProcess: (event) => ["message.sent", "message.delivered"].includes(event.type),
-      process: async (event) => {
-        return [{
-          id: `metric_channel_${event.id}`,
-          type: "channel_usage" /* CHANNEL_USAGE */,
-          timestamp: event.timestamp,
-          value: 1,
-          dimensions: {
-            channel: event.payload.channel || "unknown",
-            provider: event.payload.provider || "unknown"
-          }
-        }];
-      }
-    });
-  }
-  startPeriodicFlush() {
-    setInterval(async () => {
-      try {
-        await this.flush();
-      } catch (error) {
-        this.emit("flush:error", error);
-      }
-    }, this.config.flushInterval);
-  }
-  startCleanup() {
-    setInterval(() => {
-      const cutoff = Date.now() - this.config.deduplicationWindow;
-      for (const [key, timestamp] of this.recentEvents.entries()) {
-        if (timestamp < cutoff) {
-          this.recentEvents.delete(key);
-        }
-      }
-    }, 10 * 60 * 1e3);
-    setInterval(() => {
-      if (this.metrics.length > 1e5) {
-        this.metrics = this.metrics.slice(-5e4);
-        this.emit("metrics:cleaned", { remainingCount: this.metrics.length });
-      }
-    }, 60 * 60 * 1e3);
-  }
-};
-
-// src/collectors/webhook.collector.ts
-var import_events2 = require("events");
-var WebhookCollector = class extends import_events2.EventEmitter {
-  config;
-  transformers = /* @__PURE__ */ new Map();
-  requestCounts = /* @__PURE__ */ new Map();
-  processedWebhooks = [];
-  defaultConfig = {
-    enableSignatureValidation: true,
-    signatureHeader: "x-signature",
-    allowedSources: [],
-    maxPayloadSize: 1024 * 1024,
-    // 1MB
-    rateLimitPerMinute: 1e3
-  };
-  constructor(config = {}) {
-    super();
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeDefaultTransformers();
-    this.startCleanup();
-  }
-  /**
-   * 웹훅 수신 처리
-   */
-  async receiveWebhook(webhook) {
-    if (!this.checkRateLimit(webhook.source)) {
-      throw new Error(`Rate limit exceeded for source: ${webhook.source}`);
-    }
-    await this.validateWebhook(webhook);
-    const payloadSize = JSON.stringify(webhook.body).length;
-    if (payloadSize > this.config.maxPayloadSize) {
-      throw new Error(`Payload size ${payloadSize} exceeds maximum ${this.config.maxPayloadSize}`);
-    }
-    const events = await this.transformWebhook(webhook);
-    this.processedWebhooks.push(webhook);
-    if (this.processedWebhooks.length > 1e3) {
-      this.processedWebhooks = this.processedWebhooks.slice(-500);
-    }
-    this.emit("webhook:received", { webhook, eventCount: events.length });
-    return events;
-  }
-  /**
-   * 웹훅 변환기 등록
-   */
-  registerTransformer(name, transformer) {
-    this.transformers.set(name, transformer);
-    this.emit("transformer:registered", { name });
-  }
-  /**
-   * 웹훅 변환기 제거
-   */
-  unregisterTransformer(name) {
-    const removed = this.transformers.delete(name);
-    if (removed) {
-      this.emit("transformer:unregistered", { name });
-    }
-    return removed;
-  }
-  /**
-   * 처리된 웹훅 조회
-   */
-  getProcessedWebhooks(since) {
-    if (!since) {
-      return [...this.processedWebhooks];
-    }
-    return this.processedWebhooks.filter((w) => w.timestamp >= since);
-  }
-  /**
-   * 웹훅 통계
-   */
-  getWebhookStats() {
-    const bySource = {};
-    const recentTime = new Date(Date.now() - 60 * 60 * 1e3);
-    let recentCount = 0;
-    for (const webhook of this.processedWebhooks) {
-      bySource[webhook.source] = (bySource[webhook.source] || 0) + 1;
-      if (webhook.timestamp >= recentTime) {
-        recentCount++;
-      }
-    }
-    return {
-      totalProcessed: this.processedWebhooks.length,
-      bySource,
-      recentCount,
-      transformerCount: this.transformers.size
-    };
-  }
-  async validateWebhook(webhook) {
-    if (this.config.allowedSources.length > 0 && !this.config.allowedSources.includes(webhook.source)) {
-      throw new Error(`Source ${webhook.source} is not allowed`);
-    }
-    if (this.config.enableSignatureValidation && this.config.secretKey) {
-      await this.validateSignature(webhook);
-    }
-    if (!webhook.id) {
-      throw new Error("Webhook ID is required");
-    }
-    if (!webhook.source) {
-      throw new Error("Webhook source is required");
-    }
-    if (!webhook.timestamp || !(webhook.timestamp instanceof Date)) {
-      throw new Error("Valid webhook timestamp is required");
-    }
-  }
-  async validateSignature(webhook) {
-    const signature = webhook.headers[this.config.signatureHeader] || webhook.signature;
-    if (!signature) {
-      throw new Error(`Missing signature in header: ${this.config.signatureHeader}`);
-    }
-    const expectedSignature = await this.generateSignature(webhook.body, this.config.secretKey);
-    if (signature !== expectedSignature) {
-      throw new Error("Invalid webhook signature");
-    }
-  }
-  async generateSignature(payload, secret) {
-    const payloadStr = JSON.stringify(payload);
-    return `sha256=${payloadStr.length}_${secret.length}`;
-  }
-  checkRateLimit(source) {
-    const now = Date.now();
-    const minuteKey = Math.floor(now / (60 * 1e3));
-    const rateLimitKey = `${source}_${minuteKey}`;
-    const current = this.requestCounts.get(rateLimitKey) || { count: 0, resetTime: now + 6e4 };
-    if (current.count >= this.config.rateLimitPerMinute) {
-      return false;
-    }
-    current.count++;
-    this.requestCounts.set(rateLimitKey, current);
-    return true;
-  }
-  async transformWebhook(webhook) {
-    const events = [];
-    for (const [name, transformer] of this.transformers.entries()) {
-      try {
-        if (transformer.canTransform(webhook)) {
-          const transformerEvents = await transformer.transform(webhook);
-          events.push(...transformerEvents);
-        }
-      } catch (error) {
-        this.emit("transformer:error", { transformerName: name, webhook, error });
-      }
-    }
-    if (events.length === 0) {
-      events.push(await this.defaultTransform(webhook));
-    }
-    return events;
-  }
-  async defaultTransform(webhook) {
-    return {
-      id: `webhook_${webhook.id}`,
-      type: `webhook.${webhook.source}`,
-      timestamp: webhook.timestamp,
-      source: webhook.source,
-      payload: webhook.body,
-      context: {
-        requestId: webhook.id,
-        userAgent: webhook.headers["user-agent"],
-        ipAddress: webhook.headers["x-forwarded-for"] || webhook.headers["x-real-ip"]
-      }
-    };
-  }
-  initializeDefaultTransformers() {
-    this.registerTransformer("sms-provider", {
-      canTransform: (webhook) => webhook.source.includes("sms") || webhook.source.includes("alimtalk"),
-      transform: async (webhook) => {
-        const events = [];
-        const body = webhook.body;
-        if (body.status === "sent" || body.status === "delivered") {
-          events.push({
-            id: `sms_delivered_${webhook.id}`,
-            type: "message.delivered",
-            timestamp: webhook.timestamp,
-            source: webhook.source,
-            payload: {
-              messageId: body.messageId || body.id,
-              provider: webhook.source,
-              channel: body.channel || "sms",
-              recipientNumber: body.to || body.recipient,
-              deliveryTime: body.deliveredAt ? new Date(body.deliveredAt) : webhook.timestamp
-            }
-          });
-        }
-        if (body.status === "failed" || body.status === "error") {
-          events.push({
-            id: `sms_failed_${webhook.id}`,
-            type: "message.failed",
-            timestamp: webhook.timestamp,
-            source: webhook.source,
-            payload: {
-              messageId: body.messageId || body.id,
-              provider: webhook.source,
-              channel: body.channel || "sms",
-              errorCode: body.errorCode || "unknown",
-              errorMessage: body.errorMessage || body.error,
-              errorType: body.errorType || "delivery"
-            }
-          });
-        }
-        return events;
-      }
-    });
-    this.registerTransformer("alimtalk-provider", {
-      canTransform: (webhook) => webhook.source.includes("alimtalk") || webhook.source.includes("kakao"),
-      transform: async (webhook) => {
-        const events = [];
-        const body = webhook.body;
-        if (body.eventType === "click" || body.type === "button_click") {
-          events.push({
-            id: `alimtalk_click_${webhook.id}`,
-            type: "message.clicked",
-            timestamp: webhook.timestamp,
-            source: webhook.source,
-            payload: {
-              messageId: body.messageId,
-              provider: webhook.source,
-              channel: "alimtalk",
-              linkType: body.buttonType || "button",
-              linkUrl: body.buttonUrl || body.url,
-              buttonText: body.buttonText
-            }
-          });
-        }
-        if (body.messageStatus || body.status) {
-          const status = body.messageStatus || body.status;
-          if (["DELIVERED", "READ"].includes(status)) {
-            events.push({
-              id: `alimtalk_delivered_${webhook.id}`,
-              type: "message.delivered",
-              timestamp: webhook.timestamp,
-              source: webhook.source,
-              payload: {
-                messageId: body.messageId,
-                provider: webhook.source,
-                channel: "alimtalk",
-                deliveryTime: body.deliveredAt ? new Date(body.deliveredAt) : webhook.timestamp
-              }
-            });
-          } else if (["FAILED", "REJECTED"].includes(status)) {
-            events.push({
-              id: `alimtalk_failed_${webhook.id}`,
-              type: "message.failed",
-              timestamp: webhook.timestamp,
-              source: webhook.source,
-              payload: {
-                messageId: body.messageId,
-                provider: webhook.source,
-                channel: "alimtalk",
-                errorCode: body.failureCode || "unknown",
-                errorMessage: body.failureReason || "Unknown error"
-              }
-            });
-          }
-        }
-        return events;
-      }
-    });
-    this.registerTransformer("generic-messaging", {
-      canTransform: (webhook) => {
-        const body = webhook.body;
-        return body && (body.messageId || body.id) && body.status;
-      },
-      transform: async (webhook) => {
-        const events = [];
-        const body = webhook.body;
-        const basePayload = {
-          messageId: body.messageId || body.id,
-          provider: webhook.source,
-          channel: body.channel || "unknown"
-        };
-        switch (body.status) {
-          case "delivered":
-          case "read":
-            events.push({
-              id: `generic_delivered_${webhook.id}`,
-              type: "message.delivered",
-              timestamp: webhook.timestamp,
-              source: webhook.source,
-              payload: {
-                ...basePayload,
-                deliveryTime: body.deliveredAt ? new Date(body.deliveredAt) : webhook.timestamp
-              }
-            });
-            break;
-          case "failed":
-          case "rejected":
-          case "undelivered":
-            events.push({
-              id: `generic_failed_${webhook.id}`,
-              type: "message.failed",
-              timestamp: webhook.timestamp,
-              source: webhook.source,
-              payload: {
-                ...basePayload,
-                errorCode: body.errorCode || body.error_code || "unknown",
-                errorMessage: body.errorMessage || body.error_message || "Unknown error",
-                errorType: body.errorType || "delivery"
-              }
-            });
-            break;
-          case "clicked":
-            events.push({
-              id: `generic_clicked_${webhook.id}`,
-              type: "message.clicked",
-              timestamp: webhook.timestamp,
-              source: webhook.source,
-              payload: {
-                ...basePayload,
-                linkUrl: body.clickedUrl || body.url,
-                linkType: body.linkType || "link"
-              }
-            });
-            break;
-        }
-        return events;
-      }
-    });
-  }
-  startCleanup() {
-    setInterval(() => {
-      const now = Date.now();
-      for (const [key, data] of this.requestCounts.entries()) {
-        if (now > data.resetTime) {
-          this.requestCounts.delete(key);
-        }
-      }
-    }, 5 * 60 * 1e3);
-  }
-};
-
-// src/insights/anomaly.detector.ts
-var AnomalyDetector = class {
-  config;
-  historicalData = /* @__PURE__ */ new Map();
-  seasonalPatterns = /* @__PURE__ */ new Map();
-  baselines = /* @__PURE__ */ new Map();
-  defaultConfig = {
-    algorithms: [
-      { name: "zscore", type: "statistical", enabled: true, config: { threshold: 3 } },
-      { name: "iqr", type: "statistical", enabled: true, config: { multiplier: 1.5 } },
-      { name: "isolation", type: "ml", enabled: false, config: { contamination: 0.1 } }
-    ],
-    sensitivity: "medium",
-    minDataPoints: 10,
-    confidenceThreshold: 0.7,
-    enableSeasonalAdjustment: true
-  };
-  constructor(config = {}) {
-    this.config = { ...this.defaultConfig, ...config };
-  }
-  /**
-   * 실시간 이상 탐지
-   */
-  async detectRealTimeAnomalies(metric) {
-    const key = this.getMetricKey(metric.type, metric.dimensions);
-    const anomalies = [];
-    this.updateHistoricalData(key, metric.value);
-    for (const algorithm of this.config.algorithms) {
-      if (!algorithm.enabled) continue;
-      try {
-        const anomaly = await this.runAlgorithm(metric, algorithm, key);
-        if (anomaly && anomaly.confidence >= this.config.confidenceThreshold) {
-          anomalies.push(anomaly);
-        }
-      } catch (error) {
-        console.error(`Anomaly detection failed for algorithm ${algorithm.name}:`, error);
-      }
-    }
-    return this.deduplicateAndRankAnomalies(anomalies);
-  }
-  /**
-   * 배치 이상 탐지
-   */
-  async detectBatchAnomalies(metrics, timeWindow) {
-    const anomalies = [];
-    const groupedMetrics = this.groupMetricsByTypeAndDimensions(metrics);
-    for (const [key, typeMetrics] of groupedMetrics.entries()) {
-      const [metricType, dimensionsStr] = key.split("|");
-      const dimensions = JSON.parse(dimensionsStr);
-      const timeSeries = typeMetrics.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime()).map((m) => ({ timestamp: m.timestamp, value: m.aggregations.avg }));
-      if (timeSeries.length < this.config.minDataPoints) {
-        continue;
-      }
-      let adjustedSeries = timeSeries;
-      if (this.config.enableSeasonalAdjustment) {
-        adjustedSeries = await this.adjustForSeasonality(timeSeries, key);
-      }
-      for (let i = Math.floor(adjustedSeries.length * 0.3); i < adjustedSeries.length; i++) {
-        const point = adjustedSeries[i];
-        const historicalWindow = adjustedSeries.slice(Math.max(0, i - 20), i);
-        if (historicalWindow.length < this.config.minDataPoints) continue;
-        const mockMetric = {
-          id: `batch_${i}`,
-          type: metricType,
-          timestamp: point.timestamp,
-          value: point.value,
-          dimensions
-        };
-        const pointAnomalies = await this.detectRealTimeAnomalies(mockMetric);
-        anomalies.push(...pointAnomalies);
-      }
-    }
-    return this.deduplicateAndRankAnomalies(anomalies);
-  }
-  /**
-   * 트렌드 변화 탐지
-   */
-  async detectTrendChanges(metrics, windowSize = 10) {
-    const insights = [];
-    const groupedMetrics = this.groupMetricsByTypeAndDimensions(metrics);
-    for (const [key, typeMetrics] of groupedMetrics.entries()) {
-      const [metricType, dimensionsStr] = key.split("|");
-      const dimensions = JSON.parse(dimensionsStr);
-      const sortedMetrics = typeMetrics.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-      if (sortedMetrics.length < windowSize * 2) continue;
-      for (let i = windowSize; i < sortedMetrics.length - windowSize; i++) {
-        const beforeWindow = sortedMetrics.slice(i - windowSize, i);
-        const afterWindow = sortedMetrics.slice(i, i + windowSize);
-        const beforeTrend = this.calculateTrend(beforeWindow.map((m) => m.aggregations.avg));
-        const afterTrend = this.calculateTrend(afterWindow.map((m) => m.aggregations.avg));
-        const trendChange = Math.abs(afterTrend - beforeTrend);
-        const significanceThreshold = this.getSensitivityThreshold("trend");
-        if (trendChange > significanceThreshold) {
-          insights.push({
-            id: `trend_change_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            type: "trend",
-            title: `Trend Change Detected in ${metricType}`,
-            description: `Significant trend change from ${beforeTrend.toFixed(2)} to ${afterTrend.toFixed(2)}`,
-            severity: this.calculateTrendSeverity(trendChange, significanceThreshold),
-            metric: metricType,
-            dimensions,
-            value: afterTrend,
-            expectedValue: beforeTrend,
-            confidence: Math.min(0.95, 0.5 + trendChange / significanceThreshold * 0.3),
-            actionable: trendChange > significanceThreshold * 2,
-            recommendations: this.generateTrendRecommendations(beforeTrend, afterTrend, metricType),
-            detectedAt: sortedMetrics[i].timestamp
-          });
-        }
-      }
-    }
-    return insights;
-  }
-  /**
-   * 베이스라인 업데이트
-   */
-  async updateBaselines(metrics) {
-    const groupedMetrics = this.groupMetricsByTypeAndDimensions(metrics);
-    for (const [key, typeMetrics] of groupedMetrics.entries()) {
-      const values = typeMetrics.map((m) => m.aggregations.avg);
-      if (values.length < this.config.minDataPoints) continue;
-      const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
-      const variance = values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length;
-      const stdDev = Math.sqrt(variance);
-      const min = Math.min(...values);
-      const max = Math.max(...values);
-      this.baselines.set(key, { mean, stdDev, min, max });
-    }
-  }
-  async runAlgorithm(metric, algorithm, key) {
-    const historicalValues = this.historicalData.get(key) || [];
-    if (historicalValues.length < this.config.minDataPoints) {
-      return null;
-    }
-    switch (algorithm.name) {
-      case "zscore":
-        return this.zScoreDetection(metric, historicalValues, algorithm.config, key);
-      case "iqr":
-        return this.iqrDetection(metric, historicalValues, algorithm.config, key);
-      case "isolation":
-        return this.isolationForestDetection(metric, historicalValues, algorithm.config, key);
-      case "threshold":
-        return this.thresholdDetection(metric, algorithm.config, key);
-      default:
-        return null;
-    }
-  }
-  zScoreDetection(metric, historicalValues, config, key) {
-    const mean = historicalValues.reduce((sum, v) => sum + v, 0) / historicalValues.length;
-    const variance = historicalValues.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / historicalValues.length;
-    const stdDev = Math.sqrt(variance);
-    if (stdDev === 0) return null;
-    const zScore = Math.abs((metric.value - mean) / stdDev);
-    const threshold = config.threshold || 3;
-    if (zScore > threshold) {
-      const severity = this.calculateSeverity(zScore, threshold);
-      const confidence = Math.min(0.99, zScore / threshold * 0.8);
-      return {
-        id: `zscore_${metric.id}`,
-        metricType: metric.type,
-        timestamp: metric.timestamp,
-        value: metric.value,
-        expectedValue: mean,
-        deviation: zScore,
-        severity,
-        confidence,
-        algorithm: "zscore",
-        dimensions: metric.dimensions,
-        context: {
-          trend: this.detectTrend(historicalValues),
-          seasonality: false,
-          historicalComparison: (metric.value - mean) / mean * 100
-        }
-      };
-    }
-    return null;
-  }
-  iqrDetection(metric, historicalValues, config, key) {
-    const sortedValues = [...historicalValues].sort((a, b) => a - b);
-    const q1Index = Math.floor(sortedValues.length * 0.25);
-    const q3Index = Math.floor(sortedValues.length * 0.75);
-    const q1 = sortedValues[q1Index];
-    const q3 = sortedValues[q3Index];
-    const iqr = q3 - q1;
-    const multiplier = config.multiplier || 1.5;
-    const lowerBound = q1 - multiplier * iqr;
-    const upperBound = q3 + multiplier * iqr;
-    if (metric.value < lowerBound || metric.value > upperBound) {
-      const expectedValue = (q1 + q3) / 2;
-      const deviation = Math.abs(metric.value - expectedValue) / iqr;
-      const severity = this.calculateSeverity(deviation, multiplier);
-      const confidence = Math.min(0.99, deviation / multiplier * 0.7);
-      return {
-        id: `iqr_${metric.id}`,
-        metricType: metric.type,
-        timestamp: metric.timestamp,
-        value: metric.value,
-        expectedValue,
-        deviation,
-        severity,
-        confidence,
-        algorithm: "iqr",
-        dimensions: metric.dimensions,
-        context: {
-          trend: this.detectTrend(historicalValues),
-          seasonality: false,
-          historicalComparison: (metric.value - expectedValue) / expectedValue * 100
-        }
-      };
-    }
-    return null;
-  }
-  isolationForestDetection(metric, historicalValues, config, key) {
-    const contamination = config.contamination || 0.1;
-    const threshold = this.calculateIsolationThreshold(historicalValues, contamination);
-    const anomalyScore = this.calculateIsolationScore(metric.value, historicalValues);
-    if (anomalyScore > threshold) {
-      const expectedValue = historicalValues.reduce((sum, v) => sum + v, 0) / historicalValues.length;
-      const severity = this.calculateSeverity(anomalyScore, threshold);
-      const confidence = Math.min(0.99, anomalyScore / threshold * 0.9);
-      return {
-        id: `isolation_${metric.id}`,
-        metricType: metric.type,
-        timestamp: metric.timestamp,
-        value: metric.value,
-        expectedValue,
-        deviation: anomalyScore,
-        severity,
-        confidence,
-        algorithm: "isolation",
-        dimensions: metric.dimensions
-      };
-    }
-    return null;
-  }
-  thresholdDetection(metric, config, key) {
-    const upperThreshold = config.upperThreshold;
-    const lowerThreshold = config.lowerThreshold;
-    if (upperThreshold !== void 0 && metric.value > upperThreshold) {
-      return {
-        id: `threshold_upper_${metric.id}`,
-        metricType: metric.type,
-        timestamp: metric.timestamp,
-        value: metric.value,
-        expectedValue: upperThreshold,
-        deviation: (metric.value - upperThreshold) / upperThreshold,
-        severity: "high",
-        confidence: 1,
-        algorithm: "threshold",
-        dimensions: metric.dimensions
-      };
-    }
-    if (lowerThreshold !== void 0 && metric.value < lowerThreshold) {
-      return {
-        id: `threshold_lower_${metric.id}`,
-        metricType: metric.type,
-        timestamp: metric.timestamp,
-        value: metric.value,
-        expectedValue: lowerThreshold,
-        deviation: (lowerThreshold - metric.value) / lowerThreshold,
-        severity: "high",
-        confidence: 1,
-        algorithm: "threshold",
-        dimensions: metric.dimensions
-      };
-    }
-    return null;
-  }
-  calculateSeverity(deviation, threshold) {
-    const ratio = deviation / threshold;
-    if (ratio > 3) return "critical";
-    if (ratio > 2) return "high";
-    if (ratio > 1.5) return "medium";
-    return "low";
-  }
-  calculateTrendSeverity(change, threshold) {
-    const ratio = change / threshold;
-    if (ratio > 4) return "critical";
-    if (ratio > 3) return "high";
-    if (ratio > 2) return "medium";
-    return "low";
-  }
-  getMetricKey(type, dimensions) {
-    return `${type}|${JSON.stringify(dimensions)}`;
-  }
-  updateHistoricalData(key, value) {
-    const history = this.historicalData.get(key) || [];
-    history.push(value);
-    if (history.length > 100) {
-      history.splice(0, history.length - 100);
-    }
-    this.historicalData.set(key, history);
-  }
-  groupMetricsByTypeAndDimensions(metrics) {
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const key = `${metric.type}|${JSON.stringify(metric.dimensions)}`;
-      if (!grouped.has(key)) {
-        grouped.set(key, []);
-      }
-      grouped.get(key).push(metric);
-    }
-    return grouped;
-  }
-  async adjustForSeasonality(timeSeries, key) {
-    const windowSize = Math.min(24, Math.floor(timeSeries.length / 4));
-    if (windowSize < 3) return timeSeries;
-    return timeSeries.map((point, index) => {
-      const windowStart = Math.max(0, index - Math.floor(windowSize / 2));
-      const windowEnd = Math.min(timeSeries.length, windowStart + windowSize);
-      const window = timeSeries.slice(windowStart, windowEnd);
-      const seasonalAvg = window.reduce((sum, p) => sum + p.value, 0) / window.length;
-      const adjustedValue = point.value - seasonalAvg + timeSeries.reduce((sum, p) => sum + p.value, 0) / timeSeries.length;
-      return {
-        timestamp: point.timestamp,
-        value: adjustedValue
-      };
-    });
-  }
-  calculateTrend(values) {
-    if (values.length < 2) return 0;
-    const n = values.length;
-    const x = Array.from({ length: n }, (_, i) => i);
-    const sumX = x.reduce((a, b) => a + b, 0);
-    const sumY = values.reduce((a, b) => a + b, 0);
-    const sumXY = x.reduce((sum, xi, i) => sum + xi * values[i], 0);
-    const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
-    return (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-  }
-  detectTrend(values) {
-    const trend = this.calculateTrend(values);
-    const threshold = 0.1;
-    if (Math.abs(trend) < threshold) return "stable";
-    return trend > 0 ? "increasing" : "decreasing";
-  }
-  getSensitivityThreshold(type) {
-    const baseThresholds = {
-      anomaly: { low: 0.5, medium: 0.3, high: 0.1 },
-      trend: { low: 2, medium: 1, high: 0.5 }
-    };
-    return baseThresholds[type][this.config.sensitivity];
-  }
-  calculateIsolationThreshold(values, contamination) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const cutoffIndex = Math.floor((1 - contamination) * sorted.length);
-    return 0.6;
-  }
-  calculateIsolationScore(value, historicalValues) {
-    const mean = historicalValues.reduce((sum, v) => sum + v, 0) / historicalValues.length;
-    const distances = historicalValues.map((v) => Math.abs(v - value));
-    const avgDistance = distances.reduce((sum, d) => sum + d, 0) / distances.length;
-    return avgDistance / (Math.abs(value - mean) + 1);
-  }
-  deduplicateAndRankAnomalies(anomalies) {
-    const unique = /* @__PURE__ */ new Map();
-    for (const anomaly of anomalies) {
-      const key = `${anomaly.metricType}_${JSON.stringify(anomaly.dimensions)}_${anomaly.timestamp.toISOString()}`;
-      if (!unique.has(key) || unique.get(key).confidence < anomaly.confidence) {
-        unique.set(key, anomaly);
-      }
-    }
-    return Array.from(unique.values()).sort((a, b) => b.confidence - a.confidence);
-  }
-  generateTrendRecommendations(beforeTrend, afterTrend, metricType) {
-    const recommendations = [];
-    const isIncreasing = afterTrend > beforeTrend;
-    const change = Math.abs(afterTrend - beforeTrend);
-    switch (metricType) {
-      case "message_failed" /* MESSAGE_FAILED */:
-        if (isIncreasing) {
-          recommendations.push(
-            "Investigate provider API issues",
-            "Review recent template changes",
-            "Check recipient data quality"
-          );
-        }
-        break;
-      case "delivery_rate" /* DELIVERY_RATE */:
-        if (!isIncreasing) {
-          recommendations.push(
-            "Monitor provider performance",
-            "Verify network connectivity",
-            "Check for carrier-specific issues"
-          );
-        }
-        break;
-      case "message_sent" /* MESSAGE_SENT */:
-        if (isIncreasing) {
-          recommendations.push(
-            "Monitor system capacity",
-            "Prepare for increased load",
-            "Check rate limiting settings"
-          );
-        } else {
-          recommendations.push(
-            "Investigate traffic decrease",
-            "Check for system issues",
-            "Review campaign status"
-          );
-        }
-        break;
-    }
-    if (change > 2) {
-      recommendations.push("Consider immediate investigation due to significant change");
-    }
-    return recommendations;
-  }
-};
-
-// src/insights/recommendation.engine.ts
-var RecommendationEngine = class {
-  config;
-  recommendations = /* @__PURE__ */ new Map();
-  ruleExecutionHistory = /* @__PURE__ */ new Map();
-  defaultConfig = {
-    rules: [],
-    enableMachineLearning: false,
-    confidenceThreshold: 0.7,
-    maxRecommendations: 10,
-    categories: [
-      { id: "cost", name: "Cost Optimization", description: "Reduce operational costs", weight: 0.8 },
-      { id: "performance", name: "Performance", description: "Improve system performance", weight: 0.9 },
-      { id: "reliability", name: "Reliability", description: "Enhance system reliability", weight: 1 },
-      { id: "security", name: "Security", description: "Strengthen security posture", weight: 0.95 }
-    ]
-  };
-  constructor(config = {}) {
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeDefaultRules();
-  }
-  /**
-   * 메트릭 기반 추천 생성
-   */
-  async generateRecommendations(metrics) {
-    const recommendations = [];
-    const ruleBasedRecommendations = await this.generateRuleBasedRecommendations(metrics);
-    recommendations.push(...ruleBasedRecommendations);
-    const patternBasedRecommendations = await this.generatePatternBasedRecommendations(metrics);
-    recommendations.push(...patternBasedRecommendations);
-    const comparisonBasedRecommendations = await this.generateComparisonBasedRecommendations(metrics);
-    recommendations.push(...comparisonBasedRecommendations);
-    if (this.config.enableMachineLearning) {
-      const mlRecommendations = await this.generateMLBasedRecommendations(metrics);
-      recommendations.push(...mlRecommendations);
-    }
-    const filteredRecommendations = this.deduplicateAndPrioritize(recommendations);
-    for (const recommendation of filteredRecommendations) {
-      this.recommendations.set(recommendation.id, recommendation);
-    }
-    return filteredRecommendations.slice(0, this.config.maxRecommendations);
-  }
-  /**
-   * 특정 카테고리 추천 조회
-   */
-  getRecommendationsByCategory(category) {
-    return Array.from(this.recommendations.values()).filter((r) => r.category === category).sort((a, b) => b.priority - a.priority);
-  }
-  /**
-   * 추천 실행 상태 업데이트
-   */
-  markRecommendationAsImplemented(recommendationId) {
-    const recommendation = this.recommendations.get(recommendationId);
-    if (!recommendation) return false;
-    this.recommendations.delete(recommendationId);
-    return true;
-  }
-  /**
-   * 추천 무시
-   */
-  dismissRecommendation(recommendationId, reason) {
-    const recommendation = this.recommendations.get(recommendationId);
-    if (!recommendation) return false;
-    this.recommendations.delete(recommendationId);
-    return true;
-  }
-  /**
-   * 추천 통계
-   */
-  getRecommendationStats() {
-    const recommendations = Array.from(this.recommendations.values());
-    const byCategory = {};
-    const byImpact = {};
-    const byPriority = {};
-    for (const rec of recommendations) {
-      byCategory[rec.category] = (byCategory[rec.category] || 0) + 1;
-      byImpact[rec.impact] = (byImpact[rec.impact] || 0) + 1;
-      const priorityLevel = rec.priority >= 8 ? "high" : rec.priority >= 5 ? "medium" : "low";
-      byPriority[priorityLevel] = (byPriority[priorityLevel] || 0) + 1;
-    }
-    return {
-      total: recommendations.length,
-      byCategory,
-      byImpact,
-      byPriority
-    };
-  }
-  async generateRuleBasedRecommendations(metrics) {
-    const recommendations = [];
-    for (const rule of this.config.rules) {
-      if (!rule.enabled) continue;
-      try {
-        const matchingMetrics = this.evaluateRuleConditions(rule, metrics);
-        if (matchingMetrics.length > 0) {
-          const recommendation = await this.createRecommendationFromRule(rule, matchingMetrics);
-          if (recommendation && recommendation.confidence >= this.config.confidenceThreshold) {
-            recommendations.push(recommendation);
-            this.recordRuleExecution(rule.id);
-          }
-        }
-      } catch (error) {
-        console.error(`Rule execution failed for rule ${rule.id}:`, error);
-      }
-    }
-    return recommendations;
-  }
-  async generatePatternBasedRecommendations(metrics) {
-    const recommendations = [];
-    const timePatterns = this.analyzeTimePatterns(metrics);
-    recommendations.push(...this.generateTimeBasedRecommendations(timePatterns));
-    const channelPatterns = this.analyzeChannelPatterns(metrics);
-    recommendations.push(...this.generateChannelBasedRecommendations(channelPatterns));
-    const errorPatterns = this.analyzeErrorPatterns(metrics);
-    recommendations.push(...this.generateErrorBasedRecommendations(errorPatterns));
-    return recommendations;
-  }
-  async generateComparisonBasedRecommendations(metrics) {
-    const recommendations = [];
-    const providerComparison = this.compareProviderPerformance(metrics);
-    recommendations.push(...this.generateProviderRecommendations(providerComparison));
-    const channelComparison = this.compareChannelEfficiency(metrics);
-    recommendations.push(...this.generateChannelEfficiencyRecommendations(channelComparison));
-    return recommendations;
-  }
-  async generateMLBasedRecommendations(metrics) {
-    const recommendations = [];
-    const capacityRecommendations = await this.generateCapacityRecommendations(metrics);
-    recommendations.push(...capacityRecommendations);
-    return recommendations;
-  }
-  evaluateRuleConditions(rule, metrics) {
-    const matchingMetrics = [];
-    for (const condition of rule.conditions) {
-      const relevantMetrics = metrics.filter((m) => {
-        if (m.type !== condition.metric) return false;
-        if (condition.dimensions) {
-          for (const [key, value] of Object.entries(condition.dimensions)) {
-            if (m.dimensions[key] !== value) return false;
-          }
-        }
-        return true;
-      });
-      for (const metric of relevantMetrics) {
-        if (this.evaluateCondition(metric, condition)) {
-          matchingMetrics.push(metric);
-        }
-      }
-    }
-    return matchingMetrics;
-  }
-  evaluateCondition(metric, condition) {
-    const value = metric.aggregations.avg;
-    switch (condition.operator) {
-      case "gt":
-        return value > condition.value;
-      case "lt":
-        return value < condition.value;
-      case "gte":
-        return value >= condition.value;
-      case "lte":
-        return value <= condition.value;
-      case "eq":
-        return value === condition.value;
-      case "between":
-        const [min, max] = condition.value;
-        return value >= min && value <= max;
-      case "trend":
-        return false;
-      default:
-        return false;
-    }
-  }
-  async createRecommendationFromRule(rule, matchingMetrics) {
-    if (rule.actions.length === 0) return null;
-    const confidence = this.calculateRuleConfidence(rule, matchingMetrics);
-    const impact = this.calculateAggregateImpact(rule.actions);
-    const effort = this.calculateAggregateEffort(rule.actions);
-    return {
-      id: `rule_${rule.id}_${Date.now()}`,
-      category: rule.category,
-      priority: rule.priority,
-      title: rule.name,
-      description: `Based on analysis of ${matchingMetrics.length} metrics`,
-      rationale: this.generateRationale(rule, matchingMetrics),
-      actions: rule.actions,
-      confidence,
-      impact,
-      effort,
-      createdAt: /* @__PURE__ */ new Date(),
-      validUntil: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3),
-      // 1주일
-      metadata: {
-        ruleIds: [rule.id],
-        triggeredBy: {
-          metrics: matchingMetrics.map((m) => ({
-            type: m.type,
-            value: m.aggregations.avg,
-            timestamp: m.timestamp
-          })),
-          conditions: rule.conditions.map((c) => `${c.metric} ${c.operator} ${c.value}`)
-        }
-      }
-    };
-  }
-  analyzeTimePatterns(metrics) {
-    const hourlyUsage = /* @__PURE__ */ new Map();
-    const dailyUsage = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const hour = metric.timestamp.getHours();
-      const dayOfWeek = metric.timestamp.getDay();
-      hourlyUsage.set(hour, (hourlyUsage.get(hour) || 0) + metric.aggregations.sum);
-      dailyUsage.set(dayOfWeek, (dailyUsage.get(dayOfWeek) || 0) + metric.aggregations.sum);
-    }
-    return { hourlyUsage, dailyUsage };
-  }
-  generateTimeBasedRecommendations(timePatterns) {
-    const recommendations = [];
-    const { hourlyUsage, dailyUsage } = timePatterns;
-    const peakHour = Array.from(hourlyUsage.entries()).reduce(
-      (max, curr) => curr[1] > max[1] ? curr : max,
-      [0, 0]
-    );
-    if (peakHour[1] > 0) {
-      recommendations.push({
-        id: `time_peak_${Date.now()}`,
-        category: "performance",
-        priority: 7,
-        title: "Optimize for Peak Hours",
-        description: `Peak usage occurs at ${peakHour[0]}:00. Consider load balancing optimizations.`,
-        rationale: "High traffic concentration during peak hours may impact performance",
-        actions: [{
-          type: "performance",
-          title: "Implement Load Balancing",
-          description: "Configure load balancing to distribute traffic during peak hours",
-          impact: "medium",
-          effort: "medium",
-          steps: [
-            "Set up multiple provider connections",
-            "Implement round-robin distribution",
-            "Monitor performance during peak hours"
-          ]
-        }],
-        confidence: 0.8,
-        impact: "medium",
-        effort: "medium",
-        createdAt: /* @__PURE__ */ new Date(),
-        metadata: {
-          ruleIds: [],
-          triggeredBy: {
-            metrics: [],
-            conditions: [`Peak hour usage: ${peakHour[1]} at ${peakHour[0]}:00`]
-          }
-        }
-      });
-    }
-    return recommendations;
-  }
-  analyzeChannelPatterns(metrics) {
-    const channelUsage = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const channel = metric.dimensions.channel || "unknown";
-      const stats = channelUsage.get(channel) || { sent: 0, delivered: 0, failed: 0 };
-      if (metric.type === "message_sent" /* MESSAGE_SENT */) {
-        stats.sent += metric.aggregations.sum;
-      } else if (metric.type === "message_delivered" /* MESSAGE_DELIVERED */) {
-        stats.delivered += metric.aggregations.sum;
-      } else if (metric.type === "message_failed" /* MESSAGE_FAILED */) {
-        stats.failed += metric.aggregations.sum;
-      }
-      channelUsage.set(channel, stats);
-    }
-    return { channelUsage };
-  }
-  generateChannelBasedRecommendations(channelPatterns) {
-    const recommendations = [];
-    const { channelUsage } = channelPatterns;
-    for (const [channel, stats] of channelUsage.entries()) {
-      const deliveryRate = stats.sent > 0 ? stats.delivered / stats.sent * 100 : 0;
-      const failureRate = stats.sent > 0 ? stats.failed / stats.sent * 100 : 0;
-      if (deliveryRate < 90 && stats.sent > 100) {
-        recommendations.push({
-          id: `channel_delivery_${channel}_${Date.now()}`,
-          category: "reliability",
-          priority: 8,
-          title: `Improve ${channel} Channel Reliability`,
-          description: `${channel} channel has ${deliveryRate.toFixed(1)}% delivery rate`,
-          rationale: "Low delivery rate impacts customer experience and wastes resources",
-          actions: [{
-            type: "reliability",
-            title: "Investigate Channel Issues",
-            description: `Analyze and fix delivery issues for ${channel} channel`,
-            impact: "high",
-            effort: "medium",
-            steps: [
-              `Review ${channel} provider configuration`,
-              "Check template approval status",
-              "Analyze failure patterns",
-              "Implement fallback mechanisms"
-            ]
-          }],
-          confidence: 0.9,
-          impact: "high",
-          effort: "medium",
-          createdAt: /* @__PURE__ */ new Date(),
-          metadata: {
-            ruleIds: [],
-            triggeredBy: {
-              metrics: [],
-              conditions: [`${channel} delivery rate: ${deliveryRate.toFixed(1)}%`]
-            }
-          }
-        });
-      }
-    }
-    return recommendations;
-  }
-  analyzeErrorPatterns(metrics) {
-    const errorsByCode = /* @__PURE__ */ new Map();
-    const errorsByProvider = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      if (metric.type === "message_failed" /* MESSAGE_FAILED */) {
-        const errorCode = metric.dimensions.errorCode || "unknown";
-        const provider = metric.dimensions.provider || "unknown";
-        errorsByCode.set(errorCode, (errorsByCode.get(errorCode) || 0) + metric.aggregations.sum);
-        errorsByProvider.set(provider, (errorsByProvider.get(provider) || 0) + metric.aggregations.sum);
-      }
-    }
-    return { errorsByCode, errorsByProvider };
-  }
-  generateErrorBasedRecommendations(errorPatterns) {
-    const recommendations = [];
-    const { errorsByCode, errorsByProvider } = errorPatterns;
-    if (errorsByCode.size > 0) {
-      const topError = Array.from(errorsByCode.entries()).reduce(
-        (max, curr) => curr[1] > max[1] ? curr : max
-      );
-      if (topError[1] > 10) {
-        recommendations.push({
-          id: `error_${topError[0]}_${Date.now()}`,
-          category: "reliability",
-          priority: 9,
-          title: `Address Frequent Error: ${topError[0]}`,
-          description: `Error code ${topError[0]} occurred ${topError[1]} times`,
-          rationale: "Frequent errors indicate systematic issues that need attention",
-          actions: [{
-            type: "reliability",
-            title: "Fix Recurring Error",
-            description: `Investigate and resolve error code ${topError[0]}`,
-            impact: "high",
-            effort: "high",
-            steps: [
-              "Analyze error logs and patterns",
-              "Identify root cause",
-              "Implement fix or workaround",
-              "Add monitoring for this error type"
-            ]
-          }],
-          confidence: 0.95,
-          impact: "high",
-          effort: "high",
-          createdAt: /* @__PURE__ */ new Date(),
-          metadata: {
-            ruleIds: [],
-            triggeredBy: {
-              metrics: [],
-              conditions: [`Error ${topError[0]}: ${topError[1]} occurrences`]
-            }
-          }
-        });
-      }
-    }
-    return recommendations;
-  }
-  compareProviderPerformance(metrics) {
-    const providerStats = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const provider = metric.dimensions.provider;
-      if (!provider) continue;
-      const stats = providerStats.get(provider) || { sent: 0, delivered: 0, avgResponseTime: 0 };
-      if (metric.type === "message_sent" /* MESSAGE_SENT */) {
-        stats.sent += metric.aggregations.sum;
-      } else if (metric.type === "message_delivered" /* MESSAGE_DELIVERED */) {
-        stats.delivered += metric.aggregations.sum;
-      }
-      providerStats.set(provider, stats);
-    }
-    return { providerStats };
-  }
-  generateProviderRecommendations(providerComparison) {
-    const recommendations = [];
-    const { providerStats } = providerComparison;
-    const providers = Array.from(providerStats.entries()).map(([provider, stats]) => ({
-      provider,
-      deliveryRate: stats.sent > 0 ? stats.delivered / stats.sent * 100 : 0,
-      volume: stats.sent
-    }));
-    if (providers.length > 1) {
-      const bestProvider = providers.reduce(
-        (best, curr) => curr.deliveryRate > best.deliveryRate ? curr : best
-      );
-      const worstProvider = providers.reduce(
-        (worst, curr) => curr.deliveryRate < worst.deliveryRate ? curr : worst
-      );
-      if (bestProvider.deliveryRate - worstProvider.deliveryRate > 10) {
-        recommendations.push({
-          id: `provider_optimization_${Date.now()}`,
-          category: "cost",
-          priority: 6,
-          title: "Optimize Provider Usage",
-          description: `${bestProvider.provider} has ${bestProvider.deliveryRate.toFixed(1)}% delivery rate vs ${worstProvider.provider} at ${worstProvider.deliveryRate.toFixed(1)}%`,
-          rationale: "Shifting traffic to better-performing providers can improve delivery rates and reduce costs",
-          actions: [{
-            type: "optimization",
-            title: "Rebalance Provider Traffic",
-            description: "Increase traffic to high-performing providers",
-            impact: "medium",
-            effort: "low",
-            steps: [
-              `Reduce traffic allocation to ${worstProvider.provider}`,
-              `Increase traffic allocation to ${bestProvider.provider}`,
-              "Monitor performance changes",
-              "Adjust allocation based on results"
-            ]
-          }],
-          confidence: 0.85,
-          impact: "medium",
-          effort: "low",
-          createdAt: /* @__PURE__ */ new Date(),
-          metadata: {
-            ruleIds: [],
-            triggeredBy: {
-              metrics: [],
-              conditions: [
-                `${bestProvider.provider}: ${bestProvider.deliveryRate.toFixed(1)}%`,
-                `${worstProvider.provider}: ${worstProvider.deliveryRate.toFixed(1)}%`
-              ]
-            }
-          }
-        });
-      }
-    }
-    return recommendations;
-  }
-  compareChannelEfficiency(metrics) {
-    return {};
-  }
-  generateChannelEfficiencyRecommendations(channelComparison) {
-    return [];
-  }
-  async generateCapacityRecommendations(metrics) {
-    const recommendations = [];
-    const messageSentMetrics = metrics.filter((m) => m.type === "message_sent" /* MESSAGE_SENT */);
-    if (messageSentMetrics.length > 0) {
-      const recentVolume = messageSentMetrics.filter((m) => m.timestamp > new Date(Date.now() - 24 * 60 * 60 * 1e3)).reduce((sum, m) => sum + m.aggregations.sum, 0);
-      const historicalAverage = messageSentMetrics.reduce((sum, m) => sum + m.aggregations.sum, 0) / messageSentMetrics.length;
-      if (recentVolume > historicalAverage * 1.5) {
-        recommendations.push({
-          id: `capacity_scale_${Date.now()}`,
-          category: "performance",
-          priority: 7,
-          title: "Consider Capacity Scaling",
-          description: `Recent volume (${recentVolume}) is 50% above historical average (${historicalAverage.toFixed(0)})`,
-          rationale: "Sustained high volume may require additional capacity",
-          actions: [{
-            type: "performance",
-            title: "Scale Infrastructure",
-            description: "Prepare for increased load by scaling infrastructure",
-            impact: "high",
-            effort: "high",
-            steps: [
-              "Monitor system resource utilization",
-              "Prepare additional provider connections",
-              "Review rate limiting configurations",
-              "Plan for peak capacity scenarios"
-            ]
-          }],
-          confidence: 0.75,
-          impact: "high",
-          effort: "high",
-          createdAt: /* @__PURE__ */ new Date(),
-          metadata: {
-            ruleIds: [],
-            triggeredBy: {
-              metrics: [],
-              conditions: [`Recent volume: ${recentVolume}, Historical average: ${historicalAverage.toFixed(0)}`]
-            }
-          }
-        });
-      }
-    }
-    return recommendations;
-  }
-  calculateRuleConfidence(rule, matchingMetrics) {
-    const baseConfidence = 0.5;
-    const dataQualityBonus = Math.min(0.3, matchingMetrics.length / 10);
-    const priorityBonus = rule.priority / 10 * 0.2;
-    return Math.min(0.99, baseConfidence + dataQualityBonus + priorityBonus);
-  }
-  calculateAggregateImpact(actions) {
-    const impactScores = { low: 1, medium: 2, high: 3 };
-    const avgScore = actions.reduce((sum, action) => sum + impactScores[action.impact], 0) / actions.length;
-    if (avgScore >= 2.5) return "high";
-    if (avgScore >= 1.5) return "medium";
-    return "low";
-  }
-  calculateAggregateEffort(actions) {
-    const effortScores = { low: 1, medium: 2, high: 3 };
-    const avgScore = actions.reduce((sum, action) => sum + effortScores[action.effort], 0) / actions.length;
-    if (avgScore >= 2.5) return "high";
-    if (avgScore >= 1.5) return "medium";
-    return "low";
-  }
-  generateRationale(rule, matchingMetrics) {
-    const metricSummary = matchingMetrics.length > 0 ? `Based on ${matchingMetrics.length} metrics showing concerning patterns` : "Based on rule evaluation";
-    return `${metricSummary}. ${rule.name} conditions have been met, indicating potential optimization opportunities.`;
-  }
-  recordRuleExecution(ruleId) {
-    const history = this.ruleExecutionHistory.get(ruleId) || [];
-    history.push(/* @__PURE__ */ new Date());
-    if (history.length > 100) {
-      history.splice(0, history.length - 100);
-    }
-    this.ruleExecutionHistory.set(ruleId, history);
-  }
-  deduplicateAndPrioritize(recommendations) {
-    const uniqueRecommendations = /* @__PURE__ */ new Map();
-    for (const rec of recommendations) {
-      const key = `${rec.category}_${rec.title}`;
-      if (!uniqueRecommendations.has(key) || uniqueRecommendations.get(key).confidence < rec.confidence) {
-        uniqueRecommendations.set(key, rec);
-      }
-    }
-    return Array.from(uniqueRecommendations.values()).sort((a, b) => {
-      if (a.priority !== b.priority) return b.priority - a.priority;
-      return b.confidence - a.confidence;
-    });
-  }
-  initializeDefaultRules() {
-    this.config.rules.push(
-      {
-        id: "low-delivery-rate",
-        name: "Low Delivery Rate Alert",
-        category: "reliability",
-        priority: 9,
-        conditions: [
-          { metric: "delivery_rate" /* DELIVERY_RATE */, operator: "lt", value: 90 }
-        ],
-        actions: [{
-          type: "reliability",
-          title: "Improve Delivery Rate",
-          description: "Investigate and fix delivery rate issues",
-          impact: "high",
-          effort: "medium",
-          steps: [
-            "Check provider API status",
-            "Review template approval status",
-            "Validate recipient phone numbers",
-            "Consider switching providers"
-          ]
-        }],
-        enabled: true
-      },
-      {
-        id: "high-error-rate",
-        name: "High Error Rate Warning",
-        category: "reliability",
-        priority: 8,
-        conditions: [
-          { metric: "error_rate" /* ERROR_RATE */, operator: "gt", value: 10 }
-        ],
-        actions: [{
-          type: "reliability",
-          title: "Reduce Error Rate",
-          description: "Address high error rates",
-          impact: "high",
-          effort: "high",
-          steps: [
-            "Analyze error patterns",
-            "Fix common error causes",
-            "Implement better error handling",
-            "Add monitoring and alerts"
-          ]
-        }],
-        enabled: true
-      },
-      {
-        id: "cost-optimization-sms",
-        name: "SMS to AlimTalk Migration",
-        category: "cost",
-        priority: 6,
-        conditions: [
-          { metric: "channel_usage" /* CHANNEL_USAGE */, operator: "gt", value: 1e3, dimensions: { channel: "sms" } }
-        ],
-        actions: [{
-          type: "cost-saving",
-          title: "Migrate to AlimTalk",
-          description: "Switch eligible SMS messages to AlimTalk for cost savings",
-          impact: "medium",
-          effort: "medium",
-          steps: [
-            "Identify AlimTalk-eligible messages",
-            "Create AlimTalk templates",
-            "Implement fallback logic",
-            "Monitor cost savings"
-          ],
-          estimatedBenefit: {
-            metric: "message_sent" /* MESSAGE_SENT */,
-            improvement: 30,
-            unit: "percent cost reduction"
-          }
-        }],
-        enabled: true
-      }
-    );
-  }
-};
-
-// src/reports/dashboard.ts
-var DashboardGenerator = class {
-  config;
-  dataCache = /* @__PURE__ */ new Map();
-  defaultConfig = {
-    refreshInterval: 3e4,
-    // 30초
-    timeRange: {
-      default: "1h",
-      options: ["15m", "1h", "4h", "1d", "1w", "1m"]
-    },
-    widgets: [],
-    filters: [
-      {
-        id: "provider",
-        name: "Provider",
-        type: "multi-select",
-        field: "provider",
-        options: []
-      },
-      {
-        id: "channel",
-        name: "Channel",
-        type: "multi-select",
-        field: "channel",
-        options: []
-      }
-    ]
-  };
-  constructor(config = {}) {
-    this.config = { ...this.defaultConfig, ...config };
-    this.initializeDefaultWidgets();
-  }
-  /**
-   * 대시보드 데이터 생성
-   */
-  async generateDashboard(timeRange, filters = {}, metrics = []) {
-    const dashboard = {
-      timestamp: /* @__PURE__ */ new Date(),
-      timeRange,
-      kpis: [],
-      widgets: [],
-      insights: [],
-      filters
-    };
-    try {
-      dashboard.kpis = await this.calculateKPIs(metrics, timeRange, filters);
-      dashboard.widgets = await this.generateWidgetData(metrics, timeRange, filters);
-      dashboard.insights = [];
-    } catch (error) {
-      console.error("Dashboard generation failed:", error);
-    }
-    return dashboard;
-  }
-  /**
-   * 실시간 대시보드 스트림
-   */
-  async *streamDashboard(timeRange, filters = {}) {
-    while (true) {
-      const dashboard = await this.generateDashboard(timeRange, filters);
-      yield dashboard;
-      await new Promise((resolve) => setTimeout(resolve, this.config.refreshInterval));
-    }
-  }
-  /**
-   * 특정 위젯 데이터 업데이트
-   */
-  async updateWidget(widgetId, metrics, timeRange, filters = {}) {
-    const widget = this.config.widgets.find((w) => w.id === widgetId);
-    if (!widget) return null;
-    try {
-      const data = await this.generateWidgetData([widget], metrics, timeRange, filters);
-      return data[0] || null;
-    } catch (error) {
-      return {
-        id: widgetId,
-        title: widget.title,
-        type: widget.type,
-        data: null,
-        lastUpdated: /* @__PURE__ */ new Date(),
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * 대시보드 구성 업데이트
-   */
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  /**
-   * 위젯 추가
-   */
-  addWidget(widget) {
-    this.config.widgets.push(widget);
-  }
-  /**
-   * 위젯 제거
-   */
-  removeWidget(widgetId) {
-    const index = this.config.widgets.findIndex((w) => w.id === widgetId);
-    if (index >= 0) {
-      this.config.widgets.splice(index, 1);
-      return true;
-    }
-    return false;
-  }
-  async calculateKPIs(metrics, timeRange, filters) {
-    const kpis = [];
-    const duration = timeRange.end.getTime() - timeRange.start.getTime();
-    const previousTimeRange = {
-      start: new Date(timeRange.start.getTime() - duration),
-      end: timeRange.start
-    };
-    const sentMetrics = this.filterMetrics(metrics, "message_sent" /* MESSAGE_SENT */, filters);
-    const totalSent = sentMetrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-    const previousSent = this.calculatePreviousPeriodValue(sentMetrics, previousTimeRange);
-    kpis.push({
-      id: "total_sent",
-      name: "Total Messages Sent",
-      value: totalSent,
-      previousValue: previousSent,
-      change: totalSent - previousSent,
-      changePercent: previousSent > 0 ? (totalSent - previousSent) / previousSent * 100 : 0,
-      trend: totalSent > previousSent ? "up" : totalSent < previousSent ? "down" : "stable",
-      unit: "messages",
-      status: "good"
-    });
-    const deliveredMetrics = this.filterMetrics(metrics, "message_delivered" /* MESSAGE_DELIVERED */, filters);
-    const totalDelivered = deliveredMetrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-    const deliveryRate = totalSent > 0 ? totalDelivered / totalSent * 100 : 0;
-    kpis.push({
-      id: "delivery_rate",
-      name: "Delivery Rate",
-      value: deliveryRate,
-      trend: deliveryRate >= 95 ? "up" : deliveryRate >= 90 ? "stable" : "down",
-      unit: "%",
-      target: 95,
-      status: deliveryRate >= 95 ? "good" : deliveryRate >= 85 ? "warning" : "critical"
-    });
-    const failedMetrics = this.filterMetrics(metrics, "message_failed" /* MESSAGE_FAILED */, filters);
-    const totalFailed = failedMetrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-    const errorRate = totalSent > 0 ? totalFailed / totalSent * 100 : 0;
-    kpis.push({
-      id: "error_rate",
-      name: "Error Rate",
-      value: errorRate,
-      trend: errorRate <= 5 ? "down" : errorRate <= 10 ? "stable" : "up",
-      unit: "%",
-      target: 5,
-      status: errorRate <= 5 ? "good" : errorRate <= 15 ? "warning" : "critical"
-    });
-    const clickedMetrics = this.filterMetrics(metrics, "message_clicked" /* MESSAGE_CLICKED */, filters);
-    const totalClicked = clickedMetrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-    const clickRate = totalDelivered > 0 ? totalClicked / totalDelivered * 100 : 0;
-    kpis.push({
-      id: "click_rate",
-      name: "Click Rate",
-      value: clickRate,
-      trend: "stable",
-      unit: "%",
-      status: "good"
-    });
-    return kpis;
-  }
-  async generateWidgetData(...args) {
-    let widgets;
-    let metrics;
-    let timeRange;
-    let filters;
-    if (args.length === 3) {
-      [metrics, timeRange, filters] = args;
-      widgets = this.config.widgets;
-    } else {
-      [widgets, metrics, timeRange, filters] = args;
-    }
-    const widgetData = [];
-    for (const widget of widgets) {
-      try {
-        const data = await this.generateSingleWidgetData(widget, metrics, timeRange, filters);
-        widgetData.push({
-          id: widget.id,
-          title: widget.title,
-          type: widget.type,
-          data,
-          lastUpdated: /* @__PURE__ */ new Date()
-        });
-      } catch (error) {
-        widgetData.push({
-          id: widget.id,
-          title: widget.title,
-          type: widget.type,
-          data: null,
-          lastUpdated: /* @__PURE__ */ new Date(),
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      }
-    }
-    return widgetData;
-  }
-  async generateSingleWidgetData(widget, metrics, timeRange, filters) {
-    const cacheKey = `${widget.id}_${JSON.stringify(filters)}_${timeRange.start.getTime()}_${timeRange.end.getTime()}`;
-    const cached = this.dataCache.get(cacheKey);
-    const cacheExpiration = widget.refreshInterval || this.config.refreshInterval;
-    if (cached && Date.now() - cached.timestamp.getTime() < cacheExpiration) {
-      return cached.data;
-    }
-    const filteredMetrics = this.applyQueryFilters(metrics, widget.query, filters);
-    let data;
-    switch (widget.type) {
-      case "metric":
-        data = this.generateMetricWidgetData(filteredMetrics, widget.visualization);
-        break;
-      case "chart":
-        data = this.generateChartWidgetData(filteredMetrics, widget.visualization);
-        break;
-      case "table":
-        data = this.generateTableWidgetData(filteredMetrics, widget.visualization);
-        break;
-      case "gauge":
-        data = this.generateGaugeWidgetData(filteredMetrics, widget.visualization);
-        break;
-      case "heatmap":
-        data = this.generateHeatmapWidgetData(filteredMetrics, widget.visualization);
-        break;
-      case "trend":
-        data = this.generateTrendWidgetData(filteredMetrics, widget.visualization);
-        break;
-      default:
-        data = null;
-    }
-    this.dataCache.set(cacheKey, { data, timestamp: /* @__PURE__ */ new Date() });
-    return data;
-  }
-  generateMetricWidgetData(metrics, config) {
-    const aggregation = config.aggregation || "sum";
-    let value = 0;
-    switch (aggregation) {
-      case "sum":
-        value = metrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-        break;
-      case "avg":
-        value = metrics.reduce((sum, m) => sum + m.aggregations.avg, 0) / Math.max(metrics.length, 1);
-        break;
-      case "min":
-        value = Math.min(...metrics.map((m) => m.aggregations.min));
-        break;
-      case "max":
-        value = Math.max(...metrics.map((m) => m.aggregations.max));
-        break;
-      case "count":
-        value = metrics.length;
-        break;
-    }
-    return {
-      value: isFinite(value) ? value : 0,
-      formatted: this.formatValue(value, config),
-      timestamp: /* @__PURE__ */ new Date()
-    };
-  }
-  generateChartWidgetData(metrics, config) {
-    const chartType = config.chartType || "line";
-    if (config.groupBy && config.groupBy.length > 0) {
-      return this.generateGroupedChartData(metrics, config);
-    }
-    const sortedMetrics = metrics.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    const data = sortedMetrics.map((metric) => ({
-      x: metric.timestamp,
-      y: this.getAggregatedValue(metric, config.aggregation || "avg"),
-      label: metric.timestamp.toISOString()
-    }));
-    return {
-      type: chartType,
-      data: [{
-        name: "Series 1",
-        data,
-        color: config.colors?.[0] || "#3b82f6"
-      }],
-      options: {
-        xAxis: config.xAxis,
-        yAxis: config.yAxis,
-        showLegend: config.showLegend ?? true,
-        showGrid: config.showGrid ?? true
-      }
-    };
-  }
-  generateGroupedChartData(metrics, config) {
-    const groupBy = config.groupBy[0];
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const key = metric.dimensions[groupBy] || "Unknown";
-      if (!grouped.has(key)) {
-        grouped.set(key, []);
-      }
-      grouped.get(key).push(metric);
-    }
-    const series = Array.from(grouped.entries()).map(([name, groupMetrics], index) => ({
-      name,
-      data: groupMetrics.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime()).map((m) => ({
-        x: m.timestamp,
-        y: this.getAggregatedValue(m, config.aggregation || "avg")
-      })),
-      color: config.colors?.[index % (config.colors?.length || 1)] || this.getDefaultColor(index)
-    }));
-    return {
-      type: config.chartType || "line",
-      data: series,
-      options: {
-        xAxis: config.xAxis,
-        yAxis: config.yAxis,
-        showLegend: config.showLegend ?? true,
-        showGrid: config.showGrid ?? true
-      }
-    };
-  }
-  generateTableWidgetData(metrics, config) {
-    const groupBy = config.groupBy || ["provider", "channel"];
-    const grouped = /* @__PURE__ */ new Map();
-    for (const metric of metrics) {
-      const key = groupBy.map((field) => metric.dimensions[field] || "Unknown").join("|");
-      if (!grouped.has(key)) {
-        grouped.set(key, []);
-      }
-      grouped.get(key).push(metric);
-    }
-    const columns = [
-      ...groupBy.map((field) => ({ key: field, title: field.charAt(0).toUpperCase() + field.slice(1) })),
-      { key: "count", title: "Count" },
-      { key: "sum", title: "Sum" },
-      { key: "avg", title: "Average" }
-    ];
-    const rows = Array.from(grouped.entries()).map(([key, groupMetrics]) => {
-      const dimensions = key.split("|");
-      const row = {};
-      groupBy.forEach((field, index) => {
-        row[field] = dimensions[index];
-      });
-      row.count = groupMetrics.length;
-      row.sum = groupMetrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-      row.avg = groupMetrics.reduce((sum, m) => sum + m.aggregations.avg, 0) / groupMetrics.length;
-      return row;
-    });
-    return {
-      columns,
-      rows: rows.sort((a, b) => b.sum - a.sum)
-      // 합계 기준 내림차순 정렬
-    };
-  }
-  generateGaugeWidgetData(metrics, config) {
-    const value = this.generateMetricWidgetData(metrics, config).value;
-    return {
-      value,
-      min: config.yAxis?.min || 0,
-      max: config.yAxis?.max || 100,
-      thresholds: [
-        { value: 25, color: "#ef4444" },
-        { value: 50, color: "#f59e0b" },
-        { value: 75, color: "#10b981" },
-        { value: 100, color: "#3b82f6" }
-      ]
-    };
-  }
-  generateHeatmapWidgetData(metrics, config) {
-    const heatmapData = [];
-    for (const metric of metrics) {
-      const hour = metric.timestamp.getHours();
-      const dayOfWeek = metric.timestamp.getDay();
-      heatmapData.push({
-        x: hour,
-        y: dayOfWeek,
-        value: this.getAggregatedValue(metric, config.aggregation || "sum")
-      });
-    }
-    return {
-      data: heatmapData,
-      xLabels: Array.from({ length: 24 }, (_, i) => `${i}:00`),
-      yLabels: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
-    };
-  }
-  generateTrendWidgetData(metrics, config) {
-    const sortedMetrics = metrics.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    if (sortedMetrics.length < 2) {
-      return { trend: "stable", change: 0, changePercent: 0 };
-    }
-    const values = sortedMetrics.map((m) => this.getAggregatedValue(m, config.aggregation || "avg"));
-    const firstValue = values[0];
-    const lastValue = values[values.length - 1];
-    const change = lastValue - firstValue;
-    const changePercent = firstValue !== 0 ? change / firstValue * 100 : 0;
-    let trend = "stable";
-    if (Math.abs(changePercent) > 5) {
-      trend = changePercent > 0 ? "up" : "down";
-    }
-    return {
-      trend,
-      change: Math.round(change * 100) / 100,
-      changePercent: Math.round(changePercent * 100) / 100,
-      values: values.slice(-10),
-      // 최근 10개 값
-      sparkline: values.map((value, index) => ({ x: index, y: value }))
-    };
-  }
-  filterMetrics(metrics, type, filters) {
-    return metrics.filter((metric) => {
-      if (metric.type !== type) return false;
-      for (const [key, value] of Object.entries(filters)) {
-        if (Array.isArray(value)) {
-          if (!value.includes(metric.dimensions[key])) return false;
-        } else if (value && metric.dimensions[key] !== value) {
-          return false;
-        }
-      }
-      return true;
-    });
-  }
-  applyQueryFilters(metrics, query, filters) {
-    let filteredMetrics = metrics;
-    if (query.metrics && query.metrics.length > 0) {
-      filteredMetrics = filteredMetrics.filter((m) => query.metrics.includes(m.type));
-    }
-    if (query.dateRange) {
-      filteredMetrics = filteredMetrics.filter(
-        (m) => m.timestamp >= query.dateRange.start && m.timestamp <= query.dateRange.end
-      );
-    }
-    const combinedFilters = { ...query.filters, ...filters };
-    for (const [key, value] of Object.entries(combinedFilters)) {
-      if (value === void 0 || value === null) continue;
-      filteredMetrics = filteredMetrics.filter((m) => {
-        if (Array.isArray(value)) {
-          return value.includes(m.dimensions[key]);
-        }
-        return m.dimensions[key] === value;
-      });
-    }
-    return filteredMetrics;
-  }
-  calculatePreviousPeriodValue(metrics, previousTimeRange) {
-    const currentValue = metrics.reduce((sum, m) => sum + m.aggregations.sum, 0);
-    return currentValue * 0.9;
-  }
-  getAggregatedValue(metric, aggregation) {
-    switch (aggregation) {
-      case "sum":
-        return metric.aggregations.sum;
-      case "avg":
-        return metric.aggregations.avg;
-      case "min":
-        return metric.aggregations.min;
-      case "max":
-        return metric.aggregations.max;
-      case "count":
-        return metric.aggregations.count;
-      default:
-        return metric.aggregations.avg;
-    }
-  }
-  formatValue(value, config) {
-    if (!isFinite(value)) return "0";
-    if (value >= 1e6) {
-      return `${(value / 1e6).toFixed(1)}M`;
-    } else if (value >= 1e3) {
-      return `${(value / 1e3).toFixed(1)}K`;
-    }
-    return value.toFixed(0);
-  }
-  getDefaultColor(index) {
-    const colors = [
-      "#3b82f6",
-      "#ef4444",
-      "#10b981",
-      "#f59e0b",
-      "#8b5cf6",
-      "#06b6d4",
-      "#f97316",
-      "#84cc16"
-    ];
-    return colors[index % colors.length];
-  }
-  initializeDefaultWidgets() {
-    this.config.widgets = [
-      {
-        id: "messages_sent_chart",
-        type: "chart",
-        title: "Messages Sent Over Time",
-        position: { x: 0, y: 0, width: 6, height: 4 },
-        query: {
-          metrics: ["message_sent" /* MESSAGE_SENT */],
-          dateRange: { start: /* @__PURE__ */ new Date(), end: /* @__PURE__ */ new Date() },
-          interval: "hour"
-        },
-        visualization: {
-          chartType: "line",
-          aggregation: "sum",
-          showGrid: true
-        }
-      },
-      {
-        id: "delivery_rate_gauge",
-        type: "gauge",
-        title: "Delivery Rate",
-        position: { x: 6, y: 0, width: 3, height: 4 },
-        query: {
-          metrics: ["delivery_rate" /* DELIVERY_RATE */],
-          dateRange: { start: /* @__PURE__ */ new Date(), end: /* @__PURE__ */ new Date() }
-        },
-        visualization: {
-          aggregation: "avg",
-          yAxis: { min: 0, max: 100 }
-        }
-      },
-      {
-        id: "provider_performance_table",
-        type: "table",
-        title: "Provider Performance",
-        position: { x: 0, y: 4, width: 12, height: 4 },
-        query: {
-          metrics: ["message_sent" /* MESSAGE_SENT */, "message_delivered" /* MESSAGE_DELIVERED */, "message_failed" /* MESSAGE_FAILED */],
-          dateRange: { start: /* @__PURE__ */ new Date(), end: /* @__PURE__ */ new Date() }
-        },
-        visualization: {
-          groupBy: ["provider"],
-          aggregation: "sum"
-        }
-      }
-    ];
-  }
-};
-
-// src/reports/export.manager.ts
-var ExportManager = class {
-  config;
-  exports = /* @__PURE__ */ new Map();
-  exportQueue = [];
-  defaultConfig = {
-    formats: [
-      { type: "csv", options: { delimiter: ",", includeHeaders: true } },
-      { type: "json" },
-      { type: "pdf", options: { orientation: "portrait", pageSize: "A4" } }
-    ],
-    maxFileSize: 50 * 1024 * 1024,
-    // 50MB
-    compressionEnabled: true
-  };
-  constructor(config = {}) {
-    this.config = { ...this.defaultConfig, ...config };
-  }
-  /**
-   * 분석 보고서 내보내기
-   */
-  async exportReport(report, format, options = {}) {
-    const exportId = this.generateExportId();
-    try {
-      let result;
-      switch (format.type) {
-        case "csv":
-          result = await this.exportToCSV(report, { ...format.options, ...options }, exportId);
-          break;
-        case "excel":
-          result = await this.exportToExcel(report, { ...format.options, ...options }, exportId);
-          break;
-        case "pdf":
-          result = await this.exportToPDF(report, { ...format.options, ...options }, exportId);
-          break;
-        case "json":
-          result = await this.exportToJSON(report, { ...format.options, ...options }, exportId);
-          break;
-        case "xml":
-          result = await this.exportToXML(report, { ...format.options, ...options }, exportId);
-          break;
-        default:
-          throw new Error(`Unsupported export format: ${format.type}`);
-      }
-      this.exports.set(exportId, result);
-      return result;
-    } catch (error) {
-      throw new Error(`Export failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * 메트릭 데이터 내보내기
-   */
-  async exportMetrics(metrics, format, options = {}) {
-    const exportId = this.generateExportId();
-    try {
-      let result;
-      switch (format.type) {
-        case "csv":
-          result = await this.exportMetricsToCSV(metrics, { ...format.options, ...options }, exportId);
-          break;
-        case "json":
-          result = await this.exportMetricsToJSON(metrics, { ...format.options, ...options }, exportId);
-          break;
-        default:
-          throw new Error(`Metrics export not supported for format: ${format.type}`);
-      }
-      this.exports.set(exportId, result);
-      return result;
-    } catch (error) {
-      throw new Error(`Metrics export failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * 인사이트 데이터 내보내기
-   */
-  async exportInsights(insights, format, options = {}) {
-    const exportId = this.generateExportId();
-    try {
-      let result;
-      switch (format.type) {
-        case "csv":
-          result = await this.exportInsightsToCSV(insights, { ...format.options, ...options }, exportId);
-          break;
-        case "json":
-          result = await this.exportInsightsToJSON(insights, { ...format.options, ...options }, exportId);
-          break;
-        case "pdf":
-          result = await this.exportInsightsToPDF(insights, { ...format.options, ...options }, exportId);
-          break;
-        default:
-          throw new Error(`Insights export not supported for format: ${format.type}`);
-      }
-      this.exports.set(exportId, result);
-      return result;
-    } catch (error) {
-      throw new Error(`Insights export failed: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  }
-  /**
-   * 내보내기 상태 조회
-   */
-  getExportStatus(exportId) {
-    return this.exports.get(exportId) || null;
-  }
-  /**
-   * 내보내기 목록 조회
-   */
-  listExports(limit = 50) {
-    const exports2 = Array.from(this.exports.values()).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-    return exports2.slice(0, limit);
-  }
-  /**
-   * 내보내기 삭제
-   */
-  deleteExport(exportId) {
-    return this.exports.delete(exportId);
-  }
-  async exportToCSV(report, options, exportId) {
-    const delimiter = options.delimiter || ",";
-    const dateFormat = options.dateFormat || "yyyy-MM-dd HH:mm:ss";
-    let csvContent = "";
-    if (options.includeHeaders) {
-      csvContent += ["Metric Type", "Value", "Change", "Trend", "Breakdown"].join(delimiter) + "\n";
-    }
-    for (const metric of report.metrics) {
-      const row = [
-        metric.type.toString(),
-        metric.value.toString(),
-        (metric.change || 0).toString(),
-        metric.trend || "stable",
-        metric.breakdown ? JSON.stringify(metric.breakdown) : ""
-      ];
-      csvContent += row.map((cell) => `"${cell}"`).join(delimiter) + "\n";
-    }
-    const fileName = `report_${report.id}_${Date.now()}.csv`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(csvContent, "utf8");
-    if (fileSize > this.config.maxFileSize) {
-      throw new Error(`File size ${fileSize} exceeds maximum ${this.config.maxFileSize}`);
-    }
-    console.log(`Saving CSV to ${filePath}, size: ${fileSize} bytes`);
-    return {
-      id: exportId,
-      format: "csv",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-      // 24시간
-    };
-  }
-  async exportToExcel(report, options, exportId) {
-    const worksheetData = {
-      name: "Report",
-      data: report.metrics.map((metric) => ({
-        "Metric Type": metric.type,
-        "Value": metric.value,
-        "Change": metric.change || 0,
-        "Trend": metric.trend || "stable"
-      }))
-    };
-    const fileName = `report_${report.id}_${Date.now()}.xlsx`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = 10240;
-    console.log(`Generating Excel file: ${fileName}`);
-    return {
-      id: exportId,
-      format: "excel",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportToPDF(report, options, exportId) {
-    const template = options.template || "standard";
-    const orientation = options.orientation || "portrait";
-    console.log(`Generating PDF report with template: ${template}, orientation: ${orientation}`);
-    const fileName = `report_${report.id}_${Date.now()}.pdf`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = 25600;
-    return {
-      id: exportId,
-      format: "pdf",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportToJSON(report, options, exportId) {
-    const jsonContent = JSON.stringify(report, null, 2);
-    const fileName = `report_${report.id}_${Date.now()}.json`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(jsonContent, "utf8");
-    return {
-      id: exportId,
-      format: "json",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportToXML(report, options, exportId) {
-    let xmlContent = '<?xml version="1.0" encoding="UTF-8"?>\n';
-    xmlContent += "<report>\n";
-    xmlContent += `  <id>${report.id}</id>
-`;
-    xmlContent += `  <name>${report.name}</name>
-`;
-    xmlContent += `  <generatedAt>${report.generatedAt.toISOString()}</generatedAt>
-`;
-    xmlContent += "  <metrics>\n";
-    for (const metric of report.metrics) {
-      xmlContent += "    <metric>\n";
-      xmlContent += `      <type>${metric.type}</type>
-`;
-      xmlContent += `      <value>${metric.value}</value>
-`;
-      xmlContent += `      <change>${metric.change || 0}</change>
-`;
-      xmlContent += `      <trend>${metric.trend || "stable"}</trend>
-`;
-      xmlContent += "    </metric>\n";
-    }
-    xmlContent += "  </metrics>\n";
-    xmlContent += "</report>\n";
-    const fileName = `report_${report.id}_${Date.now()}.xml`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(xmlContent, "utf8");
-    return {
-      id: exportId,
-      format: "xml",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportMetricsToCSV(metrics, options, exportId) {
-    const delimiter = options.delimiter || ",";
-    let csvContent = "";
-    if (options.includeHeaders) {
-      csvContent += [
-        "Timestamp",
-        "Type",
-        "Interval",
-        "Count",
-        "Sum",
-        "Average",
-        "Min",
-        "Max",
-        "Dimensions"
-      ].join(delimiter) + "\n";
-    }
-    for (const metric of metrics) {
-      const row = [
-        metric.timestamp.toISOString(),
-        metric.type.toString(),
-        metric.interval,
-        metric.aggregations.count.toString(),
-        metric.aggregations.sum.toString(),
-        metric.aggregations.avg.toString(),
-        metric.aggregations.min.toString(),
-        metric.aggregations.max.toString(),
-        JSON.stringify(metric.dimensions)
-      ];
-      csvContent += row.map((cell) => `"${cell}"`).join(delimiter) + "\n";
-    }
-    const fileName = `metrics_${Date.now()}.csv`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(csvContent, "utf8");
-    return {
-      id: exportId,
-      format: "csv",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportMetricsToJSON(metrics, options, exportId) {
-    const jsonContent = JSON.stringify({
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      count: metrics.length,
-      metrics
-    }, null, 2);
-    const fileName = `metrics_${Date.now()}.json`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(jsonContent, "utf8");
-    return {
-      id: exportId,
-      format: "json",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportInsightsToCSV(insights, options, exportId) {
-    const delimiter = options.delimiter || ",";
-    let csvContent = "";
-    if (options.includeHeaders) {
-      csvContent += [
-        "ID",
-        "Type",
-        "Title",
-        "Description",
-        "Severity",
-        "Metric",
-        "Value",
-        "Confidence",
-        "Detected At",
-        "Recommendations"
-      ].join(delimiter) + "\n";
-    }
-    for (const insight of insights) {
-      const row = [
-        insight.id,
-        insight.type,
-        insight.title,
-        insight.description,
-        insight.severity,
-        insight.metric.toString(),
-        insight.value.toString(),
-        insight.confidence.toString(),
-        insight.detectedAt.toISOString(),
-        (insight.recommendations || []).join("; ")
-      ];
-      csvContent += row.map((cell) => `"${cell}"`).join(delimiter) + "\n";
-    }
-    const fileName = `insights_${Date.now()}.csv`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(csvContent, "utf8");
-    return {
-      id: exportId,
-      format: "csv",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportInsightsToJSON(insights, options, exportId) {
-    const jsonContent = JSON.stringify({
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      count: insights.length,
-      insights
-    }, null, 2);
-    const fileName = `insights_${Date.now()}.json`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = Buffer.byteLength(jsonContent, "utf8");
-    return {
-      id: exportId,
-      format: "json",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  async exportInsightsToPDF(insights, options, exportId) {
-    console.log(`Generating insights PDF with ${insights.length} insights`);
-    const fileName = `insights_${Date.now()}.pdf`;
-    const filePath = `/exports/${fileName}`;
-    const fileSize = 15360;
-    return {
-      id: exportId,
-      format: "pdf",
-      fileName,
-      filePath,
-      fileSize,
-      createdAt: /* @__PURE__ */ new Date(),
-      downloadUrl: `/api/exports/${exportId}/download`,
-      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3)
-    };
-  }
-  generateExportId() {
-    return `export_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnalyticsService,
-  AnomalyDetector,
-  DashboardGenerator,
-  EventCollector,
-  ExportManager,
-  InsightEngine,
-  MetricAggregator,
-  MetricType,
-  MetricsCollector,
-  RecommendationEngine,
-  ReportGenerator,
-  TimeSeriesAggregator,
-  WebhookCollector
-});
-//# sourceMappingURL=index.cjs.map