/**
 * Dependency Resolver Types
 */
import { QueuedTask } from '../queue/types';
/**
 * Resolution status for a task
 */
export declare enum ResolutionStatus {
    PENDING = "pending",// Not yet processed
    READY = "ready",// All dependencies resolved
    BLOCKED = "blocked",// Waiting for dependencies
    IN_PROGRESS = "in_progress",// Currently executing
    COMPLETED = "completed",// Successfully completed
    FAILED = "failed",// Failed execution
    SKIPPED = "skipped"
}
/**
 * Resolved task with execution metadata
 */
export interface ResolvedTask {
    task: QueuedTask;
    status: ResolutionStatus;
    dependencies: Set<string>;
    dependents: Set<string>;
    executionLevel: number;
    criticalPath: boolean;
    estimatedStartTime?: Date;
    actualStartTime?: Date;
    completionTime?: Date;
    failureReason?: string;
    attempts: number;
    maxAttempts: number;
}
/**
 * Resolution context for a set of tasks
 */
export interface ResolutionContext {
    id: string;
    projectId: string;
    tasks: Map<string, ResolvedTask>;
    executionLevels: Map<number, Set<string>>;
    readyTasks: Set<string>;
    blockedTasks: Set<string>;
    inProgressTasks: Set<string>;
    completedTasks: Set<string>;
    failedTasks: Set<string>;
    skippedTasks: Set<string>;
    totalTasks: number;
    resolvedAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    statistics: ResolutionStatistics;
}
/**
 * Resolution statistics
 */
export interface ResolutionStatistics {
    totalDependencies: number;
    maxDependencyDepth: number;
    averageDependencies: number;
    criticalPathLength: number;
    estimatedTotalTime: number;
    actualTotalTime?: number;
    parallelismFactor: number;
    successRate?: number;
}
/**
 * Dependency resolution strategy
 */
export declare enum ResolutionStrategy {
    EAGER = "eager",// Start tasks as soon as dependencies are met
    LAZY = "lazy",// Wait for optimal resource allocation
    BATCHED = "batched",// Process tasks in batches
    PRIORITY = "priority",// Prioritize critical path tasks
    BALANCED = "balanced"
}
/**
 * Resolution event
 */
export interface ResolutionEvent {
    type: ResolutionEventType;
    taskId: string;
    timestamp: Date;
    details?: any;
}
/**
 * Resolution event types
 */
export declare enum ResolutionEventType {
    TASK_READY = "task_ready",
    TASK_STARTED = "task_started",
    TASK_COMPLETED = "task_completed",
    TASK_FAILED = "task_failed",
    TASK_SKIPPED = "task_skipped",
    DEPENDENCY_RESOLVED = "dependency_resolved",
    CIRCULAR_DEPENDENCY = "circular_dependency",
    RESOLUTION_COMPLETE = "resolution_complete"
}
/**
 * Resolver configuration
 */
export interface ResolverConfig {
    strategy: ResolutionStrategy;
    maxRetries: number;
    retryDelay: number;
    skipOnDependencyFailure: boolean;
    allowPartialExecution: boolean;
    optimizeCriticalPath: boolean;
    maxParallelTasks: number;
    timeoutPerTask: number;
    checkInterval: number;
}
/**
 * Execution plan
 */
export interface ExecutionPlan {
    contextId: string;
    levels: ExecutionLevel[];
    criticalPath: string[];
    estimatedDuration: number;
    maxParallelism: number;
    dependencies: Map<string, Set<string>>;
    strategy: ResolutionStrategy;
}
/**
 * Execution level
 */
export interface ExecutionLevel {
    level: number;
    tasks: string[];
    canRunInParallel: boolean;
    estimatedDuration: number;
    dependencies: string[];
}
/**
 * Task execution result
 */
export interface TaskExecutionResult {
    taskId: string;
    success: boolean;
    duration: number;
    output?: any;
    error?: Error;
    retryable: boolean;
}
/**
 * Resolution progress
 */
export interface ResolutionProgress {
    contextId: string;
    totalTasks: number;
    completedTasks: number;
    failedTasks: number;
    skippedTasks: number;
    inProgressTasks: number;
    readyTasks: number;
    blockedTasks: number;
    percentComplete: number;
    estimatedTimeRemaining?: number;
    currentLevel: number;
    totalLevels: number;
}
//# sourceMappingURL=types.d.ts.map