import { z } from 'zod';
export interface TimeSeriesPoint {
    metric: string;
    timestamp: number;
    value: number | string | boolean;
    tags: Record<string, string>;
    fields?: Record<string, unknown>;
}
export interface TimeSeriesSchema {
    metric: string;
    dataType: 'counter' | 'gauge' | 'histogram' | 'summary' | 'set';
    unit: string;
    description: string;
    retentionDays: number;
    downsamplingRules: DownsamplingRule[];
    compressionType: 'gorilla' | 'zstd' | 'none';
    tags: Record<string, {
        type: 'string' | 'number' | 'boolean';
        indexed: boolean;
        required: boolean;
    }>;
    fields?: Record<string, {
        type: 'string' | 'number' | 'boolean' | 'object';
        indexed: boolean;
    }>;
}
export interface DownsamplingRule {
    interval: string;
    retention: string;
    aggregations: AggregationFunction[];
}
export type AggregationFunction = 'avg' | 'sum' | 'min' | 'max' | 'count' | 'first' | 'last' | 'median' | 'stddev' | 'p50' | 'p90' | 'p95' | 'p99' | 'rate' | 'increase' | 'derivative';
export interface TimeRange {
    start: number | string;
    end?: number | string;
}
export interface TimeSeriesQuery {
    metrics: string[];
    timeRange: TimeRange;
    filters?: Record<string, string | string[]>;
    aggregation?: {
        function: AggregationFunction;
        interval?: string;
        groupBy?: string[];
    };
    limit?: number;
    orderBy?: 'timestamp' | 'value';
    orderDirection?: 'asc' | 'desc';
}
export interface TimeSeriesAggregationQuery {
    metric: string;
    timeRange: TimeRange;
    groupBy?: string[];
    aggregations: Array<{
        type: AggregationFunction;
        alias?: string;
    }>;
    having?: Record<string, {
        $gt?: number;
        $gte?: number;
        $lt?: number;
        $lte?: number;
        $eq?: number;
        $ne?: number;
    }>;
    interval?: string;
    fill?: 'null' | 'zero' | 'previous' | number;
}
export interface ContinuousQuery {
    name: string;
    query: string;
    interval: string;
    retention: string;
    destination?: string;
    enabled: boolean;
    lastRun?: string;
    nextRun?: string;
}
export interface TimeSeriesSubscription {
    id: string;
    metrics: string[];
    filters?: Record<string, string | string[]>;
    aggregateWindow?: string;
    onData: (point: TimeSeriesPoint) => void;
    onError: (error: Error) => void;
}
export interface AnomalyDetectionConfig {
    metric: string;
    method: 'isolation_forest' | 'statistical' | 'prophet' | 'lstm';
    sensitivity: number;
    seasonality?: {
        enabled: boolean;
        period: string;
    };
    threshold?: {
        upper?: number;
        lower?: number;
    };
}
export interface Anomaly {
    timestamp: number;
    value: number;
    expected: number;
    score: number;
    tags: Record<string, string>;
    method: string;
}
export interface ForecastConfig {
    metric: string;
    method: 'prophet' | 'arima' | 'linear' | 'exponential';
    horizon: string;
    includeConfidence: boolean;
    seasonality?: {
        yearly?: boolean;
        weekly?: boolean;
        daily?: boolean;
    };
    holidays?: string[];
}
export interface ForecastResult {
    timestamp: number;
    value: number;
    upperBound?: number;
    lowerBound?: number;
    confidence?: number;
}
export interface TimeSeriesStats {
    metric: string;
    timeRange: TimeRange;
    count: number;
    min: number;
    max: number;
    avg: number;
    sum: number;
    stddev: number;
    percentiles: {
        p50: number;
        p90: number;
        p95: number;
        p99: number;
    };
    cardinality: Record<string, number>;
}
export interface StreamProcessor {
    name: string;
    input: {
        metrics: string[];
        filters?: Record<string, string | string[]>;
    };
    operations: StreamOperation[];
    output: {
        metric?: string;
        webhook?: string;
        notification?: string;
    };
    enabled: boolean;
}
export type StreamOperation = {
    type: 'filter';
    condition: string;
} | {
    type: 'map';
    expression: string;
} | {
    type: 'window';
    size: string;
    type: 'tumbling' | 'sliding' | 'session';
} | {
    type: 'aggregate';
    functions: AggregationFunction[];
    groupBy?: string[];
} | {
    type: 'join';
    stream: string;
    key: string;
    window: string;
};
export declare const TimeSeriesPointSchema: z.ZodObject<{
    metric: z.ZodString;
    timestamp: z.ZodNumber;
    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
    tags: z.ZodRecord<z.ZodString, z.ZodString>;
    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
export declare const TimeSeriesSchemaSchema: z.ZodObject<{
    metric: z.ZodString;
    dataType: z.ZodEnum<{
        set: "set";
        counter: "counter";
        gauge: "gauge";
        histogram: "histogram";
        summary: "summary";
    }>;
    unit: z.ZodString;
    description: z.ZodString;
    retentionDays: z.ZodNumber;
    downsamplingRules: z.ZodArray<z.ZodObject<{
        interval: z.ZodString;
        retention: z.ZodString;
        aggregations: z.ZodArray<z.ZodEnum<{
            avg: "avg";
            sum: "sum";
            min: "min";
            max: "max";
            count: "count";
            first: "first";
            last: "last";
            median: "median";
            stddev: "stddev";
            p50: "p50";
            p90: "p90";
            p95: "p95";
            p99: "p99";
            rate: "rate";
            increase: "increase";
            derivative: "derivative";
        }>>;
    }, z.core.$strip>>;
    compressionType: z.ZodDefault<z.ZodEnum<{
        gorilla: "gorilla";
        zstd: "zstd";
        none: "none";
    }>>;
    tags: z.ZodRecord<z.ZodString, z.ZodObject<{
        type: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
        }>;
        indexed: z.ZodDefault<z.ZodBoolean>;
        required: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
        type: z.ZodEnum<{
            string: "string";
            number: "number";
            boolean: "boolean";
            object: "object";
        }>;
        indexed: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
export declare const TimeSeriesQuerySchema: z.ZodObject<{
    metrics: z.ZodArray<z.ZodString>;
    timeRange: z.ZodObject<{
        start: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
        end: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
    }, z.core.$strip>;
    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
    aggregation: z.ZodOptional<z.ZodObject<{
        function: z.ZodEnum<{
            avg: "avg";
            sum: "sum";
            min: "min";
            max: "max";
            count: "count";
            first: "first";
            last: "last";
            median: "median";
            stddev: "stddev";
            p50: "p50";
            p90: "p90";
            p95: "p95";
            p99: "p99";
            rate: "rate";
            increase: "increase";
            derivative: "derivative";
        }>;
        interval: z.ZodOptional<z.ZodString>;
        groupBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    limit: z.ZodDefault<z.ZodNumber>;
    orderBy: z.ZodDefault<z.ZodEnum<{
        value: "value";
        timestamp: "timestamp";
    }>>;
    orderDirection: z.ZodDefault<z.ZodEnum<{
        asc: "asc";
        desc: "desc";
    }>>;
}, z.core.$strip>;
export declare const ContinuousQuerySchema: z.ZodObject<{
    name: z.ZodString;
    query: z.ZodString;
    interval: z.ZodString;
    retention: z.ZodString;
    destination: z.ZodOptional<z.ZodString>;
    enabled: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
export declare const AnomalyDetectionSchema: z.ZodObject<{
    metric: z.ZodString;
    method: z.ZodEnum<{
        isolation_forest: "isolation_forest";
        statistical: "statistical";
        prophet: "prophet";
        lstm: "lstm";
    }>;
    sensitivity: z.ZodNumber;
    seasonality: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodBoolean;
        period: z.ZodString;
    }, z.core.$strip>>;
    threshold: z.ZodOptional<z.ZodObject<{
        upper: z.ZodOptional<z.ZodNumber>;
        lower: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;
export declare const ForecastSchema: z.ZodObject<{
    metric: z.ZodString;
    method: z.ZodEnum<{
        prophet: "prophet";
        arima: "arima";
        linear: "linear";
        exponential: "exponential";
    }>;
    horizon: z.ZodString;
    includeConfidence: z.ZodDefault<z.ZodBoolean>;
    seasonality: z.ZodOptional<z.ZodObject<{
        yearly: z.ZodOptional<z.ZodBoolean>;
        weekly: z.ZodOptional<z.ZodBoolean>;
        daily: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
    holidays: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
//# sourceMappingURL=timeseries.d.ts.map