/**
 * Advanced Requirements Analysis Processor
 * Specialized AI processor for sophisticated requirements analysis and modeling
 *
 * @class AdvancedRequirementsAnalysisProcessor
 * @description Handles advanced requirements analysis including process modeling,
 * use case generation, business rules extraction, and impact analysis.
 *
 * @version 1.0.0
 * @author Requirements Gathering Agent Team
 * @created 2025-01-27
 *
 * @filepath src/modules/ai/processors/AdvancedRequirementsAnalysisProcessor.ts
 */
import { BaseAIProcessor } from './BaseAIProcessor.js';
export interface ProcessModel {
    modelType: 'BPMN' | 'Flowchart' | 'ValueStream' | 'Swimlane';
    processes: ProcessDefinition[];
    actors: Actor[];
    dataFlows: DataFlow[];
    businessRules: string[];
    metrics: ProcessMetric[];
}
export interface ProcessDefinition {
    id: string;
    name: string;
    description: string;
    steps: ProcessStep[];
    inputs: string[];
    outputs: string[];
    owner: string;
    triggers: string[];
}
export interface ProcessStep {
    id: string;
    name: string;
    type: 'task' | 'decision' | 'gateway' | 'event';
    description: string;
    actor: string;
    duration: string;
    businessRules: string[];
    exceptions: string[];
}
export interface Actor {
    id: string;
    name: string;
    role: string;
    responsibilities: string[];
    skills: string[];
}
export interface DataFlow {
    from: string;
    to: string;
    data: string;
    format: string;
    frequency: string;
}
export interface ProcessMetric {
    name: string;
    description: string;
    target: string;
    measurement: string;
}
export interface UseCaseModel {
    system: string;
    actors: UseCaseActor[];
    useCases: UseCase[];
    relationships: UseCaseRelationship[];
}
export interface UseCaseActor {
    id: string;
    name: string;
    type: 'primary' | 'secondary' | 'system';
    description: string;
    goals: string[];
}
export interface UseCase {
    id: string;
    name: string;
    description: string;
    actor: string;
    preconditions: string[];
    postconditions: string[];
    mainFlow: string[];
    alternativeFlows: AlternativeFlow[];
    exceptionFlows: ExceptionFlow[];
    businessRules: string[];
    nonFunctionalRequirements: string[];
}
export interface AlternativeFlow {
    id: string;
    name: string;
    condition: string;
    steps: string[];
}
export interface ExceptionFlow {
    id: string;
    name: string;
    exception: string;
    handling: string[];
}
export interface UseCaseRelationship {
    type: 'include' | 'extend' | 'generalization';
    from: string;
    to: string;
    condition?: string;
}
export interface BusinessRulesCatalog {
    categories: BusinessRuleCategory[];
    rules: BusinessRule[];
    conflicts: RuleConflict[];
    dependencies: RuleDependency[];
}
export interface BusinessRuleCategory {
    id: string;
    name: string;
    description: string;
    priority: 'high' | 'medium' | 'low';
}
export interface BusinessRule {
    id: string;
    name: string;
    category: string;
    description: string;
    statement: string;
    rationale: string;
    source: string;
    type: 'constraint' | 'derivation' | 'existence' | 'action';
    priority: 'mandatory' | 'important' | 'optional';
    testCriteria: string[];
}
export interface RuleConflict {
    rule1: string;
    rule2: string;
    conflictType: string;
    resolution: string;
}
export interface RuleDependency {
    dependentRule: string;
    prerequisiteRule: string;
    dependencyType: string;
}
export interface ImpactAnalysis {
    requirement: string;
    impactedAreas: ImpactArea[];
    riskAssessment: RiskAssessment;
    effortEstimate: EffortEstimate;
    recommendations: string[];
}
export interface ImpactArea {
    area: string;
    impactType: 'high' | 'medium' | 'low';
    description: string;
    affectedComponents: string[];
    mitigationActions: string[];
}
export interface RiskAssessment {
    risks: Risk[];
    overallRiskLevel: 'high' | 'medium' | 'low';
    mitigationStrategy: string;
}
export interface Risk {
    description: string;
    probability: 'high' | 'medium' | 'low';
    impact: 'high' | 'medium' | 'low';
    mitigation: string;
}
export interface EffortEstimate {
    analysisEffort: string;
    developmentEffort: string;
    testingEffort: string;
    totalEffort: string;
    assumptions: string[];
}
export declare class AdvancedRequirementsAnalysisProcessor extends BaseAIProcessor {
    private aiProcessor;
    /**
     * Generates process models from requirements
     */
    generateProcessModel(requirements: string[], modelType: 'BPMN' | 'Flowchart' | 'ValueStream' | 'Swimlane', projectContext: string): Promise<string | null>;
    /**
     * Creates comprehensive use case models
     */
    createUseCaseModel(functionalRequirements: string[], projectContext: string): Promise<string | null>;
    /**
     * Extracts and catalogs business rules from requirements
     */
    extractBusinessRules(requirements: string[], projectContext: string): Promise<string | null>;
    /**
     * Performs comprehensive impact analysis for requirement changes
     */
    analyzeRequirementImpact(requirement: string, existingRequirements: string[], projectContext: string): Promise<string | null>;
    /**
     * Generates gap analysis between current and future state
     */
    generateGapAnalysis(currentState: string, futureState: string, projectContext: string): Promise<string | null>;
    /**
     * Helper method to provide model-type specific guidance
     */
    private getModelTypeSpecificGuidance;
}
//# sourceMappingURL=AdvancedRequirementsAnalysisProcessor.d.ts.map