/**
 * Core interfaces for the NoSQL Time Series Storage Module
 */
import type { TimeSeriesPoint, TimeSeriesSchema, TimeRange, TimeSeriesQuery, TimeSeriesAggregationQuery, ContinuousQuery, AnomalyDetectionConfig, ForecastConfig, AggregationFunction } from '../../types/timeseries';
export interface TimeSeriesConfig {
    ingestion: IngestionConfig;
    storage: StorageConfig;
    query: QueryConfig;
    analytics: AnalyticsConfig;
    realtime: RealtimeConfig;
}
export interface IngestionConfig {
    batchSize: number;
    flushIntervalMs: number;
    maxConcurrentBatches: number;
    enableCompression: boolean;
    enableDeduplication: boolean;
    writeAheadLog?: {
        enabled: boolean;
        maxSizeBytes: number;
    };
}
export interface StorageConfig {
    hotTierRetentionHours: number;
    warmTierRetentionDays: number;
    coldTierRetentionDays: number;
    compressionEnabled: boolean;
    compressionType: 'gorilla' | 'zstd' | 'lz4' | 'snappy';
    shardingStrategy: 'time-based' | 'metric-based' | 'hash-based';
    shardIntervalHours: number;
    maxShardSizeBytes: number;
}
export interface QueryConfig {
    maxPointsPerQuery: number;
    defaultTimeoutMs: number;
    cacheEnabled: boolean;
    cacheTtlMs: number;
    enableQueryOptimization: boolean;
    enableParallelExecution: boolean;
}
export interface AnalyticsConfig {
    anomalyDetection: {
        enabled: boolean;
        defaultSensitivity: number;
        methods: string[];
        maxModelsPerMetric: number;
    };
    forecasting: {
        enabled: boolean;
        defaultHorizon: string;
        methods: string[];
        maxHistoryDays: number;
    };
    alerting: {
        enabled: boolean;
        maxAlertsPerMinute: number;
        channels: string[];
    };
}
export interface RealtimeConfig {
    maxSubscriptions: number;
    maxConnectionsPerSubscription: number;
    heartbeatIntervalMs: number;
    enableBackpressure: boolean;
    bufferSizeBytes: number;
}
export interface TimeSeriesStorageAdapter {
    name: string;
    tier: 'hot' | 'warm' | 'cold';
    write(points: TimeSeriesPoint[]): Promise<void>;
    read(query: TimeSeriesQuery): Promise<TimeSeriesPoint[]>;
    delete(metric: string, timeRange: TimeRange): Promise<void>;
    writeBatch(batches: TimeSeriesPoint[][]): Promise<void>;
    readBatch(queries: TimeSeriesQuery[]): Promise<TimeSeriesPoint[][]>;
    createSchema(schema: TimeSeriesSchema): Promise<void>;
    updateSchema(metric: string, schema: Partial<TimeSeriesSchema>): Promise<void>;
    getSchema(metric: string): Promise<TimeSeriesSchema | null>;
    listSchemas(): Promise<TimeSeriesSchema[]>;
    compact(metric?: string): Promise<void>;
    vacuum(): Promise<void>;
    getStats(): Promise<StorageStats>;
}
export interface StorageStats {
    totalPoints: number;
    totalMetrics: number;
    totalSizeBytes: number;
    compressionRatio: number;
    queryLatencyMs: {
        p50: number;
        p95: number;
        p99: number;
    };
    writeThroughput: {
        pointsPerSecond: number;
        bytesPerSecond: number;
    };
}
export interface IngestionEngine {
    writePoint(point: TimeSeriesPoint): Promise<void>;
    writeBatch(points: TimeSeriesPoint[]): Promise<void>;
    createWriteStream(): WritableStream<TimeSeriesPoint>;
    writePrometheusMetrics(metrics: string): Promise<void>;
    writeInfluxDBLine(line: string): Promise<void>;
    writeStatsD(metric: string): Promise<void>;
    createIngestionStream(options?: StreamOptions): Promise<WritableStream<TimeSeriesPoint>>;
    getIngestionStats(): Promise<IngestionStats>;
}
export interface StreamOptions {
    batchSize?: number;
    flushInterval?: number;
    compression?: boolean;
    deduplication?: boolean;
    onError?: (error: Error) => void;
    onSuccess?: (batchSize: number) => void;
}
export interface IngestionStats {
    pointsIngested: number;
    batchesProcessed: number;
    errorsCount: number;
    duplicatesDropped: number;
    avgBatchSize: number;
    ingestionRatePerSecond: number;
    bufferUtilization: number;
}
export interface QueryEngine {
    query(query: TimeSeriesQuery): Promise<TimeSeriesQueryResult>;
    aggregate(query: TimeSeriesAggregationQuery): Promise<TimeSeriesAggregationResult>;
    movingAverage(options: MovingAverageOptions): Promise<TimeSeriesPoint[]>;
    derivative(metric: string, timeRange: TimeRange): Promise<TimeSeriesPoint[]>;
    histogram(metric: string, timeRange: TimeRange, buckets: number): Promise<HistogramResult>;
    timeBucket(interval: string, timestamp: number): number;
    timeGap(points: TimeSeriesPoint[], maxGapMs: number): TimeGap[];
    interpolate(points: TimeSeriesPoint[], method: 'linear' | 'spline'): TimeSeriesPoint[];
    createLiveQuery(query: TimeSeriesQuery): Promise<ReadableStream<TimeSeriesPoint>>;
    createContinuousQuery(cq: ContinuousQuery): Promise<string>;
    explainQuery(query: TimeSeriesQuery): Promise<QueryPlan>;
    optimizeQuery(query: TimeSeriesQuery): Promise<TimeSeriesQuery>;
}
export interface TimeSeriesQueryResult {
    points: TimeSeriesPoint[];
    metadata: {
        totalPoints: number;
        executionTimeMs: number;
        fromCache: boolean;
        scannedShards: string[];
    };
}
export interface TimeSeriesAggregationResult {
    buckets: Array<{
        timestamp: number;
        values: Record<string, number>;
        groupBy?: Record<string, string>;
    }>;
    metadata: {
        totalBuckets: number;
        executionTimeMs: number;
        fromCache: boolean;
    };
}
export interface MovingAverageOptions {
    metric: string;
    timeRange: TimeRange;
    window: string;
    step?: string;
}
export interface TimeGap {
    start: number;
    end: number;
    durationMs: number;
}
export interface HistogramResult {
    buckets: Array<{
        min: number;
        max: number;
        count: number;
    }>;
    stats: {
        total: number;
        min: number;
        max: number;
        avg: number;
    };
}
export interface QueryPlan {
    steps: QueryStep[];
    estimatedCost: number;
    estimatedRows: number;
    tiersAccessed: string[];
    indexesUsed: string[];
}
export interface QueryStep {
    operation: string;
    description: string;
    cost: number;
    parallelizable: boolean;
}
export interface AnomalyDetector {
    trainModel(metric: string, config: AnomalyDetectionConfig): Promise<string>;
    updateModel(modelId: string, data: TimeSeriesPoint[]): Promise<void>;
    deleteModel(modelId: string): Promise<void>;
    detectAnomalies(metric: string, timeRange: TimeRange, config?: AnomalyDetectionConfig): Promise<Anomaly[]>;
    detectRealtime(point: TimeSeriesPoint, config: AnomalyDetectionConfig): Promise<Anomaly | null>;
    detectBatch(points: TimeSeriesPoint[], config: AnomalyDetectionConfig): Promise<Anomaly[]>;
}
export interface Anomaly {
    timestamp: number;
    value: number;
    expected: number;
    score: number;
    tags: Record<string, string>;
    method: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
}
export interface ForecastingEngine {
    forecast(config: ForecastConfig): Promise<ForecastResult[]>;
    forecastRealtime(metric: string, horizon: string): Promise<ReadableStream<ForecastResult>>;
    trainForecastModel(metric: string, config: ForecastConfig): Promise<string>;
    evaluateModel(modelId: string): Promise<ModelEvaluation>;
}
export interface ForecastResult {
    timestamp: number;
    value: number;
    upperBound?: number;
    lowerBound?: number;
    confidence?: number;
}
export interface ModelEvaluation {
    mae: number;
    mse: number;
    rmse: number;
    mape: number;
    r2: number;
    lastUpdated: string;
}
export interface AlertingSystem {
    createAlertRule(rule: AlertRule): Promise<string>;
    updateAlertRule(ruleId: string, rule: Partial<AlertRule>): Promise<void>;
    deleteAlertRule(ruleId: string): Promise<void>;
    getAlertRule(ruleId: string): Promise<AlertRule | null>;
    listAlertRules(): Promise<AlertRule[]>;
    evaluateAlerts(): Promise<void>;
    evaluateAlert(ruleId: string): Promise<Alert[]>;
    fireAlert(alert: Alert): Promise<void>;
    acknowledgeAlert(alertId: string, user: string): Promise<void>;
    resolveAlert(alertId: string, user: string): Promise<void>;
    addNotificationChannel(channel: NotificationChannel): Promise<string>;
    removeNotificationChannel(channelId: string): Promise<void>;
}
export interface AlertRule {
    id: string;
    name: string;
    metric: string;
    condition: AlertCondition;
    threshold: number;
    evaluationInterval: string;
    forDuration?: string;
    labels: Record<string, string>;
    annotations: Record<string, string>;
    notificationChannels: string[];
    silenceRules?: SilenceRule[];
    enabled: boolean;
}
export interface AlertCondition {
    operator: '>' | '<' | '>=' | '<=' | '==' | '!=';
    aggregation: AggregationFunction;
    timeRange: string;
    groupBy?: string[];
}
export interface SilenceRule {
    matchers: Record<string, string>;
    startTime: string;
    endTime: string;
    createdBy: string;
    comment: string;
}
export interface Alert {
    id: string;
    ruleId: string;
    metric: string;
    value: number;
    threshold: number;
    condition: string;
    severity: 'info' | 'warning' | 'critical';
    status: 'firing' | 'resolved' | 'acknowledged';
    startsAt: string;
    endsAt?: string;
    acknowledgedBy?: string;
    acknowledgedAt?: string;
    labels: Record<string, string>;
    annotations: Record<string, string>;
}
export interface NotificationChannel {
    id: string;
    type: 'email' | 'webhook' | 'slack' | 'pagerduty' | 'sms';
    name: string;
    config: Record<string, unknown>;
    enabled: boolean;
}
export interface CompressionManager {
    compress(data: TimeSeriesPoint[], algorithm: string): Promise<CompressedBlock>;
    decompress(block: CompressedBlock): Promise<TimeSeriesPoint[]>;
    gorillaCompress(values: number[], timestamps: number[]): Promise<Uint8Array>;
    gorillaDecompress(data: Uint8Array): Promise<{
        values: number[];
        timestamps: number[];
    }>;
    zstdCompress(data: Uint8Array, level?: number): Promise<Uint8Array>;
    zstdDecompress(data: Uint8Array): Promise<Uint8Array>;
    getCompressionStats(): Promise<CompressionStats>;
}
export interface CompressedBlock {
    algorithm: string;
    originalSize: number;
    compressedSize: number;
    compressionRatio: number;
    data: Uint8Array;
    checksum: string;
    metadata: {
        pointCount: number;
        startTime: number;
        endTime: number;
        metrics: string[];
    };
}
export interface CompressionStats {
    totalBlocks: number;
    totalOriginalBytes: number;
    totalCompressedBytes: number;
    averageCompressionRatio: number;
    algorithmStats: Record<string, {
        blocks: number;
        ratio: number;
        avgCompressionTimeMs: number;
    }>;
}
export interface ProtocolAdapter {
    name: string;
    version: string;
    parse(data: string | Uint8Array): Promise<TimeSeriesPoint[]>;
    format(points: TimeSeriesPoint[]): Promise<string | Uint8Array>;
    validate(data: string | Uint8Array): Promise<boolean>;
    getSchema?(): Promise<object>;
}
export interface RealtimeManager {
    subscribe(subscription: TimeSeriesSubscription): Promise<string>;
    unsubscribe(subscriptionId: string): Promise<void>;
    broadcast(points: TimeSeriesPoint[]): Promise<void>;
    broadcastToSubscription(subscriptionId: string, points: TimeSeriesPoint[]): Promise<void>;
    addConnection(connectionId: string, metadata?: Record<string, unknown>): Promise<void>;
    removeConnection(connectionId: string): Promise<void>;
    getActiveConnections(): Promise<string[]>;
    pauseSubscription(subscriptionId: string): Promise<void>;
    resumeSubscription(subscriptionId: string): Promise<void>;
}
export interface TimeSeriesSubscription {
    id: string;
    connectionId: string;
    metrics: string[];
    filters?: Record<string, string | string[]>;
    aggregateWindow?: string;
    maxPointsPerSecond?: number;
    bufferSize?: number;
}
//# sourceMappingURL=interfaces.d.ts.map