import { ProjectContext, AIToolAllocation, OptimizationMethodology, Risk, MitigationStrategy, ContingencyPlan, ScalingPolicy, EscalationPolicy, TrendData, AccuracyMetrics, PredictionConfidence } from '../types/index.js';
export interface ResourceOptimizationConfig {
    optimizationMode: 'cost' | 'performance' | 'balanced' | 'custom';
    optimizationFrequency: 'realtime' | 'hourly' | 'daily' | 'weekly' | 'on_demand';
    maxOptimizationTime: number;
    resourceTypes: ResourceType[];
    allocationStrategies: AllocationStrategy[];
    scalingPolicies: ScalingPolicyConfig[];
    resourceConstraints: ResourceConstraint[];
    aiToolCategories: AIToolCategory[];
    toolPriorities: ToolPriority[];
    usagePatterns: UsagePattern[];
    costModels: CostModel[];
    performanceTargets: PerformanceTarget[];
    slaRequirements: SLARequirement[];
    qualityThresholds: QualityThreshold[];
    latencyTargets: LatencyTarget[];
    budgetConstraints: BudgetConstraint[];
    costOptimization: CostOptimizationConfig;
    chargeback: ChargebackConfig;
    costTracking: CostTrackingConfig;
    monitoringEnabled: boolean;
    metricsCollection: MetricsCollectionConfig;
    alerting: AlertingConfig;
    reporting: ReportingConfig;
    organizationalMemoryIntegration: boolean;
    crossProjectOptimization: boolean;
    externalIntegrations: ExternalIntegration[];
    securityConstraints: SecurityConstraint[];
    complianceRequirements: ComplianceRequirement[];
    auditConfiguration: AuditConfig;
}
export type ResourceType = 'ai_model_instances' | 'compute_capacity' | 'memory_allocation' | 'storage_capacity' | 'network_bandwidth' | 'api_quotas' | 'human_resources' | 'tool_licenses' | 'cloud_resources' | 'hardware_resources';
export interface AllocationStrategy {
    name: string;
    type: 'round_robin' | 'weighted' | 'priority_based' | 'performance_based' | 'cost_optimized' | 'ml_optimized';
    description: string;
    parameters: Record<string, any>;
    applicableResources: ResourceType[];
    priority: number;
    constraints: AllocationConstraint[];
}
export interface AllocationConstraint {
    type: 'minimum' | 'maximum' | 'ratio' | 'dependency' | 'exclusivity';
    resource: ResourceType;
    value: number;
    unit: string;
    condition: string;
    enforcement: 'strict' | 'flexible' | 'advisory';
}
export interface ScalingPolicyConfig extends ScalingPolicy {
    resourceType: ResourceType;
    enabled: boolean;
    priority: number;
    dependencies: string[];
    constraints: ScalingConstraint[];
}
export interface ScalingConstraint {
    type: 'budget' | 'performance' | 'availability' | 'security' | 'compliance';
    value: number;
    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'between';
    enforcement: 'hard' | 'soft';
    description: string;
}
export interface ResourceConstraint {
    resourceType: ResourceType;
    constraint: 'availability' | 'capacity' | 'cost' | 'performance' | 'security';
    value: number;
    unit: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    flexible: boolean;
    exceptions: ResourceException[];
}
export interface ResourceException {
    condition: string;
    action: 'override' | 'escalate' | 'defer' | 'reject';
    approver: string;
    duration: number;
    justification: string;
}
export interface AIToolCategory {
    category: string;
    tools: AIToolDefinition[];
    defaultAllocation: number;
    priority: number;
    costTier: 'low' | 'medium' | 'high' | 'premium';
    performanceClass: 'basic' | 'standard' | 'premium' | 'enterprise';
}
export interface AIToolDefinition {
    name: string;
    type: string;
    capabilities: string[];
    resourceRequirements: ResourceRequirement[];
    costStructure: CostStructure;
    performanceMetrics: PerformanceMetrics;
    scalingCharacteristics: ScalingCharacteristics;
    dependencies: ToolDependency[];
}
export interface ResourceRequirement {
    resourceType: ResourceType;
    minimum: number;
    recommended: number;
    maximum: number;
    unit: string;
    scalable: boolean;
    priority: number;
}
export interface CostStructure {
    model: 'fixed' | 'variable' | 'tiered' | 'hybrid';
    baseCost: number;
    variableCost: number;
    tiers: CostTier[];
    currency: string;
    billingPeriod: 'hourly' | 'daily' | 'monthly' | 'annual';
}
export interface CostTier {
    threshold: number;
    rate: number;
    unit: string;
    description: string;
}
export interface PerformanceMetrics {
    latency: LatencyMetrics;
    throughput: ThroughputMetrics;
    availability: AvailabilityMetrics;
    accuracy: AccuracyMetrics;
    reliability: ReliabilityMetrics;
}
export interface LatencyMetrics {
    p50: number;
    p95: number;
    p99: number;
    unit: string;
    target: number;
}
export interface ThroughputMetrics {
    requests_per_second: number;
    tokens_per_second: number;
    concurrent_requests: number;
    batch_size: number;
}
export interface AvailabilityMetrics {
    uptime_percentage: number;
    mtbf: number;
    mttr: number;
    sla_target: number;
}
export interface ReliabilityMetrics {
    error_rate: number;
    success_rate: number;
    retry_rate: number;
    timeout_rate: number;
}
export interface ScalingCharacteristics {
    horizontal_scaling: boolean;
    vertical_scaling: boolean;
    auto_scaling: boolean;
    scaling_factor: number;
    cooldown_period: number;
    warmup_time: number;
}
export interface ToolDependency {
    dependency_type: 'requires' | 'enhances' | 'conflicts' | 'alternatives';
    tool: string;
    version?: string;
    optional: boolean;
    impact: string;
}
export interface ToolPriority {
    tool: string;
    category: string;
    priority: number;
    weight: number;
    conditions: PriorityCondition[];
    adjustments: PriorityAdjustment[];
}
export interface PriorityCondition {
    condition: string;
    operator: string;
    value: any;
    impact: number;
}
export interface PriorityAdjustment {
    trigger: string;
    adjustment: number;
    duration: number;
    reason: string;
}
export interface UsagePattern {
    pattern_name: string;
    tools: string[];
    temporal_pattern: TemporalPattern;
    resource_pattern: ResourcePattern;
    predictability: number;
    optimization_potential: number;
}
export interface TemporalPattern {
    pattern_type: 'periodic' | 'burst' | 'gradual' | 'random' | 'event_driven';
    frequency: string;
    duration: number;
    intensity: number;
    seasonality: SeasonalityInfo[];
}
export interface ResourcePattern {
    primary_resources: ResourceType[];
    resource_correlation: ResourceCorrelation[];
    bottleneck_probability: number;
    optimization_opportunity: number;
}
export interface ResourceCorrelation {
    resource1: ResourceType;
    resource2: ResourceType;
    correlation: number;
    lag: number;
    causality: 'none' | 'unidirectional' | 'bidirectional';
}
export interface SeasonalityInfo {
    period: 'hourly' | 'daily' | 'weekly' | 'monthly' | 'quarterly';
    amplitude: number;
    phase: number;
    confidence: number;
}
export interface CostModel {
    model_name: string;
    scope: 'tool' | 'category' | 'project' | 'organization';
    variables: CostVariable[];
    formula: string;
    accuracy: number;
    update_frequency: string;
}
export interface CostVariable {
    name: string;
    type: 'usage' | 'time' | 'performance' | 'quality' | 'fixed';
    coefficient: number;
    unit: string;
    source: string;
}
export interface PerformanceTarget {
    metric: string;
    target: number;
    tolerance: number;
    unit: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    measurement: string;
}
export interface SLARequirement {
    metric: string;
    target: number;
    penalty: number;
    measurement_window: string;
    escalation: EscalationRule[];
}
export interface EscalationRule {
    threshold: number;
    action: string;
    delay: number;
    stakeholders: string[];
}
export interface QualityThreshold {
    metric: string;
    warning: number;
    critical: number;
    target: number;
    description: string;
}
export interface LatencyTarget {
    operation: string;
    p50_target: number;
    p95_target: number;
    p99_target: number;
    unit: string;
}
export interface BudgetConstraint {
    scope: 'tool' | 'category' | 'project' | 'team' | 'organization';
    period: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'annual';
    limit: number;
    currency: string;
    enforcement: 'hard' | 'soft' | 'advisory';
    alerts: BudgetAlert[];
}
export interface BudgetAlert {
    threshold: number;
    action: 'notify' | 'throttle' | 'suspend' | 'redirect';
    recipients: string[];
    escalation: boolean;
}
export interface CostOptimizationConfig {
    enabled: boolean;
    aggressiveness: 'conservative' | 'moderate' | 'aggressive' | 'maximum';
    strategies: CostOptimizationStrategy[];
    constraints: CostConstraint[];
    reporting: ReportingConfig;
}
export interface CostOptimizationStrategy {
    strategy: 'resource_rightsizing' | 'usage_optimization' | 'vendor_negotiation' | 'alternative_solutions' | 'demand_shaping';
    enabled: boolean;
    priority: number;
    parameters: Record<string, any>;
    expected_savings: number;
}
export interface CostConstraint {
    type: 'minimum_service_level' | 'maximum_disruption' | 'compliance_requirement' | 'performance_threshold';
    value: number;
    enforcement: 'strict' | 'flexible';
    exceptions: string[];
}
export interface ChargebackConfig {
    enabled: boolean;
    model: 'usage_based' | 'allocation_based' | 'project_based' | 'hybrid';
    frequency: 'real_time' | 'daily' | 'weekly' | 'monthly';
    accuracy: 'estimated' | 'actual' | 'hybrid';
    reporting: ChargebackReporting;
}
export interface ChargebackReporting {
    recipients: string[];
    format: 'summary' | 'detailed' | 'both';
    delivery: 'email' | 'dashboard' | 'api' | 'all';
    customization: ReportCustomization[];
}
export interface ReportCustomization {
    field: string;
    aggregation: 'sum' | 'average' | 'max' | 'min' | 'count';
    grouping: string[];
    filtering: string[];
}
export interface CostTrackingConfig {
    granularity: 'transaction' | 'session' | 'daily' | 'weekly';
    attribution: AttributionConfig;
    forecasting: ForecastingConfig;
    anomaly_detection: AnomalyDetectionConfig;
}
export interface AttributionConfig {
    model: 'direct' | 'proportional' | 'activity_based' | 'ml_based';
    accuracy_target: number;
    update_frequency: string;
    validation: ValidationConfig;
}
export interface ForecastingConfig {
    horizon: number;
    method: 'statistical' | 'ml' | 'hybrid';
    confidence_level: number;
    accuracy_threshold: number;
}
export interface AnomalyDetectionConfig {
    sensitivity: 'low' | 'medium' | 'high';
    methods: AnomalyDetectionMethod[];
    thresholds: AnomalyThreshold[];
    actions: AnomalyAction[];
}
export interface AnomalyDetectionMethod {
    method: 'statistical' | 'ml' | 'rule_based' | 'hybrid';
    parameters: Record<string, any>;
    accuracy: number;
    sensitivity: number;
}
export interface AnomalyThreshold {
    metric: string;
    threshold: number;
    duration: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
}
export interface AnomalyAction {
    trigger: string;
    action: 'alert' | 'investigate' | 'auto_correct' | 'escalate';
    parameters: Record<string, any>;
    approval_required: boolean;
}
export interface MetricsCollectionConfig {
    frequency: number;
    metrics: MetricDefinition[];
    storage: StorageConfig;
    retention: RetentionPolicy;
}
export interface MetricDefinition {
    name: string;
    type: 'counter' | 'gauge' | 'histogram' | 'summary';
    unit: string;
    tags: string[];
    aggregation: string[];
}
export interface StorageConfig {
    backend: 'memory' | 'disk' | 'database' | 'cloud';
    compression: boolean;
    encryption: boolean;
    replication: number;
}
export interface RetentionPolicy {
    raw_data: string;
    aggregated_data: string;
    compression_schedule: string;
    archival_policy: string;
}
export interface AlertingConfig {
    enabled: boolean;
    channels: AlertChannel[];
    rules: AlertRule[];
    escalation: EscalationPolicy;
    suppression: SuppressionConfig;
}
export interface AlertChannel {
    type: 'email' | 'slack' | 'webhook' | 'sms' | 'dashboard';
    configuration: Record<string, any>;
    severity_filter: string[];
    enabled: boolean;
}
export interface AlertRule {
    name: string;
    condition: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    frequency: number;
    suppression_time: number;
    actions: AlertAction[];
}
export interface AlertAction {
    action: 'notify' | 'auto_remediate' | 'scale' | 'redirect' | 'throttle';
    parameters: Record<string, any>;
    conditions: string[];
    approval_required: boolean;
}
export interface SuppressionConfig {
    enabled: boolean;
    rules: SuppressionRule[];
    default_duration: number;
    max_duration: number;
}
export interface SuppressionRule {
    condition: string;
    duration: number;
    reason: string;
    auto_lift: boolean;
}
export interface ReportingConfig {
    enabled: boolean;
    frequency: 'hourly' | 'daily' | 'weekly' | 'monthly';
    recipients: string[];
    format: 'pdf' | 'html' | 'json' | 'csv';
    content: ReportContent;
}
export interface ReportContent {
    sections: ReportSection[];
    customization: ReportCustomization[];
    filters: ReportFilter[];
    visualization: VisualizationConfig;
}
export interface ReportSection {
    name: string;
    type: 'summary' | 'details' | 'trends' | 'recommendations' | 'alerts';
    content: string[];
    required: boolean;
}
export interface ReportFilter {
    field: string;
    operator: string;
    value: any;
    logic: 'and' | 'or';
}
export interface VisualizationConfig {
    charts: ChartConfig[];
    themes: string;
    interactive: boolean;
    export_options: string[];
}
export interface ChartConfig {
    type: 'line' | 'bar' | 'pie' | 'scatter' | 'heatmap';
    data_source: string;
    aggregation: string;
    time_range: string;
    filters: string[];
}
export interface ExternalIntegration {
    type: 'cloud_provider' | 'monitoring_system' | 'cost_management' | 'hr_system' | 'project_management';
    name: string;
    configuration: Record<string, any>;
    enabled: boolean;
    priority: number;
    data_mapping: DataMapping[];
}
export interface DataMapping {
    source_field: string;
    target_field: string;
    transformation: string;
    validation: string;
}
export interface SecurityConstraint {
    type: 'access_control' | 'data_protection' | 'audit_trail' | 'encryption' | 'isolation';
    requirement: string;
    enforcement: 'mandatory' | 'recommended' | 'optional';
    impact: string;
    exceptions: SecurityException[];
}
export interface SecurityException {
    condition: string;
    justification: string;
    approver: string;
    expiration: Date;
    monitoring: boolean;
}
export interface ComplianceRequirement {
    framework: string;
    requirement: string;
    control: string;
    implementation: string;
    validation: string;
    frequency: string;
}
export interface AuditConfig {
    enabled: boolean;
    scope: string[];
    retention: string;
    encryption: boolean;
    access_control: AuditAccessControl;
}
export interface AuditAccessControl {
    read_access: string[];
    write_access: string[];
    admin_access: string[];
    external_auditor_access: boolean;
}
export interface ValidationConfig {
    method: string;
    frequency: string;
    accuracy_threshold: number;
    correction_strategy: string;
}
export interface ResourceOptimizationRequest {
    sessionId: string;
    scope: 'project' | 'team' | 'organization';
    projectContext?: ProjectContext;
    optimizationType: 'cost' | 'performance' | 'comprehensive' | 'targeted';
    timeframe: {
        analysisWindow: {
            startDate: Date;
            endDate: Date;
        };
        optimizationHorizon: number;
    };
    objectives: OptimizationObjective[];
    constraints: OptimizationConstraint[];
    configuration: Partial<ResourceOptimizationConfig>;
    customParameters: Record<string, any>;
}
export interface OptimizationObjective {
    type: 'minimize_cost' | 'maximize_performance' | 'improve_efficiency' | 'reduce_waste' | 'enhance_quality';
    weight: number;
    target?: number;
    priority: 'low' | 'medium' | 'high' | 'critical';
    metrics: string[];
    constraints: string[];
}
export interface OptimizationConstraint {
    type: 'budget' | 'performance' | 'availability' | 'security' | 'compliance' | 'capacity';
    value: number;
    operator: 'eq' | 'lt' | 'lte' | 'gt' | 'gte' | 'between';
    enforcement: 'strict' | 'flexible' | 'advisory';
    penalty: number;
    description: string;
}
export interface OptimizationResult {
    sessionId: string;
    executedAt: Date;
    scope: string;
    optimizationType: string;
    currentState: CurrentResourceState;
    utilization: ResourceUtilizationAnalysis;
    costs: CostAnalysis;
    performance: PerformanceAnalysis;
    bottlenecks: BottleneckAnalysis;
    recommendations: ResourceOptimizationRecommendation[];
    scenarios: OptimizationScenario[];
    tradeoffs: TradeoffAnalysis;
    projectedSavings: ProjectedSavings;
    riskAssessment: OptimizationRiskAssessment;
    implementation: ImplementationPlan;
    aiToolOptimizations: AIToolOptimizationResult[];
    allocationChanges: AllocationChange[];
    scalingRecommendations: ScalingRecommendation[];
    confidence: PredictionConfidence;
    methodology: OptimizationMethodology;
    validation: OptimizationValidation;
    processingTime: number;
    dataQuality: OptimizationDataQuality;
    nextOptimizationScheduled?: Date;
}
export interface CurrentResourceState {
    snapshot_time: Date;
    resources: ResourceSnapshot[];
    total_capacity: Record<ResourceType, number>;
    total_allocated: Record<ResourceType, number>;
    total_utilized: Record<ResourceType, number>;
    efficiency_score: number;
    waste_indicators: WasteIndicator[];
}
export interface ResourceSnapshot {
    resourceType: ResourceType;
    total_capacity: number;
    allocated: number;
    utilized: number;
    available: number;
    efficiency: number;
    cost: number;
    trends: TrendData[];
    health_status: 'healthy' | 'degraded' | 'critical' | 'unknown';
}
export interface WasteIndicator {
    type: 'underutilized' | 'overprovisioned' | 'idle' | 'inefficient' | 'redundant';
    resourceType: ResourceType;
    amount: number;
    cost_impact: number;
    frequency: number;
    remediation: string[];
}
export interface ResourceUtilizationAnalysis {
    overall_utilization: number;
    utilization_by_resource: Record<ResourceType, UtilizationMetrics>;
    utilization_patterns: UtilizationPattern[];
    peak_usage: PeakUsageAnalysis;
    capacity_planning: CapacityPlanningInsight[];
}
export interface UtilizationMetrics {
    average: number;
    peak: number;
    valley: number;
    variance: number;
    trend: 'increasing' | 'stable' | 'decreasing';
    efficiency_score: number;
}
export interface UtilizationPattern {
    pattern_type: 'periodic' | 'burst' | 'steady' | 'declining' | 'growth';
    resources: ResourceType[];
    frequency: string;
    predictability: number;
    optimization_potential: number;
    impact: string;
}
export interface PeakUsageAnalysis {
    peak_periods: PeakPeriod[];
    capacity_headroom: number;
    bottleneck_resources: ResourceType[];
    scaling_opportunities: ScalingOpportunity[];
}
export interface PeakPeriod {
    start_time: Date;
    end_time: Date;
    resources: ResourceType[];
    utilization: number;
    causes: string[];
    mitigation: string[];
}
export interface ScalingOpportunity {
    resourceType: ResourceType;
    direction: 'scale_up' | 'scale_down' | 'scale_out' | 'scale_in';
    magnitude: number;
    timing: string;
    cost_impact: number;
    risk: 'low' | 'medium' | 'high';
}
export interface CapacityPlanningInsight {
    resourceType: ResourceType;
    current_capacity: number;
    projected_demand: ProjectedDemand[];
    recommended_capacity: number;
    timeline: string;
    investment_required: number;
    roi: number;
}
export interface ProjectedDemand {
    timeframe: string;
    demand: number;
    confidence: number;
    factors: string[];
    scenarios: DemandScenario[];
}
export interface DemandScenario {
    scenario: 'optimistic' | 'realistic' | 'pessimistic';
    probability: number;
    demand: number;
    implications: string[];
}
export interface CostAnalysis {
    total_cost: number;
    cost_by_resource: Record<ResourceType, number>;
    cost_trends: TrendData[];
    cost_drivers: CostDriver[];
    optimization_opportunities: CostOptimizationOpportunity[];
    budget_variance: BudgetVariance;
}
export interface CostDriver {
    driver: string;
    contribution: number;
    trend: 'increasing' | 'stable' | 'decreasing';
    controllable: boolean;
    optimization_potential: number;
    actions: string[];
}
export interface CostOptimizationOpportunity {
    opportunity: string;
    potential_savings: number;
    effort: 'low' | 'medium' | 'high';
    risk: 'low' | 'medium' | 'high';
    timeframe: string;
    implementation: string[];
    dependencies: string[];
}
export interface BudgetVariance {
    budgeted: number;
    actual: number;
    variance: number;
    variance_percentage: number;
    explanation: string[];
    forecast: BudgetForecast;
}
export interface BudgetForecast {
    projected_spend: number;
    confidence: number;
    risk_factors: string[];
    mitigation: string[];
}
export interface PerformanceAnalysis {
    overall_performance: number;
    performance_by_resource: Record<ResourceType, PerformanceMetrics>;
    performance_trends: TrendData[];
    bottlenecks: PerformanceBottleneck[];
    optimization_opportunities: PerformanceOptimizationOpportunity[];
}
export interface PerformanceBottleneck {
    resourceType: ResourceType;
    severity: 'low' | 'medium' | 'high' | 'critical';
    impact: string;
    causes: string[];
    frequency: number;
    mitigation: string[];
    cost_to_resolve: number;
}
export interface PerformanceOptimizationOpportunity {
    opportunity: string;
    resources: ResourceType[];
    potential_improvement: number;
    effort: 'low' | 'medium' | 'high';
    cost: number;
    timeframe: string;
    dependencies: string[];
}
export interface BottleneckAnalysis {
    bottlenecks: SystemBottleneck[];
    bottleneck_patterns: BottleneckPattern[];
    impact_assessment: BottleneckImpact;
    resolution_strategies: BottleneckResolution[];
}
export interface SystemBottleneck {
    type: 'resource' | 'process' | 'configuration' | 'dependency';
    location: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    frequency: number;
    duration: number;
    impact: BottleneckImpactMetrics;
    causes: string[];
    resolution: string[];
}
export interface BottleneckPattern {
    pattern: string;
    frequency: string;
    conditions: string[];
    predictability: number;
    prevention: string[];
}
export interface BottleneckImpact {
    performance_degradation: number;
    cost_impact: number;
    user_impact: string;
    business_impact: string;
    technical_debt: number;
}
export interface BottleneckImpactMetrics {
    latency_increase: number;
    throughput_decrease: number;
    error_rate_increase: number;
    cost_increase: number;
    user_satisfaction_impact: number;
}
export interface BottleneckResolution {
    strategy: string;
    cost: number;
    effort: 'low' | 'medium' | 'high';
    timeframe: string;
    effectiveness: number;
    risk: 'low' | 'medium' | 'high';
    implementation: string[];
}
export interface ResourceOptimizationRecommendation {
    id: string;
    type: 'reallocation' | 'scaling' | 'replacement' | 'consolidation' | 'elimination';
    priority: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    resources: ResourceType[];
    impact: OptimizationImpact;
    implementation: ImplementationDetails;
    risks: OptimizationRisk[];
    dependencies: string[];
    alternatives: Alternative[];
    validation: RecommendationValidation;
}
export interface OptimizationImpact {
    cost_savings: number;
    performance_improvement: number;
    efficiency_gain: number;
    capacity_change: number;
    quality_impact: string;
    risk_reduction: number;
    timeframe: string;
}
export interface ImplementationDetails {
    steps: ImplementationStep[];
    duration: string;
    effort: 'low' | 'medium' | 'high';
    resources_required: RequiredResource[];
    prerequisites: string[];
    rollback_plan: string[];
    validation_criteria: string[];
}
export interface ImplementationStep {
    step: number;
    description: string;
    duration: string;
    dependencies: string[];
    resources: string[];
    risks: string[];
    validation: string[];
}
export interface RequiredResource {
    type: 'human' | 'technical' | 'financial' | 'infrastructure';
    description: string;
    quantity: number;
    unit: string;
    duration: string;
    cost: number;
    availability: 'available' | 'limited' | 'unavailable';
}
export interface OptimizationRisk {
    risk: string;
    probability: number;
    impact: 'low' | 'medium' | 'high' | 'critical';
    category: 'technical' | 'operational' | 'financial' | 'strategic';
    mitigation: string[];
    contingency: string[];
    monitoring: string[];
}
export interface Alternative {
    alternative: string;
    description: string;
    impact: OptimizationImpact;
    cost: number;
    effort: 'low' | 'medium' | 'high';
    risk: 'low' | 'medium' | 'high';
    pros: string[];
    cons: string[];
}
export interface RecommendationValidation {
    feasibility: 'high' | 'medium' | 'low' | 'unknown';
    accuracy: number;
    confidence: number;
    assumptions: string[];
    limitations: string[];
    validation_method: string;
}
export interface OptimizationScenario {
    scenario: string;
    description: string;
    parameters: Record<string, any>;
    outcomes: ScenarioOutcome;
    probability: number;
    recommendations: string[];
    trade_offs: TradeOff[];
}
export interface ScenarioOutcome {
    cost_impact: number;
    performance_impact: number;
    risk_level: 'low' | 'medium' | 'high' | 'critical';
    implementation_complexity: 'low' | 'medium' | 'high';
    time_to_benefit: string;
    sustainability: number;
}
export interface TradeOff {
    dimension1: string;
    dimension2: string;
    relationship: 'positive' | 'negative' | 'neutral' | 'complex';
    impact: number;
    context: string;
    optimization_strategy: string;
}
export interface TradeoffAnalysis {
    tradeoffs: TradeOff[];
    pareto_frontier: ParetoPoint[];
    optimization_space: OptimizationSpace;
    sensitivity_analysis: SensitivityAnalysis;
}
export interface ParetoPoint {
    point_id: string;
    objectives: Record<string, number>;
    solution: Record<string, any>;
    trade_offs: string[];
    feasibility: number;
}
export interface OptimizationSpace {
    dimensions: OptimizationDimension[];
    feasible_region: FeasibleRegion;
    optimal_points: OptimalPoint[];
    constraints_impact: ConstraintImpact[];
}
export interface OptimizationDimension {
    dimension: string;
    range: {
        min: number;
        max: number;
    };
    granularity: number;
    unit: string;
    importance: number;
}
export interface FeasibleRegion {
    boundaries: Boundary[];
    volume: number;
    constraints: string[];
    characteristics: string[];
}
export interface Boundary {
    constraint: string;
    equation: string;
    impact: string;
    flexibility: number;
}
export interface OptimalPoint {
    point: Record<string, number>;
    objective_value: number;
    constraints_satisfied: string[];
    trade_offs: string[];
    robustness: number;
}
export interface ConstraintImpact {
    constraint: string;
    impact_on_solution_space: number;
    criticality: 'low' | 'medium' | 'high' | 'critical';
    relaxation_potential: number;
    relaxation_cost: number;
}
export interface SensitivityAnalysis {
    parameters: ParameterSensitivity[];
    constraints: ConstraintSensitivity[];
    objectives: ObjectiveSensitivity[];
    interactions: InteractionEffect[];
}
export interface ParameterSensitivity {
    parameter: string;
    sensitivity: number;
    impact_range: {
        min: number;
        max: number;
    };
    critical_thresholds: number[];
    recommendations: string[];
}
export interface ConstraintSensitivity {
    constraint: string;
    shadow_price: number;
    allowable_increase: number;
    allowable_decrease: number;
    binding: boolean;
}
export interface ObjectiveSensitivity {
    objective: string;
    weight_sensitivity: number;
    target_sensitivity: number;
    robustness: number;
    critical_factors: string[];
}
export interface InteractionEffect {
    factors: string[];
    interaction_strength: number;
    synergy: 'positive' | 'negative' | 'neutral';
    impact: string;
    management_strategy: string;
}
export interface ProjectedSavings {
    total_savings: number;
    savings_breakdown: SavingsBreakdown;
    confidence: PredictionConfidence;
    timeframe: string;
    assumptions: string[];
    sensitivity: SavingsSensitivity;
}
export interface SavingsBreakdown {
    cost_reduction: number;
    efficiency_gains: number;
    waste_elimination: number;
    process_improvement: number;
    technology_optimization: number;
}
export interface SavingsSensitivity {
    best_case: number;
    worst_case: number;
    most_likely: number;
    factors: SensitivityFactor[];
}
export interface SensitivityFactor {
    factor: string;
    impact: number;
    probability: number;
    mitigation: string[];
}
export interface OptimizationRiskAssessment {
    overall_risk: 'low' | 'medium' | 'high' | 'critical';
    risk_categories: RiskCategory[];
    mitigation_strategies: MitigationStrategy[];
    contingency_plans: ContingencyPlan[];
    monitoring_plan: RiskMonitoringPlan;
}
export interface RiskCategory {
    category: string;
    risks: Risk[];
    probability: number;
    impact: 'low' | 'medium' | 'high' | 'critical';
    mitigation_cost: number;
    residual_risk: number;
}
export interface RiskMonitoringPlan {
    indicators: RiskIndicator[];
    monitoring_frequency: string;
    escalation_triggers: EscalationTrigger[];
    reporting: RiskReporting;
}
export interface RiskIndicator {
    indicator: string;
    threshold: number;
    measurement: string;
    frequency: string;
    owner: string;
}
export interface EscalationTrigger {
    condition: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    action: string;
    stakeholders: string[];
    timeline: string;
}
export interface RiskReporting {
    frequency: string;
    recipients: string[];
    format: string;
    escalation: boolean;
}
export interface ImplementationPlan {
    phases: ImplementationPhase[];
    timeline: ImplementationTimeline;
    dependencies: ImplementationDependency[];
    resources: ImplementationResource[];
    milestones: ImplementationMilestone[];
    risks: ImplementationRisk[];
}
export interface ImplementationPhase {
    phase: string;
    description: string;
    duration: string;
    activities: ImplementationActivity[];
    deliverables: string[];
    success_criteria: string[];
    risks: string[];
    dependencies: string[];
}
export interface ImplementationActivity {
    activity: string;
    description: string;
    duration: string;
    owner: string;
    resources: string[];
    dependencies: string[];
    deliverables: string[];
}
export interface ImplementationTimeline {
    start_date: Date;
    end_date: Date;
    critical_path: string[];
    buffer_time: number;
    checkpoints: Checkpoint[];
}
export interface Checkpoint {
    name: string;
    date: Date;
    criteria: string[];
    stakeholders: string[];
    decision_points: string[];
}
export interface ImplementationDependency {
    dependency: string;
    type: 'internal' | 'external' | 'technical' | 'resource' | 'approval';
    criticality: 'low' | 'medium' | 'high' | 'critical';
    owner: string;
    timeline: string;
    alternatives: string[];
}
export interface ImplementationResource {
    resource: string;
    type: 'human' | 'financial' | 'technical' | 'infrastructure';
    quantity: number;
    availability: Date[];
    constraints: string[];
    alternatives: string[];
}
export interface ImplementationMilestone {
    milestone: string;
    date: Date;
    description: string;
    deliverables: string[];
    success_criteria: string[];
    stakeholders: string[];
    risks: string[];
}
export interface ImplementationRisk {
    risk: string;
    phase: string;
    probability: number;
    impact: 'low' | 'medium' | 'high' | 'critical';
    mitigation: string[];
    contingency: string[];
    owner: string;
}
export interface AIToolOptimizationResult {
    tool: string;
    current_allocation: AIToolAllocation;
    recommended_allocation: AIToolAllocation;
    optimization_type: 'increase' | 'decrease' | 'rebalance' | 'replace' | 'eliminate';
    justification: string;
    impact: ToolOptimizationImpact;
    implementation: ToolImplementationPlan;
}
export interface ToolOptimizationImpact {
    cost_change: number;
    performance_change: number;
    utilization_change: number;
    quality_impact: string;
    user_impact: string;
    business_impact: string;
}
export interface ToolImplementationPlan {
    steps: string[];
    timeline: string;
    resources: string[];
    risks: string[];
    rollback: string[];
    validation: string[];
}
export interface AllocationChange {
    resourceType: ResourceType;
    current_allocation: number;
    recommended_allocation: number;
    change: number;
    change_percentage: number;
    justification: string;
    impact: AllocationImpact;
    timeline: string;
}
export interface AllocationImpact {
    cost_impact: number;
    performance_impact: number;
    capacity_impact: number;
    risk_impact: string;
    stakeholder_impact: string;
}
export interface ScalingRecommendation {
    resourceType: ResourceType;
    action: 'scale_up' | 'scale_down' | 'scale_out' | 'scale_in' | 'auto_scale';
    magnitude: number;
    timing: 'immediate' | 'scheduled' | 'conditional' | 'gradual';
    triggers: string[];
    constraints: string[];
    impact: ScalingImpact;
    monitoring: string[];
}
export interface ScalingImpact {
    capacity_change: number;
    cost_change: number;
    performance_change: number;
    availability_change: number;
    complexity_change: string;
}
export interface OptimizationValidation {
    validation_methods: ValidationMethod[];
    accuracy_metrics: ValidationAccuracy;
    confidence_intervals: ConfidenceInterval[];
    sensitivity_tests: SensitivityTest[];
    scenario_testing: ScenarioTest[];
}
export interface ValidationMethod {
    method: 'simulation' | 'historical_validation' | 'expert_review' | 'pilot_testing' | 'statistical_analysis';
    description: string;
    accuracy: number;
    confidence: number;
    limitations: string[];
}
export interface ValidationAccuracy {
    overall_accuracy: number;
    accuracy_by_metric: Record<string, number>;
    error_analysis: ErrorAnalysis;
    improvement_recommendations: string[];
}
export interface ErrorAnalysis {
    mean_absolute_error: number;
    root_mean_square_error: number;
    bias: number;
    variance: number;
    systematic_errors: string[];
    random_errors: string[];
}
export interface ConfidenceInterval {
    metric: string;
    lower_bound: number;
    upper_bound: number;
    confidence_level: number;
    interpretation: string;
}
export interface SensitivityTest {
    parameter: string;
    test_range: {
        min: number;
        max: number;
    };
    impact_on_recommendations: number;
    critical_thresholds: number[];
    robustness: 'high' | 'medium' | 'low';
}
export interface ScenarioTest {
    scenario: string;
    parameters: Record<string, any>;
    outcome_variance: number;
    recommendation_stability: number;
    risk_factors: string[];
}
export interface OptimizationDataQuality {
    completeness: number;
    accuracy: number;
    timeliness: number;
    consistency: number;
    reliability: number;
    data_sources: DataSource[];
    quality_issues: DataQualityIssue[];
    recommendations: string[];
}
export interface DataSource {
    source: string;
    type: 'internal' | 'external' | 'synthetic' | 'historical';
    quality_score: number;
    coverage: number;
    freshness: number;
    reliability: number;
}
export interface DataQualityIssue {
    issue: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    impact: string;
    affected_metrics: string[];
    resolution: string;
    prevention: string[];
}
export declare class ResourceOptimizationService {
    private config;
    private organizationalMemory?;
    private optimizationCache;
    private monitoringMetrics;
    private activeOptimizations;
    constructor(config: ResourceOptimizationConfig);
    private initializeService;
    optimizeResources(request: ResourceOptimizationRequest): Promise<OptimizationResult>;
    monitorResourceUtilization(scope: 'project' | 'team' | 'organization', projectContext?: ProjectContext): Promise<ResourceUtilizationSnapshot>;
    optimizeAIToolAllocations(request: ResourceOptimizationRequest, currentState: CurrentResourceAnalysis): Promise<AIToolOptimizationResult[]>;
    generateCostOptimizations(request: ResourceOptimizationRequest): Promise<CostOptimizationOpportunity[]>;
    private initializeOptimizationEngines;
    private initializeMonitoring;
    private loadOrganizationalMemory;
    private initializeExternalIntegrations;
    private validateOptimizationRequest;
    private getCachedOptimization;
    private analyzeCurrentResourceState;
    private performOptimizationAnalysis;
    private generateOptimizationRecommendations;
    private evaluateOptimizationScenarios;
    private assessOptimizationRisks;
    private createImplementationPlan;
    private analyzeTradeoffs;
    private calculateProjectedSavings;
    private calculateAllocationChanges;
    private generateScalingRecommendations;
    private calculateOptimizationConfidence;
    private getOptimizationMethodology;
    private validateOptimizationResults;
    private assessDataQuality;
    private scheduleNextOptimization;
    private cacheOptimizationResult;
    private updateOrganizationalMemory;
    private collectResourceMetrics;
    private checkUtilizationAlerts;
    private analyzeTrends;
    private calculateOverallUtilization;
    private calculateEfficiencyScore;
    private generateQuickRecommendations;
    private storeMetricsHistory;
    private getCurrentToolAllocation;
    private calculateOptimalAllocation;
    private shouldOptimizeTool;
    private determineOptimizationType;
    private generateOptimizationJustification;
    private calculateToolOptimizationImpact;
    private createToolImplementationPlan;
    private analyzeCosts;
    private identifyWaste;
    private generateWasteReductionOpportunities;
    private analyzeUsagePatterns;
    private generateUsageOptimizationOpportunities;
    private evaluateAlternatives;
    private generateAlternativeOpportunities;
    private identifyVolumeOpportunities;
    private prioritizeCostOpportunities;
    private loadMemoryFromStorage;
    private initializeIntegration;
}
interface ResourceUtilizationSnapshot {
    timestamp: Date;
    scope: string;
    resources: ResourceSnapshot[];
    overall_utilization: number;
    efficiency_score: number;
    alerts: UtilizationAlert[];
    trends: UtilizationTrend[];
    recommendations: QuickRecommendation[];
}
interface UtilizationAlert {
    type: 'high_utilization' | 'low_utilization' | 'waste' | 'bottleneck';
    resource: ResourceType;
    severity: 'low' | 'medium' | 'high' | 'critical';
    message: string;
    threshold: number;
    current_value: number;
    recommendations: string[];
}
interface UtilizationTrend {
    resource: ResourceType;
    direction: 'increasing' | 'stable' | 'decreasing';
    rate: number;
    confidence: number;
    prediction: TrendPrediction;
}
interface TrendPrediction {
    horizon: number;
    predicted_value: number;
    confidence: number;
    factors: string[];
}
interface QuickRecommendation {
    type: 'scaling' | 'reallocation' | 'optimization' | 'investigation';
    resource: ResourceType;
    action: string;
    priority: 'low' | 'medium' | 'high' | 'urgent';
    impact: string;
    effort: 'low' | 'medium' | 'high';
}
interface CurrentResourceAnalysis {
    summary: CurrentResourceState;
    utilization: ResourceUtilizationAnalysis;
    costs: CostAnalysis;
    performance: PerformanceAnalysis;
    bottlenecks: BottleneckAnalysis;
}
export default ResourceOptimizationService;
//# sourceMappingURL=resource-optimization.d.ts.map