/**
 * Main Time Series Storage Engine
 *
 * Orchestrates all time series components and provides the main API for
 * time series operations in NoSQL.
 *
 * Features:
 * - High-performance ingestion (1M+ points/second)
 * - Automatic tiered storage management
 * - Advanced querying and analytics
 * - Real-time streaming capabilities
 * - Anomaly detection and forecasting
 * - Protocol support (Prometheus, InfluxDB, StatsD)
 * - Comprehensive monitoring and metrics
 */
import type { TimeSeriesPoint, TimeSeriesSchema, TimeSeriesQuery, TimeSeriesAggregationQuery, ContinuousQuery, TimeRange, AnomalyDetectionConfig, ForecastConfig, TimeSeriesSubscription } from '../../types/timeseries';
import type { TimeSeriesConfig } from './interfaces';
export declare class TimeSeriesStorageEngine {
    private config;
    private storageAdapter;
    private ingestionEngine;
    private queryEngine;
    private compressionManager;
    private downsamplingManager;
    private anomalyDetector?;
    private forecastingEngine?;
    private alertingSystem?;
    private realtimeManager?;
    private isInitialized;
    private healthStatus;
    constructor(config: TimeSeriesConfig, env: {
        D1: D1Database;
        KV: KVNamespace;
        R2: R2Bucket;
    });
    initialize(): Promise<void>;
    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>;
    query(query: TimeSeriesQuery): Promise<import("./interfaces").TimeSeriesQueryResult>;
    aggregate(query: TimeSeriesAggregationQuery): Promise<import("./interfaces").TimeSeriesAggregationResult>;
    movingAverage(options: {
        metric: string;
        timeRange: TimeRange;
        window: string;
        step?: string;
    }): Promise<TimeSeriesPoint[]>;
    derivative(metric: string, timeRange: TimeRange): Promise<TimeSeriesPoint[]>;
    histogram(metric: string, timeRange: TimeRange, buckets: number): Promise<import("./interfaces").HistogramResult>;
    timeBucket(interval: string, timestamp: number): number;
    timeGap(points: TimeSeriesPoint[], maxGapMs: number): import("./interfaces").TimeGap[];
    interpolate(points: TimeSeriesPoint[], method: 'linear' | 'spline'): TimeSeriesPoint[];
    createLiveQuery(query: TimeSeriesQuery): Promise<ReadableStream<TimeSeriesPoint>>;
    createContinuousQuery(cq: ContinuousQuery): Promise<string>;
    createSchema(schema: TimeSeriesSchema): Promise<void>;
    updateSchema(metric: string, schema: Partial<TimeSeriesSchema>): Promise<void>;
    getSchema(metric: string): Promise<TimeSeriesSchema | null>;
    listSchemas(): Promise<TimeSeriesSchema[]>;
    detectAnomalies(metric: string, timeRange: TimeRange, config?: AnomalyDetectionConfig): Promise<import("./interfaces").Anomaly[]>;
    trainAnomalyModel(metric: string, config: AnomalyDetectionConfig): Promise<string>;
    forecast(config: ForecastConfig): Promise<import("./interfaces").ForecastResult[]>;
    trainForecastModel(metric: string, config: ForecastConfig): Promise<string>;
    subscribe(subscription: TimeSeriesSubscription): Promise<string>;
    unsubscribe(subscriptionId: string): Promise<void>;
    createAlertRule(rule: any): Promise<string>;
    evaluateAlerts(): Promise<void>;
    addRetentionPolicy(policy: any): Promise<void>;
    processDownsampling(metric?: string): Promise<void>;
    compact(metric?: string): Promise<void>;
    vacuum(): Promise<void>;
    getStats(): Promise<{
        storage: import("./interfaces").StorageStats;
        ingestion: import("./interfaces").IngestionStats;
        compression: import("./interfaces").CompressionStats;
        downsampling: import("./storage/downsampling-manager").DownsamplingStats;
        health: EngineHealthStatus;
    }>;
    getHealth(): Promise<EngineHealthStatus>;
    close(): Promise<void>;
    private ensureInitialized;
    private initializeStorageAdapter;
    private initializeAnomalyDetector;
    private initializeForecastingEngine;
    private initializeAlertingSystem;
    private initializeRealtimeManager;
}
interface EngineHealthStatus {
    status: 'initializing' | 'healthy' | 'degraded' | 'error' | 'stopped';
    components: Record<string, 'healthy' | 'degraded' | 'error'>;
    lastCheck: number;
    error?: string;
}
export {};
//# sourceMappingURL=storage-engine.d.ts.map