/**
 * Master Plan Parser Types
 */
import { TaskPriority } from '../queue/types';
/**
 * Master plan input
 */
export interface MasterPlan {
    id: string;
    title: string;
    description: string;
    objectives: string[];
    constraints?: PlanConstraints;
    metadata?: Record<string, any>;
}
/**
 * Plan constraints
 */
export interface PlanConstraints {
    maxTerminals?: number;
    timeLimit?: number;
    tokenBudget?: number;
    priority?: TaskPriority;
    requiredCapabilities?: string[];
    preferredCapabilities?: string[];
}
/**
 * Parsed task from master plan
 */
export interface ParsedTask {
    id: string;
    name: string;
    description: string;
    type: TaskType;
    estimatedTokens: number;
    estimatedTime: number;
    requiredCapabilities: string[];
    dependencies: string[];
    priority: number;
    parallelizable: boolean;
    metadata?: {
        sourceSection?: string;
        confidence?: number;
        keywords?: string[];
        specialization?: string;
    };
}
/**
 * Task type classification
 */
export declare enum TaskType {
    ANALYSIS = "analysis",
    DESIGN = "design",
    IMPLEMENTATION = "implementation",
    TESTING = "testing",
    DOCUMENTATION = "documentation",
    REVIEW = "review",
    DEPLOYMENT = "deployment",
    RESEARCH = "research",
    REFACTORING = "refactoring",
    OPTIMIZATION = "optimization",
    INTEGRATION = "integration",
    MIGRATION = "migration"
}
/**
 * Dependency graph node
 */
export interface DependencyNode {
    taskId: string;
    task: ParsedTask;
    dependencies: Set<string>;
    dependents: Set<string>;
    level: number;
    criticalPath: boolean;
}
/**
 * Dependency graph
 */
export interface DependencyGraph {
    nodes: Map<string, DependencyNode>;
    roots: Set<string>;
    leaves: Set<string>;
    levels: Map<number, Set<string>>;
    criticalPath: string[];
}
/**
 * Parsing result
 */
export interface ParsingResult {
    plan: MasterPlan;
    tasks: ParsedTask[];
    graph: DependencyGraph;
    statistics: ParsingStatistics;
    warnings: ParsingWarning[];
    errors?: ParsingError[];
}
/**
 * Parsing statistics
 */
export interface ParsingStatistics {
    totalTasks: number;
    totalDependencies: number;
    estimatedTotalTokens: number;
    estimatedTotalTime: number;
    parallelizableTasks: number;
    criticalPathLength: number;
    maxParallelism: number;
    tasksByType: Record<TaskType, number>;
    capabilitiesRequired: string[];
}
/**
 * Parsing warning
 */
export interface ParsingWarning {
    type: WarningType;
    message: string;
    taskId?: string;
    suggestion?: string;
}
/**
 * Warning types
 */
export declare enum WarningType {
    AMBIGUOUS_DEPENDENCY = "ambiguous_dependency",
    HIGH_TOKEN_USAGE = "high_token_usage",
    MISSING_CAPABILITY = "missing_capability",
    CIRCULAR_DEPENDENCY = "circular_dependency",
    UNBALANCED_WORKLOAD = "unbalanced_workload",
    UNCLEAR_REQUIREMENT = "unclear_requirement"
}
/**
 * Parsing error
 */
export interface ParsingError {
    type: ErrorType;
    message: string;
    details?: any;
}
/**
 * Error types
 */
export declare enum ErrorType {
    INVALID_PLAN = "invalid_plan",
    PARSING_FAILED = "parsing_failed",
    DEPENDENCY_CYCLE = "dependency_cycle",
    RESOURCE_EXCEEDED = "resource_exceeded",
    INVALID_CONSTRAINT = "invalid_constraint"
}
/**
 * Task template for common patterns
 */
export interface TaskTemplate {
    name: string;
    pattern: RegExp;
    type: TaskType;
    baseTokens: number;
    baseTime: number;
    requiredCapabilities: string[];
    keywords: string[];
}
/**
 * Parsing configuration
 */
export interface ParserConfig {
    maxTasksPerPlan: number;
    maxDependencyDepth: number;
    defaultTokenEstimate: number;
    defaultTimeEstimate: number;
    enableNLPAnalysis: boolean;
    enableTemplateMatching: boolean;
    confidenceThreshold: number;
    taskTemplates: TaskTemplate[];
}
//# sourceMappingURL=types.d.ts.map