import { AgentCapabilityProfile, EvolutionChange, EvolutionObjective, EvolutionActivity, EvolutionConstraint, EvolutionValidation, ResourceRequirement, AutonomousCapabilityType, EvolutionStrategy, EvolutionTimeline, EvolutionResource, ImplementationPhase } from '../types/index.js';
export interface AgentEvolutionConfig {
    evolutionMode: 'conservative' | 'moderate' | 'aggressive' | 'experimental';
    evolutionFrequency: 'continuous' | 'hourly' | 'daily' | 'weekly' | 'triggered';
    maxEvolutionRate: number;
    safetyLevel: 'strict' | 'moderate' | 'flexible' | 'experimental';
    rollbackEnabled: boolean;
    validationRequired: boolean;
    humanOversight: boolean;
    performanceThresholds: PerformanceThreshold[];
    benchmarkingEnabled: boolean;
    continuousMonitoring: boolean;
    performanceHistory: number;
    learningStrategies: EvolutionStrategy[];
    metaLearningEnabled: boolean;
    crossAgentLearning: boolean;
    experienceTransfer: boolean;
    capabilityCategories: AutonomousCapabilityType[];
    emergentCapabilityDetection: boolean;
    capabilityPruning: boolean;
    specialization_depth: number;
    computationalBudget: ComputationalBudget;
    resourceOptimization: boolean;
    parallelEvolution: boolean;
    distributedEvolution: boolean;
    organizationalMemoryIntegration: boolean;
    crossProjectLearning: boolean;
    externalKnowledgeIntegration: boolean;
}
export interface PerformanceThreshold {
    metric: string;
    threshold_type: 'minimum' | 'target' | 'maximum';
    value: number;
    improvement_required: boolean;
    urgency: 'low' | 'medium' | 'high' | 'critical';
}
export interface ComputationalBudget {
    max_cpu_usage: number;
    max_memory_usage: number;
    max_execution_time: number;
    max_api_calls: number;
    cost_per_evolution: number;
    daily_budget: number;
}
export interface AgentEvolutionRequest {
    agentId: string;
    evolutionType: 'performance_optimization' | 'capability_enhancement' | 'specialization' | 'comprehensive';
    triggerContext: EvolutionTriggerContext;
    constraints: EvolutionConstraint[];
    objectives: EvolutionObjective[];
    timeline: EvolutionTimeline;
    resources: EvolutionResource[];
}
export interface EvolutionTriggerContext {
    trigger_type: 'scheduled' | 'performance_degradation' | 'opportunity_detected' | 'user_request' | 'environmental_change';
    trigger_data: Record<string, any>;
    context_information: ContextInformation;
    urgency_level: 'low' | 'medium' | 'high' | 'critical';
    confidence: number;
}
export interface ContextInformation {
    current_performance: PerformanceSnapshot;
    recent_interactions: InteractionHistory[];
    environmental_factors: EnvironmentalFactor[];
    resource_availability: ResourceAvailability;
    strategic_priorities: StrategicPriority[];
}
export interface PerformanceSnapshot {
    timestamp: Date;
    metrics: Record<string, number>;
    trends: PerformanceTrend[];
    anomalies: PerformanceAnomaly[];
    benchmark_comparisons: BenchmarkComparison[];
}
export interface PerformanceTrend {
    metric: string;
    direction: 'improving' | 'stable' | 'declining';
    rate: number;
    confidence: number;
    projection: TrendProjection;
}
export interface TrendProjection {
    timeframe: string;
    projected_value: number;
    confidence_interval: {
        min: number;
        max: number;
    };
    factors: string[];
}
export interface PerformanceAnomaly {
    anomaly_type: 'spike' | 'drop' | 'plateau' | 'oscillation';
    metric: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    duration: number;
    potential_causes: string[];
    impact_assessment: string;
}
export interface BenchmarkComparison {
    benchmark_type: 'historical' | 'peer' | 'industry' | 'theoretical';
    metric: string;
    current_value: number;
    benchmark_value: number;
    percentile_rank: number;
    gap_analysis: GapAnalysis;
}
export interface GapAnalysis {
    gap_size: number;
    gap_significance: 'minor' | 'moderate' | 'significant' | 'critical';
    closing_strategy: string[];
    estimated_effort: 'low' | 'medium' | 'high';
    expected_benefit: number;
}
export interface InteractionHistory {
    interaction_id: string;
    timestamp: Date;
    interaction_type: 'task_execution' | 'learning' | 'adaptation' | 'collaboration';
    context: InteractionContext;
    performance: InteractionPerformance;
    outcomes: InteractionOutcome[];
    lessons_learned: LessonLearned[];
}
export interface InteractionContext {
    domain: string;
    complexity: 'low' | 'medium' | 'high' | 'very_high';
    stakeholders: string[];
    constraints: string[];
    resources_used: string[];
}
export interface InteractionPerformance {
    quality_score: number;
    efficiency_score: number;
    user_satisfaction: number;
    time_to_completion: number;
    resource_utilization: number;
    error_rate: number;
}
export interface InteractionOutcome {
    outcome_type: 'success' | 'partial_success' | 'failure' | 'learning';
    description: string;
    metrics: Record<string, number>;
    stakeholder_feedback: StakeholderFeedback[];
    artifacts_generated: string[];
}
export interface StakeholderFeedback {
    stakeholder_id: string;
    feedback_type: 'rating' | 'comment' | 'suggestion' | 'complaint';
    content: string;
    sentiment: 'positive' | 'neutral' | 'negative';
    actionable: boolean;
}
export interface LessonLearned {
    lesson_category: 'success_pattern' | 'failure_pattern' | 'optimization_opportunity' | 'best_practice';
    lesson_description: string;
    applicability: string[];
    confidence: number;
    validation_required: boolean;
}
export interface EnvironmentalFactor {
    factor_type: 'technical' | 'organizational' | 'market' | 'regulatory' | 'social';
    factor_name: string;
    impact_on_performance: number;
    trend: 'increasing' | 'stable' | 'decreasing';
    predictability: number;
    adaptation_strategy: string[];
}
export interface ResourceAvailability {
    computational_resources: ComputationalResourceStatus;
    human_resources: HumanResourceStatus;
    external_services: ExternalServiceStatus;
    knowledge_resources: KnowledgeResourceStatus;
}
export interface ComputationalResourceStatus {
    cpu_availability: number;
    memory_availability: number;
    storage_availability: number;
    network_bandwidth: number;
    cost_constraints: number;
}
export interface HumanResourceStatus {
    expert_availability: ExpertAvailability[];
    collaboration_capacity: number;
    supervision_level: 'minimal' | 'moderate' | 'extensive';
    feedback_frequency: string;
}
export interface ExpertAvailability {
    expertise_domain: string;
    availability_level: 'low' | 'medium' | 'high';
    response_time: string;
    consultation_cost: number;
}
export interface ExternalServiceStatus {
    api_quotas: APIQuota[];
    service_reliability: ServiceReliability[];
    cost_budgets: CostBudget[];
    integration_health: IntegrationHealth[];
}
export interface APIQuota {
    service_name: string;
    quota_limit: number;
    quota_used: number;
    quota_reset_time: Date;
    overage_cost: number;
}
export interface ServiceReliability {
    service_name: string;
    uptime_percentage: number;
    response_time_avg: number;
    error_rate: number;
    recent_incidents: string[];
}
export interface CostBudget {
    budget_category: string;
    total_budget: number;
    budget_used: number;
    budget_remaining: number;
    budget_period: string;
}
export interface IntegrationHealth {
    integration_name: string;
    health_status: 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
    last_health_check: Date;
    issues: string[];
    resolution_status: string;
}
export interface KnowledgeResourceStatus {
    knowledge_bases: KnowledgeBaseStatus[];
    documentation_currency: DocumentationCurrency[];
    expert_networks: ExpertNetworkStatus[];
    learning_materials: LearningMaterialStatus[];
}
export interface KnowledgeBaseStatus {
    kb_name: string;
    coverage: number;
    accuracy: number;
    currency: number;
    access_level: 'full' | 'limited' | 'restricted';
}
export interface DocumentationCurrency {
    doc_category: string;
    last_updated: Date;
    update_frequency: string;
    staleness_risk: 'low' | 'medium' | 'high';
}
export interface ExpertNetworkStatus {
    network_name: string;
    active_experts: number;
    response_rate: number;
    expertise_coverage: string[];
    collaboration_quality: number;
}
export interface LearningMaterialStatus {
    material_type: string;
    availability: 'available' | 'limited' | 'unavailable';
    quality_rating: number;
    relevance_score: number;
    access_cost: number;
}
export interface StrategicPriority {
    priority_name: string;
    priority_level: 'low' | 'medium' | 'high' | 'critical';
    alignment_with_evolution: number;
    timeline: string;
    success_metrics: string[];
}
export interface AgentEvolutionResult {
    evolutionId: string;
    agentId: string;
    evolutionStartTime: Date;
    evolutionEndTime: Date;
    evolutionStatus: 'completed' | 'failed' | 'partial' | 'rolled_back';
    preEvolutionProfile: AgentCapabilityProfile;
    preEvolutionMetrics: PerformanceMetrics;
    evolutionProcess: EvolutionProcess;
    implementedChanges: EvolutionChange[];
    validationResults: EvolutionValidation[];
    postEvolutionProfile: AgentCapabilityProfile;
    postEvolutionMetrics: PerformanceMetrics;
    improvementAnalysis: ImprovementAnalysis;
    riskAssessment: EvolutionRiskAssessment;
    safetyValidation: SafetyValidationResult;
    rollbackPlan: RollbackPlan;
    nextEvolutionRecommendations: NextEvolutionRecommendation[];
    longTermEvolutionStrategy: LongTermEvolutionStrategy;
    computationalCost: ComputationalCost;
    resourceUtilization: EvolutionResourceUtilization;
    lessonsLearned: EvolutionLessonLearned[];
}
export interface EvolutionProcess {
    methodology: string;
    phases: EvolutionProcessPhase[];
    decision_points: EvolutionDecisionPoint[];
    optimization_techniques: OptimizationTechnique[];
    validation_checkpoints: ValidationCheckpoint[];
}
export interface EvolutionProcessPhase {
    phase_name: string;
    phase_description: string;
    start_time: Date;
    end_time: Date;
    activities: EvolutionActivity[];
    outputs: PhaseOutput[];
    success_criteria: string[];
    validation_results: PhaseValidationResult[];
}
export interface PhaseOutput {
    output_type: 'analysis' | 'design' | 'implementation' | 'validation' | 'optimization';
    output_name: string;
    output_description: string;
    output_data: any;
    quality_score: number;
}
export interface PhaseValidationResult {
    validation_type: string;
    validation_criteria: string[];
    validation_outcome: 'passed' | 'failed' | 'conditional';
    validation_score: number;
    issues_identified: ValidationIssue[];
    recommendations: string[];
}
export interface ValidationIssue {
    issue_type: 'performance' | 'safety' | 'compatibility' | 'resource' | 'quality';
    issue_severity: 'low' | 'medium' | 'high' | 'critical';
    issue_description: string;
    potential_impact: string;
    mitigation_options: string[];
}
export interface EvolutionDecisionPoint {
    decision_name: string;
    decision_context: string;
    alternatives: DecisionAlternative[];
    decision_criteria: DecisionCriterion[];
    selected_alternative: string;
    decision_rationale: string;
    confidence_level: number;
    reversibility: boolean;
}
export interface DecisionAlternative {
    alternative_name: string;
    alternative_description: string;
    expected_outcomes: ExpectedOutcome[];
    resource_requirements: ResourceRequirement[];
    risks: AlternativeRisk[];
    benefits: AlternativeBenefit[];
}
export interface ExpectedOutcome {
    outcome_metric: string;
    expected_value: number;
    confidence_level: number;
    time_to_realization: string;
    dependencies: string[];
}
export interface AlternativeRisk {
    risk_description: string;
    risk_probability: number;
    risk_impact: 'low' | 'medium' | 'high' | 'critical';
    mitigation_strategies: string[];
}
export interface AlternativeBenefit {
    benefit_description: string;
    benefit_magnitude: number;
    benefit_sustainability: string;
    beneficiaries: string[];
}
export interface DecisionCriterion {
    criterion_name: string;
    criterion_weight: number;
    measurement_method: string;
    target_value: number;
    critical_criterion: boolean;
}
export interface OptimizationTechnique {
    technique_name: string;
    technique_type: 'gradient_based' | 'evolutionary' | 'bayesian' | 'reinforcement_learning' | 'hybrid';
    technique_description: string;
    application_context: string[];
    parameters: OptimizationParameters;
    performance_characteristics: TechniquePerformance;
}
export interface OptimizationParameters {
    learning_rate?: number;
    population_size?: number;
    generations?: number;
    mutation_rate?: number;
    crossover_rate?: number;
    exploration_rate?: number;
    convergence_criteria?: ConvergenceCriteria;
}
export interface ConvergenceCriteria {
    max_iterations: number;
    tolerance: number;
    improvement_threshold: number;
    stagnation_limit: number;
}
export interface TechniquePerformance {
    convergence_speed: 'slow' | 'medium' | 'fast';
    solution_quality: 'acceptable' | 'good' | 'excellent';
    computational_cost: 'low' | 'medium' | 'high';
    robustness: 'low' | 'medium' | 'high';
}
export interface ValidationCheckpoint {
    checkpoint_name: string;
    checkpoint_timing: 'before_phase' | 'during_phase' | 'after_phase' | 'continuous';
    validation_methods: ValidationMethod[];
    success_criteria: CheckpointCriterion[];
    failure_handling: CheckpointFailureHandling;
}
export interface ValidationMethod {
    method_name: string;
    method_type: 'static_analysis' | 'dynamic_testing' | 'performance_testing' | 'safety_verification' | 'human_review';
    method_description: string;
    automation_level: 'manual' | 'semi_automated' | 'fully_automated';
    execution_time: string;
}
export interface CheckpointCriterion {
    criterion_name: string;
    criterion_type: 'threshold' | 'comparison' | 'trend' | 'pattern';
    target_value: any;
    tolerance: number;
    mandatory: boolean;
}
export interface CheckpointFailureHandling {
    failure_actions: FailureAction[];
    escalation_procedures: EscalationProcedure[];
    recovery_options: RecoveryOption[];
}
export interface FailureAction {
    action_type: 'retry' | 'rollback' | 'skip' | 'escalate' | 'abort';
    action_conditions: string[];
    action_parameters: Record<string, any>;
    automatic_execution: boolean;
}
export interface EscalationProcedure {
    escalation_level: number;
    escalation_trigger: string;
    escalation_target: string;
    escalation_timeline: string;
    escalation_information: string[];
}
export interface RecoveryOption {
    recovery_strategy: string;
    recovery_steps: string[];
    recovery_time: string;
    recovery_cost: number;
    recovery_success_probability: number;
}
export interface PerformanceMetrics {
    core_metrics: CoreMetric[];
    efficiency_metrics: EfficiencyMetric[];
    quality_metrics: QualityMetric[];
    user_experience_metrics: UserExperienceMetric[];
    business_metrics: BusinessMetric[];
}
export interface CoreMetric {
    metric_name: string;
    metric_value: number;
    metric_unit: string;
    benchmark_value?: number;
    target_value?: number;
    trend: MetricTrend;
}
export interface MetricTrend {
    direction: 'improving' | 'stable' | 'declining';
    rate_of_change: number;
    volatility: number;
    predictability: number;
}
export interface EfficiencyMetric {
    resource_type: string;
    utilization_rate: number;
    efficiency_score: number;
    waste_percentage: number;
    optimization_potential: number;
}
export interface QualityMetric {
    quality_dimension: string;
    quality_score: number;
    quality_trend: string;
    quality_factors: QualityFactor[];
    improvement_areas: string[];
}
export interface QualityFactor {
    factor_name: string;
    contribution: number;
    controllability: 'high' | 'medium' | 'low';
    improvement_strategy: string[];
}
export interface UserExperienceMetric {
    experience_dimension: string;
    satisfaction_score: number;
    usability_score: number;
    engagement_level: number;
    feedback_summary: FeedbackSummary;
}
export interface FeedbackSummary {
    positive_feedback_percentage: number;
    negative_feedback_percentage: number;
    neutral_feedback_percentage: number;
    common_themes: FeedbackTheme[];
    improvement_suggestions: string[];
}
export interface FeedbackTheme {
    theme: string;
    frequency: number;
    sentiment: 'positive' | 'neutral' | 'negative';
    impact_assessment: string;
}
export interface BusinessMetric {
    metric_name: string;
    metric_value: number;
    business_impact: number;
    roi_calculation: ROICalculation;
    strategic_alignment: number;
}
export interface ROICalculation {
    investment_cost: number;
    benefit_value: number;
    roi_percentage: number;
    payback_period: string;
    net_present_value: number;
}
export interface ImprovementAnalysis {
    overall_improvement: OverallImprovement;
    capability_improvements: CapabilityImprovement[];
    performance_improvements: PerformanceImprovement[];
    unexpected_benefits: UnexpectedBenefit[];
    areas_for_further_improvement: ImprovementArea[];
}
export interface OverallImprovement {
    improvement_score: number;
    improvement_percentage: number;
    improvement_significance: 'minor' | 'moderate' | 'significant' | 'transformational';
    improvement_sustainability: number;
    improvement_generalizability: number;
}
export interface CapabilityImprovement {
    capability_name: string;
    before_proficiency: number;
    after_proficiency: number;
    improvement_magnitude: number;
    improvement_quality: string;
    evidence: ImprovementEvidence[];
}
export interface ImprovementEvidence {
    evidence_type: 'performance_data' | 'user_feedback' | 'benchmark_comparison' | 'expert_assessment';
    evidence_description: string;
    evidence_strength: 'weak' | 'moderate' | 'strong' | 'conclusive';
    evidence_source: string;
}
export interface PerformanceImprovement {
    metric_name: string;
    baseline_value: number;
    improved_value: number;
    improvement_percentage: number;
    statistical_significance: number;
    improvement_attribution: ImprovementAttribution[];
}
export interface ImprovementAttribution {
    contributing_factor: string;
    contribution_percentage: number;
    confidence_level: number;
    supporting_evidence: string[];
}
export interface UnexpectedBenefit {
    benefit_description: string;
    benefit_value: number;
    discovery_context: string;
    potential_for_replication: number;
    strategic_value: number;
}
export interface ImprovementArea {
    area_name: string;
    current_state: string;
    target_state: string;
    improvement_potential: number;
    implementation_complexity: 'low' | 'medium' | 'high';
    resource_requirements: string[];
}
export interface EvolutionRiskAssessment {
    overall_risk_level: 'low' | 'medium' | 'high' | 'critical';
    risk_categories: EvolutionRiskCategory[];
    risk_mitigation_effectiveness: number;
    residual_risk_level: 'low' | 'medium' | 'high';
    risk_monitoring_plan: RiskMonitoringPlan;
}
export interface EvolutionRiskCategory {
    category_name: string;
    risks: IdentifiedRisk[];
    category_risk_level: 'low' | 'medium' | 'high' | 'critical';
    mitigation_strategies: CategoryMitigationStrategy[];
}
export interface IdentifiedRisk {
    risk_id: string;
    risk_description: string;
    risk_probability: number;
    risk_impact: 'low' | 'medium' | 'high' | 'critical';
    risk_velocity: string;
    risk_detection_difficulty: 'easy' | 'moderate' | 'difficult';
}
export interface CategoryMitigationStrategy {
    strategy_name: string;
    strategy_description: string;
    strategy_effectiveness: number;
    implementation_cost: number;
    implementation_time: string;
}
export interface RiskMonitoringPlan {
    monitoring_frequency: string;
    risk_indicators: RiskIndicator[];
    escalation_triggers: RiskEscalationTrigger[];
    response_procedures: RiskResponseProcedure[];
}
export interface RiskIndicator {
    indicator_name: string;
    indicator_type: 'leading' | 'lagging' | 'concurrent';
    measurement_method: string;
    alert_thresholds: IndicatorThreshold[];
    monitoring_automation: boolean;
}
export interface IndicatorThreshold {
    threshold_level: 'warning' | 'critical' | 'emergency';
    threshold_value: number;
    response_time_requirement: string;
    automatic_response: AutomaticResponse[];
}
export interface AutomaticResponse {
    response_type: 'notification' | 'mitigation' | 'escalation' | 'shutdown';
    response_parameters: Record<string, any>;
    response_conditions: string[];
    human_oversight_required: boolean;
}
export interface RiskEscalationTrigger {
    trigger_condition: string;
    escalation_path: string[];
    escalation_timeline: string;
    escalation_criteria: string[];
}
export interface RiskResponseProcedure {
    procedure_name: string;
    trigger_conditions: string[];
    response_steps: ResponseStep[];
    success_criteria: string[];
    fallback_procedures: string[];
}
export interface ResponseStep {
    step_description: string;
    step_owner: string;
    step_duration: string;
    step_dependencies: string[];
    step_validation: string[];
}
export interface SafetyValidationResult {
    validation_status: 'passed' | 'failed' | 'conditional' | 'pending';
    safety_score: number;
    safety_categories: SafetyCategory[];
    safety_violations: SafetyViolation[];
    safety_recommendations: SafetyRecommendation[];
}
export interface SafetyCategory {
    category_name: string;
    category_score: number;
    validation_tests: SafetyTest[];
    compliance_status: 'compliant' | 'non_compliant' | 'partial' | 'unknown';
}
export interface SafetyTest {
    test_name: string;
    test_type: 'functional' | 'security' | 'performance' | 'reliability' | 'ethical';
    test_result: 'passed' | 'failed' | 'warning';
    test_score: number;
    test_evidence: TestEvidence[];
}
export interface TestEvidence {
    evidence_type: 'log' | 'metric' | 'output' | 'behavior' | 'observation';
    evidence_description: string;
    evidence_value: any;
    evidence_interpretation: string;
}
export interface SafetyViolation {
    violation_type: 'policy' | 'constraint' | 'threshold' | 'behavior' | 'outcome';
    violation_severity: 'low' | 'medium' | 'high' | 'critical';
    violation_description: string;
    potential_consequences: string[];
    remediation_required: boolean;
}
export interface SafetyRecommendation {
    recommendation_type: 'immediate_action' | 'process_improvement' | 'monitoring_enhancement' | 'constraint_adjustment';
    recommendation_description: string;
    implementation_priority: 'low' | 'medium' | 'high' | 'urgent';
    implementation_effort: 'low' | 'medium' | 'high';
    expected_benefit: string;
}
export interface RollbackPlan {
    rollback_triggers: RollbackTrigger[];
    rollback_procedures: RollbackProcedure[];
    rollback_validation: RollbackValidation;
    rollback_timeline: string;
    rollback_dependencies: string[];
}
export interface RollbackTrigger {
    trigger_condition: string;
    trigger_priority: 'low' | 'medium' | 'high' | 'emergency';
    automatic_rollback: boolean;
    human_approval_required: boolean;
    trigger_monitoring: boolean;
}
export interface RollbackProcedure {
    procedure_name: string;
    procedure_steps: RollbackStep[];
    procedure_validation: string[];
    procedure_duration: string;
    procedure_resources: string[];
}
export interface RollbackStep {
    step_description: string;
    step_order: number;
    step_criticality: 'low' | 'medium' | 'high' | 'critical';
    step_validation: string[];
    step_dependencies: string[];
}
export interface RollbackValidation {
    validation_criteria: string[];
    validation_methods: string[];
    success_indicators: string[];
    failure_procedures: string[];
}
export interface NextEvolutionRecommendation {
    recommendation_id: string;
    recommendation_type: 'capability_enhancement' | 'performance_optimization' | 'specialization' | 'integration';
    recommendation_description: string;
    expected_benefits: ExpectedBenefit[];
    implementation_plan: RecommendationImplementationPlan;
    resource_requirements: ResourceRequirement[];
    risk_assessment: RecommendationRiskAssessment;
    priority_score: number;
}
export interface ExpectedBenefit {
    benefit_category: string;
    benefit_description: string;
    benefit_magnitude: number;
    benefit_timeline: string;
    benefit_sustainability: number;
}
export interface RecommendationImplementationPlan {
    implementation_phases: ImplementationPhase[];
    implementation_timeline: string;
    implementation_milestones: string[];
    implementation_dependencies: string[];
    implementation_constraints: string[];
}
export interface RecommendationRiskAssessment {
    risk_level: 'low' | 'medium' | 'high' | 'critical';
    key_risks: string[];
    mitigation_strategies: string[];
    contingency_plans: string[];
    monitoring_requirements: string[];
}
export interface LongTermEvolutionStrategy {
    strategy_horizon: string;
    strategic_objectives: StrategicObjective[];
    evolution_roadmap: EvolutionRoadmap;
    capability_targets: CapabilityTarget[];
    success_metrics: StrategySuccessMetric[];
}
export interface StrategicObjective {
    objective_name: string;
    objective_description: string;
    objective_timeline: string;
    objective_metrics: string[];
    objective_dependencies: string[];
}
export interface EvolutionRoadmap {
    roadmap_phases: RoadmapPhase[];
    critical_milestones: CriticalMilestone[];
    decision_points: StrategicDecisionPoint[];
    resource_planning: StrategicResourcePlanning;
}
export interface RoadmapPhase {
    phase_name: string;
    phase_duration: string;
    phase_objectives: string[];
    phase_deliverables: string[];
    phase_dependencies: string[];
}
export interface CriticalMilestone {
    milestone_name: string;
    milestone_date: Date;
    milestone_criteria: string[];
    milestone_stakeholders: string[];
    milestone_risks: string[];
}
export interface StrategicDecisionPoint {
    decision_name: string;
    decision_timeline: string;
    decision_criteria: string[];
    decision_options: string[];
    decision_implications: string[];
}
export interface StrategicResourcePlanning {
    resource_categories: string[];
    resource_allocation_strategy: string;
    resource_acquisition_plan: string[];
    resource_optimization_opportunities: string[];
}
export interface CapabilityTarget {
    capability_name: string;
    current_level: number;
    target_level: number;
    development_strategy: string[];
    achievement_timeline: string;
    measurement_methods: string[];
}
export interface StrategySuccessMetric {
    metric_name: string;
    metric_type: 'outcome' | 'output' | 'impact' | 'efficiency';
    target_value: number;
    measurement_frequency: string;
    reporting_stakeholders: string[];
}
export interface ComputationalCost {
    total_cost: number;
    cost_breakdown: CostBreakdown[];
    cost_efficiency: number;
    cost_comparison: CostComparison;
    cost_optimization_opportunities: string[];
}
export interface CostBreakdown {
    cost_category: string;
    cost_amount: number;
    cost_percentage: number;
    cost_justification: string;
    optimization_potential: number;
}
export interface CostComparison {
    baseline_cost: number;
    actual_cost: number;
    cost_variance: number;
    cost_variance_explanation: string[];
    cost_trend_analysis: string;
}
export interface EvolutionResourceUtilization {
    cpu_utilization: ResourceUtilizationMetric;
    memory_utilization: ResourceUtilizationMetric;
    storage_utilization: ResourceUtilizationMetric;
    network_utilization: ResourceUtilizationMetric;
    external_service_utilization: ExternalServiceUtilization[];
}
export interface ResourceUtilizationMetric {
    peak_utilization: number;
    average_utilization: number;
    utilization_efficiency: number;
    utilization_pattern: string;
    optimization_recommendations: string[];
}
export interface ExternalServiceUtilization {
    service_name: string;
    requests_made: number;
    data_transferred: number;
    cost_incurred: number;
    efficiency_score: number;
}
export interface EvolutionLessonLearned {
    lesson_category: string;
    lesson_description: string;
    lesson_context: string;
    lesson_applicability: string[];
    lesson_validation: LessonValidation;
    lesson_integration: LessonIntegration;
}
export interface LessonValidation {
    validation_method: string;
    validation_confidence: number;
    validation_evidence: string[];
    validation_limitations: string[];
}
export interface LessonIntegration {
    integration_status: 'planned' | 'in_progress' | 'completed' | 'deferred';
    integration_method: string[];
    integration_timeline: string;
    integration_stakeholders: string[];
}
export declare class AutonomousAgentEvolutionService {
    private config;
    private organizationalMemory?;
    private agentProfiles;
    private evolutionHistory;
    private performanceMonitoring;
    private safetyMechanisms;
    constructor(config: AgentEvolutionConfig);
    private initializeService;
    evolveAgent(request: AgentEvolutionRequest): Promise<AgentEvolutionResult>;
    analyzeAgentCapabilities(agentId: string): Promise<AgentCapabilityProfile>;
    monitorAgentPerformance(agentId: string): Promise<PerformanceSnapshot>;
    private initializeEvolutionEngines;
    private initializePerformanceMonitoring;
    private initializeSafetyFrameworks;
    private loadOrganizationalMemory;
    private initializeLearningFrameworks;
    private validateEvolutionRequest;
    private analyzeCurrentAgentState;
    planEvolutionStrategy(request: AgentEvolutionRequest): Promise<any>;
    performSafetyValidation(evolutionProcess: any): Promise<any>;
    developLongTermStrategy(agentId: string): Promise<any>;
    generateInitialProfile(agentId: string): Promise<any>;
    updateCapabilityProfile(agentId: string, currentProfile: any): Promise<any>;
    detectEmergentCapabilities(agentId: string, profile: any): Promise<any[]>;
    analyzeLearningPatterns(agentId: string): Promise<any>;
    analyzeAdaptationMechanisms(agentId: string): Promise<any[]>;
    collectPerformanceMetrics(agentId: string): Promise<any>;
    analyzePerformanceTrends(agentId: string): Promise<any>;
    detectPerformanceAnomalies(agentId: string, metrics: any): Promise<any[]>;
    performBenchmarkComparisons(agentId: string, metrics: any): Promise<any>;
    checkEvolutionTriggers(agentId: string): Promise<boolean>;
    loadMemoryFromStorage(): Promise<any>;
    executeEvolutionProcess(evolutionId?: string, request?: any, evolutionPlan?: any, preEvolutionState?: any): Promise<any>;
    analyzePostEvolutionState(agentId: string): Promise<any>;
    assessEvolutionRisks(evolutionPlan: any): Promise<any>;
    createRollbackPlan(evolutionPlan: any): Promise<any>;
    analyzeImprovements(preEvolutionState: any): Promise<any>;
    generateNextEvolutionRecommendations(agentId: string): Promise<any>;
    calculateComputationalCost(evolutionPlan: any): Promise<any>;
    analyzeResourceUtilization(metrics: any): Promise<any>;
    extractLessonsLearned(evolutionData: any): Promise<any>;
}
export default AutonomousAgentEvolutionService;
//# sourceMappingURL=autonomous-agent-evolution.d.ts.map