@llm-dev-ops/agentics-cli 1.4.26 → 1.4.27

package/dist/bundled-agents/analytics-hub-agents/dist/agents/strategic-recommendation/types.d.ts

@@ -0,0 +1,2271 @@
+/**
+ * Strategic Recommendation Agent - Type Definitions
+ *
+ * Defines types for aggregating signals, analyzing trends,
+ * and generating strategic recommendations across multiple data sources.
+ *
+ * @module agents/strategic-recommendation/types
+ */
+import { z } from 'zod';
+/**
+ * Time range for signal aggregation
+ */
+export declare const TimeRangeSchema: z.ZodObject<{
+    startTime: z.ZodString;
+    endTime: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    startTime: string;
+    endTime: string;
+}, {
+    startTime: string;
+    endTime: string;
+}>;
+export type TimeRange = z.infer<typeof TimeRangeSchema>;
+export type UUID = string;
+export type ISODateString = string;
+/**
+ * Data source types that can feed into the agent
+ */
+export declare enum DataSource {
+    Observatory = "llm-observatory",
+    Sentinel = "llm-sentinel",
+    CostOps = "llm-cost-ops",
+    Governance = "llm-governance-dashboard",
+    Registry = "llm-registry",
+    PolicyEngine = "llm-policy-engine"
+}
+/**
+ * Source layer types (legacy support)
+ */
+export type SourceLayer = 'observatory' | 'cost-ops' | 'governance' | 'consensus';
+/**
+ * Individual signal from a source layer
+ */
+export declare const SignalSchema: z.ZodObject<{
+    signalId: z.ZodString;
+    layer: z.ZodString;
+    timestamp: z.ZodString;
+    metricType: z.ZodString;
+    value: z.ZodNumber;
+    confidence: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    value: number;
+    signalId: string;
+    confidence: number;
+    layer: string;
+    metricType: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    timestamp: string;
+    value: number;
+    signalId: string;
+    confidence: number;
+    layer: string;
+    metricType: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type Signal = z.infer<typeof SignalSchema>;
+/**
+ * Aggregated signals from multiple sources (enhanced)
+ * Note: Enhanced fields are optional for backward compatibility
+ */
+export declare const SignalAggregationSchema: z.ZodObject<{
+    aggregation_id: z.ZodOptional<z.ZodString>;
+    timeWindow: z.ZodObject<{
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        startTime: string;
+        endTime: string;
+    }, {
+        startTime: string;
+        endTime: string;
+    }>;
+    time_window: z.ZodOptional<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+        granularity: z.ZodEnum<["minute", "hour", "day", "week", "month"]>;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+        granularity: "minute" | "hour" | "day" | "week" | "month";
+    }, {
+        start: string;
+        end: string;
+        granularity: "minute" | "hour" | "day" | "week" | "month";
+    }>>;
+    signalsByLayer: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        signalId: z.ZodString;
+        layer: z.ZodString;
+        timestamp: z.ZodString;
+        metricType: z.ZodString;
+        value: z.ZodNumber;
+        confidence: z.ZodNumber;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        value: number;
+        signalId: string;
+        confidence: number;
+        layer: string;
+        metricType: string;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        timestamp: string;
+        value: number;
+        signalId: string;
+        confidence: number;
+        layer: string;
+        metricType: string;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    by_source: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        signal_count: z.ZodNumber;
+        avg_severity: z.ZodNumber;
+        dominant_categories: z.ZodArray<z.ZodString, "many">;
+        key_metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        signal_count: number;
+        avg_severity: number;
+        dominant_categories: string[];
+        key_metrics: Record<string, number>;
+    }, {
+        source: string;
+        signal_count: number;
+        avg_severity: number;
+        dominant_categories: string[];
+        key_metrics: Record<string, number>;
+    }>, "many">>;
+    totalSignals: z.ZodNumber;
+    layersIncluded: z.ZodArray<z.ZodString, "many">;
+    aggregated_metrics: z.ZodOptional<z.ZodObject<{
+        total_events: z.ZodNumber;
+        unique_resources: z.ZodNumber;
+        avg_latency_ms: z.ZodOptional<z.ZodNumber>;
+        total_cost: z.ZodOptional<z.ZodNumber>;
+        error_rate: z.ZodOptional<z.ZodNumber>;
+        security_incidents: z.ZodOptional<z.ZodNumber>;
+        policy_violations: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        total_events: number;
+        unique_resources: number;
+        avg_latency_ms?: number | undefined;
+        total_cost?: number | undefined;
+        error_rate?: number | undefined;
+        security_incidents?: number | undefined;
+        policy_violations?: number | undefined;
+    }, {
+        total_events: number;
+        unique_resources: number;
+        avg_latency_ms?: number | undefined;
+        total_cost?: number | undefined;
+        error_rate?: number | undefined;
+        security_incidents?: number | undefined;
+        policy_violations?: number | undefined;
+    }>>;
+    statistics: z.ZodOptional<z.ZodObject<{
+        mean: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        median: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        std_dev: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        percentiles: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        mean: Record<string, number>;
+        median: Record<string, number>;
+        std_dev: Record<string, number>;
+        percentiles: Record<string, Record<string, number>>;
+    }, {
+        mean: Record<string, number>;
+        median: Record<string, number>;
+        std_dev: Record<string, number>;
+        percentiles: Record<string, Record<string, number>>;
+    }>>;
+    temporal_patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pattern_type: z.ZodEnum<["spike", "dip", "cyclical", "trending"]>;
+        detected_at: z.ZodString;
+        strength: z.ZodNumber;
+        description: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        pattern_type: "spike" | "dip" | "cyclical" | "trending";
+        detected_at: string;
+        strength: number;
+    }, {
+        description: string;
+        pattern_type: "spike" | "dip" | "cyclical" | "trending";
+        detected_at: string;
+        strength: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    totalSignals: number;
+    timeWindow: {
+        startTime: string;
+        endTime: string;
+    };
+    signalsByLayer: Record<string, {
+        timestamp: string;
+        value: number;
+        signalId: string;
+        confidence: number;
+        layer: string;
+        metricType: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[]>;
+    layersIncluded: string[];
+    statistics?: {
+        mean: Record<string, number>;
+        median: Record<string, number>;
+        std_dev: Record<string, number>;
+        percentiles: Record<string, Record<string, number>>;
+    } | undefined;
+    aggregation_id?: string | undefined;
+    time_window?: {
+        start: string;
+        end: string;
+        granularity: "minute" | "hour" | "day" | "week" | "month";
+    } | undefined;
+    by_source?: {
+        source: string;
+        signal_count: number;
+        avg_severity: number;
+        dominant_categories: string[];
+        key_metrics: Record<string, number>;
+    }[] | undefined;
+    aggregated_metrics?: {
+        total_events: number;
+        unique_resources: number;
+        avg_latency_ms?: number | undefined;
+        total_cost?: number | undefined;
+        error_rate?: number | undefined;
+        security_incidents?: number | undefined;
+        policy_violations?: number | undefined;
+    } | undefined;
+    temporal_patterns?: {
+        description: string;
+        pattern_type: "spike" | "dip" | "cyclical" | "trending";
+        detected_at: string;
+        strength: number;
+    }[] | undefined;
+}, {
+    totalSignals: number;
+    timeWindow: {
+        startTime: string;
+        endTime: string;
+    };
+    signalsByLayer: Record<string, {
+        timestamp: string;
+        value: number;
+        signalId: string;
+        confidence: number;
+        layer: string;
+        metricType: string;
+        metadata?: Record<string, unknown> | undefined;
+    }[]>;
+    layersIncluded: string[];
+    statistics?: {
+        mean: Record<string, number>;
+        median: Record<string, number>;
+        std_dev: Record<string, number>;
+        percentiles: Record<string, Record<string, number>>;
+    } | undefined;
+    aggregation_id?: string | undefined;
+    time_window?: {
+        start: string;
+        end: string;
+        granularity: "minute" | "hour" | "day" | "week" | "month";
+    } | undefined;
+    by_source?: {
+        source: string;
+        signal_count: number;
+        avg_severity: number;
+        dominant_categories: string[];
+        key_metrics: Record<string, number>;
+    }[] | undefined;
+    aggregated_metrics?: {
+        total_events: number;
+        unique_resources: number;
+        avg_latency_ms?: number | undefined;
+        total_cost?: number | undefined;
+        error_rate?: number | undefined;
+        security_incidents?: number | undefined;
+        policy_violations?: number | undefined;
+    } | undefined;
+    temporal_patterns?: {
+        description: string;
+        pattern_type: "spike" | "dip" | "cyclical" | "trending";
+        detected_at: string;
+        strength: number;
+    }[] | undefined;
+}>;
+export type SignalAggregation = z.infer<typeof SignalAggregationSchema>;
+/**
+ * Trend direction
+ */
+export type TrendDirection = 'increasing' | 'decreasing' | 'stable' | 'volatile';
+/**
+ * Trend analysis for a specific metric
+ */
+export declare const TrendAnalysisSchema: z.ZodObject<{
+    metricType: z.ZodString;
+    layer: z.ZodString;
+    direction: z.ZodEnum<["increasing", "decreasing", "stable", "volatile"]>;
+    magnitude: z.ZodNumber;
+    velocity: z.ZodNumber;
+    dataPoints: z.ZodNumber;
+    confidence: z.ZodNumber;
+    anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        value: z.ZodNumber;
+        deviationScore: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        value: number;
+        deviationScore: number;
+    }, {
+        timestamp: string;
+        value: number;
+        deviationScore: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    direction: "increasing" | "decreasing" | "stable" | "volatile";
+    layer: string;
+    metricType: string;
+    magnitude: number;
+    velocity: number;
+    dataPoints: number;
+    anomalies?: {
+        timestamp: string;
+        value: number;
+        deviationScore: number;
+    }[] | undefined;
+}, {
+    confidence: number;
+    direction: "increasing" | "decreasing" | "stable" | "volatile";
+    layer: string;
+    metricType: string;
+    magnitude: number;
+    velocity: number;
+    dataPoints: number;
+    anomalies?: {
+        timestamp: string;
+        value: number;
+        deviationScore: number;
+    }[] | undefined;
+}>;
+export type TrendAnalysis = z.infer<typeof TrendAnalysisSchema>;
+/**
+ * Cross-domain correlation between different signal types (enhanced)
+ * Identifies relationships between different domains (cost, security, performance)
+ * Note: Enhanced fields are optional for backward compatibility
+ */
+export declare const CrossDomainCorrelationSchema: z.ZodObject<{
+    correlation_id: z.ZodOptional<z.ZodString>;
+    correlationId: z.ZodString;
+    primaryTrend: z.ZodObject<{
+        metricType: z.ZodString;
+        layer: z.ZodString;
+        direction: z.ZodEnum<["increasing", "decreasing", "stable", "volatile"]>;
+        magnitude: z.ZodNumber;
+        velocity: z.ZodNumber;
+        dataPoints: z.ZodNumber;
+        confidence: z.ZodNumber;
+        anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            timestamp: z.ZodString;
+            value: z.ZodNumber;
+            deviationScore: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }, {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    }, {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    }>;
+    secondaryTrend: z.ZodObject<{
+        metricType: z.ZodString;
+        layer: z.ZodString;
+        direction: z.ZodEnum<["increasing", "decreasing", "stable", "volatile"]>;
+        magnitude: z.ZodNumber;
+        velocity: z.ZodNumber;
+        dataPoints: z.ZodNumber;
+        confidence: z.ZodNumber;
+        anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            timestamp: z.ZodString;
+            value: z.ZodNumber;
+            deviationScore: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }, {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    }, {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    }>;
+    domains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<["cost", "security", "performance", "governance", "compliance"]>;
+        metrics: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        metrics: string[];
+        domain: "cost" | "performance" | "security" | "compliance" | "governance";
+    }, {
+        metrics: string[];
+        domain: "cost" | "performance" | "security" | "compliance" | "governance";
+    }>, "many">>;
+    correlations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metric_a: z.ZodString;
+        metric_b: z.ZodString;
+        correlation_coefficient: z.ZodNumber;
+        p_value: z.ZodNumber;
+        is_significant: z.ZodBoolean;
+        relationship_type: z.ZodEnum<["positive", "negative", "none"]>;
+    }, "strip", z.ZodTypeAny, {
+        metric_a: string;
+        metric_b: string;
+        correlation_coefficient: number;
+        p_value: number;
+        is_significant: boolean;
+        relationship_type: "positive" | "negative" | "none";
+    }, {
+        metric_a: string;
+        metric_b: string;
+        correlation_coefficient: number;
+        p_value: number;
+        is_significant: boolean;
+        relationship_type: "positive" | "negative" | "none";
+    }>, "many">>;
+    correlationCoefficient: z.ZodNumber;
+    strength: z.ZodEnum<["weak", "moderate", "strong"]>;
+    lagTime: z.ZodOptional<z.ZodNumber>;
+    causality: z.ZodOptional<z.ZodEnum<["none", "potential", "likely"]>>;
+    causal_relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        cause_metric: z.ZodString;
+        effect_metric: z.ZodString;
+        lag_time: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        confidence: number;
+        evidence: string[];
+        cause_metric: string;
+        effect_metric: string;
+        lag_time?: string | undefined;
+    }, {
+        confidence: number;
+        evidence: string[];
+        cause_metric: string;
+        effect_metric: string;
+        lag_time?: string | undefined;
+    }>, "many">>;
+    insights: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        insight_type: z.ZodEnum<["trade_off", "synergy", "cascade_effect", "feedback_loop"]>;
+        description: z.ZodString;
+        affected_domains: z.ZodArray<z.ZodString, "many">;
+        impact_score: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+        affected_domains: string[];
+        impact_score: number;
+    }, {
+        description: string;
+        insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+        affected_domains: string[];
+        impact_score: number;
+    }>, "many">>;
+    anomalous_correlations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        metrics: z.ZodArray<z.ZodString, "many">;
+        expected_correlation: z.ZodNumber;
+        actual_correlation: z.ZodNumber;
+        deviation_score: z.ZodNumber;
+        possible_explanation: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        metrics: string[];
+        deviation_score: number;
+        expected_correlation: number;
+        actual_correlation: number;
+        possible_explanation?: string | undefined;
+    }, {
+        metrics: string[];
+        deviation_score: number;
+        expected_correlation: number;
+        actual_correlation: number;
+        possible_explanation?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    strength: "weak" | "moderate" | "strong";
+    correlationId: string;
+    primaryTrend: {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    };
+    secondaryTrend: {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    };
+    correlationCoefficient: number;
+    correlation_id?: string | undefined;
+    domains?: {
+        metrics: string[];
+        domain: "cost" | "performance" | "security" | "compliance" | "governance";
+    }[] | undefined;
+    correlations?: {
+        metric_a: string;
+        metric_b: string;
+        correlation_coefficient: number;
+        p_value: number;
+        is_significant: boolean;
+        relationship_type: "positive" | "negative" | "none";
+    }[] | undefined;
+    lagTime?: number | undefined;
+    causality?: "none" | "potential" | "likely" | undefined;
+    causal_relationships?: {
+        confidence: number;
+        evidence: string[];
+        cause_metric: string;
+        effect_metric: string;
+        lag_time?: string | undefined;
+    }[] | undefined;
+    insights?: {
+        description: string;
+        insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+        affected_domains: string[];
+        impact_score: number;
+    }[] | undefined;
+    anomalous_correlations?: {
+        metrics: string[];
+        deviation_score: number;
+        expected_correlation: number;
+        actual_correlation: number;
+        possible_explanation?: string | undefined;
+    }[] | undefined;
+}, {
+    strength: "weak" | "moderate" | "strong";
+    correlationId: string;
+    primaryTrend: {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    };
+    secondaryTrend: {
+        confidence: number;
+        direction: "increasing" | "decreasing" | "stable" | "volatile";
+        layer: string;
+        metricType: string;
+        magnitude: number;
+        velocity: number;
+        dataPoints: number;
+        anomalies?: {
+            timestamp: string;
+            value: number;
+            deviationScore: number;
+        }[] | undefined;
+    };
+    correlationCoefficient: number;
+    correlation_id?: string | undefined;
+    domains?: {
+        metrics: string[];
+        domain: "cost" | "performance" | "security" | "compliance" | "governance";
+    }[] | undefined;
+    correlations?: {
+        metric_a: string;
+        metric_b: string;
+        correlation_coefficient: number;
+        p_value: number;
+        is_significant: boolean;
+        relationship_type: "positive" | "negative" | "none";
+    }[] | undefined;
+    lagTime?: number | undefined;
+    causality?: "none" | "potential" | "likely" | undefined;
+    causal_relationships?: {
+        confidence: number;
+        evidence: string[];
+        cause_metric: string;
+        effect_metric: string;
+        lag_time?: string | undefined;
+    }[] | undefined;
+    insights?: {
+        description: string;
+        insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+        affected_domains: string[];
+        impact_score: number;
+    }[] | undefined;
+    anomalous_correlations?: {
+        metrics: string[];
+        deviation_score: number;
+        expected_correlation: number;
+        actual_correlation: number;
+        possible_explanation?: string | undefined;
+    }[] | undefined;
+}>;
+export type CrossDomainCorrelation = z.infer<typeof CrossDomainCorrelationSchema>;
+/**
+ * Recommendation priority level
+ */
+export type RecommendationPriority = 'critical' | 'high' | 'medium' | 'low';
+/**
+ * Recommendation category
+ */
+export type RecommendationCategory = 'cost-optimization' | 'performance-improvement' | 'risk-mitigation' | 'capacity-planning' | 'governance-compliance' | 'strategic-initiative';
+/**
+ * Strategic recommendation
+ */
+export declare const StrategicRecommendationSchema: z.ZodObject<{
+    recommendationId: z.ZodString;
+    category: z.ZodEnum<["cost-optimization", "performance-improvement", "risk-mitigation", "capacity-planning", "governance-compliance", "strategic-initiative"]>;
+    priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    title: z.ZodString;
+    description: z.ZodString;
+    rationale: z.ZodString;
+    supportingCorrelations: z.ZodArray<z.ZodString, "many">;
+    supportingTrends: z.ZodArray<z.ZodString, "many">;
+    expectedImpact: z.ZodOptional<z.ZodObject<{
+        costSavings: z.ZodOptional<z.ZodNumber>;
+        performanceGain: z.ZodOptional<z.ZodNumber>;
+        riskReduction: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        costSavings?: number | undefined;
+        performanceGain?: number | undefined;
+        riskReduction?: number | undefined;
+    }, {
+        costSavings?: number | undefined;
+        performanceGain?: number | undefined;
+        riskReduction?: number | undefined;
+    }>>;
+    confidence: z.ZodNumber;
+    timeHorizon: z.ZodEnum<["immediate", "short-term", "medium-term", "long-term"]>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    confidence: number;
+    category: "cost-optimization" | "performance-improvement" | "risk-mitigation" | "capacity-planning" | "governance-compliance" | "strategic-initiative";
+    priority: "critical" | "low" | "medium" | "high";
+    title: string;
+    recommendationId: string;
+    rationale: string;
+    supportingCorrelations: string[];
+    supportingTrends: string[];
+    timeHorizon: "immediate" | "short-term" | "medium-term" | "long-term";
+    metadata?: Record<string, unknown> | undefined;
+    expectedImpact?: {
+        costSavings?: number | undefined;
+        performanceGain?: number | undefined;
+        riskReduction?: number | undefined;
+    } | undefined;
+}, {
+    description: string;
+    confidence: number;
+    category: "cost-optimization" | "performance-improvement" | "risk-mitigation" | "capacity-planning" | "governance-compliance" | "strategic-initiative";
+    priority: "critical" | "low" | "medium" | "high";
+    title: string;
+    recommendationId: string;
+    rationale: string;
+    supportingCorrelations: string[];
+    supportingTrends: string[];
+    timeHorizon: "immediate" | "short-term" | "medium-term" | "long-term";
+    metadata?: Record<string, unknown> | undefined;
+    expectedImpact?: {
+        costSavings?: number | undefined;
+        performanceGain?: number | undefined;
+        riskReduction?: number | undefined;
+    } | undefined;
+}>;
+export type StrategicRecommendation = z.infer<typeof StrategicRecommendationSchema>;
+export declare const DataSourceSchema: z.ZodNativeEnum<typeof DataSource>;
+/**
+ * Input to the Strategic Recommendation Agent (enhanced)
+ */
+export declare const StrategicRecommendationInputSchema: z.ZodObject<{
+    request_id: z.ZodString;
+    timeWindow: z.ZodObject<{
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        startTime: string;
+        endTime: string;
+    }, {
+        startTime: string;
+        endTime: string;
+    }>;
+    time_range: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+    sourceLayers: z.ZodArray<z.ZodString, "many">;
+    data_sources: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof DataSource>, "many">>;
+    focus_areas: z.ZodOptional<z.ZodArray<z.ZodEnum<["cost", "security", "performance", "governance", "compliance", "operations"]>, "many">>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodUnknown;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        description?: string | undefined;
+        value?: unknown;
+    }, {
+        type: string;
+        description?: string | undefined;
+        value?: unknown;
+    }>, "many">>;
+    minConfidence: z.ZodDefault<z.ZodNumber>;
+    min_confidence: z.ZodOptional<z.ZodNumber>;
+    maxRecommendations: z.ZodDefault<z.ZodNumber>;
+    max_recommendations: z.ZodOptional<z.ZodNumber>;
+    focusCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include_details: z.ZodOptional<z.ZodBoolean>;
+    executionRef: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        previous_recommendations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        implemented_actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            recommendation_id: z.ZodString;
+            action_taken: z.ZodString;
+            outcome: z.ZodEnum<["successful", "failed", "partial"]>;
+            impact_observed: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            recommendation_id: string;
+            action_taken: string;
+            outcome: "successful" | "failed" | "partial";
+            impact_observed?: Record<string, number> | undefined;
+        }, {
+            recommendation_id: string;
+            action_taken: string;
+            outcome: "successful" | "failed" | "partial";
+            impact_observed?: Record<string, number> | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        previous_recommendations?: string[] | undefined;
+        implemented_actions?: {
+            recommendation_id: string;
+            action_taken: string;
+            outcome: "successful" | "failed" | "partial";
+            impact_observed?: Record<string, number> | undefined;
+        }[] | undefined;
+    }, {
+        previous_recommendations?: string[] | undefined;
+        implemented_actions?: {
+            recommendation_id: string;
+            action_taken: string;
+            outcome: "successful" | "failed" | "partial";
+            impact_observed?: Record<string, number> | undefined;
+        }[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    executionRef: string;
+    timeWindow: {
+        startTime: string;
+        endTime: string;
+    };
+    request_id: string;
+    time_range: {
+        start: string;
+        end: string;
+    };
+    sourceLayers: string[];
+    minConfidence: number;
+    maxRecommendations: number;
+    data_sources?: DataSource[] | undefined;
+    focus_areas?: ("cost" | "performance" | "security" | "compliance" | "governance" | "operations")[] | undefined;
+    constraints?: {
+        type: string;
+        description?: string | undefined;
+        value?: unknown;
+    }[] | undefined;
+    min_confidence?: number | undefined;
+    max_recommendations?: number | undefined;
+    focusCategories?: string[] | undefined;
+    include_details?: boolean | undefined;
+    context?: {
+        previous_recommendations?: string[] | undefined;
+        implemented_actions?: {
+            recommendation_id: string;
+            action_taken: string;
+            outcome: "successful" | "failed" | "partial";
+            impact_observed?: Record<string, number> | undefined;
+        }[] | undefined;
+    } | undefined;
+}, {
+    executionRef: string;
+    timeWindow: {
+        startTime: string;
+        endTime: string;
+    };
+    request_id: string;
+    time_range: {
+        start: string;
+        end: string;
+    };
+    sourceLayers: string[];
+    data_sources?: DataSource[] | undefined;
+    focus_areas?: ("cost" | "performance" | "security" | "compliance" | "governance" | "operations")[] | undefined;
+    constraints?: {
+        type: string;
+        description?: string | undefined;
+        value?: unknown;
+    }[] | undefined;
+    minConfidence?: number | undefined;
+    min_confidence?: number | undefined;
+    maxRecommendations?: number | undefined;
+    max_recommendations?: number | undefined;
+    focusCategories?: string[] | undefined;
+    include_details?: boolean | undefined;
+    context?: {
+        previous_recommendations?: string[] | undefined;
+        implemented_actions?: {
+            recommendation_id: string;
+            action_taken: string;
+            outcome: "successful" | "failed" | "partial";
+            impact_observed?: Record<string, number> | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+export type StrategicRecommendationInput = z.infer<typeof StrategicRecommendationInputSchema>;
+/**
+ * Output from the Strategic Recommendation Agent (enhanced)
+ * Note: Enhanced fields are optional for backward compatibility
+ */
+export declare const StrategicRecommendationOutputSchema: z.ZodObject<{
+    request_id: z.ZodOptional<z.ZodString>;
+    recommendations: z.ZodArray<z.ZodObject<{
+        recommendationId: z.ZodString;
+        category: z.ZodEnum<["cost-optimization", "performance-improvement", "risk-mitigation", "capacity-planning", "governance-compliance", "strategic-initiative"]>;
+        priority: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        title: z.ZodString;
+        description: z.ZodString;
+        rationale: z.ZodString;
+        supportingCorrelations: z.ZodArray<z.ZodString, "many">;
+        supportingTrends: z.ZodArray<z.ZodString, "many">;
+        expectedImpact: z.ZodOptional<z.ZodObject<{
+            costSavings: z.ZodOptional<z.ZodNumber>;
+            performanceGain: z.ZodOptional<z.ZodNumber>;
+            riskReduction: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            costSavings?: number | undefined;
+            performanceGain?: number | undefined;
+            riskReduction?: number | undefined;
+        }, {
+            costSavings?: number | undefined;
+            performanceGain?: number | undefined;
+            riskReduction?: number | undefined;
+        }>>;
+        confidence: z.ZodNumber;
+        timeHorizon: z.ZodEnum<["immediate", "short-term", "medium-term", "long-term"]>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        confidence: number;
+        category: "cost-optimization" | "performance-improvement" | "risk-mitigation" | "capacity-planning" | "governance-compliance" | "strategic-initiative";
+        priority: "critical" | "low" | "medium" | "high";
+        title: string;
+        recommendationId: string;
+        rationale: string;
+        supportingCorrelations: string[];
+        supportingTrends: string[];
+        timeHorizon: "immediate" | "short-term" | "medium-term" | "long-term";
+        metadata?: Record<string, unknown> | undefined;
+        expectedImpact?: {
+            costSavings?: number | undefined;
+            performanceGain?: number | undefined;
+            riskReduction?: number | undefined;
+        } | undefined;
+    }, {
+        description: string;
+        confidence: number;
+        category: "cost-optimization" | "performance-improvement" | "risk-mitigation" | "capacity-planning" | "governance-compliance" | "strategic-initiative";
+        priority: "critical" | "low" | "medium" | "high";
+        title: string;
+        recommendationId: string;
+        rationale: string;
+        supportingCorrelations: string[];
+        supportingTrends: string[];
+        timeHorizon: "immediate" | "short-term" | "medium-term" | "long-term";
+        metadata?: Record<string, unknown> | undefined;
+        expectedImpact?: {
+            costSavings?: number | undefined;
+            performanceGain?: number | undefined;
+            riskReduction?: number | undefined;
+        } | undefined;
+    }>, "many">;
+    signal_aggregation: z.ZodOptional<z.ZodObject<{
+        aggregation_id: z.ZodOptional<z.ZodString>;
+        timeWindow: z.ZodObject<{
+            startTime: z.ZodString;
+            endTime: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            startTime: string;
+            endTime: string;
+        }, {
+            startTime: string;
+            endTime: string;
+        }>;
+        time_window: z.ZodOptional<z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+            granularity: z.ZodEnum<["minute", "hour", "day", "week", "month"]>;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+            granularity: "minute" | "hour" | "day" | "week" | "month";
+        }, {
+            start: string;
+            end: string;
+            granularity: "minute" | "hour" | "day" | "week" | "month";
+        }>>;
+        signalsByLayer: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            signalId: z.ZodString;
+            layer: z.ZodString;
+            timestamp: z.ZodString;
+            metricType: z.ZodString;
+            value: z.ZodNumber;
+            confidence: z.ZodNumber;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            value: number;
+            signalId: string;
+            confidence: number;
+            layer: string;
+            metricType: string;
+            metadata?: Record<string, unknown> | undefined;
+        }, {
+            timestamp: string;
+            value: number;
+            signalId: string;
+            confidence: number;
+            layer: string;
+            metricType: string;
+            metadata?: Record<string, unknown> | undefined;
+        }>, "many">>;
+        by_source: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            signal_count: z.ZodNumber;
+            avg_severity: z.ZodNumber;
+            dominant_categories: z.ZodArray<z.ZodString, "many">;
+            key_metrics: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            signal_count: number;
+            avg_severity: number;
+            dominant_categories: string[];
+            key_metrics: Record<string, number>;
+        }, {
+            source: string;
+            signal_count: number;
+            avg_severity: number;
+            dominant_categories: string[];
+            key_metrics: Record<string, number>;
+        }>, "many">>;
+        totalSignals: z.ZodNumber;
+        layersIncluded: z.ZodArray<z.ZodString, "many">;
+        aggregated_metrics: z.ZodOptional<z.ZodObject<{
+            total_events: z.ZodNumber;
+            unique_resources: z.ZodNumber;
+            avg_latency_ms: z.ZodOptional<z.ZodNumber>;
+            total_cost: z.ZodOptional<z.ZodNumber>;
+            error_rate: z.ZodOptional<z.ZodNumber>;
+            security_incidents: z.ZodOptional<z.ZodNumber>;
+            policy_violations: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            total_events: number;
+            unique_resources: number;
+            avg_latency_ms?: number | undefined;
+            total_cost?: number | undefined;
+            error_rate?: number | undefined;
+            security_incidents?: number | undefined;
+            policy_violations?: number | undefined;
+        }, {
+            total_events: number;
+            unique_resources: number;
+            avg_latency_ms?: number | undefined;
+            total_cost?: number | undefined;
+            error_rate?: number | undefined;
+            security_incidents?: number | undefined;
+            policy_violations?: number | undefined;
+        }>>;
+        statistics: z.ZodOptional<z.ZodObject<{
+            mean: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            median: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            std_dev: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            percentiles: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            mean: Record<string, number>;
+            median: Record<string, number>;
+            std_dev: Record<string, number>;
+            percentiles: Record<string, Record<string, number>>;
+        }, {
+            mean: Record<string, number>;
+            median: Record<string, number>;
+            std_dev: Record<string, number>;
+            percentiles: Record<string, Record<string, number>>;
+        }>>;
+        temporal_patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pattern_type: z.ZodEnum<["spike", "dip", "cyclical", "trending"]>;
+            detected_at: z.ZodString;
+            strength: z.ZodNumber;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            pattern_type: "spike" | "dip" | "cyclical" | "trending";
+            detected_at: string;
+            strength: number;
+        }, {
+            description: string;
+            pattern_type: "spike" | "dip" | "cyclical" | "trending";
+            detected_at: string;
+            strength: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        totalSignals: number;
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        signalsByLayer: Record<string, {
+            timestamp: string;
+            value: number;
+            signalId: string;
+            confidence: number;
+            layer: string;
+            metricType: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[]>;
+        layersIncluded: string[];
+        statistics?: {
+            mean: Record<string, number>;
+            median: Record<string, number>;
+            std_dev: Record<string, number>;
+            percentiles: Record<string, Record<string, number>>;
+        } | undefined;
+        aggregation_id?: string | undefined;
+        time_window?: {
+            start: string;
+            end: string;
+            granularity: "minute" | "hour" | "day" | "week" | "month";
+        } | undefined;
+        by_source?: {
+            source: string;
+            signal_count: number;
+            avg_severity: number;
+            dominant_categories: string[];
+            key_metrics: Record<string, number>;
+        }[] | undefined;
+        aggregated_metrics?: {
+            total_events: number;
+            unique_resources: number;
+            avg_latency_ms?: number | undefined;
+            total_cost?: number | undefined;
+            error_rate?: number | undefined;
+            security_incidents?: number | undefined;
+            policy_violations?: number | undefined;
+        } | undefined;
+        temporal_patterns?: {
+            description: string;
+            pattern_type: "spike" | "dip" | "cyclical" | "trending";
+            detected_at: string;
+            strength: number;
+        }[] | undefined;
+    }, {
+        totalSignals: number;
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        signalsByLayer: Record<string, {
+            timestamp: string;
+            value: number;
+            signalId: string;
+            confidence: number;
+            layer: string;
+            metricType: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[]>;
+        layersIncluded: string[];
+        statistics?: {
+            mean: Record<string, number>;
+            median: Record<string, number>;
+            std_dev: Record<string, number>;
+            percentiles: Record<string, Record<string, number>>;
+        } | undefined;
+        aggregation_id?: string | undefined;
+        time_window?: {
+            start: string;
+            end: string;
+            granularity: "minute" | "hour" | "day" | "week" | "month";
+        } | undefined;
+        by_source?: {
+            source: string;
+            signal_count: number;
+            avg_severity: number;
+            dominant_categories: string[];
+            key_metrics: Record<string, number>;
+        }[] | undefined;
+        aggregated_metrics?: {
+            total_events: number;
+            unique_resources: number;
+            avg_latency_ms?: number | undefined;
+            total_cost?: number | undefined;
+            error_rate?: number | undefined;
+            security_incidents?: number | undefined;
+            policy_violations?: number | undefined;
+        } | undefined;
+        temporal_patterns?: {
+            description: string;
+            pattern_type: "spike" | "dip" | "cyclical" | "trending";
+            detected_at: string;
+            strength: number;
+        }[] | undefined;
+    }>>;
+    cross_domain_correlations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        correlation_id: z.ZodOptional<z.ZodString>;
+        correlationId: z.ZodString;
+        primaryTrend: z.ZodObject<{
+            metricType: z.ZodString;
+            layer: z.ZodString;
+            direction: z.ZodEnum<["increasing", "decreasing", "stable", "volatile"]>;
+            magnitude: z.ZodNumber;
+            velocity: z.ZodNumber;
+            dataPoints: z.ZodNumber;
+            confidence: z.ZodNumber;
+            anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                timestamp: z.ZodString;
+                value: z.ZodNumber;
+                deviationScore: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }, {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        }, {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        }>;
+        secondaryTrend: z.ZodObject<{
+            metricType: z.ZodString;
+            layer: z.ZodString;
+            direction: z.ZodEnum<["increasing", "decreasing", "stable", "volatile"]>;
+            magnitude: z.ZodNumber;
+            velocity: z.ZodNumber;
+            dataPoints: z.ZodNumber;
+            confidence: z.ZodNumber;
+            anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                timestamp: z.ZodString;
+                value: z.ZodNumber;
+                deviationScore: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }, {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        }, {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        }>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            domain: z.ZodEnum<["cost", "security", "performance", "governance", "compliance"]>;
+            metrics: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            metrics: string[];
+            domain: "cost" | "performance" | "security" | "compliance" | "governance";
+        }, {
+            metrics: string[];
+            domain: "cost" | "performance" | "security" | "compliance" | "governance";
+        }>, "many">>;
+        correlations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            metric_a: z.ZodString;
+            metric_b: z.ZodString;
+            correlation_coefficient: z.ZodNumber;
+            p_value: z.ZodNumber;
+            is_significant: z.ZodBoolean;
+            relationship_type: z.ZodEnum<["positive", "negative", "none"]>;
+        }, "strip", z.ZodTypeAny, {
+            metric_a: string;
+            metric_b: string;
+            correlation_coefficient: number;
+            p_value: number;
+            is_significant: boolean;
+            relationship_type: "positive" | "negative" | "none";
+        }, {
+            metric_a: string;
+            metric_b: string;
+            correlation_coefficient: number;
+            p_value: number;
+            is_significant: boolean;
+            relationship_type: "positive" | "negative" | "none";
+        }>, "many">>;
+        correlationCoefficient: z.ZodNumber;
+        strength: z.ZodEnum<["weak", "moderate", "strong"]>;
+        lagTime: z.ZodOptional<z.ZodNumber>;
+        causality: z.ZodOptional<z.ZodEnum<["none", "potential", "likely"]>>;
+        causal_relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cause_metric: z.ZodString;
+            effect_metric: z.ZodString;
+            lag_time: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodNumber;
+            evidence: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            evidence: string[];
+            cause_metric: string;
+            effect_metric: string;
+            lag_time?: string | undefined;
+        }, {
+            confidence: number;
+            evidence: string[];
+            cause_metric: string;
+            effect_metric: string;
+            lag_time?: string | undefined;
+        }>, "many">>;
+        insights: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            insight_type: z.ZodEnum<["trade_off", "synergy", "cascade_effect", "feedback_loop"]>;
+            description: z.ZodString;
+            affected_domains: z.ZodArray<z.ZodString, "many">;
+            impact_score: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+            affected_domains: string[];
+            impact_score: number;
+        }, {
+            description: string;
+            insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+            affected_domains: string[];
+            impact_score: number;
+        }>, "many">>;
+        anomalous_correlations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            metrics: z.ZodArray<z.ZodString, "many">;
+            expected_correlation: z.ZodNumber;
+            actual_correlation: z.ZodNumber;
+            deviation_score: z.ZodNumber;
+            possible_explanation: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            metrics: string[];
+            deviation_score: number;
+            expected_correlation: number;
+            actual_correlation: number;
+            possible_explanation?: string | undefined;
+        }, {
+            metrics: string[];
+            deviation_score: number;
+            expected_correlation: number;
+            actual_correlation: number;
+            possible_explanation?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        strength: "weak" | "moderate" | "strong";
+        correlationId: string;
+        primaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        secondaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        correlationCoefficient: number;
+        correlation_id?: string | undefined;
+        domains?: {
+            metrics: string[];
+            domain: "cost" | "performance" | "security" | "compliance" | "governance";
+        }[] | undefined;
+        correlations?: {
+            metric_a: string;
+            metric_b: string;
+            correlation_coefficient: number;
+            p_value: number;
+            is_significant: boolean;
+            relationship_type: "positive" | "negative" | "none";
+        }[] | undefined;
+        lagTime?: number | undefined;
+        causality?: "none" | "potential" | "likely" | undefined;
+        causal_relationships?: {
+            confidence: number;
+            evidence: string[];
+            cause_metric: string;
+            effect_metric: string;
+            lag_time?: string | undefined;
+        }[] | undefined;
+        insights?: {
+            description: string;
+            insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+            affected_domains: string[];
+            impact_score: number;
+        }[] | undefined;
+        anomalous_correlations?: {
+            metrics: string[];
+            deviation_score: number;
+            expected_correlation: number;
+            actual_correlation: number;
+            possible_explanation?: string | undefined;
+        }[] | undefined;
+    }, {
+        strength: "weak" | "moderate" | "strong";
+        correlationId: string;
+        primaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        secondaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        correlationCoefficient: number;
+        correlation_id?: string | undefined;
+        domains?: {
+            metrics: string[];
+            domain: "cost" | "performance" | "security" | "compliance" | "governance";
+        }[] | undefined;
+        correlations?: {
+            metric_a: string;
+            metric_b: string;
+            correlation_coefficient: number;
+            p_value: number;
+            is_significant: boolean;
+            relationship_type: "positive" | "negative" | "none";
+        }[] | undefined;
+        lagTime?: number | undefined;
+        causality?: "none" | "potential" | "likely" | undefined;
+        causal_relationships?: {
+            confidence: number;
+            evidence: string[];
+            cause_metric: string;
+            effect_metric: string;
+            lag_time?: string | undefined;
+        }[] | undefined;
+        insights?: {
+            description: string;
+            insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+            affected_domains: string[];
+            impact_score: number;
+        }[] | undefined;
+        anomalous_correlations?: {
+            metrics: string[];
+            deviation_score: number;
+            expected_correlation: number;
+            actual_correlation: number;
+            possible_explanation?: string | undefined;
+        }[] | undefined;
+    }>, "many">>;
+    system_health: z.ZodOptional<z.ZodObject<{
+        overall_score: z.ZodNumber;
+        dimensions: z.ZodArray<z.ZodObject<{
+            dimension: z.ZodString;
+            score: z.ZodNumber;
+            trend: z.ZodEnum<["improving", "stable", "degrading"]>;
+            critical_issues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            score: number;
+            dimension: string;
+            trend: "stable" | "improving" | "degrading";
+            critical_issues?: string[] | undefined;
+        }, {
+            score: number;
+            dimension: string;
+            trend: "stable" | "improving" | "degrading";
+            critical_issues?: string[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        overall_score: number;
+        dimensions: {
+            score: number;
+            dimension: string;
+            trend: "stable" | "improving" | "degrading";
+            critical_issues?: string[] | undefined;
+        }[];
+    }, {
+        overall_score: number;
+        dimensions: {
+            score: number;
+            dimension: string;
+            trend: "stable" | "improving" | "degrading";
+            critical_issues?: string[] | undefined;
+        }[];
+    }>>;
+    kpis: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        current_value: z.ZodNumber;
+        target_value: z.ZodOptional<z.ZodNumber>;
+        trend: z.ZodObject<{
+            metricType: z.ZodString;
+            layer: z.ZodString;
+            direction: z.ZodEnum<["increasing", "decreasing", "stable", "volatile"]>;
+            magnitude: z.ZodNumber;
+            velocity: z.ZodNumber;
+            dataPoints: z.ZodNumber;
+            confidence: z.ZodNumber;
+            anomalies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                timestamp: z.ZodString;
+                value: z.ZodNumber;
+                deviationScore: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }, {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        }, {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        }>;
+        status: z.ZodEnum<["healthy", "warning", "critical"]>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        status: "warning" | "critical" | "healthy";
+        current_value: number;
+        trend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        target_value?: number | undefined;
+    }, {
+        name: string;
+        status: "warning" | "critical" | "healthy";
+        current_value: number;
+        trend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        target_value?: number | undefined;
+    }>, "many">>;
+    decision_event: z.ZodOptional<z.ZodObject<{
+        agent_id: z.ZodString;
+        agent_version: z.ZodString;
+        decision_type: z.ZodString;
+        inputs_hash: z.ZodString;
+        outputs: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        confidence: z.ZodNumber;
+        constraints_applied: z.ZodArray<z.ZodString, "many">;
+        execution_ref: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        agent_id: string;
+        agent_version: string;
+        decision_type: string;
+        inputs_hash: string;
+        outputs: Record<string, unknown>;
+        confidence: number;
+        constraints_applied: string[];
+        execution_ref?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        timestamp: string;
+        agent_id: string;
+        agent_version: string;
+        decision_type: string;
+        inputs_hash: string;
+        outputs: Record<string, unknown>;
+        confidence: number;
+        constraints_applied: string[];
+        execution_ref?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>>;
+    totalSignalsAnalyzed: z.ZodNumber;
+    trendsIdentified: z.ZodNumber;
+    correlationsFound: z.ZodNumber;
+    overallConfidence: z.ZodNumber;
+    analysisMetadata: z.ZodObject<{
+        timeWindow: z.ZodObject<{
+            startTime: z.ZodString;
+            endTime: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            startTime: string;
+            endTime: string;
+        }, {
+            startTime: string;
+            endTime: string;
+        }>;
+        layersAnalyzed: z.ZodArray<z.ZodString, "many">;
+        processingDuration: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        layersAnalyzed: string[];
+        processingDuration?: number | undefined;
+    }, {
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        layersAnalyzed: string[];
+        processingDuration?: number | undefined;
+    }>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        agent_version: z.ZodString;
+        processing_time_ms: z.ZodNumber;
+        data_sources_used: z.ZodArray<z.ZodNativeEnum<typeof DataSource>, "many">;
+        events_analyzed: z.ZodNumber;
+        model_version: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        agent_version: string;
+        processing_time_ms: number;
+        data_sources_used: DataSource[];
+        events_analyzed: number;
+        model_version?: string | undefined;
+    }, {
+        timestamp: string;
+        agent_version: string;
+        processing_time_ms: number;
+        data_sources_used: DataSource[];
+        events_analyzed: number;
+        model_version?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    recommendations: {
+        description: string;
+        confidence: number;
+        category: "cost-optimization" | "performance-improvement" | "risk-mitigation" | "capacity-planning" | "governance-compliance" | "strategic-initiative";
+        priority: "critical" | "low" | "medium" | "high";
+        title: string;
+        recommendationId: string;
+        rationale: string;
+        supportingCorrelations: string[];
+        supportingTrends: string[];
+        timeHorizon: "immediate" | "short-term" | "medium-term" | "long-term";
+        metadata?: Record<string, unknown> | undefined;
+        expectedImpact?: {
+            costSavings?: number | undefined;
+            performanceGain?: number | undefined;
+            riskReduction?: number | undefined;
+        } | undefined;
+    }[];
+    totalSignalsAnalyzed: number;
+    trendsIdentified: number;
+    correlationsFound: number;
+    overallConfidence: number;
+    analysisMetadata: {
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        layersAnalyzed: string[];
+        processingDuration?: number | undefined;
+    };
+    metadata?: {
+        timestamp: string;
+        agent_version: string;
+        processing_time_ms: number;
+        data_sources_used: DataSource[];
+        events_analyzed: number;
+        model_version?: string | undefined;
+    } | undefined;
+    decision_event?: {
+        timestamp: string;
+        agent_id: string;
+        agent_version: string;
+        decision_type: string;
+        inputs_hash: string;
+        outputs: Record<string, unknown>;
+        confidence: number;
+        constraints_applied: string[];
+        execution_ref?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | undefined;
+    request_id?: string | undefined;
+    signal_aggregation?: {
+        totalSignals: number;
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        signalsByLayer: Record<string, {
+            timestamp: string;
+            value: number;
+            signalId: string;
+            confidence: number;
+            layer: string;
+            metricType: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[]>;
+        layersIncluded: string[];
+        statistics?: {
+            mean: Record<string, number>;
+            median: Record<string, number>;
+            std_dev: Record<string, number>;
+            percentiles: Record<string, Record<string, number>>;
+        } | undefined;
+        aggregation_id?: string | undefined;
+        time_window?: {
+            start: string;
+            end: string;
+            granularity: "minute" | "hour" | "day" | "week" | "month";
+        } | undefined;
+        by_source?: {
+            source: string;
+            signal_count: number;
+            avg_severity: number;
+            dominant_categories: string[];
+            key_metrics: Record<string, number>;
+        }[] | undefined;
+        aggregated_metrics?: {
+            total_events: number;
+            unique_resources: number;
+            avg_latency_ms?: number | undefined;
+            total_cost?: number | undefined;
+            error_rate?: number | undefined;
+            security_incidents?: number | undefined;
+            policy_violations?: number | undefined;
+        } | undefined;
+        temporal_patterns?: {
+            description: string;
+            pattern_type: "spike" | "dip" | "cyclical" | "trending";
+            detected_at: string;
+            strength: number;
+        }[] | undefined;
+    } | undefined;
+    cross_domain_correlations?: {
+        strength: "weak" | "moderate" | "strong";
+        correlationId: string;
+        primaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        secondaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        correlationCoefficient: number;
+        correlation_id?: string | undefined;
+        domains?: {
+            metrics: string[];
+            domain: "cost" | "performance" | "security" | "compliance" | "governance";
+        }[] | undefined;
+        correlations?: {
+            metric_a: string;
+            metric_b: string;
+            correlation_coefficient: number;
+            p_value: number;
+            is_significant: boolean;
+            relationship_type: "positive" | "negative" | "none";
+        }[] | undefined;
+        lagTime?: number | undefined;
+        causality?: "none" | "potential" | "likely" | undefined;
+        causal_relationships?: {
+            confidence: number;
+            evidence: string[];
+            cause_metric: string;
+            effect_metric: string;
+            lag_time?: string | undefined;
+        }[] | undefined;
+        insights?: {
+            description: string;
+            insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+            affected_domains: string[];
+            impact_score: number;
+        }[] | undefined;
+        anomalous_correlations?: {
+            metrics: string[];
+            deviation_score: number;
+            expected_correlation: number;
+            actual_correlation: number;
+            possible_explanation?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    system_health?: {
+        overall_score: number;
+        dimensions: {
+            score: number;
+            dimension: string;
+            trend: "stable" | "improving" | "degrading";
+            critical_issues?: string[] | undefined;
+        }[];
+    } | undefined;
+    kpis?: {
+        name: string;
+        status: "warning" | "critical" | "healthy";
+        current_value: number;
+        trend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        target_value?: number | undefined;
+    }[] | undefined;
+}, {
+    recommendations: {
+        description: string;
+        confidence: number;
+        category: "cost-optimization" | "performance-improvement" | "risk-mitigation" | "capacity-planning" | "governance-compliance" | "strategic-initiative";
+        priority: "critical" | "low" | "medium" | "high";
+        title: string;
+        recommendationId: string;
+        rationale: string;
+        supportingCorrelations: string[];
+        supportingTrends: string[];
+        timeHorizon: "immediate" | "short-term" | "medium-term" | "long-term";
+        metadata?: Record<string, unknown> | undefined;
+        expectedImpact?: {
+            costSavings?: number | undefined;
+            performanceGain?: number | undefined;
+            riskReduction?: number | undefined;
+        } | undefined;
+    }[];
+    totalSignalsAnalyzed: number;
+    trendsIdentified: number;
+    correlationsFound: number;
+    overallConfidence: number;
+    analysisMetadata: {
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        layersAnalyzed: string[];
+        processingDuration?: number | undefined;
+    };
+    metadata?: {
+        timestamp: string;
+        agent_version: string;
+        processing_time_ms: number;
+        data_sources_used: DataSource[];
+        events_analyzed: number;
+        model_version?: string | undefined;
+    } | undefined;
+    decision_event?: {
+        timestamp: string;
+        agent_id: string;
+        agent_version: string;
+        decision_type: string;
+        inputs_hash: string;
+        outputs: Record<string, unknown>;
+        confidence: number;
+        constraints_applied: string[];
+        execution_ref?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | undefined;
+    request_id?: string | undefined;
+    signal_aggregation?: {
+        totalSignals: number;
+        timeWindow: {
+            startTime: string;
+            endTime: string;
+        };
+        signalsByLayer: Record<string, {
+            timestamp: string;
+            value: number;
+            signalId: string;
+            confidence: number;
+            layer: string;
+            metricType: string;
+            metadata?: Record<string, unknown> | undefined;
+        }[]>;
+        layersIncluded: string[];
+        statistics?: {
+            mean: Record<string, number>;
+            median: Record<string, number>;
+            std_dev: Record<string, number>;
+            percentiles: Record<string, Record<string, number>>;
+        } | undefined;
+        aggregation_id?: string | undefined;
+        time_window?: {
+            start: string;
+            end: string;
+            granularity: "minute" | "hour" | "day" | "week" | "month";
+        } | undefined;
+        by_source?: {
+            source: string;
+            signal_count: number;
+            avg_severity: number;
+            dominant_categories: string[];
+            key_metrics: Record<string, number>;
+        }[] | undefined;
+        aggregated_metrics?: {
+            total_events: number;
+            unique_resources: number;
+            avg_latency_ms?: number | undefined;
+            total_cost?: number | undefined;
+            error_rate?: number | undefined;
+            security_incidents?: number | undefined;
+            policy_violations?: number | undefined;
+        } | undefined;
+        temporal_patterns?: {
+            description: string;
+            pattern_type: "spike" | "dip" | "cyclical" | "trending";
+            detected_at: string;
+            strength: number;
+        }[] | undefined;
+    } | undefined;
+    cross_domain_correlations?: {
+        strength: "weak" | "moderate" | "strong";
+        correlationId: string;
+        primaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        secondaryTrend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        correlationCoefficient: number;
+        correlation_id?: string | undefined;
+        domains?: {
+            metrics: string[];
+            domain: "cost" | "performance" | "security" | "compliance" | "governance";
+        }[] | undefined;
+        correlations?: {
+            metric_a: string;
+            metric_b: string;
+            correlation_coefficient: number;
+            p_value: number;
+            is_significant: boolean;
+            relationship_type: "positive" | "negative" | "none";
+        }[] | undefined;
+        lagTime?: number | undefined;
+        causality?: "none" | "potential" | "likely" | undefined;
+        causal_relationships?: {
+            confidence: number;
+            evidence: string[];
+            cause_metric: string;
+            effect_metric: string;
+            lag_time?: string | undefined;
+        }[] | undefined;
+        insights?: {
+            description: string;
+            insight_type: "trade_off" | "synergy" | "cascade_effect" | "feedback_loop";
+            affected_domains: string[];
+            impact_score: number;
+        }[] | undefined;
+        anomalous_correlations?: {
+            metrics: string[];
+            deviation_score: number;
+            expected_correlation: number;
+            actual_correlation: number;
+            possible_explanation?: string | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    system_health?: {
+        overall_score: number;
+        dimensions: {
+            score: number;
+            dimension: string;
+            trend: "stable" | "improving" | "degrading";
+            critical_issues?: string[] | undefined;
+        }[];
+    } | undefined;
+    kpis?: {
+        name: string;
+        status: "warning" | "critical" | "healthy";
+        current_value: number;
+        trend: {
+            confidence: number;
+            direction: "increasing" | "decreasing" | "stable" | "volatile";
+            layer: string;
+            metricType: string;
+            magnitude: number;
+            velocity: number;
+            dataPoints: number;
+            anomalies?: {
+                timestamp: string;
+                value: number;
+                deviationScore: number;
+            }[] | undefined;
+        };
+        target_value?: number | undefined;
+    }[] | undefined;
+}>;
+export type StrategicRecommendationOutput = z.infer<typeof StrategicRecommendationOutputSchema>;
+/**
+ * Agent configuration
+ */
+export declare const StrategicRecommendationAgentConfigSchema: z.ZodObject<{
+    agent_id: z.ZodString;
+    version: z.ZodString;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodEnum<["anthropic", "openai", "custom"]>;
+        model_name: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "custom" | "anthropic" | "openai";
+        model_name: string;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+    }, {
+        provider: "custom" | "anthropic" | "openai";
+        model_name: string;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+    }>>;
+    default_constraints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        value?: unknown;
+    }, {
+        type: string;
+        value?: unknown;
+    }>, "many">>;
+    confidence_thresholds: z.ZodOptional<z.ZodObject<{
+        min_overall: z.ZodNumber;
+        min_data_quality: z.ZodNumber;
+        min_trend_strength: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        min_overall: number;
+        min_data_quality: number;
+        min_trend_strength: number;
+    }, {
+        min_overall: number;
+        min_data_quality: number;
+        min_trend_strength: number;
+    }>>;
+    source_priorities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    features: z.ZodOptional<z.ZodObject<{
+        enable_causal_analysis: z.ZodOptional<z.ZodBoolean>;
+        enable_predictive_modeling: z.ZodOptional<z.ZodBoolean>;
+        enable_anomaly_detection: z.ZodOptional<z.ZodBoolean>;
+        enable_cross_domain_correlation: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enable_causal_analysis?: boolean | undefined;
+        enable_predictive_modeling?: boolean | undefined;
+        enable_anomaly_detection?: boolean | undefined;
+        enable_cross_domain_correlation?: boolean | undefined;
+    }, {
+        enable_causal_analysis?: boolean | undefined;
+        enable_predictive_modeling?: boolean | undefined;
+        enable_anomaly_detection?: boolean | undefined;
+        enable_cross_domain_correlation?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    agent_id: string;
+    model?: {
+        provider: "custom" | "anthropic" | "openai";
+        model_name: string;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+    } | undefined;
+    default_constraints?: {
+        type: string;
+        value?: unknown;
+    }[] | undefined;
+    confidence_thresholds?: {
+        min_overall: number;
+        min_data_quality: number;
+        min_trend_strength: number;
+    } | undefined;
+    source_priorities?: Record<string, number> | undefined;
+    features?: {
+        enable_causal_analysis?: boolean | undefined;
+        enable_predictive_modeling?: boolean | undefined;
+        enable_anomaly_detection?: boolean | undefined;
+        enable_cross_domain_correlation?: boolean | undefined;
+    } | undefined;
+}, {
+    version: string;
+    agent_id: string;
+    model?: {
+        provider: "custom" | "anthropic" | "openai";
+        model_name: string;
+        temperature?: number | undefined;
+        max_tokens?: number | undefined;
+    } | undefined;
+    default_constraints?: {
+        type: string;
+        value?: unknown;
+    }[] | undefined;
+    confidence_thresholds?: {
+        min_overall: number;
+        min_data_quality: number;
+        min_trend_strength: number;
+    } | undefined;
+    source_priorities?: Record<string, number> | undefined;
+    features?: {
+        enable_causal_analysis?: boolean | undefined;
+        enable_predictive_modeling?: boolean | undefined;
+        enable_anomaly_detection?: boolean | undefined;
+        enable_cross_domain_correlation?: boolean | undefined;
+    } | undefined;
+}>;
+export type StrategicRecommendationAgentConfig = z.infer<typeof StrategicRecommendationAgentConfigSchema>;
+export type ValidatedSignalAggregation = z.infer<typeof SignalAggregationSchema>;
+export type ValidatedCrossDomainCorrelation = z.infer<typeof CrossDomainCorrelationSchema>;
+export type ValidatedStrategicRecommendationInput = z.infer<typeof StrategicRecommendationInputSchema>;
+export type ValidatedStrategicRecommendationOutput = z.infer<typeof StrategicRecommendationOutputSchema>;
+export type ValidatedStrategicRecommendationAgentConfig = z.infer<typeof StrategicRecommendationAgentConfigSchema>;
+//# sourceMappingURL=types.d.ts.map