import { WorkflowSession, WorkflowType } from '../types/workflow';
import { EventEmitter } from 'events';
/**
 * Workflow optimization interfaces
 */
export interface WorkflowOptimizationStrategy {
    name: string;
    description: string;
    priority: number;
    applicableWorkflowTypes: WorkflowType[];
    estimatedSpeedup: number;
    resourceRequirements: ResourceRequirements;
    execute: (workflow: WorkflowSession, context: OptimizationContext) => Promise<OptimizationResult>;
}
export interface ResourceRequirements {
    minCPU: number;
    minMemory: number;
    minDisk: number;
    networkBandwidth?: number;
}
export interface OptimizationContext {
    systemLoad: number;
    availableResources: ResourceAvailability;
    workflowHistory: WorkflowPerformanceHistory[];
    userPriority: WorkflowPriority;
}
export interface ResourceAvailability {
    cpu: number;
    memory: number;
    disk: number;
    networkBandwidth: number;
}
export interface WorkflowPerformanceHistory {
    workflowId: string;
    type: WorkflowType;
    duration: number;
    resourceUsage: ResourceUsageSnapshot;
    success: boolean;
    optimizationsApplied: string[];
}
export interface ResourceUsageSnapshot {
    peakCPU: number;
    peakMemory: number;
    diskIO: number;
    networkUsage: number;
}
export declare enum WorkflowPriority {
    LOW = 1,
    NORMAL = 2,
    HIGH = 3,
    CRITICAL = 4
}
export interface OptimizationResult {
    success: boolean;
    strategy: string;
    estimatedImprovement: number;
    actualImprovement?: number;
    resourceSavings?: ResourceSavings;
    metadata?: Record<string, any>;
}
export interface ResourceSavings {
    cpuReduction: number;
    memoryReduction: number;
    timeReduction: number;
}
export interface WorkflowSchedule {
    workflowId: string;
    priority: WorkflowPriority;
    estimatedDuration: number;
    resourceRequirements: ResourceRequirements;
    scheduledTime: Date;
    dependencies: string[];
    maxDelay: number;
}
export interface BackgroundJob {
    id: string;
    type: BackgroundJobType;
    priority: WorkflowPriority;
    payload: any;
    scheduledFor: Date;
    maxRetries: number;
    retryCount: number;
    status: JobStatus;
    createdAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    error?: string;
}
export declare enum BackgroundJobType {
    DOCUMENT_GENERATION = "document_generation",
    CACHE_WARMING = "cache_warming",
    WORKFLOW_OPTIMIZATION = "workflow_optimization",
    PERFORMANCE_ANALYSIS = "performance_analysis",
    RESOURCE_CLEANUP = "resource_cleanup"
}
export declare enum JobStatus {
    PENDING = "pending",
    RUNNING = "running",
    COMPLETED = "completed",
    FAILED = "failed",
    CANCELLED = "cancelled"
}
/**
 * Advanced workflow optimizer with intelligent scheduling
 */
export declare class WorkflowOptimizer extends EventEmitter {
    private logger;
    private optimizationStrategies;
    private workflowHistory;
    private backgroundJobs;
    private scheduledWorkflows;
    private isRunning;
    private optimizationInterval?;
    private jobProcessingInterval?;
    private performanceBaseline;
    constructor();
    /**
     * Start the workflow optimizer
     */
    start(): Promise<void>;
    /**
     * Stop the workflow optimizer
     */
    stop(): Promise<void>;
    /**
     * Optimize a workflow before execution
     */
    optimizeWorkflow(workflow: WorkflowSession, options?: {
        priority?: WorkflowPriority;
        maxOptimizationTime?: number;
    }): Promise<{
        optimizedWorkflow: WorkflowSession;
        appliedOptimizations: OptimizationResult[];
        estimatedSpeedup: number;
    }>;
    /**
     * Schedule a workflow for optimal execution timing
     */
    scheduleWorkflow(workflowId: string, options?: {
        priority?: WorkflowPriority;
        maxDelay?: number;
        resourceRequirements?: Partial<ResourceRequirements>;
    }): Promise<{
        scheduledTime: Date;
        estimatedDuration: number;
        reasoning: string;
    }>;
    /**
     * Queue a background job
     */
    queueBackgroundJob(type: BackgroundJobType, payload: any, options?: {
        priority?: WorkflowPriority;
        scheduledFor?: Date;
        maxRetries?: number;
    }): Promise<string>;
    /**
     * Get workflow performance analytics
     */
    getPerformanceAnalytics(): {
        averageOptimizationImprovements: Record<string, number>;
        resourceUtilizationTrends: ResourceUtilizationTrends;
        bottleneckAnalysis: BottleneckAnalysis;
        recommendations: OptimizationRecommendation[];
    };
    private initializeOptimizationStrategies;
    private buildOptimizationContext;
    private selectOptimizationStrategies;
    private meetsResourceRequirements;
    private optimizeExpertQueue;
    private estimateWorkflowDuration;
    private findOptimalSchedulingSlot;
    private generateSchedulingReasoning;
    private performOptimizationAnalysis;
    private processBackgroundJobs;
    private executeBackgroundJob;
    private executeJobByType;
    private updatePerformanceBaseline;
    private cleanupHistory;
    private analyzeResourceTrends;
    private identifyBottlenecks;
    private generateOptimizationRecommendations;
    private waitForRunningJobs;
    private hashProjectDescription;
    private generateJobId;
}
interface ResourceUtilizationTrends {
    cpuTrend: 'increasing' | 'decreasing' | 'stable';
    memoryTrend: 'increasing' | 'decreasing' | 'stable';
    networkTrend: 'increasing' | 'decreasing' | 'stable';
}
interface BottleneckAnalysis {
    primaryBottleneck: 'cpu' | 'memory' | 'disk' | 'network' | 'none';
    bottleneckSeverity: 'low' | 'medium' | 'high' | 'critical';
    affectedWorkflows: number;
    recommendations: string[];
}
interface OptimizationRecommendation {
    type: 'resource' | 'configuration' | 'architecture';
    priority: 'low' | 'medium' | 'high';
    title: string;
    description: string;
    estimatedImprovement: number;
    implementationEffort: 'low' | 'medium' | 'high';
}
export declare const workflowOptimizer: WorkflowOptimizer;
export {};
//# sourceMappingURL=workflowOptimizer.d.ts.map