export interface AgentConfig {
    apiKeys: {
        openai?: string;
        anthropic?: string;
    };
    defaults: {
        model: string;
        temperature: number;
        maxTokens: number;
    };
    directories: {
        config: string;
        cache: string;
        logs: string;
    };
    features: {
        autoSave: boolean;
        contextAware: boolean;
        interactiveMode: boolean;
    };
}
export interface ProjectContext {
    rootPath: string;
    projectType: string;
    language: string;
    framework?: string;
    packageManager?: 'npm' | 'yarn' | 'pnpm';
    dependencies: string[];
    devDependencies?: string[];
    structure?: ProjectStructure;
    testDirectory?: string;
    sourceDirectory?: string;
    fileStructure?: {
        directories: string[];
        files: string[];
        fileTypes: Record<string, number>;
    };
    patterns?: CodePattern[];
    currentFile?: string;
}
export interface CodebaseSnapshot {
    content: string;
    timestamp: Date;
    metadata?: Record<string, any>;
}
export interface ProjectStructure {
    files: string[];
    directories: string[];
    entryPoints: string[];
    configFiles: string[];
    testFiles: string[];
}
export interface AnalysisResult {
    summary: string;
    insights: string[];
    suggestions: string[];
    metrics: {
        complexity: number;
        maintainability: number;
        testCoverage?: number;
    };
    patterns: CodePattern[];
}
export interface CodeMetrics {
    complexity: number;
    maintainability: number;
    testCoverage?: number;
    linesOfCode: number;
    logicalLinesOfCode: number;
    cyclomaticComplexity: number;
    cognitiveComplexity: number;
    halsteadVolume: number;
    maintainabilityIndex: number;
    technicalDebt: number;
    duplication: number;
}
export interface CodePattern {
    type: string;
    name?: string;
    location?: string;
    description: string;
    confidence?: number;
    example?: string;
    language?: string;
    filePath?: string;
    metadata?: Record<string, any>;
}
export interface GenerationRequest {
    type: 'function' | 'class' | 'component' | 'test' | 'file' | 'project';
    description: string;
    context?: ProjectContext;
    options: {
        language: string;
        framework?: string;
        style?: 'functional' | 'oop' | 'mixed';
        includeTests: boolean;
        includeComments: boolean;
    };
}
export interface GenerationResult {
    code: string;
    filename: string;
    dependencies?: string[];
    tests?: string;
    documentation?: string;
    integrationNotes?: string;
    refactoringOpportunities?: string[];
    qualityMetrics?: {
        complexity: string;
        maintainability: string;
        testability: string;
        security: string;
    };
}
export interface CommandContext {
    workingDirectory: string;
    config: AgentConfig;
    projectContext?: ProjectContext;
    sessionId: string;
    verbose: boolean;
}
export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
export interface LogEntry {
    level: LogLevel;
    message: string;
    timestamp: Date;
    context?: Record<string, unknown>;
}
export { Message, ToolCall } from './agent';
export * from './analysis';
export interface CompileError {
    line: number;
    column: number;
    message: string;
    severity: 'error' | 'warning' | 'info';
}
export interface TestResult {
    name: string;
    passed: boolean;
    status: 'passed' | 'failed' | 'skipped';
    duration: number;
    error?: string | undefined;
    output?: string;
    assertions?: number;
}
export interface TDDSessionContext {
    sessionId: string;
    projectContext: ProjectContext;
    currentPhase: 'red' | 'green' | 'refactor';
    testHistory: TestResult[];
    codeHistory: string[];
    aiInsights: any[];
    preferences: {
        testFramework: string;
        codingStyle: string;
        aiAssistanceLevel: 'low' | 'medium' | 'high';
    };
    metrics: {
        cycleCount: number;
        totalTime: number;
        testCoverage: number;
    };
    createdAt: Date;
    lastActivity: Date;
}
export interface PerformanceMetrics {
    executionTime: number;
    memoryUsage: number;
    cpuUsage: number;
    compilationTime: number;
    errorCount?: number;
    successRate?: number;
}
export interface ExecutionResult {
    success: boolean;
    output: string;
    errors: CompileError[];
    testResults: TestResult[];
    performance: PerformanceMetrics;
}
export interface TestSuite {
    id?: string;
    name: string;
    targetId?: string;
    targetType?: string;
    tests: TestResult[];
    unitTests?: TestCase[];
    integrationTests?: IntegrationTest[];
    performanceTests?: PerformanceTest[];
    securityTests?: SecurityTest[];
    propertyBasedTests?: PropertyBasedTest[];
    fuzzingTests?: any[];
    framework?: TestFramework | string;
    configuration?: Record<string, any>;
    coverage?: TestCoverage;
    metadata?: {
        generatedAt: Date;
        totalTests: number;
        estimatedDuration: number;
        complexity: string;
        framework?: string;
        generationTime?: number;
        estimatedRunTime?: number;
        riskLevel?: string;
    };
    generatedCode: string;
}
export interface SecurityValidationResult {
    isSecure: boolean;
    violations: Array<{
        type: 'injection' | 'path_traversal' | 'unsafe_eval' | 'file_access';
        severity: 'high' | 'medium' | 'low';
        location: {
            line: number;
            column: number;
        };
        message: string;
    }>;
}
export interface CodeHealingResult {
    healedCode: string;
    changes: Array<{
        type: 'variable_declaration' | 'type_annotation' | 'import_addition' | 'syntax_fix';
        location: {
            line: number;
            column: number;
        };
        description: string;
    }>;
    confidence: number;
}
export * from './ai-tool-integration';
export interface TypeScriptWorkflowConfig {
    cacheEnabled: boolean;
    cacheTTL: number;
    maxCacheSize: number;
    preferredCompilerVersion: string;
    enablePerformanceOptimizations: boolean;
    includeAdvancedExamples: boolean;
    enableErrorRecovery: boolean;
}
export interface TypeScriptDocumentationQuery {
    type: 'api_reference' | 'ast_manipulation' | 'compiler_options' | 'best_practices' | 'error_resolution';
    context: string;
    specificAPI?: string;
    astNodeType?: number;
    errorCode?: string;
    compilerVersion?: string;
    cacheKey?: string;
}
export interface TypeScriptWorkflowResult {
    success: boolean;
    documentation: string;
    codeExamples: CodeExample[];
    relatedAPIs: string[];
    bestPractices: string[];
    performanceNotes: string[];
    troubleshootingGuide?: TroubleshootingGuide;
    cacheMetadata: CacheMetadata;
}
export interface CodeExample {
    title: string;
    description: string;
    code: string;
    language: 'typescript' | 'javascript';
    complexity: 'basic' | 'intermediate' | 'advanced';
    compilerVersion: string;
    tags: string[];
}
export interface TroubleshootingGuide {
    commonIssues: Issue[];
    debuggingSteps: string[];
    relatedErrors: string[];
    quickFixes: QuickFix[];
}
export interface Issue {
    problem: string;
    cause: string;
    solution: string;
    codeExample?: string;
}
export interface QuickFix {
    description: string;
    code: string;
    automated: boolean;
}
export interface CacheMetadata {
    key: string;
    timestamp: Date;
    ttl: number;
    hitCount: number;
    source: 'context7' | 'local_cache' | 'fallback';
}
export type ProjectDomain = 'web_frontend' | 'web_backend' | 'fullstack_web' | 'mobile_native' | 'mobile_cross_platform' | 'data_science' | 'machine_learning' | 'desktop_application' | 'embedded_systems' | 'devops_infrastructure' | 'game_development' | 'blockchain' | 'api_microservices' | 'cli_tools' | 'library_framework' | 'unknown';
export interface ProjectCharacteristics {
    domain: ProjectDomain;
    confidence: number;
    frameworks: string[];
    languages: string[];
    dependencies: string[];
    architecturalPatterns: string[];
    complexity: 'simple' | 'moderate' | 'complex' | 'enterprise';
    teamSize: 'solo' | 'small' | 'medium' | 'large';
    developmentStage: 'prototype' | 'development' | 'production' | 'maintenance';
    performanceRequirements: 'low' | 'medium' | 'high' | 'critical';
    securityRequirements: 'low' | 'medium' | 'high' | 'critical';
    scalabilityRequirements: 'low' | 'medium' | 'high' | 'critical';
}
export interface MemoryManager {
    store(key: string, value: any, ttl?: number): Promise<void>;
    retrieve(key: string): Promise<any>;
    delete(key: string): Promise<boolean>;
    exists(key: string): Promise<boolean>;
    clear(): Promise<void>;
    conversations(): MemoryCollection<any>;
    sessions(): MemoryCollection<any>;
    projects(): MemoryCollection<any>;
    users(): MemoryCollection<any>;
    knowledge(): MemoryCollection<any>;
    adaptations(): MemoryCollection<any>;
    feedbacks(): MemoryCollection<any>;
    suggestions(): MemoryCollection<any>;
    storeConversation(sessionId: string, messages: any[]): Promise<void>;
    getConversationHistory(sessionId: string, limit?: number): Promise<any[]>;
    storeSession(session: any): Promise<void>;
    getActiveSession(sessionId: string): Promise<any | null>;
    storeProjectMemory(projectPath: string, memory: any): Promise<void>;
    getProjectMemory(projectPath: string): Promise<any | null>;
    getUserProfile(userId: string): Promise<UserProfile | null>;
    updateUserProfile(userId: string, updates: Partial<UserProfile>): Promise<void>;
    query(collection: string, query: any): Promise<any[]>;
    similarItems(collection: string, item: any, threshold?: number): Promise<any[]>;
    conceptSearch(concept: string, limit?: number): Promise<any[]>;
    codeSearch(query: string, context?: any): Promise<any[]>;
    conversationSearch(query: string, sessionId?: string): Promise<any[]>;
    updateKnowledgeFromMessage(message: any): Promise<void>;
    updateKnowledgeFromProject(project: any): Promise<void>;
    addOrUpdateKnowledgeNode(node: any): Promise<void>;
    createBackup(path?: string): Promise<string>;
    restoreFromBackup(backupPath: string): Promise<void>;
    syncWithRemote(): Promise<void>;
    getSyncStatus(): Promise<any>;
    resolveConflict(conflictId: string, resolution: any): Promise<void>;
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
}
export interface MemoryCollection<T> {
    insert(item: T): Promise<string>;
    find(query: any): Promise<T[]>;
    findOne(query: any): Promise<T | null>;
    update(id: string, updates: Partial<T>): Promise<boolean>;
    delete(id: string): Promise<boolean>;
    count(query?: any): Promise<number>;
}
export interface MemoryCollection<T> {
    insert(item: T): Promise<string>;
    find(query: any): Promise<T[]>;
    findOne(query: any): Promise<T | null>;
    update(id: string, updates: Partial<T>): Promise<boolean>;
    delete(id: string): Promise<boolean>;
    count(query?: any): Promise<number>;
}
export interface ToolUsageAnalysis {
    userId: string;
    analysisDate: Date;
    timeRange: {
        start: Date;
        end: Date;
    };
    totalSessions: number;
    overall: {
        totalToolCalls: number;
        successRate: number;
        averageResponseTime: number;
        errorRate: number;
        userSatisfactionScore: number;
    };
    toolSpecific: Record<string, {
        callCount: number;
        successRate: number;
        errorTypes: Record<string, number>;
        averageResponseTime: number;
        complexityDistribution: Record<string, number>;
        outcomes: {
            success: number;
            failure: number;
            partial: number;
        };
        frequency: number;
        complexity: {
            average: number;
            min: number;
            max: number;
            distribution: number[];
        };
        userFeedback: {
            positive: number;
            negative: number;
            neutral: number;
        };
        trends: {
            direction: 'improving' | 'declining' | 'stable';
            velocity: number;
            confidence: number;
        };
    }>;
    patterns: {
        preferredTools: string[];
        toolCombinations: Array<{
            tools: string[];
            frequency: number;
            successRate: number;
        }>;
        timeOfDay: Record<string, number>;
        sessionLength: {
            average: number;
            distribution: number[];
        };
        taskTypes: Record<string, {
            frequency: number;
            preferredTools: string[];
            successRate: number;
        }>;
    };
    learning: {
        improvementRate: number;
        newToolAdoption: string[];
        skillProgression: Record<string, {
            initialLevel: number;
            currentLevel: number;
            trajectory: 'improving' | 'stable' | 'declining';
        }>;
        adaptationSpeed: number;
    };
    recommendations: {
        toolsToImprove: string[];
        newToolsToTry: string[];
        trainingAreas: string[];
        optimizationOpportunities: string[];
    };
}
export interface UserProfile {
    id: string;
    createdAt: Date;
    lastUpdated: Date;
    preferences: {
        verbosity: 'minimal' | 'concise' | 'detailed' | 'comprehensive';
        explanation_depth: 'surface' | 'intermediate' | 'deep';
        code_style: 'functional' | 'oop' | 'mixed' | 'adaptive';
        examples_preference: 'minimal' | 'some' | 'many';
        error_handling: 'strict' | 'permissive' | 'context_aware';
        performance_focus: 'readability' | 'efficiency' | 'balanced';
        testing_approach: 'tdd' | 'post_implementation' | 'minimal';
        documentation_level: 'inline' | 'comprehensive' | 'external';
        learningStyle: 'visual' | 'auditory' | 'kinesthetic' | 'hands_on';
        learningPace: 'fast' | 'moderate' | 'slow' | 'adaptive';
        timeAvailability: 'limited' | 'moderate' | 'flexible' | 'extensive';
        preferredComplexity: 'simple' | 'moderate' | 'complex' | 'progressive';
    };
    skillLevel: {
        overall: CompetencyLevel;
        domains: Record<string, CompetencyLevel>;
        tools: Record<string, CompetencyLevel>;
        languages: Record<string, CompetencyLevel>;
        frameworks: Record<string, CompetencyLevel>;
    };
    workPatterns: Array<{
        type: 'project_type' | 'task_pattern' | 'time_pattern' | 'tool_pattern';
        pattern: string;
        frequency: number;
        context: Record<string, any>;
        outcomes: Record<string, number>;
    }>;
    codeStyle: {
        indentation: 'spaces' | 'tabs';
        indentSize: number;
        quotes: 'single' | 'double' | 'backticks';
        semicolons: boolean;
        trailingCommas: boolean;
        namingConvention: 'camelCase' | 'snake_case' | 'kebab-case' | 'PascalCase';
        lineLength: number;
        bracketStyle: 'same-line' | 'new-line' | 'mixed';
    };
    communicationStyle: {
        formality: 'casual' | 'professional' | 'academic';
        responseLength: 'brief' | 'moderate' | 'detailed';
        technicalDepth: 'beginner' | 'intermediate' | 'expert';
        examplePreference: 'conceptual' | 'practical' | 'both';
    };
    learningHistory: Array<{
        timestamp: Date;
        topic: string;
        method: string;
        outcome: 'successful' | 'partially_successful' | 'unsuccessful';
        duration: number;
        confidence: number;
        notes?: string;
    }>;
    goals: Array<{
        id: string;
        title: string;
        description: string;
        category: 'skill' | 'project' | 'learning' | 'productivity';
        priority: 'low' | 'medium' | 'high' | 'critical';
        status: 'active' | 'paused' | 'completed' | 'cancelled';
        progress: number;
        deadline?: Date;
        milestones: Array<{
            title: string;
            completed: boolean;
            completedAt?: Date;
        }>;
    }>;
    context: {
        primaryRole: string;
        experienceLevel: 'beginner' | 'intermediate' | 'advanced' | 'expert';
        teamSize: number;
        workEnvironment: 'individual' | 'small_team' | 'large_team' | 'enterprise';
        projectTypes: string[];
        constraints: string[];
        tools: string[];
        methodologies: string[];
    };
    analytics: {
        totalSessions: number;
        totalMessages: number;
        averageSessionLength: number;
        mostActiveHours: number[];
        toolUsageFrequency: Record<string, number>;
        successMetrics: Record<string, number>;
        satisfactionScore: number;
        improvementAreas: string[];
    };
}
export interface TrainingAnalysis {
    userId: string;
    analysisDate: Date;
    assessment: {
        toolCompetencies: Map<string, CompetencyLevel>;
        skillGaps: {
            identified: string[];
            recommendations: string[];
            priority: 'low' | 'medium' | 'high';
            timeline: string;
        };
        learningMetrics: {
            learningVelocity: number;
            retentionRate: number;
            adaptationSpeed: number;
            preferredLearningStyle: string;
        };
        insights: {
            strengths: string[];
            improvements: string[];
            recommendations: string[];
            overallTrend: 'improving' | 'stable' | 'declining';
        };
        assessmentDate: Date;
        confidence: number;
    };
    recommendations: TrainingRecommendation[];
    learningPath: LearningPath;
    estimatedDuration: string;
    priority: 'low' | 'medium' | 'high';
    confidence: number;
    metadata: {
        analysisVersion: string;
        dataQuality: number;
        completeness: number;
        lastToolUsageDate: Date;
        recommendationCount: number;
        estimatedEffort: 'low' | 'medium' | 'high';
    };
}
export interface ProgressUpdate {
    moduleId: string;
    completionPercentage: number;
    timeSpent: number;
    estimatedTime: number;
    assessmentScore?: number;
    feedback?: string;
    challenges?: string[];
    achievements?: string[];
    nextSteps?: string[];
}
export interface ProgressAnalysis {
    currentProgress: ProgressUpdate;
    effectiveness: {
        completionRate: number;
        timeEfficiency: number;
        qualityScore: number;
        retentionRate: number;
    };
    adaptations: Array<{
        type: string;
        reason: string;
        action: string;
    }>;
    nextRecommendations: string[];
    estimatedCompletion: Date;
}
export interface TrainingInsights {
    patterns: {
        preferredTimes: string[];
        optimalSessionLength: number;
        bestPerformingTopics: string[];
        challengingAreas: string[];
    };
    predictions: {
        projectedCompletion: Date;
        riskFactors: string[];
        successProbability: number;
        recommendedAdjustments: string[];
    };
    insights: string[];
    summary: string;
    confidence: number;
    generatedAt: Date;
}
export interface DomainOrchestrationStrategy {
    domain: ProjectDomain;
    name: string;
    description: string;
    preferredTools: string[];
    toolPriorities: Record<string, number>;
    workflowPatterns: DomainWorkflowPattern[];
    triggerMappings: Record<string, DomainTriggerMapping>;
    optimizationGoals: DomainOptimizationGoal[];
    conflictResolutionRules: DomainConflictRule[];
    performanceExpectations: PerformanceExpectations;
}
export interface DomainWorkflowPattern {
    name: string;
    trigger: string;
    description: string;
    toolSequence: DomainToolStep[];
    parallelizable: boolean;
    estimatedDuration: number;
    successCriteria: string[];
    fallbackStrategies: string[];
}
export interface DomainToolStep {
    toolType: string;
    capability: string;
    inputPreparation: (context: any) => Record<string, any>;
    outputProcessing: (output: any) => any;
    dependencies: string[];
    optional: boolean;
    timeout: number;
}
export interface DomainTriggerMapping {
    originalTrigger: string;
    domainSpecificTrigger: string;
    toolSelectionStrategy: string;
    contextEnhancement: Record<string, any>;
    priorityAdjustment: number;
}
export interface DomainOptimizationGoal {
    name: string;
    description: string;
    metric: string;
    target: number;
    weight: number;
    measurementStrategy: string;
}
export interface DomainConflictRule {
    id: string;
    domain: ProjectDomain;
    conflictType: string;
    participants: string[];
    resolutionStrategy: string;
    domainKnowledge: Record<string, any>;
    priority: number;
}
export interface PerformanceExpectations {
    responseTime: {
        target: number;
        max: number;
    };
    accuracy: {
        target: number;
        min: number;
    };
    resourceUsage: {
        memory: number;
        cpu: number;
    };
    cacheEfficiency: {
        target: number;
        min: number;
    };
}
export interface PredictiveContext {
    recentActions: string[];
    currentFocus: string;
    timeOfDay: string;
    dayOfWeek: string;
    sessionDuration: number;
    previousSuccessfulPatterns: string[];
    developerPreferences: Record<string, any>;
    projectHistory: string[];
}
export interface PredictionResult {
    predictedTools: string[];
    confidence: number;
    reasoning: string;
    suggestedPreparation: Record<string, any>;
    alternativeScenarios: AlternativeScenario[];
}
export interface AlternativeScenario {
    scenario: string;
    probability: number;
    tools: string[];
    reasoning: string;
}
export interface ConflictResolutionContext {
    conflictType: string;
    participants: string[];
    domainContext: ProjectCharacteristics;
    historicalResolutions: ConflictResolutionHistory[];
    currentPriorities: Record<string, number>;
    userPreferences: Record<string, any>;
}
export interface ConflictResolutionHistory {
    conflictType: string;
    participants: string[];
    resolutionStrategy: string;
    outcome: 'successful' | 'failed' | 'partial';
    userSatisfaction: number;
    timestamp: Date;
    context: Record<string, any>;
}
export interface SemanticInformation {
    type: 'documentation' | 'pattern' | 'analysis' | 'reasoning';
    content: any;
    metadata: {
        source: string;
        timestamp: Date;
        confidence: number;
        relevance: number;
        freshness: number;
    };
    relationships: SemanticRelationship[];
    applicability: {
        domains: ProjectDomain[];
        contexts: string[];
        limitations: string[];
    };
}
export interface SemanticRelationship {
    type: 'supports' | 'contradicts' | 'enhances' | 'requires' | 'alternative_to';
    target: string;
    strength: number;
    description: string;
}
export type ReviewType = 'security' | 'performance' | 'maintainability' | 'best_practices' | 'architecture' | 'testing' | 'comprehensive';
export type ReviewPriority = 'low' | 'medium' | 'high' | 'critical';
export type ReviewStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
export type ReviewOutcome = 'approved' | 'needs_changes' | 'rejected' | 'conditional_approval';
export interface CodeReviewConfiguration {
    reviewTypes: ReviewType[];
    domainSpecificRules: boolean;
    aiAgentCount: number;
    conflictResolutionEnabled: boolean;
    performanceOptimizationEnabled: boolean;
    securityScanningEnabled: boolean;
    automaticFixSuggestions: boolean;
    interactiveMode: boolean;
    qualityGate: {
        minimumScore: number;
        requiredApprovals: number;
        blockingIssues: string[];
    };
}
export interface ReviewWorkflowConfig {
    stages: ReviewStage[];
    parallelExecution: boolean;
    timeoutMinutes: number;
    retryPolicy: {
        maxRetries: number;
        backoffStrategy: 'linear' | 'exponential';
    };
    notifications: {
        onStart: boolean;
        onCompletion: boolean;
        onError: boolean;
        channels: string[];
    };
}
export interface ReviewStage {
    name: string;
    type: ReviewType;
    aiAgents: string[];
    criteria: ReviewCriteria[];
    requiredForApproval: boolean;
    timeoutMinutes: number;
    dependencies: string[];
}
export interface AIReviewAgent {
    type: string;
    specialization: ReviewType[];
    capabilities: string[];
    configuration: {
        model: string;
        temperature: number;
        maxTokens: number;
        contextWindow: number;
    };
    performanceMetrics: {
        accuracy: number;
        speed: number;
        reliability: number;
        lastUpdated: Date;
    };
    domainExpertise: ProjectDomain[];
}
export interface ReviewCriteria {
    category: ReviewType;
    name: string;
    description: string;
    weight: number;
    severity: ReviewPriority;
    automatedCheck: boolean;
    customRules?: ReviewRule[];
    domainSpecific: boolean;
    applicableLanguages: string[];
    patterns: {
        positive: string[];
        negative: string[];
        contextual: string[];
    };
}
export interface ReviewRule {
    id: string;
    name: string;
    pattern: string;
    severity: ReviewPriority;
    message: string;
    suggestion?: string;
    autofix?: {
        enabled: boolean;
        pattern: string;
        replacement: string;
        confidence: number;
    };
    metadata: {
        category: ReviewType;
        language: string;
        framework?: string;
        domain?: ProjectDomain;
    };
}
export interface ReviewFinding {
    id: string;
    type: ReviewType;
    severity: ReviewPriority;
    title: string;
    description: string;
    location: {
        file: string;
        line: number;
        column?: number;
        endLine?: number;
        endColumn?: number;
    };
    rule?: ReviewRule;
    suggestion: {
        description: string;
        code?: string;
        confidence: number;
        effort: 'low' | 'medium' | 'high';
    };
    context: {
        surroundingCode: string;
        relevantSymbols: string[];
        dependencies: string[];
    };
    aiAgent: string;
    confidence: number;
    metadata: Record<string, any>;
}
export interface CodeReviewRequest {
    sessionId: string;
    type: ReviewType | ReviewType[];
    scope: {
        files?: string[];
        directories?: string[];
        commitRange?: string;
        entireProject?: boolean;
    };
    configuration: CodeReviewConfiguration;
    workflow?: ReviewWorkflowConfig;
    context: {
        projectContext: ProjectContext;
        domainCharacteristics?: ProjectCharacteristics;
        previousReviews?: ReviewSession[];
        userPreferences?: Record<string, any>;
    };
    priority: ReviewPriority;
    deadline?: Date;
    requestedBy: string;
    metadata: Record<string, any>;
}
export interface CodeReviewResult {
    sessionId: string;
    status: ReviewStatus;
    outcome?: ReviewOutcome;
    startTime: Date;
    endTime?: Date;
    duration?: number;
    findings: ReviewFinding[];
    summary: {
        totalIssues: number;
        issuesBySeverity: Record<ReviewPriority, number>;
        issuesByType: Record<ReviewType, number>;
        overallScore: number;
        recommendation: string;
        keyInsights: string[];
    };
    metrics: {
        filesAnalyzed: number;
        linesOfCode: number;
        coveragePercentage: number;
        performanceScore: number;
        securityScore: number;
        maintainabilityScore: number;
    };
    aiAgentResults: AIAgentReviewResult[];
    conflicts?: ConflictResolution[];
    workflow: {
        stagesCompleted: string[];
        stagesFailed: string[];
        totalStages: number;
        parallelExecutionTime?: number;
    };
    qualityGate: {
        passed: boolean;
        score: number;
        requirements: QualityGateRequirement[];
    };
    suggestions: ReviewSuggestion[];
    metadata: Record<string, any>;
}
export interface AIAgentReviewResult {
    agentType: string;
    status: ReviewStatus;
    findings: ReviewFinding[];
    executionTime: number;
    confidence: number;
    specializedInsights: string[];
    performanceMetrics: {
        accuracy: number;
        coverage: number;
        falsePositiveRate: number;
    };
    resourceUsage: {
        tokensUsed: number;
        apiCalls: number;
        cacheHits: number;
    };
}
export interface ConflictResolution {
    id?: string;
    conflictId: string;
    type: 'disagreement' | 'contradiction' | 'priority_mismatch' | 'scope_overlap';
    participants: string[];
    findings: ReviewFinding[];
    hierarchy?: any;
    expertiseWeights?: any;
    criteriaWeights?: Record<string, number>;
    learningInsights?: any;
    resolution: {
        strategy: string;
        finalDecision: ReviewFinding | ReviewFinding[];
        confidence: number;
        reasoning: string;
    };
    resolutionTime: number;
    consensusRecommendations?: any[];
    confidenceScore?: number;
    fallbackPlan?: any;
    metadata?: any;
    alternativeOptions?: any[];
    conflictingRecommendations?: any[];
    context?: any;
    decisionCriteria?: any;
    conflictAnalysis?: any;
    outcome?: string;
    resolutionStrategy?: string;
    resolutionValidation?: {
        method: string;
        confidence: number;
        criteria: string[];
        result: boolean;
    };
}
export interface QualityGateRequirement {
    name: string;
    type: 'score_threshold' | 'issue_count' | 'severity_limit' | 'coverage_minimum';
    target: number;
    actual: number;
    passed: boolean;
    blocking: boolean;
    description: string;
}
export interface ReviewSuggestion {
    id: string;
    type: 'improvement' | 'optimization' | 'refactoring' | 'architecture' | 'security';
    priority: ReviewPriority;
    title: string;
    description: string;
    impact: {
        effort: 'low' | 'medium' | 'high';
        benefit: 'low' | 'medium' | 'high';
        risk: 'low' | 'medium' | 'high';
    };
    implementation: {
        steps: string[];
        estimatedTime: number;
        prerequisites: string[];
        codeChanges?: {
            file: string;
            changes: string;
        }[];
    };
    relatedFindings: string[];
    aiAgent: string;
    confidence: number;
}
export interface ReviewSession {
    sessionId: string;
    request: CodeReviewRequest;
    result?: CodeReviewResult;
    status: ReviewStatus;
    createdAt: Date;
    updatedAt: Date;
    progress: {
        currentStage?: string;
        completedStages: string[];
        overallProgress: number;
        estimatedTimeRemaining?: number;
    };
    participants: {
        human: string[];
        ai: string[];
    };
    logs: ReviewLogEntry[];
    workspace: {
        temporaryFiles: string[];
        analysisArtifacts: string[];
        generatedReports: string[];
    };
}
export interface ReviewLogEntry {
    timestamp: Date;
    level: 'debug' | 'info' | 'warn' | 'error';
    source: string;
    message: string;
    context?: Record<string, any>;
    findingId?: string;
    stageName?: string;
}
export interface ReviewAnalytics {
    sessionId: string;
    metrics: {
        totalDuration: number;
        agentPerformance: Record<string, AgentPerformanceMetrics>;
        findingAccuracy: number;
        userSatisfaction?: number;
        automationEfficiency: number;
    };
    patterns: {
        commonIssues: string[];
        improvementTrends: string[];
        agentAgreement: number;
        conflictFrequency: number;
    };
    recommendations: {
        workflowOptimization: string[];
        agentTuning: string[];
        ruleAdjustments: string[];
    };
}
export interface AgentPerformanceMetrics {
    executionTime: number;
    findingsCount: number;
    accuracy: number;
    falsePositiveRate: number;
    coverage: number;
    resourceEfficiency: number;
    userRating?: number;
}
export interface ReviewLearningData {
    sessionId: string;
    outcomes: {
        userAcceptedFindings: string[];
        userRejectedFindings: string[];
        userModifiedFindings: Record<string, ReviewFinding>;
    };
    feedbacks: {
        overallRating: number;
        agentRatings: Record<string, number>;
        suggestions: string[];
        complaints: string[];
    };
    contextualData: {
        projectCharacteristics: ProjectCharacteristics;
        codebaseMetrics: CodeMetrics;
        domainSpecificFactors: Record<string, any>;
    };
    improvementOpportunities: string[];
    timestamp: Date;
}
export type LearningScope = 'project' | 'team' | 'organization' | 'global';
export type PatternType = 'development' | 'architectural' | 'testing' | 'deployment' | 'quality' | 'performance' | 'security';
export type PatternMaturity = 'emerging' | 'validated' | 'proven' | 'deprecated';
export type PredictionConfidence = 'low' | 'medium' | 'high' | 'very_high';
export interface OrganizationalMemory {
    id: string;
    scope: LearningScope;
    createdAt: Date;
    updatedAt: Date;
    version: string;
    patterns: ProjectPattern[];
    bestPractices: BestPracticeRecord[];
    insights: OrganizationalInsight[];
    metrics: OrganizationalMetrics;
    learningModels: LearningModel[];
    knowledgeGraph: KnowledgeGraph;
    metadata: {
        projectCount: number;
        teamCount: number;
        totalInteractions: number;
        lastAnalysisDate: Date;
        confidenceLevel: number;
    };
}
export interface ProjectPattern {
    id: string;
    type: PatternType;
    name: string;
    description: string;
    scope: LearningScope;
    maturity: PatternMaturity;
    frequency: number;
    effectiveness: number;
    context: {
        domains: ProjectDomain[];
        languages: string[];
        frameworks: string[];
        teamSizes: string[];
        projectSizes: string[];
    };
    artifacts: {
        codeExamples: CodeArtifact[];
        configurationTemplates: ConfigurationTemplate[];
        testPatterns: TestPattern[];
        documentationTemplates: DocumentationTemplate[];
    };
    metrics: {
        adoptionRate: number;
        successRate: number;
        timeToImplement: number;
        maintenanceOverhead: number;
        developerSatisfaction: number;
    };
    relationships: PatternRelationship[];
    evolution: PatternEvolution[];
    validation: PatternValidation;
    aiConfidence: number;
    lastUpdated: Date;
}
export interface BestPracticeRecord {
    id: string;
    category: PatternType;
    title: string;
    description: string;
    rationale: string;
    scope: LearningScope;
    maturity: PatternMaturity;
    discoveryMethod: 'automated_analysis' | 'expert_input' | 'ai_identification' | 'community_feedback';
    evidence: {
        dataPoints: number;
        successStories: SuccessStory[];
        metrics: BestPracticeMetrics;
        validationResults: ValidationResult[];
    };
    implementation: {
        guidelines: string[];
        codeExamples: CodeArtifact[];
        toolSupport: string[];
        automationLevel: 'manual' | 'semi_automated' | 'fully_automated';
    };
    adoption: {
        currentAdopters: number;
        adoptionTrend: TrendData[];
        barriers: AdoptionBarrier[];
        incentives: AdoptionIncentive[];
    };
    impact: {
        qualityImprovement: number;
        velocityImprovement: number;
        costReduction: number;
        riskReduction: number;
    };
    aiAnalysis: AIAnalysisResult;
    createdAt: Date;
    updatedAt: Date;
}
export interface OrganizationalInsight {
    id: string;
    type: 'trend' | 'anomaly' | 'opportunity' | 'risk' | 'prediction';
    severity: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    scope: LearningScope;
    confidence: PredictionConfidence;
    evidence: {
        dataPoints: DataPoint[];
        patterns: string[];
        correlations: Correlation[];
        statisticalSignificance: number;
    };
    recommendations: {
        immediate: ActionableRecommendation[];
        shortTerm: ActionableRecommendation[];
        longTerm: ActionableRecommendation[];
    };
    impact: {
        affectedAreas: string[];
        estimatedBenefit: number;
        implementationCost: number;
        timeframe: string;
    };
    aiGenerated: boolean;
    validatedByHuman: boolean;
    implementationStatus: 'identified' | 'planned' | 'in_progress' | 'completed' | 'dismissed';
    createdAt: Date;
    expiresAt?: Date;
}
export interface OrganizationalMetrics {
    period: {
        startDate: Date;
        endDate: Date;
    };
    velocity: {
        averageStoryPoints: number;
        velocityTrend: TrendData[];
        predictedVelocity: PredictionData[];
        factors: VelocityFactor[];
    };
    quality: {
        defectRate: number;
        qualityTrend: TrendData[];
        predictedQuality: PredictionData[];
        qualityFactors: QualityFactor[];
    };
    efficiency: {
        codeReusability: number;
        automationLevel: number;
        resourceUtilization: number;
        efficiencyTrend: TrendData[];
    };
    learning: {
        patternAdoptionRate: number;
        knowledgeGrowth: number;
        crossTeamSharing: number;
        aiAccuracyImprovement: number;
    };
    predictiveAccuracy: {
        velocityPredictions: AccuracyMetrics;
        qualityPredictions: AccuracyMetrics;
        resourcePredictions: AccuracyMetrics;
        overallAccuracy: number;
    };
}
export interface LearningModel {
    id: string;
    type: 'velocity_prediction' | 'quality_prediction' | 'pattern_recognition' | 'resource_optimization';
    name: string;
    description: string;
    version: string;
    algorithm: string;
    features: ModelFeature[];
    performance: {
        accuracy: number;
        precision: number;
        recall: number;
        f1Score: number;
        lastEvaluation: Date;
    };
    training: {
        datasetSize: number;
        lastTrained: Date;
        trainingDuration: number;
        validationSplit: number;
    };
    deployment: {
        status: 'development' | 'testing' | 'production' | 'deprecated';
        endpoints: string[];
        scalingPolicy: ScalingPolicy;
        monitoring: ModelMonitoring;
    };
    metadata: {
        createdBy: string;
        owner: string;
        tags: string[];
        documentation: string;
    };
}
export interface KnowledgeGraph {
    nodes: KnowledgeNode[];
    edges: KnowledgeEdge[];
    clusters: KnowledgeCluster[];
    metrics: {
        totalNodes: number;
        totalEdges: number;
        density: number;
        centrality: Record<string, number>;
        communities: CommunityStructure[];
    };
    analysis: {
        keyNodes: string[];
        criticalPaths: string[][];
        recommendations: GraphRecommendation[];
        lastAnalyzed: Date;
    };
}
export interface CodeArtifact {
    id: string;
    type: 'snippet' | 'function' | 'class' | 'module' | 'project_template';
    name: string;
    description: string;
    language: string;
    framework?: string;
    content: string;
    metadata: {
        author: string;
        created: Date;
        lastModified: Date;
        usageCount: number;
        rating: number;
        tags: string[];
    };
    validation: {
        syntaxValid: boolean;
        testsCovered: boolean;
        securityChecked: boolean;
        performanceTested: boolean;
    };
    relationships: {
        dependencies: string[];
        dependents: string[];
        alternatives: string[];
        improvements: string[];
    };
}
export interface ConfigurationTemplate {
    id: string;
    name: string;
    description: string;
    type: 'build' | 'deployment' | 'testing' | 'security' | 'monitoring';
    technology: string;
    content: Record<string, any>;
    variables: TemplateVariable[];
    validation: TemplateValidation;
    usage: {
        adoptionCount: number;
        successRate: number;
        lastUsed: Date;
    };
    metadata: {
        created: Date;
        version: string;
        maintainer: string;
        documentation: string;
    };
}
export interface TestPattern {
    id: string;
    name: string;
    description: string;
    category: 'unit' | 'integration' | 'e2e' | 'performance' | 'security';
    framework: string;
    language: string;
    pattern: string;
    example: string;
    metrics: {
        coverage: number;
        reliability: number;
        maintainability: number;
        executionTime: number;
    };
    applicability: {
        domains: ProjectDomain[];
        contexts: string[];
        prerequisites: string[];
    };
    validation: {
        tested: boolean;
        validated: boolean;
        lastValidation: Date;
    };
}
export interface DocumentationTemplate {
    id: string;
    name: string;
    description: string;
    type: 'readme' | 'api_docs' | 'architecture' | 'runbook' | 'tutorial';
    format: 'markdown' | 'rst' | 'html' | 'confluence';
    template: string;
    sections: DocumentationSection[];
    automation: {
        autoGenerated: boolean;
        updateFrequency: string;
        triggers: string[];
    };
    quality: {
        completeness: number;
        accuracy: number;
        usefulness: number;
        lastReviewed: Date;
    };
}
export interface PatternRelationship {
    type: 'depends_on' | 'conflicts_with' | 'enhances' | 'alternative_to' | 'evolves_to';
    targetPatternId: string;
    strength: number;
    description: string;
    evidence: string[];
    confidence: number;
}
export interface PatternEvolution {
    version: string;
    date: Date;
    changes: PatternChange[];
    reason: string;
    impact: EvolutionImpact;
    validationResults: ValidationResult[];
}
export interface PatternValidation {
    status: 'pending' | 'in_progress' | 'validated' | 'rejected';
    method: 'automated' | 'expert_review' | 'community_feedback' | 'field_testing';
    results: ValidationResult[];
    confidence: number;
    lastValidated: Date;
    nextValidation?: Date;
}
export interface VelocityPrediction {
    sessionId: string;
    period: {
        startDate: Date;
        endDate: Date;
    };
    predictions: {
        storyPoints: PredictionData;
        features: PredictionData;
        bugFixes: PredictionData;
        technicalDebt: PredictionData;
    };
    factors: VelocityFactor[];
    confidence: PredictionConfidence;
    recommendations: VelocityRecommendation[];
    historicalBaseline: HistoricalData;
    methodology: PredictionMethodology;
    createdAt: Date;
    validatedAt?: Date;
    actualResults?: ActualVelocityData;
}
export interface QualityPrediction {
    sessionId: string;
    metricType: string;
    period: {
        startDate: Date;
        endDate: Date;
    };
    predictions: {
        defectRate: PredictionData;
        codeQuality: PredictionData;
        testCoverage: PredictionData;
        technicalDebt: PredictionData;
        securityRisk: PredictionData;
    };
    factors: QualityFactor[];
    confidence: PredictionConfidence;
    recommendations: QualityRecommendation[];
    thresholds: QualityThreshold[];
    methodology: PredictionMethodology;
    createdAt: Date;
    validatedAt?: Date;
    actualResults?: ActualQualityData;
    metadata?: Record<string, any>;
}
export interface ResourceOptimization {
    sessionId: string;
    scope: 'project' | 'team' | 'organization';
    period: {
        startDate: Date;
        endDate: Date;
    };
    currentState: {
        resources: ResourceAllocation[];
        utilization: ResourceUtilization[];
        costs: ResourceCost[];
        bottlenecks: ResourceBottleneck[];
    };
    optimization: {
        recommendations: ResourceRecommendation[];
        projectedSavings: number;
        implementationCost: number;
        riskAssessment: RiskAssessment;
        timeline: OptimizationTimeline;
    };
    aiTools: {
        currentAllocation: AIToolAllocation[];
        recommendedAllocation: AIToolAllocation[];
        efficiencyGains: EfficiencyGain[];
        costOptimization: CostOptimization[];
    };
    methodology: OptimizationMethodology;
    createdAt: Date;
    implementedAt?: Date;
    measuredResults?: OptimizationResults;
}
export interface SuccessStory {
    id: string;
    title: string;
    description: string;
    projectId: string;
    teamId: string;
    outcomes: Outcome[];
    metrics: SuccessMetrics;
    lessons: string[];
    artifacts: string[];
    testimonial?: string;
    createdAt: Date;
}
export interface ValidationResult {
    id: string;
    type: 'automated' | 'human' | 'field_test';
    status: 'passed' | 'failed' | 'partial';
    score: number;
    details: string;
    evidence: string[];
    timestamp: Date;
    validator: string;
}
export interface BestPracticeMetrics {
    adoptionRate: number;
    successRate: number;
    impactScore: number;
    satisfactionRating: number;
    timeToValue: number;
    maintenanceCost: number;
    scalabilityIndex: number;
}
export interface TrendData {
    date: Date;
    value: number;
    context?: Record<string, any>;
}
export interface PredictionData {
    value: number;
    confidence: PredictionConfidence;
    range: {
        min: number;
        max: number;
    };
    factors: string[];
    methodology: string;
}
export interface VelocityFactor {
    name: string;
    impact: number;
    confidence: number;
    description: string;
    category: 'team' | 'process' | 'technical' | 'external';
    controllable: boolean;
}
export interface QualityFactor {
    name: string;
    impact: number;
    confidence: number;
    description: string;
    category: 'code' | 'process' | 'team' | 'tools';
    measurable: boolean;
}
export interface ActionableRecommendation {
    id: string;
    title: string;
    description: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    effort: 'low' | 'medium' | 'high';
    impact: 'low' | 'medium' | 'high';
    category: string;
    steps: ActionStep[];
    prerequisites: string[];
    risks: Risk[];
    expectedOutcome: string;
    successMetrics: string[];
    timeframe: string;
    assignee?: string;
    status: 'proposed' | 'approved' | 'in_progress' | 'completed' | 'rejected';
}
export interface DataPoint {
    timestamp: Date;
    source: string;
    type: string;
    value: any;
    context: Record<string, any>;
    confidence: number;
}
export interface Correlation {
    factor1: string;
    factor2: string;
    strength: number;
    type: 'positive' | 'negative' | 'complex';
    significance: number;
    description: string;
}
export interface ModelFeature {
    name: string;
    type: 'numerical' | 'categorical' | 'text' | 'boolean';
    importance: number;
    description: string;
    source: string;
    preprocessing: string[];
}
export interface AccuracyMetrics {
    mape: number;
    rmse: number;
    r2: number;
    lastEvaluated: Date;
    sampleSize: number;
}
export interface KnowledgeNode {
    id: string;
    type: 'pattern' | 'practice' | 'insight' | 'project' | 'team' | 'technology';
    label: string;
    description: string;
    properties: Record<string, any>;
    metrics: {
        centrality: number;
        clustering: number;
        influence: number;
    };
    lastUpdated: Date;
}
export interface KnowledgeEdge {
    id: string;
    source: string;
    target: string;
    type: string;
    weight: number;
    properties: Record<string, any>;
    confidence: number;
    lastUpdated: Date;
}
export interface KnowledgeCluster {
    id: string;
    name: string;
    description: string;
    nodes: string[];
    cohesion: number;
    topics: string[];
    significance: number;
}
export interface AIAnalysisResult {
    analysisId: string;
    timestamp: Date;
    model: string;
    confidence: number;
    findings: string[];
    recommendations: string[];
    metadata: Record<string, any>;
}
export interface AdoptionBarrier {
    type: 'technical' | 'cultural' | 'process' | 'resource';
    description: string;
    severity: 'low' | 'medium' | 'high';
    mitigation: string[];
}
export interface AdoptionIncentive {
    type: 'benefit' | 'reward' | 'support' | 'recognition';
    description: string;
    effectiveness: number;
    cost: number;
}
export interface PatternChange {
    type: 'improvement' | 'bug_fix' | 'deprecation' | 'enhancement';
    description: string;
    impact: 'minor' | 'major' | 'breaking';
    details: string[];
}
export interface EvolutionImpact {
    affectedUsers: number;
    migrationEffort: 'low' | 'medium' | 'high';
    backwardCompatible: boolean;
    benefits: string[];
    risks: string[];
}
export interface TemplateVariable {
    name: string;
    type: string;
    required: boolean;
    defaultValue?: any;
    description: string;
    validation?: string;
}
export interface TemplateValidation {
    syntaxValid: boolean;
    variablesResolved: boolean;
    testPassed: boolean;
    lastValidated: Date;
    errors: string[];
}
export interface DocumentationSection {
    name: string;
    required: boolean;
    template: string;
    examples: string[];
    guidelines: string[];
}
export interface HistoricalData {
    period: {
        startDate: Date;
        endDate: Date;
    };
    metrics: Record<string, number>;
    trends: TrendData[];
    context: Record<string, any>;
}
export interface PredictionMethodology {
    algorithm: string;
    features: string[];
    trainingData: {
        size: number;
        period: {
            startDate: Date;
            endDate: Date;
        };
    };
    validation: {
        method: string;
        accuracy: number;
        confidence: number;
    };
    assumptions: string[];
    limitations: string[];
}
export interface ActualVelocityData {
    storyPoints: number;
    features: number;
    bugFixes: number;
    technicalDebt: number;
    measuredAt: Date;
    context: Record<string, any>;
}
export interface ActualQualityData {
    defectRate: number;
    codeQuality: number;
    testCoverage: number;
    technicalDebt: number;
    securityRisk: number;
    measuredAt: Date;
    context: Record<string, any>;
}
export interface VelocityRecommendation {
    type: 'process' | 'technical' | 'team' | 'tools';
    title: string;
    description: string;
    expectedImpact: number;
    effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high';
    implementation: ActionStep[];
}
export interface QualityRecommendation {
    type: 'process' | 'technical' | 'training' | 'tools';
    title: string;
    description: string;
    expectedImpact: number;
    effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high';
    implementation: ActionStep[];
}
export interface QualityThreshold {
    metric: string;
    warning: number;
    critical: number;
    target: number;
    description: string;
}
export interface ResourceAllocation {
    resourceType: string;
    allocated: number;
    utilized: number;
    cost: number;
    efficiency: number;
}
export interface ResourceUtilization {
    resourceId: string;
    utilizationRate: number;
    peakUsage: number;
    averageUsage: number;
    trends: TrendData[];
}
export interface ResourceCost {
    resourceType: string;
    totalCost: number;
    costPerUnit: number;
    period: {
        startDate: Date;
        endDate: Date;
    };
    trends: TrendData[];
}
export interface ResourceBottleneck {
    resourceType: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    description: string;
    impact: string;
    recommendations: string[];
}
export interface ResourceRecommendation {
    type: 'reallocation' | 'scaling' | 'optimization' | 'replacement';
    description: string;
    expectedSavings: number;
    implementationCost: number;
    effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high';
    timeline: string;
    risks: Risk[];
}
export interface RiskAssessment {
    overallRisk: 'low' | 'medium' | 'high' | 'critical';
    risks: Risk[];
    mitigation: MitigationStrategy[];
    contingencyPlans: ContingencyPlan[];
    id?: string;
    userId?: string;
    skillGaps: {
        identified: string[];
        recommendations: string[];
        priority: 'low' | 'medium' | 'high';
        timeline: string;
    };
    assessmentDate: Date;
    toolCompetencies: Map<string, CompetencyLevel>;
    overallLevel?: any;
    learningMetrics: {
        learningVelocity: number;
        retentionRate: number;
        adaptationSpeed: number;
        preferredLearningStyle: string;
    };
    insights: {
        strengths: string[];
        improvements: string[];
        recommendations: string[];
        overallTrend: 'improving' | 'declining' | 'stable';
    };
    confidence: number;
}
export interface Risk {
    id: string;
    type: string;
    description: string;
    probability: number;
    impact: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
    mitigation: string[];
}
export interface MitigationStrategy {
    riskId: string;
    strategy: string;
    cost: number;
    effectiveness: number;
    timeframe: string;
}
export interface ContingencyPlan {
    trigger: string;
    response: string;
    resources: string[];
    timeline: string;
}
export interface OptimizationTimeline {
    phases: OptimizationPhase[];
    totalDuration: string;
    milestones: Milestone[];
    dependencies: Dependency[];
}
export interface OptimizationPhase {
    name: string;
    description: string;
    duration: string;
    activities: Activity[];
    deliverables: string[];
    resources: string[];
}
export interface Milestone {
    name: string;
    date: Date;
    description: string;
    criteria: string[];
    dependencies: string[];
}
export interface Dependency {
    id: string;
    description: string;
    type: 'internal' | 'external';
    impact: 'low' | 'medium' | 'high';
}
export interface Activity {
    name: string;
    description: string;
    duration: string;
    resources: string[];
    dependencies: string[];
}
export interface AIToolAllocation {
    toolType: string;
    currentUsage: number;
    recommendedUsage: number;
    cost: number;
    efficiency: number;
    utilization: number;
}
export interface EfficiencyGain {
    area: string;
    currentEfficiency: number;
    projectedEfficiency: number;
    gainPercentage: number;
    source: string;
}
export interface CostOptimization {
    category: string;
    currentCost: number;
    optimizedCost: number;
    savings: number;
    implementation: string[];
}
export interface OptimizationMethodology {
    approach: string;
    algorithms: string[];
    dataSourced: string[];
    assumptions: string[];
    limitations: string[];
    validation: ValidationMethodology;
}
export interface ValidationMethodology {
    method: string;
    criteria: string[];
    metrics: string[];
    baseline: Record<string, number>;
}
export interface OptimizationResults {
    measuredAt: Date;
    savings: number;
    efficiencyGains: Record<string, number>;
    userSatisfaction: number;
    unexpectedBenefits: string[];
    lessonsLearned: string[];
}
export interface ScalingPolicy {
    type: 'automatic' | 'manual' | 'scheduled';
    triggers: ScalingTrigger[];
    limits: ScalingLimits;
    strategy: string;
}
export interface ScalingTrigger {
    metric: string;
    threshold: number;
    action: 'scale_up' | 'scale_down';
    cooldown: number;
}
export interface ScalingLimits {
    minInstances: number;
    maxInstances: number;
    maxCost: number;
    maxLatency: number;
}
export interface ModelMonitoring {
    metrics: MonitoringMetric[];
    alerts: MonitoringAlert[];
    dashboards: string[];
    reportingFrequency: string;
}
export interface MonitoringMetric {
    name: string;
    type: string;
    threshold: number;
    aggregation: string;
    unit: string;
}
export interface MonitoringAlert {
    name: string;
    condition: string;
    severity: 'info' | 'warning' | 'error' | 'critical';
    channels: string[];
    escalation: EscalationPolicy;
}
export interface EscalationPolicy {
    levels: EscalationLevel[];
    timeout: number;
    finalAction: string;
}
export interface EscalationLevel {
    level: number;
    delay: number;
    channels: string[];
    actions: string[];
}
export interface CommunityStructure {
    id: string;
    name: string;
    nodes: string[];
    density: number;
    modularity: number;
    topics: string[];
}
export interface GraphRecommendation {
    type: 'connection' | 'cluster' | 'centrality' | 'path';
    description: string;
    benefit: string;
    effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high';
}
export interface Outcome {
    metric: string;
    before: number;
    after: number;
    improvement: number;
    unit: string;
    significance: number;
}
export interface SuccessMetrics {
    roi: number;
    timeToValue: number;
    adoptionRate: number;
    satisfactionScore: number;
    sustainabilityIndex: number;
}
export interface ActionStep {
    step: number;
    description: string;
    duration: string;
    prerequisites: string[];
    deliverables: string[];
    risks: string[];
}
export type AutonomousCapabilityType = 'self_analysis' | 'self_improvement' | 'architecture_design' | 'meta_programming' | 'advanced_reasoning' | 'autonomous_testing' | 'code_evolution' | 'pattern_generation' | 'workflow_creation' | 'agent_generation';
export type EvolutionStrategy = 'genetic_algorithm' | 'reinforcement_learning' | 'gradient_descent' | 'bayesian_optimization' | 'evolutionary_strategy' | 'neural_architecture_search';
export type ReasoningPattern = 'chain_of_thought' | 'tree_of_thought' | 'graph_reasoning' | 'causal_inference' | 'abductive_reasoning' | 'inductive_reasoning' | 'deductive_reasoning';
export interface AutonomousAgentEvolution {
    agentId: string;
    currentCapabilities: AgentCapabilityProfile;
    evolutionHistory: EvolutionEvent[];
    performanceMetrics: AgentPerformanceMetrics;
    improvementOpportunities: ImprovementOpportunity[];
    evolutionPlan: EvolutionPlan;
    constraints: EvolutionConstraint[];
    safetyMechanisms: SafetyMechanism[];
    validationResults: EvolutionValidation[];
}
export interface AgentCapabilityProfile {
    coreCapabilities: CoreCapability[];
    specializations: SpecializationCapability[];
    emergentCapabilities: EmergentCapability[];
    performanceCharacteristics: PerformanceCharacteristic[];
    learningPatterns: LearningPattern[];
    adaptationMechanisms: AdaptationMechanism[];
    knowledgeDomains: KnowledgeDomain[];
}
export interface CoreCapability {
    id: string;
    name: string;
    type: AutonomousCapabilityType;
    version: string;
    description: string;
    proficiencyLevel: number;
    reliability: number;
    efficiency: number;
    adaptability: number;
    dependencies: string[];
    prerequisites: string[];
    outputs: CapabilityOutput[];
    metadata: CapabilityMetadata;
}
export interface SpecializationCapability {
    domain: string;
    expertise_level: 'novice' | 'intermediate' | 'advanced' | 'expert' | 'master';
    specific_skills: SpecificSkill[];
    knowledge_depth: number;
    application_breadth: number;
    innovation_potential: number;
}
export interface EmergentCapability {
    id: string;
    emergence_context: string;
    capability_description: string;
    emergence_conditions: string[];
    stability: number;
    utility: number;
    replicability: number;
    validation_status: 'discovered' | 'validated' | 'integrated' | 'deprecated';
}
export interface PerformanceCharacteristic {
    metric: string;
    current_value: number;
    target_value: number;
    trend: 'improving' | 'stable' | 'declining';
    benchmark: number;
    factors: PerformanceFactor[];
}
export interface LearningPattern {
    pattern_type: 'supervised' | 'unsupervised' | 'reinforcement' | 'transfer' | 'meta_learning';
    effectiveness: number;
    context: string[];
    adaptation_rate: number;
    retention_rate: number;
    generalization_ability: number;
}
export interface AdaptationMechanism {
    mechanism: string;
    triggers: string[];
    adaptation_speed: 'slow' | 'medium' | 'fast' | 'real_time';
    scope: 'local' | 'domain' | 'global';
    stability: number;
    reversibility: boolean;
}
export interface KnowledgeDomain {
    domain: string;
    depth: number;
    breadth: number;
    currency: number;
    accuracy: number;
    sources: string[];
    last_updated: Date;
}
export interface EvolutionEvent {
    id: string;
    timestamp: Date;
    event_type: 'capability_enhancement' | 'knowledge_acquisition' | 'performance_optimization' | 'adaptation' | 'specialization';
    description: string;
    trigger: EvolutionTrigger;
    changes: EvolutionChange[];
    outcomes: EvolutionOutcome[];
    validation: EvolutionValidation;
    rollback_available: boolean;
}
export interface EvolutionTrigger {
    trigger_type: 'performance_threshold' | 'user_feedback' | 'environmental_change' | 'opportunity_detection' | 'scheduled_improvement';
    trigger_data: Record<string, any>;
    confidence: number;
    urgency: 'low' | 'medium' | 'high' | 'critical';
}
export interface EvolutionChange {
    component: string;
    change_type: 'addition' | 'modification' | 'removal' | 'optimization';
    before_state: any;
    after_state: any;
    impact_assessment: ImpactAssessment;
    reversibility: boolean;
}
export interface EvolutionOutcome {
    metric: string;
    before_value: number;
    after_value: number;
    improvement: number;
    confidence: number;
    validation_method: string;
    sustainability: number;
}
export interface ImprovementOpportunity {
    id: string;
    type: 'performance' | 'capability' | 'efficiency' | 'quality' | 'innovation';
    description: string;
    current_state: string;
    target_state: string;
    potential_impact: ImpactAssessment;
    implementation_strategy: ImplementationStrategy;
    resources_required: ResourceRequirement[];
    risks: EvolutionRisk[];
    timeline: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    dependencies: string[];
}
export interface SuccessCriterion {
    criterion: string;
    metric: string;
    target_value: number;
    measurement_method: string;
    priority: 'low' | 'medium' | 'high';
}
export interface EvolutionPlan {
    id: string;
    objectives: EvolutionObjective[];
    strategies: EvolutionStrategy[];
    phases: EvolutionPhase[];
    timeline: EvolutionTimeline;
    resources: EvolutionResource[];
    risks: EvolutionRisk[];
    success_criteria: SuccessCriterion[];
    monitoring_plan: MonitoringPlan;
}
export interface EvolutionObjective {
    objective: string;
    target_metric: string;
    current_value: number;
    target_value: number;
    deadline: Date;
    priority: 'low' | 'medium' | 'high' | 'critical';
    dependencies: string[];
}
export interface EvolutionPhase {
    phase: string;
    description: string;
    duration: string;
    objectives: string[];
    activities: EvolutionActivity[];
    deliverables: string[];
    success_criteria: string[];
    risks: string[];
}
export interface EvolutionActivity {
    activity: string;
    description: string;
    type: 'analysis' | 'design' | 'implementation' | 'testing' | 'validation' | 'deployment';
    duration: string;
    resources: string[];
    prerequisites: string[];
    outputs: string[];
}
export interface EvolutionTimeline {
    start_date: Date;
    end_date: Date;
    milestones: EvolutionMilestone[];
    critical_path: string[];
    dependencies: EvolutionDependency[];
}
export interface EvolutionMilestone {
    name: string;
    date: Date;
    description: string;
    deliverables: string[];
    success_criteria: string[];
    validation_method: string;
}
export interface EvolutionDependency {
    id: string;
    dependency_type: 'internal' | 'external' | 'technical' | 'resource';
    description: string;
    impact: 'low' | 'medium' | 'high' | 'critical';
    mitigation: string[];
}
export interface EvolutionResource {
    resource_type: 'computational' | 'data' | 'knowledge' | 'time' | 'external_service';
    description: string;
    quantity: number;
    availability: 'available' | 'limited' | 'unavailable';
    cost: number;
    alternatives: string[];
}
export interface EvolutionConstraint {
    constraint_type: 'safety' | 'performance' | 'resource' | 'ethical' | 'regulatory';
    description: string;
    enforcement: 'strict' | 'flexible' | 'advisory';
    monitoring: boolean;
    exceptions: ConstraintException[];
}
export interface ConstraintException {
    condition: string;
    justification: string;
    approver: string;
    expiration: Date;
    monitoring_required: boolean;
}
export interface SafetyMechanism {
    mechanism_type: 'validation' | 'monitoring' | 'rollback' | 'circuit_breaker' | 'sandbox';
    description: string;
    triggers: string[];
    actions: SafetyAction[];
    effectiveness: number;
    test_frequency: string;
}
export interface SafetyAction {
    action: string;
    conditions: string[];
    parameters: Record<string, any>;
    automatic: boolean;
    fallback: string[];
}
export interface EvolutionValidation {
    validation_type: 'functional' | 'performance' | 'safety' | 'integration' | 'regression';
    method: string;
    criteria: ValidationCriterion[];
    results: ValidationResult[];
    confidence: number;
    timestamp: Date;
}
export interface ValidationCriterion {
    criterion: string;
    metric: string;
    threshold: number;
    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'between';
    critical: boolean;
}
export interface EvolutionRisk {
    risk_type: 'technical' | 'operational' | 'security' | 'performance' | 'ethical';
    description: string;
    probability: number;
    impact: 'low' | 'medium' | 'high' | 'critical';
    mitigation: RiskMitigation[];
    contingency: ContingencyPlan[];
    monitoring: RiskMonitoring;
}
export interface RiskMitigation {
    strategy: string;
    effectiveness: number;
    cost: number;
    implementation_time: string;
    prerequisites: string[];
}
export interface RiskIndicator {
    name: string;
    metric: string;
    threshold: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
    trend: 'increasing' | 'decreasing' | 'stable';
}
export interface RiskMonitoring {
    indicators: RiskIndicator[];
    frequency: string;
    escalation: EscalationProcedure;
    automated: boolean;
}
export interface EscalationProcedure {
    levels: EscalationLevel[];
    timeout: number;
    final_action: string;
}
export interface ArchitectureAlternative {
    name: string;
    description: string;
    pros: string[];
    cons: string[];
    complexity: 'low' | 'medium' | 'high';
    cost: number;
    timeline: string;
    risks: string[];
}
export interface ArchitectureEvaluation {
    criteria: string[];
    scores: Record<string, number>;
    recommendation: string;
    rationale: string;
}
export interface ArchitectureImplementationPlan {
    phases: string[];
    timeline: string;
    resources: string[];
    dependencies: string[];
    milestones: string[];
}
export interface ArchitectureValidation {
    tests: string[];
    metrics: string[];
    criteria: string[];
    status: 'pending' | 'in_progress' | 'completed' | 'failed';
}
export interface AutonomousArchitectureDesign {
    designId: string;
    projectContext: ProjectContext;
    requirements: ArchitecturalRequirement[];
    constraints: ArchitecturalConstraint[];
    designProcess: DesignProcess;
    architecture: SystemArchitecture;
    alternatives: ArchitectureAlternative[];
    evaluation: ArchitectureEvaluation;
    implementation_plan: ArchitectureImplementationPlan;
    validation: ArchitectureValidation;
}
export interface ArchitecturalRequirement {
    id: string;
    type: 'functional' | 'non_functional' | 'quality' | 'constraint' | 'business';
    description: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    source: string;
    acceptance_criteria: AcceptanceCriterion[];
    dependencies: string[];
    conflicts: RequirementConflict[];
}
export interface AcceptanceCriterion {
    criterion: string;
    measurable: boolean;
    measurement_method: string;
    target_value: any;
    validation_method: string;
}
export interface RequirementConflict {
    conflicting_requirement: string;
    conflict_type: 'incompatible' | 'trade_off' | 'resource_contention';
    resolution_strategy: string;
    impact: string;
}
export interface ArchitecturalConstraint {
    constraint_type: 'technical' | 'business' | 'regulatory' | 'resource' | 'temporal';
    description: string;
    enforcement_level: 'strict' | 'flexible' | 'advisory';
    impact: ConstraintImpact;
    alternatives: ConstraintAlternative[];
}
export interface ConstraintImpact {
    affected_components: string[];
    impact_description: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    mitigation_options: string[];
}
export interface ConstraintAlternative {
    alternative: string;
    trade_offs: string[];
    feasibility: number;
    impact: string;
}
export interface DesignProcess {
    methodology: string;
    phases: DesignPhase[];
    decision_points: DecisionPoint[];
    iterations: DesignIteration[];
    reasoning_chain: ReasoningStep[];
    validation_checkpoints: ValidationCheckpoint[];
}
export interface DesignPhase {
    phase: string;
    objectives: string[];
    activities: DesignActivity[];
    outputs: DesignOutput[];
    duration: string;
    dependencies: string[];
}
export interface DesignActivity {
    activity: string;
    description: string;
    inputs: string[];
    outputs: string[];
    method: string;
    tools: string[];
    duration: string;
}
export interface DesignOutput {
    output_type: 'model' | 'diagram' | 'specification' | 'prototype' | 'analysis';
    name: string;
    description: string;
    format: string;
    validation_criteria: string[];
}
export interface DecisionPoint {
    decision: string;
    alternatives: DecisionAlternative[];
    criteria: DecisionCriterion[];
    selected_alternative: string;
    rationale: string;
    confidence: number;
    reversibility: boolean;
}
export interface DecisionAlternative {
    alternative: string;
    description: string;
    pros: string[];
    cons: string[];
    cost: number;
    risk: 'low' | 'medium' | 'high';
    complexity: 'low' | 'medium' | 'high';
    evaluation_score: number;
}
export interface DecisionCriterion {
    criterion: string;
    weight: number;
    measurement_method: string;
    target_value: any;
    importance: 'low' | 'medium' | 'high' | 'critical';
}
export interface DesignIteration {
    iteration: number;
    objectives: string[];
    changes: DesignChange[];
    improvements: DesignImprovement[];
    feedback_incorporated: FeedbackIncorporation[];
    validation_results: ValidationResult[];
}
export interface DesignChange {
    component: string;
    change_type: 'addition' | 'modification' | 'removal' | 'refactoring';
    reason: string;
    impact: ChangeImpact;
    validation: ChangeValidation;
}
export interface ChangeImpact {
    affected_components: string[];
    impact_type: 'functional' | 'performance' | 'security' | 'maintainability' | 'cost';
    magnitude: 'minor' | 'moderate' | 'significant' | 'major';
    risk_assessment: string;
}
export interface ChangeValidation {
    validation_method: string;
    criteria: string[];
    results: string[];
    approved: boolean;
    approver: string;
}
export interface DesignImprovement {
    improvement: string;
    benefit: string;
    implementation_effort: 'low' | 'medium' | 'high';
    priority: 'low' | 'medium' | 'high' | 'critical';
    dependencies: string[];
}
export interface FeedbackIncorporation {
    feedback_source: string;
    feedback_type: 'requirement_change' | 'constraint_update' | 'improvement_suggestion' | 'concern';
    original_feedback: string;
    interpretation: string;
    incorporation_method: string;
    design_changes: string[];
}
export interface ReasoningStep {
    step: number;
    reasoning_type: ReasoningPattern;
    input: string;
    process: string;
    output: string;
    confidence: number;
    validation: StepValidation;
    alternatives_considered: string[];
}
export interface StepValidation {
    validation_method: string;
    criteria: string[];
    result: 'valid' | 'invalid' | 'uncertain';
    confidence: number;
    issues: string[];
}
export interface ValidationCheckpoint {
    checkpoint: string;
    criteria: CheckpointCriterion[];
    validation_method: string;
    result: CheckpointResult;
    actions_required: string[];
}
export interface CheckpointCriterion {
    criterion: string;
    measurement: string;
    threshold: any;
    weight: number;
    critical: boolean;
}
export interface CheckpointResult {
    overall_result: 'pass' | 'fail' | 'conditional_pass';
    individual_results: IndividualResult[];
    overall_score: number;
    recommendations: string[];
    next_steps: string[];
}
export interface IndividualResult {
    criterion: string;
    result: 'pass' | 'fail' | 'warning';
    score: number;
    details: string;
    improvement_suggestions: string[];
}
export interface SystemArchitecture {
    architecture_style: string;
    components: ArchitecturalComponent[];
    connections: ArchitecturalConnection[];
    layers: ArchitecturalLayer[];
    patterns: ArchitecturalPattern[];
    technologies: TechnologySelection[];
    deployment: DeploymentArchitecture;
    data_architecture: DataArchitecture;
    security_architecture: SecurityArchitecture;
}
export interface DataArchitecture {
    databases: string[];
    data_flow: string[];
    storage_strategy: string;
    backup_strategy: string;
    data_governance: string[];
}
export interface SecurityArchitecture {
    authentication: string;
    authorization: string;
    encryption: string[];
    security_controls: string[];
    compliance_standards: string[];
}
export interface ArchitecturalComponent {
    id: string;
    name: string;
    type: 'service' | 'module' | 'library' | 'database' | 'interface' | 'gateway';
    description: string;
    responsibilities: string[];
    interfaces: ComponentInterface[];
    dependencies: ComponentDependency[];
    quality_attributes: QualityAttribute[];
    implementation_notes: string[];
}
export interface ComponentInterface {
    interface_name: string;
    interface_type: 'api' | 'event' | 'message' | 'data' | 'ui';
    specification: InterfaceSpecification;
    consumers: string[];
    providers: string[];
    quality_requirements: QualityRequirement[];
}
export interface InterfaceSpecification {
    protocol: string;
    format: string;
    operations: Operation[];
    data_models: DataModel[];
    error_handling: ErrorHandling;
    versioning: VersioningStrategy;
}
export interface Operation {
    name: string;
    description: string;
    inputs: Parameter[];
    outputs: Parameter[];
    preconditions: string[];
    postconditions: string[];
    side_effects: string[];
}
export interface Parameter {
    name: string;
    type: string;
    description: string;
    required: boolean;
    constraints: ParameterConstraint[];
    default_value?: any;
}
export interface ParameterConstraint {
    constraint_type: 'range' | 'format' | 'enum' | 'pattern' | 'custom';
    constraint_value: any;
    error_message: string;
}
export interface DataModel {
    name: string;
    description: string;
    fields: DataField[];
    relationships: DataRelationship[];
    constraints: DataConstraint[];
    indices: DataIndex[];
}
export interface DataField {
    name: string;
    type: string;
    description: string;
    required: boolean;
    constraints: FieldConstraint[];
    metadata: Record<string, any>;
}
export interface DataRelationship {
    relationship_type: 'one_to_one' | 'one_to_many' | 'many_to_many';
    target_entity: string;
    description: string;
    constraints: RelationshipConstraint[];
    cascading_behavior: CascadingBehavior;
}
export interface DataConstraint {
    constraint_type: 'unique' | 'foreign_key' | 'check' | 'not_null' | 'custom';
    description: string;
    enforcement_level: 'strict' | 'advisory';
    violation_handling: string;
}
export interface DataIndex {
    index_name: string;
    fields: string[];
    index_type: 'primary' | 'unique' | 'composite' | 'partial' | 'expression';
    performance_characteristics: IndexPerformance;
}
export interface ErrorHandling {
    error_categories: ErrorCategory[];
    error_responses: ErrorResponse[];
    retry_strategies: RetryStrategy[];
    fallback_mechanisms: FallbackMechanism[];
}
export interface ErrorCategory {
    category: string;
    error_codes: string[];
    description: string;
    handling_strategy: string;
    user_communication: string;
}
export interface ErrorResponse {
    error_code: string;
    http_status?: number;
    message_template: string;
    additional_data: string[];
    logging_level: 'debug' | 'info' | 'warning' | 'error' | 'critical';
}
export interface RetryStrategy {
    error_types: string[];
    max_retries: number;
    backoff_strategy: 'linear' | 'exponential' | 'constant';
    backoff_parameters: Record<string, number>;
    circuit_breaker: boolean;
}
export interface FallbackMechanism {
    trigger_conditions: string[];
    fallback_action: string;
    fallback_data_source?: string;
    graceful_degradation: boolean;
    user_notification: boolean;
}
export interface VersioningStrategy {
    versioning_scheme: 'semantic' | 'date_based' | 'sequential' | 'hash_based';
    backward_compatibility: 'strict' | 'loose' | 'breaking_allowed';
    deprecation_policy: DeprecationPolicy;
    migration_support: MigrationSupport;
}
export interface DeprecationPolicy {
    notice_period: string;
    sunset_timeline: string;
    migration_assistance: boolean;
    legacy_support_duration: string;
}
export interface MigrationSupport {
    automated_migration: boolean;
    migration_tools: string[];
    documentation: string[];
    support_channels: string[];
}
export interface ComponentDependency {
    dependency_type: 'uses' | 'implements' | 'extends' | 'configures' | 'manages';
    target_component: string;
    dependency_nature: 'compile_time' | 'runtime' | 'deployment' | 'configuration';
    coupling_strength: 'loose' | 'moderate' | 'tight';
    failure_impact: DependencyFailureImpact;
}
export interface DependencyFailureImpact {
    impact_type: 'none' | 'degraded' | 'failure' | 'cascade_failure';
    mitigation_strategies: string[];
    recovery_procedures: string[];
    monitoring_requirements: string[];
}
export interface QualityAttribute {
    id: string;
    name?: string;
    description?: string;
    category?: string;
    measurableCharacteristics?: string[];
    scenarios?: string[];
    tradeoffs?: string[];
    measurementMethods?: string[];
    attribute: 'performance' | 'security' | 'reliability' | 'scalability' | 'maintainability' | 'usability';
    requirements: QualityRequirement[];
    measurement_methods: MeasurementMethod[];
    target_values: QualityTarget[];
    monitoring: QualityMonitoring;
}
export interface QualityRequirement {
    requirement: string;
    measurable: boolean;
    target_value: any;
    acceptable_range: QualityRange;
    priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface QualityRange {
    min_acceptable: any;
    target: any;
    max_acceptable: any;
    optimal?: any;
}
export interface MeasurementMethod {
    method: string;
    tools: string[];
    frequency: string;
    automation_level: 'manual' | 'semi_automated' | 'fully_automated';
    accuracy: number;
}
export interface QualityTarget {
    metric: string;
    target_value: any;
    measurement_unit: string;
    achievement_timeline: string;
    dependencies: string[];
}
export interface QualityMonitoring {
    monitoring_strategy: string;
    key_indicators: QualityIndicator[];
    alerting_thresholds: AlertingThreshold[];
    reporting_frequency: string;
    dashboard_requirements: string[];
}
export interface QualityIndicator {
    indicator: string;
    measurement: string;
    normal_range: QualityRange;
    trend_analysis: boolean;
    correlation_factors: string[];
}
export interface AlertingThreshold {
    threshold_type: 'warning' | 'critical' | 'emergency';
    condition: string;
    threshold_value: any;
    escalation_procedure: string[];
    auto_remediation: boolean;
}
export interface CapabilityOutput {
    output_type: string;
    format: string;
    schema: Record<string, any>;
    quality_metrics: string[];
}
export interface CapabilityMetadata {
    created_date: Date;
    last_updated: Date;
    usage_count: number;
    success_rate: number;
    user_feedback: UserFeedback[];
    optimization_history: OptimizationRecord[];
}
export interface UserFeedback {
    feedback_id: string;
    user_id: string;
    rating: number;
    comments: string;
    suggestions: string[];
    timestamp: Date;
}
export interface OptimizationRecord {
    optimization_date: Date;
    optimization_type: string;
    before_metrics: Record<string, number>;
    after_metrics: Record<string, number>;
    improvement: number;
    method: string;
}
export interface SpecificSkill {
    skill: string;
    proficiency: number;
    last_used: Date;
    frequency: number;
    improvement_trend: 'improving' | 'stable' | 'declining';
}
export interface PerformanceFactor {
    factor: string;
    contribution: number;
    controllable: boolean;
    optimization_potential: number;
}
export interface ImpactAssessment {
    scope: 'component' | 'system' | 'organization' | 'ecosystem';
    magnitude: 'minor' | 'moderate' | 'significant' | 'transformational';
    time_horizon: string;
    affected_stakeholders: string[];
    risk_level: 'low' | 'medium' | 'high' | 'critical';
    mitigation_strategies: string[];
}
export interface ImplementationStrategy {
    approach: string;
    phases: ImplementationPhase[];
    resources: ResourceRequirement[];
    timeline: string;
    success_criteria: string[];
    risk_mitigation: string[];
}
export interface ImplementationPhase {
    phase: string;
    description: string;
    duration: string;
    activities: string[];
    deliverables: string[];
    dependencies: string[];
    success_criteria: string[];
}
export interface ResourceRequirement {
    resource_type: 'human' | 'computational' | 'financial' | 'technical' | 'time';
    description: string;
    quantity: number;
    unit: string;
    availability_requirements: string;
    alternatives: string[];
}
export interface MonitoringPlan {
    monitoring_objectives: string[];
    key_metrics: MonitoringMetric[];
    data_collection: DataCollection;
    analysis_methods: AnalysisMethod[];
    reporting: MonitoringReporting;
    alerting: MonitoringAlerting;
}
export interface MonitoringMetric {
    metric_name: string;
    description: string;
    measurement_method: string;
    frequency: string;
    threshold_values: ThresholdValue[];
    trend_analysis: boolean;
}
export interface ThresholdValue {
    threshold_type: 'warning' | 'critical' | 'target';
    value: number;
    action_required: string[];
    escalation: boolean;
}
export interface DataCollection {
    collection_methods: string[];
    data_sources: string[];
    collection_frequency: string;
    data_quality_requirements: string[];
    storage_requirements: string[];
}
export interface AnalysisMethod {
    method: string;
    purpose: string;
    frequency: string;
    tools: string[];
    output_format: string;
}
export interface MonitoringReporting {
    report_types: string[];
    audiences: string[];
    frequency: string;
    delivery_methods: string[];
    customization_options: string[];
}
export interface EscalationRule {
    condition: string;
    level: number;
    delay: number;
    actions: string[];
}
export interface SuppressionRule {
    condition: string;
    duration: number;
    scope: string;
    reason: string;
}
export interface MonitoringAlerting {
    alert_channels: string[];
    escalation_rules: EscalationRule[];
    suppression_rules: SuppressionRule[];
    notification_preferences: NotificationPreference[];
}
export interface NotificationPreference {
    user_id: string;
    channels: string[];
    severity_filter: string[];
    time_restrictions: TimeRestriction[];
    grouping_preferences: GroupingPreference[];
}
export interface TimeRestriction {
    start_time: string;
    end_time: string;
    days_of_week: string[];
    timezone: string;
}
export interface GroupingPreference {
    grouping_criteria: string;
    max_group_size: number;
    grouping_window: string;
    summary_format: string;
}
export interface FieldConstraint {
    constraint_type: 'length' | 'format' | 'range' | 'enum' | 'pattern';
    constraint_value: any;
    error_message: string;
}
export interface RelationshipConstraint {
    constraint_type: 'cardinality' | 'integrity' | 'business_rule';
    description: string;
    enforcement: 'strict' | 'advisory';
}
export interface CascadingBehavior {
    on_delete: 'cascade' | 'restrict' | 'set_null' | 'set_default';
    on_update: 'cascade' | 'restrict' | 'set_null' | 'set_default';
    business_rules: string[];
}
export interface IndexPerformance {
    query_performance_improvement: number;
    storage_overhead: number;
    maintenance_cost: string;
    usage_patterns: string[];
}
export interface ArchitecturalConnection {
    connection_id: string;
    source_component: string;
    target_component: string;
    connection_type: 'synchronous' | 'asynchronous' | 'event_driven' | 'data_flow';
    protocol: string;
    quality_of_service: QualityOfService;
    security_requirements: SecurityRequirement[];
    monitoring_requirements: ConnectionMonitoring;
}
export interface QualityOfService {
    reliability: number;
    latency_requirements: LatencyRequirement;
    throughput_requirements: ThroughputRequirement;
    availability_requirements: AvailabilityRequirement;
}
export interface LatencyRequirement {
    max_latency: number;
    average_latency_target: number;
    percentile_requirements: PercentileRequirement[];
    timeout_settings: TimeoutSetting[];
}
export interface PercentileRequirement {
    percentile: number;
    max_latency: number;
    measurement_window: string;
}
export interface TimeoutSetting {
    timeout_type: 'connection' | 'read' | 'total';
    timeout_value: number;
    retry_policy: string;
}
export interface ThroughputRequirement {
    min_throughput: number;
    target_throughput: number;
    peak_throughput: number;
    scaling_strategy: string;
}
export interface AvailabilityRequirement {
    target_availability: number;
    measurement_period: string;
    downtime_tolerance: string;
    recovery_requirements: RecoveryRequirement;
}
export interface RecoveryRequirement {
    recovery_time_objective: string;
    recovery_point_objective: string;
    backup_strategy: string;
    disaster_recovery: string;
}
export interface SecurityRequirement {
    requirement_type: 'authentication' | 'authorization' | 'encryption' | 'audit' | 'privacy';
    description: string;
    implementation_guidance: string[];
    compliance_standards: string[];
    validation_methods: string[];
}
export interface ConnectionMonitoring {
    metrics_to_monitor: string[];
    monitoring_frequency: string;
    alert_conditions: AlertCondition[];
    logging_requirements: LoggingRequirement[];
}
export interface AlertCondition {
    condition: string;
    threshold: any;
    severity: 'info' | 'warning' | 'error' | 'critical';
    response_action: string[];
}
export interface LoggingRequirement {
    log_level: 'debug' | 'info' | 'warning' | 'error' | 'critical';
    log_format: string;
    retention_period: string;
    sensitive_data_handling: string;
}
export interface ArchitecturalLayer {
    layer_name: string;
    layer_type: 'presentation' | 'business' | 'data' | 'infrastructure' | 'cross_cutting';
    description: string;
    components: string[];
    responsibilities: string[];
    interfaces: LayerInterface[];
    dependencies: LayerDependency[];
    constraints: LayerConstraint[];
}
export interface LayerInterface {
    interface_name: string;
    exposed_operations: string[];
    access_patterns: string[];
    performance_characteristics: LayerPerformance;
}
export interface LayerPerformance {
    expected_latency: string;
    throughput_capacity: string;
    scalability_limits: string;
    resource_requirements: string[];
}
export interface LayerDependency {
    dependent_layer: string;
    dependency_type: 'uses' | 'extends' | 'configures';
    coupling_level: 'loose' | 'moderate' | 'tight';
    interaction_patterns: string[];
}
export interface LayerConstraint {
    constraint: string;
    enforcement_mechanism: string;
    violation_handling: string;
    exceptions: string[];
}
export interface ArchitecturalPattern {
    id: string;
    name?: string;
    category?: string;
    qualityAttributes?: Record<string, number>;
    benefits?: string[];
    drawbacks?: string[];
    applicableContexts?: string[];
    implementationComplexity?: string;
    maturityLevel?: string;
    pattern_name: string;
    pattern_type: 'structural' | 'behavioral' | 'creational' | 'architectural' | 'integration';
    description: string;
    application_context: string[];
    implementation_guidance: PatternImplementation;
    trade_offs: string[];
    alternatives: PatternAlternative[];
}
export interface PatternImplementation {
    implementation_steps: string[];
    code_examples: PatternCodeExample[];
    configuration_requirements: string[];
    testing_strategies: string[];
    monitoring_considerations: string[];
}
export interface PatternCodeExample {
    language: string;
    framework: string;
    code_snippet: string;
    explanation: string;
    best_practices: string[];
}
export interface PatternAlternative {
    alternative_pattern: string;
    comparison: string;
    selection_criteria: string[];
    migration_path: string;
}
export interface TechnologySelection {
    technology_category: 'programming_language' | 'framework' | 'database' | 'middleware' | 'infrastructure';
    selected_technology: string;
    version: string;
    justification: TechnologyJustification;
    alternatives_considered: TechnologyAlternative[];
    integration_requirements: IntegrationRequirement[];
    lifecycle_considerations: LifecycleConsideration[];
}
export interface TechnologyJustification {
    selection_criteria: SelectionCriterion[];
    evaluation_results: EvaluationResult[];
    decision_rationale: string;
    risk_assessment: TechnologyRisk[];
}
export interface SelectionCriterion {
    criterion: string;
    weight: number;
    measurement_method: string;
    target_score: number;
}
export interface EvaluationResult {
    technology: string;
    criterion_scores: Record<string, number>;
    overall_score: number;
    pros: string[];
    cons: string[];
    recommendation: string;
}
export interface TechnologyRisk {
    risk_type: 'technical' | 'vendor' | 'security' | 'performance' | 'lifecycle';
    description: string;
    probability: number;
    impact: 'low' | 'medium' | 'high' | 'critical';
    mitigation_strategies: string[];
}
export interface TechnologyAlternative {
    technology: string;
    comparison_summary: string;
    pros: string[];
    cons: string[];
    migration_effort: 'low' | 'medium' | 'high';
}
export interface IntegrationRequirement {
    integration_point: string;
    integration_type: 'api' | 'data' | 'event' | 'ui' | 'batch';
    requirements: string[];
    complexity: 'low' | 'medium' | 'high';
}
export interface LifecycleConsideration {
    lifecycle_phase: 'development' | 'testing' | 'deployment' | 'maintenance' | 'retirement';
    considerations: string[];
    support_requirements: string[];
    cost_implications: string;
}
export interface DeploymentArchitecture {
    deployment_model: 'on_premise' | 'cloud' | 'hybrid' | 'edge';
    infrastructure_components: InfrastructureComponent[];
    deployment_environments: DeploymentEnvironment[];
    scaling_strategy: ScalingStrategy;
    disaster_recovery: DisasterRecoveryPlan;
    monitoring_and_observability: ObservabilityStrategy;
}
export interface InfrastructureComponent {
    component_type: 'compute' | 'storage' | 'network' | 'security' | 'monitoring';
    name: string;
    specifications: ComponentSpecification[];
    redundancy: RedundancyConfiguration;
    monitoring: ComponentMonitoring;
}
export interface ComponentSpecification {
    specification_type: 'performance' | 'capacity' | 'security' | 'availability';
    value: string;
    justification: string;
    alternatives: string[];
}
export interface RedundancyConfiguration {
    redundancy_level: 'none' | 'basic' | 'high' | 'fault_tolerant';
    backup_strategy: string;
    failover_mechanism: string;
    recovery_procedures: string[];
}
export interface ComponentMonitoring {
    monitoring_metrics: string[];
    alerting_rules: string[];
    log_aggregation: string;
    health_checks: HealthCheck[];
}
export interface HealthCheck {
    check_name: string;
    check_type: 'liveness' | 'readiness' | 'startup';
    endpoint: string;
    frequency: string;
    timeout: string;
    failure_threshold: number;
}
export interface DeploymentEnvironment {
    environment_name: string;
    environment_type: 'development' | 'testing' | 'staging' | 'production';
    configuration: EnvironmentConfiguration;
    deployment_pipeline: DeploymentPipeline;
    access_controls: AccessControl[];
}
export interface EnvironmentConfiguration {
    resource_allocation: ResourceAllocation;
    environment_variables: EnvironmentVariable[];
    secrets_management: SecretsManagement;
    networking: NetworkConfiguration;
}
export interface EnvironmentVariable {
    name: string;
    value_source: 'static' | 'config_map' | 'secret' | 'computed';
    description: string;
    required: boolean;
}
export interface SecretsManagement {
    secrets_provider: string;
    encryption_at_rest: boolean;
    encryption_in_transit: boolean;
    rotation_policy: RotationPolicy;
    access_controls: string[];
}
export interface RotationPolicy {
    rotation_frequency: string;
    automated_rotation: boolean;
    notification_strategy: string;
    rollback_procedure: string;
}
export interface NetworkConfiguration {
    network_topology: string;
    security_groups: SecurityGroup[];
    load_balancing: LoadBalancingConfiguration;
    service_discovery: ServiceDiscoveryConfiguration;
}
export interface SecurityGroup {
    group_name: string;
    ingress_rules: NetworkRule[];
    egress_rules: NetworkRule[];
    associated_components: string[];
}
export interface NetworkRule {
    protocol: string;
    port_range: string;
    source_destination: string;
    description: string;
}
export interface LoadBalancingConfiguration {
    load_balancer_type: 'application' | 'network' | 'gateway';
    algorithm: 'round_robin' | 'least_connections' | 'ip_hash' | 'weighted';
    health_check_configuration: HealthCheckConfiguration;
    ssl_termination: SSLConfiguration;
}
export interface HealthCheckConfiguration {
    protocol: string;
    path: string;
    interval: string;
    timeout: string;
    healthy_threshold: number;
    unhealthy_threshold: number;
}
export interface SSLConfiguration {
    ssl_termination: boolean;
    certificate_source: string;
    tls_version: string;
    cipher_suites: string[];
}
export interface ServiceDiscoveryConfiguration {
    discovery_method: 'dns' | 'service_registry' | 'load_balancer';
    service_registry: string;
    health_check_integration: boolean;
    auto_registration: boolean;
}
export interface DeploymentPipeline {
    pipeline_stages: PipelineStage[];
    triggers: PipelineTrigger[];
    approval_gates: ApprovalGate[];
    rollback_strategy: RollbackStrategy;
}
export interface PipelineStage {
    stage_name: string;
    stage_type: 'build' | 'test' | 'security_scan' | 'deploy' | 'verification';
    actions: PipelineAction[];
    success_criteria: string[];
    failure_handling: FailureHandling;
}
export interface PipelineAction {
    action_name: string;
    action_type: string;
    parameters: Record<string, any>;
    timeout: string;
    retry_policy: RetryPolicy;
}
export interface RetryPolicy {
    max_attempts: number;
    backoff_strategy: string;
    retry_conditions: string[];
}
export interface FailureHandling {
    failure_action: 'stop' | 'continue' | 'rollback' | 'notify';
    notification_channels: string[];
    escalation_procedures: string[];
}
export interface PipelineTrigger {
    trigger_type: 'manual' | 'webhook' | 'schedule' | 'event';
    trigger_configuration: Record<string, any>;
    conditions: TriggerCondition[];
}
export interface TriggerCondition {
    condition_type: 'branch' | 'tag' | 'file_change' | 'time' | 'approval';
    condition_value: string;
    condition_operator: string;
}
export interface ApprovalGate {
    gate_name: string;
    required_approvers: string[];
    approval_criteria: string[];
    timeout: string;
    escalation: string[];
}
export interface RollbackStrategy {
    rollback_triggers: string[];
    rollback_method: 'blue_green' | 'canary' | 'rolling' | 'recreate';
    rollback_validation: string[];
    data_migration_handling: string;
}
export interface AccessControl {
    principal_type: 'user' | 'group' | 'service_account' | 'role';
    principal_id: string;
    permissions: Permission[];
    conditions: AccessCondition[];
}
export interface Permission {
    resource: string;
    actions: string[];
    effect: 'allow' | 'deny';
    constraints: PermissionConstraint[];
}
export interface PermissionConstraint {
    constraint_type: 'time' | 'location' | 'mfa' | 'request_context';
    constraint_value: any;
    enforcement: 'strict' | 'advisory';
}
export interface AccessCondition {
    condition: string;
    values: any[];
    operator: 'equals' | 'not_equals' | 'in' | 'not_in' | 'matches';
}
export interface ScalingStrategy {
    scaling_type: 'horizontal' | 'vertical' | 'hybrid';
    auto_scaling: AutoScalingConfiguration;
    manual_scaling: ManualScalingConfiguration;
    scaling_policies: ScalingPolicy[];
}
export interface AutoScalingConfiguration {
    enabled: boolean;
    scaling_metrics: ScalingMetric[];
    scaling_targets: ScalingTarget[];
    scaling_cooldown: ScalingCooldown;
}
export interface ScalingMetric {
    metric_name: string;
    metric_source: string;
    aggregation_method: string;
    scaling_factor: number;
}
export interface ScalingTarget {
    target_type: 'utilization' | 'queue_length' | 'response_time' | 'custom';
    target_value: number;
    tolerance: number;
}
export interface ScalingCooldown {
    scale_up_cooldown: string;
    scale_down_cooldown: string;
    stabilization_window: string;
}
export interface ManualScalingConfiguration {
    scaling_procedures: ScalingProcedure[];
    approval_requirements: string[];
    validation_steps: string[];
    rollback_procedures: string[];
}
export interface ScalingProcedure {
    procedure_name: string;
    scaling_direction: 'up' | 'down';
    steps: ProcedureStep[];
    validation_criteria: string[];
}
export interface ProcedureStep {
    step_name: string;
    description: string;
    commands: string[];
    validation: string[];
    rollback: string[];
}
export interface DisasterRecoveryPlan {
    recovery_objectives: RecoveryObjective[];
    backup_strategy: BackupStrategy;
    recovery_procedures: RecoveryProcedure[];
    testing_schedule: TestingSchedule;
    communication_plan: CommunicationPlan;
}
export interface RecoveryObjective {
    objective_type: 'rto' | 'rpo' | 'rco' | 'rmo';
    target_value: string;
    measurement_method: string;
    criticality: 'low' | 'medium' | 'high' | 'critical';
}
export interface BackupStrategy {
    backup_frequency: string;
    backup_retention: string;
    backup_locations: BackupLocation[];
    backup_verification: BackupVerification;
}
export interface BackupLocation {
    location_type: 'local' | 'remote' | 'cloud' | 'offsite';
    location_details: string;
    encryption: boolean;
    access_controls: string[];
}
export interface BackupVerification {
    verification_frequency: string;
    verification_method: string;
    success_criteria: string[];
    failure_procedures: string[];
}
export interface RecoveryProcedure {
    scenario: string;
    recovery_steps: RecoveryStep[];
    estimated_recovery_time: string;
    resources_required: string[];
    dependencies: string[];
}
export interface RecoveryStep {
    step_name: string;
    description: string;
    responsible_party: string;
    estimated_duration: string;
    success_criteria: string[];
    rollback_option: boolean;
}
export interface TestingSchedule {
    test_frequency: string;
    test_types: DisasterRecoveryTest[];
    test_environments: string[];
    success_criteria: string[];
}
export interface DisasterRecoveryTest {
    test_name: string;
    test_type: 'tabletop' | 'walkthrough' | 'simulation' | 'full_test';
    scope: string[];
    duration: string;
    participants: string[];
}
export interface CommunicationPlan {
    stakeholders: Stakeholder[];
    communication_channels: CommunicationChannel[];
    escalation_procedures: string[];
    status_update_frequency: string;
}
export interface Stakeholder {
    stakeholder_type: 'internal' | 'external' | 'customer' | 'vendor' | 'regulator';
    contact_information: ContactInformation;
    notification_preferences: NotificationPreference[];
    escalation_level: number;
}
export interface ContactInformation {
    primary_contact: string;
    backup_contacts: string[];
    contact_methods: ContactMethod[];
    availability: AvailabilityWindow[];
}
export interface ContactMethod {
    method: 'email' | 'phone' | 'sms' | 'slack' | 'teams' | 'pager';
    contact_details: string;
    priority: number;
}
export interface AvailabilityWindow {
    start_time: string;
    end_time: string;
    days_of_week: string[];
    timezone: string;
}
export interface CommunicationChannel {
    id: string;
    sourceToolId: string;
    targetToolId: string;
    protocol?: CommunicationProtocol;
    adapter?: ProtocolAdapter;
    messageQueue?: MessageQueue;
    synchronizationState?: SynchronizationState;
    context?: InterToolContext;
    status?: 'active' | 'inactive' | 'error';
    establishedAt?: Date;
    lastActivity?: Date;
    messageCount?: number;
    errorCount?: number;
    channel_name: string;
    channel_type: 'broadcast' | 'targeted' | 'escalation';
    audience: string[];
    message_templates: MessageTemplate[];
    latencyMetrics?: any;
    qualityOfService?: any;
    reliabilityMetrics?: any;
    metadata?: any;
    throughputMetrics?: {
        messagesPerSecond: number;
        bytesPerSecond: number;
        peakThroughput: number;
    };
}
export interface MessageTemplate {
    template_name: string;
    template_type: 'initial_notification' | 'status_update' | 'resolution' | 'post_mortem';
    template_content: string;
    required_fields: string[];
}
export interface ObservabilityStrategy {
    monitoring_stack: MonitoringStack;
    logging_strategy: LoggingStrategy;
    tracing_strategy: TracingStrategy;
    metrics_strategy: MetricsStrategy;
    alerting_strategy: AlertingStrategy;
}
export interface MonitoringStack {
    monitoring_tools: MonitoringTool[];
    data_collection: ObservabilityDataCollection;
    data_storage: ObservabilityDataStorage;
    visualization: ObservabilityVisualization;
}
export interface MonitoringTool {
    tool_name: string;
    tool_type: 'infrastructure' | 'application' | 'business' | 'security' | 'custom';
    configuration: ToolConfiguration;
    integration_points: string[];
}
export interface ToolConfiguration {
    deployment_method: string;
    configuration_parameters: Record<string, any>;
    resource_requirements: string[];
    high_availability: boolean;
}
export interface ObservabilityDataCollection {
    collection_methods: DataCollectionMethod[];
    sampling_strategies: SamplingStrategy[];
    data_enrichment: DataEnrichment[];
}
export interface DataCollectionMethod {
    method_name: string;
    method_type: 'push' | 'pull' | 'streaming';
    data_sources: string[];
    collection_frequency: string;
    data_format: string;
}
export interface SamplingStrategy {
    strategy_name: string;
    sampling_rate: number;
    sampling_conditions: string[];
    adaptive_sampling: boolean;
}
export interface DataEnrichment {
    enrichment_type: 'metadata' | 'context' | 'correlation' | 'classification';
    enrichment_source: string;
    enrichment_rules: string[];
}
export interface ObservabilityDataStorage {
    storage_tiers: StorageTier[];
    retention_policies: DataRetentionPolicy[];
    compression: DataCompression;
    partitioning: DataPartitioning;
}
export interface StorageTier {
    tier_name: string;
    tier_type: 'hot' | 'warm' | 'cold' | 'archive';
    storage_duration: string;
    access_pattern: string;
    cost_characteristics: string;
}
export interface DataRetentionPolicy {
    data_type: string;
    retention_period: string;
    archival_strategy: string;
    deletion_policy: string;
    compliance_requirements: string[];
}
export interface DataCompression {
    compression_algorithm: string;
    compression_ratio: number;
    performance_impact: string;
    compatibility: string[];
}
export interface DataPartitioning {
    partitioning_strategy: 'time_based' | 'hash_based' | 'range_based' | 'hybrid';
    partition_key: string;
    partition_size: string;
    partition_management: PartitionManagement;
}
export interface PartitionManagement {
    automatic_partitioning: boolean;
    partition_pruning: boolean;
    partition_maintenance: string[];
    performance_optimization: string[];
}
export interface ObservabilityVisualization {
    dashboards: ObservabilityDashboard[];
    reporting: ObservabilityReporting;
    alerting_visualization: AlertingVisualization;
}
export interface ObservabilityDashboard {
    dashboard_name: string;
    dashboard_type: 'operational' | 'business' | 'security' | 'executive' | 'troubleshooting';
    audience: string[];
    widgets: DashboardWidget[];
    refresh_rate: string;
}
export interface VisualizationOptions {
    chart_type?: string;
    color_scheme?: string;
    time_range?: string;
    aggregation?: string;
    filters?: Record<string, any>;
}
export interface ObservabilityReporting {
    report_types: ObservabilityReport[];
    distribution: ReportDistribution;
    automation: ReportAutomation;
}
export interface ObservabilityReport {
    report_name: string;
    report_type: 'sla' | 'performance' | 'capacity' | 'security' | 'cost' | 'compliance';
    content: ReportContent[];
    frequency: string;
    format: string;
}
export interface ReportContent {
    section_name: string;
    content_type: 'metrics' | 'trends' | 'analysis' | 'recommendations';
    data_sources: string[];
    visualization: boolean;
}
export interface ReportDistribution {
    distribution_methods: string[];
    recipients: ReportRecipient[];
    delivery_schedule: string;
    customization_options: string[];
}
export interface ReportRecipient {
    recipient_id: string;
    recipient_type: 'individual' | 'group' | 'role';
    delivery_preferences: DeliveryPreference[];
    content_customization: ContentCustomization[];
}
export interface DeliveryPreference {
    delivery_method: string;
    delivery_format: string;
    delivery_time: string;
    delivery_frequency: string;
}
export interface ContentCustomization {
    customization_type: 'filter' | 'aggregation' | 'format' | 'sections';
    customization_parameters: Record<string, any>;
}
export interface ReportAutomation {
    automated_generation: boolean;
    trigger_conditions: string[];
    quality_checks: string[];
    distribution_automation: boolean;
}
export interface AlertingVisualization {
    alert_dashboards: string[];
    alert_summaries: AlertSummary[];
    alert_analytics: AlertAnalytics[];
}
export interface AlertSummary {
    summary_type: 'count' | 'trend' | 'severity_distribution' | 'resolution_time';
    time_window: string;
    grouping: string[];
    visualization: string;
}
export interface AlertAnalytics {
    analytics_type: 'pattern_analysis' | 'correlation_analysis' | 'predictive_analysis';
    analysis_window: string;
    output_format: string;
    automation_level: string;
}
export interface LoggingStrategy {
    log_levels: LogLevel[];
    log_formats: LogFormat[];
    log_routing: LogRouting;
    log_processing: LogProcessing;
    log_analysis: LogAnalysis;
}
export interface LogLevelConfig {
    level_name: string;
    level_priority: number;
    use_cases: string[];
    retention_policy: string;
}
export interface LogFormat {
    format_name: string;
    format_type: 'structured' | 'unstructured' | 'semi_structured';
    schema: LogSchema;
    serialization: string;
}
export interface LogSchema {
    required_fields: LogField[];
    optional_fields: LogField[];
    custom_fields: LogField[];
    field_validation: FieldValidation[];
}
export interface LogField {
    field_name: string;
    field_type: string;
    description: string;
    constraints: FieldConstraint[];
    indexing: boolean;
}
export interface FieldValidation {
    field_name: string;
    validation_rules: ValidationRule[];
    error_handling: string;
}
export interface ValidationRule {
    rule_type: 'format' | 'range' | 'enum' | 'custom';
    rule_definition: any;
    error_message: string;
}
export interface LogRouting {
    routing_rules: LogRoutingRule[];
    default_destination: string;
    routing_performance: RoutingPerformance;
}
export interface LogRoutingRule {
    rule_name: string;
    conditions: LogCondition[];
    destinations: LogDestination[];
    transformation: LogTransformation[];
}
export interface LogCondition {
    field: string;
    operator: string;
    value: any;
    logic_operator?: 'and' | 'or' | 'not';
}
export interface LogDestination {
    destination_type: 'file' | 'database' | 'queue' | 'stream' | 'api';
    destination_config: Record<string, any>;
    buffer_config: BufferConfig;
    error_handling: DestinationErrorHandling;
}
export interface BufferConfig {
    buffer_size: number;
    flush_interval: string;
    compression: boolean;
    overflow_strategy: 'drop' | 'block' | 'expand';
}
export interface DestinationErrorHandling {
    retry_policy: RetryPolicy;
    dead_letter_queue: boolean;
    fallback_destination?: string;
    error_logging: boolean;
}
export interface LogTransformation {
    transformation_type: 'filter' | 'enrich' | 'mask' | 'aggregate' | 'format';
    transformation_config: Record<string, any>;
    performance_impact: string;
}
export interface RoutingPerformance {
    throughput_capacity: string;
    latency_characteristics: string;
    resource_utilization: string;
    scaling_behavior: string;
}
export interface LogProcessing {
    processing_pipeline: ProcessingStage[];
    real_time_processing: RealTimeProcessing;
    batch_processing: BatchProcessing;
}
export interface ProcessingStage {
    stage_name: string;
    stage_type: 'parsing' | 'enrichment' | 'filtering' | 'aggregation' | 'classification';
    processing_logic: ProcessingLogic;
    performance_requirements: StagePerformance;
}
export interface ProcessingLogic {
    algorithm: string;
    parameters: Record<string, any>;
    dependencies: string[];
    error_handling: string[];
}
export interface StagePerformance {
    throughput_requirement: string;
    latency_requirement: string;
    resource_limits: ResourceLimits;
    scaling_policy: string;
}
export interface ResourceLimits {
    cpu_limit: string;
    memory_limit: string;
    disk_limit: string;
    network_limit: string;
}
export interface RealTimeProcessing {
    stream_processing_engine: string;
    window_configurations: WindowConfiguration[];
    state_management: StateManagement;
    exactly_once_semantics: boolean;
}
export interface WindowConfiguration {
    window_type: 'tumbling' | 'sliding' | 'session' | 'global';
    window_size: string;
    window_slide?: string;
    session_timeout?: string;
}
export interface StateManagement {
    state_backend: string;
    checkpointing: CheckpointingConfig;
    state_ttl: string;
    state_migration: boolean;
}
export interface CheckpointingConfig {
    checkpoint_interval: string;
    checkpoint_timeout: string;
    checkpoint_storage: string;
    incremental_checkpoints: boolean;
}
export interface BatchProcessing {
    batch_scheduler: string;
    batch_configurations: BatchConfiguration[];
    resource_management: BatchResourceManagement;
    error_recovery: BatchErrorRecovery;
}
export interface BatchConfiguration {
    batch_name: string;
    schedule: string;
    input_sources: string[];
    output_destinations: string[];
    processing_logic: string;
}
export interface BatchResourceManagement {
    resource_allocation: string;
    priority_management: string;
    resource_sharing: boolean;
    auto_scaling: boolean;
}
export interface BatchErrorRecovery {
    retry_policy: RetryPolicy;
    checkpoint_strategy: string;
    partial_failure_handling: string;
    data_consistency_checks: string[];
}
export interface LogAnalysis {
    analysis_types: LogAnalysisType[];
    anomaly_detection: LogAnomalyDetection;
    correlation_analysis: LogCorrelationAnalysis;
    pattern_mining: LogPatternMining;
}
export interface LogAnalysisType {
    analysis_name: string;
    analysis_method: 'statistical' | 'ml' | 'rule_based' | 'hybrid';
    analysis_scope: string;
    output_format: string;
    automation_level: string;
}
export interface LogAnomalyDetection {
    detection_algorithms: AnomalyDetectionAlgorithm[];
    baseline_models: BaselineModel[];
    alert_configuration: AnomalyAlertConfiguration;
}
export interface AnomalyDetectionAlgorithm {
    algorithm_name: string;
    algorithm_type: 'statistical' | 'ml' | 'deep_learning' | 'ensemble';
    parameters: Record<string, any>;
    training_requirements: TrainingRequirements;
}
export interface TrainingRequirements {
    training_data_size: string;
    retraining_frequency: string;
    feature_engineering: boolean;
    validation_method: string;
}
export interface BaselineModel {
    model_name: string;
    model_type: 'static' | 'adaptive' | 'seasonal';
    update_frequency: string;
    performance_metrics: ModelPerformanceMetrics;
}
export interface ModelPerformanceMetrics {
    accuracy: number;
    precision: number;
    recall: number;
    f1_score: number;
    false_positive_rate: number;
}
export interface AnomalyAlertConfiguration {
    alert_thresholds: AnomalyThreshold[];
    suppression_rules: AnomalySuppression[];
    escalation_policies: AnomalyEscalation[];
}
export interface AnomalyThreshold {
    anomaly_type: string;
    severity_level: 'low' | 'medium' | 'high' | 'critical';
    threshold_value: number;
    confidence_level: number;
}
export interface AnomalySuppression {
    suppression_condition: string;
    suppression_duration: string;
    override_conditions: string[];
}
export interface AnomalyEscalation {
    escalation_trigger: string;
    escalation_path: string[];
    escalation_timeline: string;
    auto_escalation: boolean;
}
export interface LogCorrelationAnalysis {
    correlation_types: CorrelationType[];
    correlation_windows: CorrelationWindow[];
    correlation_algorithms: CorrelationAlgorithm[];
}
export interface CorrelationType {
    correlation_name: string;
    correlation_scope: 'temporal' | 'causal' | 'statistical' | 'semantic';
    correlation_strength_threshold: number;
}
export interface CorrelationWindow {
    window_type: 'fixed' | 'sliding' | 'adaptive';
    window_size: string;
    overlap_percentage?: number;
}
export interface CorrelationAlgorithm {
    algorithm_name: string;
    algorithm_description: string;
    computational_complexity: string;
    accuracy_characteristics: string;
}
export interface LogPatternMining {
    mining_algorithms: PatternMiningAlgorithm[];
    pattern_types: LogPatternType[];
    pattern_validation: PatternValidation;
}
export interface PatternMiningAlgorithm {
    algorithm_name: string;
    algorithm_type: 'frequent_pattern' | 'sequential_pattern' | 'clustering' | 'classification';
    parameters: Record<string, any>;
    scalability: string;
}
export interface LogPatternType {
    pattern_name: string;
    pattern_description: string;
    pattern_significance: string;
    pattern_actionability: string;
}
export interface PatternValidation {
    validation_methods: string[];
    validation_criteria: string[];
    validation_frequency: string;
    validation_automation: boolean;
}
export interface TracingStrategy {
    tracing_architecture: TracingArchitecture;
    instrumentation: TracingInstrumentation;
    sampling: TracingSampling;
    trace_processing: TraceProcessing;
    trace_analysis: TraceAnalysis;
}
export interface TracingArchitecture {
    tracing_backend: string;
    trace_collection: TraceCollection;
    trace_storage: TraceStorage;
    trace_querying: TraceQuerying;
}
export interface TraceCollection {
    collection_protocols: string[];
    collection_endpoints: CollectionEndpoint[];
    collection_reliability: CollectionReliability;
}
export interface CollectionEndpoint {
    endpoint_type: 'push' | 'pull';
    endpoint_url: string;
    authentication: EndpointAuthentication;
    rate_limiting: EndpointRateLimit;
}
export interface EndpointAuthentication {
    auth_method: 'api_key' | 'bearer_token' | 'mutual_tls' | 'oauth2';
    auth_config: Record<string, any>;
    token_refresh: boolean;
}
export interface EndpointRateLimit {
    requests_per_second: number;
    burst_capacity: number;
    throttling_strategy: string;
}
export interface CollectionReliability {
    retry_policy: RetryPolicy;
    circuit_breaker: boolean;
    fallback_strategy: string;
    health_monitoring: boolean;
}
export interface TraceStorage {
    storage_backend: string;
    storage_configuration: TraceStorageConfig;
    index_strategy: TraceIndexStrategy;
    retention_policy: TraceRetentionPolicy;
}
export interface TraceStorageConfig {
    replication_factor: number;
    consistency_level: string;
    compression: boolean;
    encryption_at_rest: boolean;
}
export interface TraceIndexStrategy {
    index_fields: string[];
    index_types: IndexType[];
    index_optimization: IndexOptimization;
}
export interface IndexType {
    index_name: string;
    index_algorithm: string;
    performance_characteristics: string;
    maintenance_requirements: string;
}
export interface IndexOptimization {
    automatic_optimization: boolean;
    optimization_schedule: string;
    performance_monitoring: boolean;
    optimization_metrics: string[];
}
export interface TraceRetentionPolicy {
    default_retention: string;
    retention_rules: TraceRetentionRule[];
    archival_strategy: TraceArchivalStrategy;
    deletion_policy: TraceDeletionPolicy;
}
export interface TraceRetentionRule {
    rule_name: string;
    conditions: TraceCondition[];
    retention_period: string;
    priority: number;
}
export interface TraceCondition {
    field: string;
    operator: string;
    value: any;
    case_sensitive: boolean;
}
export interface TraceArchivalStrategy {
    archival_triggers: string[];
    archival_format: string;
    archival_location: string;
    retrieval_process: string;
}
export interface TraceDeletionPolicy {
    deletion_triggers: string[];
    deletion_verification: boolean;
    deletion_logging: boolean;
    recovery_options: string[];
}
export interface TraceQuerying {
    query_languages: string[];
    query_optimization: QueryOptimization;
    query_caching: QueryCaching;
    query_rate_limiting: QueryRateLimit;
}
export interface QueryOptimization {
    automatic_optimization: boolean;
    optimization_techniques: string[];
    performance_monitoring: boolean;
    optimization_metrics: string[];
}
export interface QueryCaching {
    cache_strategy: string;
    cache_size: string;
    cache_ttl: string;
    cache_invalidation: string[];
}
export interface QueryRateLimit {
    queries_per_user: number;
    concurrent_queries: number;
    query_timeout: string;
    resource_limits: QueryResourceLimits;
}
export interface QueryResourceLimits {
    max_memory: string;
    max_cpu: string;
    max_execution_time: string;
    max_result_size: string;
}
export interface AIOrchestrationStrategy {
    id: string;
    name: string;
    description: string;
    applicableContexts: string[];
    toolCoordination: 'sequential' | 'parallel' | 'adaptive' | 'hierarchical';
    parallelization: boolean;
    adaptivity: 'low' | 'medium' | 'high';
    complexity: 'low' | 'medium' | 'high';
    performance: {
        predictability: number;
        efficiency: number;
        scalability: number;
    };
    riskLevel: 'low' | 'medium' | 'high';
    learningCapability: 'basic' | 'intermediate' | 'advanced';
}
export interface OrchestrationContext {
    type: string;
    projectId?: string;
    taskType: string;
    complexity: 'low' | 'medium' | 'high';
    timeConstraints?: {
        deadline?: Date;
        estimatedDuration?: number;
    };
    qualityRequirements: string[];
    resourceConstraints?: {
        memoryLimit?: number;
        cpuLimit?: number;
        networkAccess?: boolean;
    };
    dependencies: string[];
    metadata?: Record<string, any>;
}
export interface ToolCapabilityMapping {
    toolName: string;
    coreCapabilities: string[];
    strengthAreas: string[];
    limitations: string[];
    optimalContexts: string[];
    performanceCharacteristics: {
        speed: number;
        accuracy: number;
        coverage: number;
        reliability: number;
    };
    resourceRequirements: {
        computeIntensive: boolean;
        memoryUsage: 'low' | 'medium' | 'high';
        networkDependency: boolean;
    };
    toolsSelected?: string[];
}
export interface OrchestrationPipeline {
    id: string;
    context: OrchestrationContext;
    taskRequirements: any;
    constraints: any;
    strategy: AIOrchestrationStrategy;
    capabilityMapping: ToolCapabilityMapping;
    pipeline: PipelineStage[];
    adaptationConfig?: any;
    executionResult?: any;
    performanceMetrics?: OrchestrationMetrics;
    learningInsights?: any;
    recommendations?: any;
    metadata?: {
        orchestratedAt: Date;
        toolsInvolved: number;
        pipelineComplexity: any;
        executionTime: number;
        successRate: number;
        optimizedAt?: Date;
        optimizationLevel?: string;
    };
    stages?: any[];
    complexity?: any;
}
export interface OrchestrationMetrics {
    totalExecutionTime: number;
    successRate: number;
    toolPerformance: Record<string, {
        executionTime: number;
        successRate: number;
        errorRate: number;
        qualityScore: number;
    }>;
    resourceUsage: {
        memoryPeak: number;
        cpuUsage: number;
        networkCalls: number;
    };
    qualityMetrics: {
        outputQuality: number;
        consistencyScore: number;
        completenessScore: number;
    };
    adaptationMetrics?: {
        adaptationsTriggered: number;
        adaptationSuccessRate: number;
        performanceImprovement: number;
    };
}
export interface AdaptiveOrchestration {
    id: string;
    projectId: string;
    projectCharacteristics: any;
    adaptiveStrategies: any[];
    learningAlgorithms: any[];
    optimizationParams: any;
    feedbackLoops: any[];
    performanceBaselines: any;
    adaptationTriggers: any[];
    learningRate: number;
    adaptationThreshold: number;
    performanceTargets: any[];
    monitoringConfig: any;
    rollbackStrategy: any;
    validationCriteria: any[];
    metadata: {
        createdAt: Date;
        projectComplexity: any;
        adaptationCapability: string;
        learningCapability: string;
        optimizationLevel: string;
    };
}
export interface OrchestrationOptimization {
    id: string;
    projectId: string;
    workflowType: string;
    baseWorkflow: WorkflowTemplate;
    projectCharacteristics: any;
    performanceGoals: any;
    optimizationAnalysis: any;
    projectOptimizations: any;
    toolOptimizations: any;
    performanceOptimizations: any;
    validation: any;
    optimizedWorkflow: any;
    improvementMetrics: any;
    implementationPlan: any;
    rollbackPlan: any;
    monitoringPlan: any;
    metadata: {
        optimizedAt: Date;
        optimizationComplexity: any;
        expectedImprovement: any;
        implementationRisk: any;
        optimizationVersion: string;
    };
}
export interface CommunicationProtocol {
    id: string;
    name: string;
    description: string;
    protocols: string[];
    messageFormats: Record<string, any>;
    authenticationMethods: string[];
    encryptionStandards: string[];
    queueConfig?: any;
    priority?: 'low' | 'normal' | 'high' | 'urgent' | 'medium';
    guaranteedDelivery?: boolean;
    maxRetries?: number;
    timeout?: number;
    errorHandling: {
        retryStrategy: string;
        timeoutHandling: string;
        fallbackMechanisms: string[];
        errorEscalation: string;
    };
    performanceOptimizations: string[];
    version?: string;
    transport?: any;
    serialization?: any;
    authentication?: any;
    type?: string;
}
export interface WorkflowTemplate {
    id: string;
    name: string;
    description: string;
    phases: {
        name: string;
        tools: string[];
        sequence: 'sequential' | 'parallel' | 'hierarchical';
        objectives: string[];
    }[];
    estimatedDuration: number;
    successCriteria: string[];
    adaptationPoints: string[];
    category?: string;
    template?: WorkflowSpecification;
    variables?: Record<string, any>;
    constraints?: SafetyConstraints;
    examples?: any[];
    documentation?: string;
    version: string;
    created: Date;
    lastModified: Date;
}
export interface OrchestrationLearning {
    id: string;
    projectId: string;
    learningType: 'success_patterns' | 'failure_analysis' | 'optimization_insights' | 'adaptation_learning';
    learningData: {
        context: OrchestrationContext;
        strategy: AIOrchestrationStrategy;
        performance: OrchestrationMetrics;
        outcomes: any;
    };
    insights: {
        patterns: string[];
        recommendations: string[];
        improvements: string[];
        warnings: string[];
    };
    applicability: {
        contexts: string[];
        projects: string[];
        constraints: string[];
    };
    confidence: number;
    validatedAt?: Date;
    metadata: {
        learnedAt: Date;
        validationStatus: 'pending' | 'validated' | 'invalidated';
        applicabilityScore: number;
        impactLevel: 'low' | 'medium' | 'high';
    };
}
export interface AITestingStrategy {
    id: string;
    name: string;
    description: string;
    applicableScenarios: string[];
    testTypes: ('unit' | 'integration' | 'e2e' | 'performance' | 'security')[];
    frameworkSupport: string[];
    aiAssistanceLevel: 'low' | 'medium' | 'high' | 'comprehensive';
    configuration: {
        coverageThreshold: number;
        testComplexity: 'simple' | 'moderate' | 'complex';
        aiModelPreferences: string[];
        generationHeuristics: Record<string, any>;
    };
    metrics: {
        effectiveness: number;
        efficiency: number;
        maintainability: number;
    };
}
export interface TestGenerationRequest {
    targetId: string;
    targetType: 'function' | 'class' | 'module' | 'file' | 'component';
    targetPath: string;
    testType: 'unit' | 'integration' | 'e2e' | 'performance' | 'security';
    requirements: {
        coverageTarget: number;
        testComplexity: 'simple' | 'moderate' | 'complex';
        includeEdgeCases: boolean;
        includeMocking: boolean;
        includeSetup: boolean;
    };
    context: {
        framework: string;
        language: string;
        existingTests?: string[];
        dependencies: string[];
    };
    constraints: {
        timeLimit?: number;
        maxTestCount?: number;
        styleguide?: string;
    };
    metadata: {
        requestedBy: string;
        priority: 'low' | 'medium' | 'high';
        deadline?: Date;
    };
}
export interface TestValidationResult {
    testId: string;
    validationStatus: 'valid' | 'invalid' | 'warning';
    validationScore: number;
    overallImprovement: number;
    issues: {
        type: 'syntax' | 'logic' | 'coverage' | 'performance' | 'style';
        severity: 'error' | 'warning' | 'info';
        description: string;
        location?: {
            line: number;
            column: number;
        };
        suggestion?: string;
    }[];
    metrics: {
        codeQuality: number;
        testCoverage: number;
        executionTime: number;
        maintainabilityIndex: number;
    };
    recommendations: string[];
}
export interface TDDWorkflow {
    id: string;
    name: string;
    description: string;
    phases: {
        name: 'red' | 'green' | 'refactor';
        type?: string;
        description: string;
        actions: string[];
        exitCriteria: string[];
        aiAssistance: boolean;
    }[];
    configuration: {
        cycleTime: number;
        automationLevel: 'manual' | 'semi-auto' | 'full-auto';
        qualityGates: QualityGateRequirement[];
    };
    qualityCriteria: {
        coverageThreshold: number;
        codeQualityThreshold: number;
        performanceThreshold: number;
        maintainabilityThreshold: number;
    };
    metrics: TDDMetrics;
}
export interface AITestAssistant {
    id: string;
    name: string;
    capabilities: {
        testGeneration: boolean;
        codeAnalysis: boolean;
        refactoringSuggestions: boolean;
        performanceOptimization: boolean;
    };
    configuration: {
        model: string;
        temperature: number;
        maxTokens: number;
        contextWindow: number;
    };
    expertise: {
        languages: string[];
        frameworks: string[];
        testingPatterns: string[];
        domainKnowledge: string[];
    };
    performance: {
        responseTime: number;
        accuracy: number;
        consistency: number;
    };
}
export interface TestCoverageAnalysis {
    overall: {
        linesCovered: number;
        totalLines: number;
        percentage: number;
    };
    overallCoverage: number;
    byType: {
        statements: number;
        branches: number;
        functions: number;
        lines: number;
    };
    uncoveredAreas: {
        file: string;
        lines: number[];
        functions: string[];
        branches: string[];
    }[];
    recommendations: {
        priority: 'high' | 'medium' | 'low';
        area: string;
        suggestion: string;
        effort: 'low' | 'medium' | 'high';
    }[];
    trend: {
        previousCoverage: number;
        change: number;
        direction: 'improving' | 'declining' | 'stable';
    };
}
export interface RefactoringSuggestion {
    id: string;
    type: 'extract_method' | 'rename_variable' | 'simplify_conditional' | 'remove_duplication' | 'improve_naming';
    description: string;
    location: {
        file: string;
        startLine: number;
        endLine: number;
        startColumn?: number;
        endColumn?: number;
    };
    impact: {
        complexity: 'reduces' | 'increases' | 'neutral';
        readability: 'improves' | 'degrades' | 'neutral';
        maintainability: 'improves' | 'degrades' | 'neutral';
        performance: 'improves' | 'degrades' | 'neutral';
    };
    effort: 'low' | 'medium' | 'high';
    confidence: number;
    preview: {
        before: string;
        after: string;
    };
    rationale: string;
}
export interface TDDMetrics {
    cycleMetrics: {
        averageCycleTime: number;
        redPhaseTime: number;
        greenPhaseTime: number;
        refactorPhaseTime: number;
    };
    qualityMetrics: {
        testCoverage: number;
        codeQuality: number;
        bugDensity: number;
        technicalDebt: number;
    };
    productivityMetrics: {
        testsWritten: number;
        codeGenerated: number;
        refactoringsPerformed: number;
        velocity: number;
    };
    aiAssistanceMetrics: {
        aiSuggestionsAccepted: number;
        aiSuggestionsRejected: number;
        timesSaved: number;
        accuracyRate: number;
    };
}
export interface TestQualityAssessment {
    testId: string;
    overallScore: number;
    dimensions: {
        correctness: {
            score: number;
            feedback: string;
            issues: string[];
        };
        completeness: {
            score: number;
            missingScenarios: string[];
            coverageGaps: string[];
        };
        maintainability: {
            score: number;
            readability: number;
            simplicity: number;
            modularity: number;
        };
        efficiency: {
            score: number;
            executionTime: number;
            resourceUsage: number;
        };
    };
    recommendations: {
        immediate: RefactoringSuggestion[];
        longTerm: RefactoringSuggestion[];
    };
}
export interface AITestRecommendation {
    id: string;
    type: 'test_missing' | 'test_improvement' | 'refactoring' | 'pattern_adoption';
    priority: 'critical' | 'high' | 'medium' | 'low';
    title: string;
    description: string;
    rationale: string;
    implementation: {
        effort: 'low' | 'medium' | 'high';
        estimatedTime: number;
        prerequisites: string[];
        steps: string[];
    };
    impact: {
        coverage: number;
        quality: number;
        maintainability: number;
        performance: number;
    };
    confidence: number;
}
export interface TestGenerationResult {
    success?: boolean;
    tests?: TestCase[];
    coverage?: TestCoverage;
    testSuite?: TestSuite;
    validation?: TestValidation;
    recommendations?: any[];
    executionPlan?: any;
    ciIntegration?: any;
    metadata: {
        generatedAt?: Date;
        framework?: string;
        totalTests?: number;
        estimatedRunTime?: number;
        generationTime?: number;
        testsGenerated?: number;
        coverageTarget?: number;
        frameworkUsed?: string;
    };
    errors?: string[];
}
export interface TestCase {
    id: string;
    name: string;
    description: string;
    code: string;
    framework: string;
    type: 'unit' | 'integration' | 'e2e' | 'performance' | 'security';
    setup?: string;
    teardown?: string;
    dependencies: string[];
    expectedOutcome: 'pass' | 'fail' | 'skip';
    metadata: {
        complexity: 'simple' | 'moderate' | 'complex';
        estimatedRunTime: number;
        tags: string[];
    };
}
export interface TestFramework {
    name: string;
    version: string;
    language: string;
    features: string[];
    configuration: Record<string, any>;
    supported: {
        unitTesting: boolean;
        integrationTesting: boolean;
        e2eTesting: boolean;
        mocking: boolean;
        coverage: boolean;
    };
}
export interface PropertyBasedTest {
    id: string;
    property: string;
    generators: {
        [key: string]: {
            type: string;
            constraints: Record<string, any>;
        };
    };
    iterations: number;
    shrinking: boolean;
    config: {
        maxExamples: number;
        timeout: number;
        seedValue?: number;
    };
}
export interface FuzzingConfiguration {
    target: string;
    strategy: 'random' | 'mutation' | 'generation' | 'hybrid';
    duration: number;
    intensity: 'low' | 'medium' | 'high';
    coverage: {
        enabled: boolean;
        threshold: number;
    };
    inputs: {
        types: string[];
        constraints: Record<string, any>;
    };
    monitoring: {
        crashes: boolean;
        performance: boolean;
        memory: boolean;
    };
    parameters?: any;
    crashDetection?: any;
}
export interface AIToolConfiguration {
    enabled: boolean;
    settings: Record<string, any>;
    priority: number;
}
export interface Context7Configuration {
    id?: string;
    projectId?: string;
    libraryId?: string;
    tokens?: number;
    topic?: string;
    cacheEnabled?: boolean;
    updateFrequency?: string;
    documentationSources?: string[];
    sourcePriorities?: any;
    retrievalPatterns?: any;
    cachingStrategy?: any;
    searchDepth?: number;
    relevanceThreshold?: number;
    contextWindowSize?: number;
    fallbackSources?: string[];
    customPatterns?: any[];
    performanceSettings?: any;
    qualityFilters?: any;
    metadata?: any;
}
export interface ExaConfiguration {
    numResults?: number;
    searchType?: string;
    maxCharacters?: number;
    searchParameters?: any;
    domain?: string;
    performanceOptimization?: any;
    id?: string;
    projectId?: string;
    queryTemplates?: any;
    resultFiltering?: any;
    securityConfig?: any;
    patternRecognition?: any;
    domainSpecialization?: any;
    metadata?: any;
}
export interface SequentialThinkingConfiguration {
    totalThoughts?: number;
    complexity?: string;
    steps?: number;
    reasoningDepth?: string;
    reasoningFrameworks?: any;
    thinkingSteps?: any;
    id?: string;
    projectId?: string;
    riskAssessment?: any;
    tradeOffAnalysis?: any;
    architecturalPatterns?: any;
    decisionCriteria?: any;
    contextualFactors?: any;
    optimizationSettings?: any;
    metadata?: any;
}
export interface SerenaConfiguration {
    maxAnswerChars?: number;
    recursive?: boolean;
    analysisType?: string;
    analysisDepth?: string;
    semanticRules?: any;
    processingSettings?: any;
    id?: string;
    projectId?: string;
    indexingStrategy?: any;
    consistencyPatterns?: any;
    codebaseSize?: number;
    semanticFilters?: any;
    refactoringCapabilities?: any;
    learningSettings?: any;
    scalabilityFeatures?: any;
    metadata?: any;
}
export interface ProjectSpecificSettings {
    projectType: string;
    framework: string;
    preferences: Record<string, any>;
}
export interface DomainSpecificSearchStrategies {
    domain: string;
    strategies: string[];
    patterns: string[];
}
export interface ReasoningFrameworks {
    framework: string;
    configuration: Record<string, any>;
    enabled: boolean;
}
export interface SemanticRules {
    rule: string;
    condition: string;
    action: string;
    priority: number;
}
export interface ConfigurationOptimization {
    strategy: string;
    parameters: Record<string, any>;
    effectiveness: number;
    timestamp?: Date;
    optimizations?: any;
}
export interface PerformanceTest {
    id: string;
    name: string;
    target: string;
    metrics: {
        responseTime: number;
        throughput: number;
        memory: number;
        cpu: number;
    };
    thresholds: {
        maxResponseTime: number;
        minThroughput: number;
        maxMemory: number;
        maxCpu: number;
    };
    loadPattern: 'constant' | 'ramp' | 'spike' | 'stress';
    duration: number;
    baseline?: any;
}
export interface SecurityTest {
    id: string;
    name: string;
    category: 'injection' | 'authentication' | 'authorization' | 'data_exposure' | 'crypto' | 'business_logic';
    severity: 'critical' | 'high' | 'medium' | 'low';
    target: string;
    technique: string;
    payload: string;
    expectedResult: 'blocked' | 'detected' | 'logged';
    compliance: string[];
    mitigation?: any;
}
export interface IntegrationTest {
    id: string;
    name: string;
    components: string[];
    interfaces: string[];
    dataFlow: {
        input: Record<string, any>;
        output: Record<string, any>;
    };
    dependencies: {
        external: string[];
        internal: string[];
    };
    environment: {
        setup: string[];
        teardown: string[];
    };
}
export interface TestCoverage {
    lines: number;
    functions: number;
    branches: number;
    statements: number;
    targetCoverage?: number;
    uncoveredLines?: number[];
    files?: {
        [filename: string]: {
            lines: number;
            functions: number;
            branches: number;
            statements: number;
        };
    };
}
export interface TestValidation {
    id: string;
    status: 'valid' | 'invalid' | 'warning';
    issues: {
        type: 'syntax' | 'logic' | 'performance' | 'style';
        severity: 'error' | 'warning' | 'info';
        message: string;
        line?: number;
    }[];
    suggestions: string[];
    quality: {
        maintainability: number;
        readability: number;
        effectiveness: number;
    };
}
export interface TestExecution {
    id: string;
    testId: string;
    status: 'running' | 'passed' | 'failed' | 'skipped' | 'timeout';
    startTime: Date;
    endTime?: Date;
    duration?: number;
    result?: {
        output: string;
        error?: string;
        assertions: {
            total: number;
            passed: number;
            failed: number;
        };
    };
    environment: {
        framework: string;
        node: string;
        os: string;
    };
}
export interface TestOptimization {
    id: string;
    originalSuite: string;
    optimizedSuite: string;
    improvements: {
        type: 'performance' | 'coverage' | 'maintainability' | 'reliability';
        description: string;
        impact: number;
    }[];
    metrics: {
        executionTime: {
            before: number;
            after: number;
            improvement: number;
        };
        coverage: {
            before: number;
            after: number;
            improvement: number;
        };
    };
}
export interface MutationTest {
    id: string;
    testSuiteId?: string;
    originalCode?: string;
    mutatedCode?: string;
    mutationType?: 'arithmetic' | 'relational' | 'logical' | 'assignment' | 'unary' | 'statement';
    location?: {
        line: number;
        column: number;
    };
    result?: 'killed' | 'survived' | 'timeout' | 'error';
    killingTests?: string[];
    mutations?: any[];
    results?: any;
    mutationScore?: number;
    weakTests?: any[];
    improvedTests?: any[];
    analysis?: any;
    recommendations?: any[];
}
export interface RegressionTest {
    id: string;
    name: string;
    version: string;
    baseline: {
        version: string;
        results: TestResult[];
        coverage: TestCoverage;
    };
    current: {
        version: string;
        results: TestResult[];
        coverage: TestCoverage;
    };
    changes: {
        type: 'new_failure' | 'new_pass' | 'performance_degradation' | 'coverage_loss';
        impact: 'critical' | 'major' | 'minor';
        description: string;
    }[];
}
export interface CodeEvolutionRequest {
    projectId: string;
    evolutionType: 'refactor' | 'modernize' | 'optimize' | 'migrate' | 'enhance';
    targetPath: string;
    evolutionGoals: string[];
    constraints: {
        performanceRequirements: Record<string, number>;
        compatibilityRequirements: string[];
        timeConstraints: number;
        qualityThresholds: Record<string, number>;
    };
    context: {
        projectType: string;
        language: string;
        framework?: string;
        currentVersion: string;
        targetVersion?: string;
    };
    preferences: {
        riskTolerance: 'low' | 'medium' | 'high';
        prioritizeSpeed: boolean;
        maintainBackwardCompatibility: boolean;
    };
}
export interface CodeEvolutionResult {
    id: string;
    projectId: string;
    request: CodeEvolutionRequest;
    currentAnalysis: any;
    technicalDebt: TechnicalDebtAnalysis;
    refactoringOpportunities: any;
    dependencyAnalysis: any;
    performanceAnalysis: any;
    evolutionPlan: MigrationPlan;
    evolutionResults: any;
    validation: any;
    metrics: EvolutionMetrics;
    recommendations: any[];
    safetyGuarantees: SafetyGuarantee;
    metadata: {
        evolutionType: string;
        startTime: Date;
        endTime: Date;
        changesApplied: number;
        [key: string]: any;
    };
    success?: boolean;
    refactoringRecommendations?: RefactoringRecommendation[];
    modernizationSteps?: CodeModernization[];
    dependencyUpdates?: DependencyUpdate[];
    optimizations?: PerformanceOptimization[];
    safetyAnalysis?: SafetyGuarantee;
    risks?: {
        type: string;
        severity: 'low' | 'medium' | 'high' | 'critical';
        mitigation: string;
    }[];
}
export interface TechnicalDebtAnalysis {
    totalDebtScore: number;
    categories: {
        codeSmells: CodeSmellDetection[];
        designDebt: number;
        testDebt: number;
        documentationDebt: number;
        dependencyDebt: number;
    };
    priorityAreas: {
        file: string;
        debtScore: number;
        type: string;
        impact: 'low' | 'medium' | 'high';
        effort: 'low' | 'medium' | 'high';
    }[];
    recommendations: RefactoringRecommendation[];
}
export interface RefactoringRecommendation {
    id: string;
    type: 'extract_method' | 'extract_class' | 'move_method' | 'rename' | 'eliminate_duplication' | 'simplify_conditional';
    target: string;
    description: string;
    benefits: string[];
    risks: string[];
    effort: 'low' | 'medium' | 'high';
    impact: 'low' | 'medium' | 'high';
    automatable: boolean;
    code: {
        before: string;
        after: string;
        diff: string;
    };
}
export interface CodeModernization {
    id: string;
    category: 'language_features' | 'api_updates' | 'dependency_upgrade' | 'pattern_modernization';
    description: string;
    fromVersion: string;
    toVersion: string;
    changes: {
        file: string;
        type: 'update' | 'replace' | 'remove' | 'add';
        oldCode?: string;
        newCode?: string;
        line?: number;
    }[];
    compatibility: {
        breakingChanges: boolean;
        deprecations: string[];
        runtimeRequirements: string[];
    };
}
export interface DependencyUpdate {
    package: string;
    currentVersion: string;
    targetVersion: string;
    type: 'major' | 'minor' | 'patch';
    changeType: 'security' | 'feature' | 'bugfix' | 'performance';
    breakingChanges: boolean;
    migrationSteps: string[];
    dependencies: string[];
    riskLevel: 'low' | 'medium' | 'high';
}
export interface PerformanceOptimization {
    id: string;
    category: 'algorithmic' | 'memory' | 'io' | 'rendering' | 'caching' | 'bundling';
    target: string;
    description: string;
    currentMetrics: {
        executionTime: number;
        memoryUsage: number;
        cacheHitRate?: number;
    };
    projectedMetrics: {
        executionTime: number;
        memoryUsage: number;
        cacheHitRate?: number;
    };
    implementation: {
        code: string;
        dependencies: string[];
        configChanges: Record<string, any>;
    };
    impact: 'low' | 'medium' | 'high';
}
export interface ArchitecturalEvolution {
    id: string;
    type: 'microservices' | 'modularization' | 'layering' | 'pattern_adoption' | 'framework_migration';
    description: string;
    currentArchitecture: {
        pattern: string;
        components: string[];
        dependencies: string[];
    };
    targetArchitecture: {
        pattern: string;
        components: string[];
        dependencies: string[];
    };
    migrationPlan: MigrationPlan;
    benefits: string[];
    challenges: string[];
}
export interface EvolutionaryAlgorithm {
    id: string;
    type: 'genetic' | 'particle_swarm' | 'simulated_annealing' | 'hill_climbing';
    parameters: {
        populationSize: number;
        generations: number;
        mutationRate: number;
        crossoverRate: number;
    };
    fitnessFunction: string;
    constraints: Record<string, any>;
    results: {
        bestSolution: any;
        fitnessScore: number;
        convergenceGeneration: number;
    };
}
export interface RefactoringPattern {
    name: string;
    category: 'structural' | 'behavioral' | 'creational';
    description: string;
    applicability: string[];
    implementation: {
        steps: string[];
        codeTemplate: string;
        prerequisites: string[];
    };
    metrics: {
        complexity: number;
        maintainability: number;
        testability: number;
    };
}
export interface CodeSmellDetection {
    type: 'long_method' | 'large_class' | 'duplicate_code' | 'god_object' | 'feature_envy' | 'data_clumps';
    location: {
        file: string;
        startLine: number;
        endLine: number;
    };
    severity: 'low' | 'medium' | 'high';
    description: string;
    metrics: {
        linesOfCode?: number;
        cyclomaticComplexity?: number;
        duplicatePercentage?: number;
    };
    suggestions: RefactoringRecommendation[];
}
export interface LegacyCodeAnalysis {
    codebaseAge: number;
    languageVersion: string;
    frameworkVersions: Record<string, string>;
    deprecatedFeatures: {
        feature: string;
        file: string;
        line: number;
        replacement: string;
    }[];
    modernizationOpportunities: CodeModernization[];
    riskFactors: {
        type: string;
        description: string;
        impact: 'low' | 'medium' | 'high';
    }[];
}
export interface MigrationPlan {
    id: string;
    phases: {
        name: string;
        description: string;
        duration: number;
        tasks: {
            id: string;
            description: string;
            type: 'code_change' | 'test_update' | 'dependency_update' | 'configuration';
            estimatedHours: number;
            dependencies: string[];
        }[];
        risks: string[];
        rollbackPlan: string;
    }[];
    totalDuration: number;
    resources: string[];
    checkpoints: {
        phase: string;
        criteria: string[];
        tests: string[];
    }[];
}
export interface OptimizationStrategy {
    id: string;
    type: 'performance' | 'memory' | 'security' | 'maintainability';
    priority: 'low' | 'medium' | 'high' | 'critical';
    target: string;
    approach: string;
    steps: string[];
    expectedImpact: {
        performance?: number;
        memory?: number;
        maintainability?: number;
    };
    implementation: {
        effort: 'low' | 'medium' | 'high';
        timeline: string;
        resources: string[];
    };
}
export interface SafetyGuarantee {
    level: 'none' | 'basic' | 'comprehensive' | 'formal';
    checks: {
        type: 'syntax' | 'type' | 'runtime' | 'property';
        description: string;
        status: 'passed' | 'failed' | 'warning';
        details?: string;
    }[];
    rollbackStrategy: {
        triggers: string[];
        steps: string[];
        automatable: boolean;
    };
    testing: {
        unitTests: number;
        integrationTests: number;
        coverageThreshold: number;
        performanceTests: boolean;
    };
}
export interface EvolutionMetrics {
    codeQuality: {
        before: number;
        after: number;
        improvement: number;
    };
    performance: {
        before: Record<string, number>;
        after: Record<string, number>;
        improvement: Record<string, number>;
    };
    maintainability: {
        before: number;
        after: number;
        improvement: number;
    };
    testCoverage: {
        before: number;
        after: number;
        improvement: number;
    };
    technicalDebt: {
        before: number;
        after: number;
        reduction: number;
    };
}
export interface ArchitecturalDecision {
    id: string;
    title?: string;
    description?: string;
    context: DecisionContext;
    criteria: DecisionCriteria[];
    alternatives: DecisionAlternative[];
    selectedAlternative: string;
    rationale: DecisionRationale;
    qualityAttributes?: any;
    tradeoffs?: any[];
    risks?: any[];
    assumptions?: any[];
    constraints?: string[];
    implications?: any[];
    reviewers?: string[];
    status: 'proposed' | 'approved' | 'implemented' | 'superseded';
    createdAt: Date;
    projectId: string;
    consequences?: {
        positive: string[];
        negative: string[];
        risks: Risk[];
    };
    implementation?: {
        plan: string[];
        timeline: string;
        resources: string[];
        dependencies: string[];
    };
    review?: {
        reviewDate: Date;
        reviewers: string[];
        approved: boolean;
        comments: string[];
    };
    metadata: {
        decisionMaker: string;
        decisionDate: Date;
        frameworkUsed?: string;
        aiAssistanceLevel?: string;
        confidenceLevel?: number;
        decisionVersion?: string;
        status: 'proposed' | 'approved' | 'implemented' | 'superseded';
        category: 'architecture' | 'technology' | 'process' | 'quality';
        impact: 'low' | 'medium' | 'high' | 'critical';
    };
}
export interface DecisionContext {
    id: string;
    project: {
        name: string;
        domain: string;
        stage: 'conception' | 'design' | 'development' | 'testing' | 'production';
        constraints: string[];
    };
    technical: {
        currentArchitecture: string;
        technologyStack: string[];
        scalabilityRequirements: string[];
        performanceTargets: Record<string, any>;
    };
    organizational: {
        team: {
            size: number;
            skills: string[];
            experience: string[];
        };
        timeline: {
            deadline: Date;
            milestones: string[];
        };
        budget: {
            constraints: string[];
            priorities: string[];
        };
    };
    external: {
        regulatory: string[];
        compliance: string[];
        marketFactors: string[];
    };
    constraints: string[];
}
export interface DecisionCriteria {
    id: string;
    name: string;
    description: string;
    category: 'functional' | 'non-functional' | 'technical' | 'business';
    weight: number;
    measurable: boolean;
    metrics: {
        measurement: string;
        target: any;
        threshold: any;
    }[];
    constraints: string[];
    type: 'performance' | 'quality' | 'efficiency' | 'compatibility';
    evaluator: string;
}
export interface DecisionAlternative {
    id: string;
    name: string;
    description: string;
    analysis: AlternativeAnalysis;
    implementation: {
        effort: 'low' | 'medium' | 'high';
        complexity: 'simple' | 'moderate' | 'complex';
        timeline: string;
        resources: string[];
    };
    evaluation: {
        pros: string[];
        cons: string[];
        risks: Risk[];
        opportunities: string[];
    };
    scores: {
        criteriaId: string;
        score: number;
        confidence: number;
        notes: string;
    }[];
    totalScore: number;
}
export interface AlternativeAnalysis {
    technical: {
        feasibility: 'high' | 'medium' | 'low';
        complexity: number;
        maintainability: number;
        scalability: number;
        performance: number;
    };
    business: {
        cost: number;
        timeToMarket: number;
        strategicAlignment: number;
        competitiveAdvantage: number;
    };
    risk: {
        technical: Risk[];
        business: Risk[];
        operational: Risk[];
        overall: 'low' | 'medium' | 'high';
    };
    dependencies: {
        internal: string[];
        external: string[];
        critical: string[];
    };
}
export interface DecisionRationale {
    summary: string;
    keyFactors: string[];
    tradeoffs: {
        accepted: string[];
        rejected: string[];
        deferred: string[];
    };
    assumptions: string[];
    constraints: string[];
    futureConsiderations: string[];
}
export interface DecisionTemplate {
    id: string;
    name: string;
    description: string;
    sections?: string[];
    requiredFields?: string[];
    optionalFields?: string[];
    evaluationCriteria?: string[];
    category: string;
    applicableContexts: string[];
    structure: {
        requiredSections: string[];
        optionalSections: string[];
        criteriaTemplates: DecisionCriteria[];
    };
    guidance: {
        bestPractices: string[];
        commonPitfalls: string[];
        resources: string[];
    };
}
export interface DecisionHistory {
    decisionId: string;
    changes: {
        timestamp: Date;
        changeType: 'created' | 'modified' | 'approved' | 'implemented' | 'superseded';
        description: string;
        changedBy: string;
        previousState?: any;
        newState?: any;
    }[];
    outcomes: {
        expected: string[];
        actual: string[];
        variance: string[];
        lessons: string[];
    };
    retrospective: {
        date: Date;
        participants: string[];
        findings: string[];
        improvements: string[];
    };
}
export interface DecisionMetrics {
    decisionQuality: {
        thoroughness: number;
        evidenceBased: number;
        stakeholderAlignment: number;
        clarity: number;
    };
    outcomeTracking: {
        implementationSuccess: number;
        performanceVsExpected: number;
        unintendedConsequences: string[];
        valueRealized: number;
    };
    processMetrics: {
        timeToDecision: number;
        stakeholdersInvolved: number;
        iterationsRequired: number;
        consensusLevel: number;
    };
}
export interface DecisionRecommendation {
    id: string;
    recommendedAlternative: string;
    confidence: 'low' | 'medium' | 'high';
    reasoning: string[];
    conditions: string[];
    mitigations: {
        risk: string;
        mitigation: string;
        owner: string;
    }[];
    nextSteps: {
        immediate: string[];
        shortTerm: string[];
        longTerm: string[];
    };
    monitoring: {
        kpis: string[];
        reviewSchedule: string;
        escalationCriteria: string[];
    };
}
export interface TechnicalDebt {
    id: string;
    decisionId?: string;
    immediateDebt?: any;
    longTermDebt?: any;
    qualityImpact?: any;
    totalDebtScore?: number;
    categories?: string[];
    severity?: string;
    businessImpact?: any;
    estimatedCost?: number;
    paybackPeriod?: number;
    createdAt?: Date;
    projectId?: string;
    type: 'architecture' | 'code' | 'documentation' | 'testing' | 'infrastructure';
    description: string;
    impact: {
        development: 'low' | 'medium' | 'high';
        maintenance: 'low' | 'medium' | 'high';
        performance: 'low' | 'medium' | 'high';
        security: 'low' | 'medium' | 'high';
    };
    estimation: {
        effort: number;
        cost: number;
        timeline: string;
    };
    mitigation: {
        strategies: string[];
        timeline: string;
        dependencies: string[];
    };
    monitoring: {
        metrics: string[];
        thresholds: Record<string, any>;
        alerts: string[];
    };
}
export interface DecisionFramework {
    id: string;
    name: string;
    description: string;
    steps?: string[];
    criteria?: string[];
    applicableContexts?: string[];
    strengths?: string[];
    limitations?: string[];
    methodology: string;
    stages: {
        name: string;
        description: string;
        activities: string[];
        deliverables: string[];
        criteria: string[];
    }[];
    tools: {
        analysisTools: string[];
        evaluationMethods: string[];
        documentationTemplates: string[];
    };
    governance: {
        roles: Record<string, string[]>;
        approvalProcess: string[];
        reviewCycles: string[];
    };
}
export interface CrossToolMessage {
    id: string;
    type: 'request' | 'response' | 'notification' | 'event' | 'command' | 'state_sync';
    sender: {
        toolId: string;
        toolName: string;
        instanceId: string;
    };
    recipient: {
        toolId: string;
        toolName?: string;
        broadcast?: boolean;
    };
    payload: {
        action: string;
        data: any;
        metadata: Record<string, any>;
    };
    routing: {
        priority: 'low' | 'normal' | 'high' | 'urgent';
        reliability: 'at-most-once' | 'at-least-once' | 'exactly-once';
        timeout?: number;
        retryPolicy?: {
            maxRetries: number;
            backoffStrategy: 'linear' | 'exponential';
            backoffBase: number;
        };
    };
    context: {
        sessionId?: string;
        correlationId?: string;
        causationId?: string;
        traceId?: string;
    };
    timestamp: Date;
    expiresAt?: Date;
    priority?: 'low' | 'normal' | 'high' | 'urgent' | 'medium';
    synchronizationRequired?: boolean;
}
export interface ToolInteraction {
    id: string;
    interactionType: 'synchronous' | 'asynchronous' | 'event-driven' | 'streaming';
    participants: {
        initiator: string;
        responders: string[];
        observers?: string[];
    };
    protocol: {
        name: string;
        version: string;
        specifications: string[];
    };
    messages: CrossToolMessage[];
    timestamp?: Date;
    latency?: any;
    success?: boolean;
    context?: any;
    state: {
        status: 'initiated' | 'in-progress' | 'completed' | 'failed' | 'timeout';
        currentPhase: string;
        progress: number;
        errors?: string[];
    };
    metrics: {
        startTime: Date;
        endTime?: Date;
        duration?: number;
        messageCount: number;
        bytesTransferred: number;
        errorCount: number;
    };
    constraints: {
        maxDuration?: number;
        maxMessages?: number;
        requiredTools?: string[];
        optionalTools?: string[];
    };
    channelId?: string;
    sourceToolId?: string;
    targetToolId?: string;
    messageType?: string;
    metadata?: any;
}
export interface MessageRouter {
    id: string;
    name: string;
    routingStrategy: 'round-robin' | 'priority' | 'load-balanced' | 'broadcast';
    routes: {
        pattern: string;
        destination: string;
        priority: number;
        filters?: Record<string, any>;
    }[];
    metrics: {
        messagesRouted: number;
        routingLatency: number;
        errorRate: number;
    };
}
export interface CrossToolEvent {
    id: string;
    type: string;
    source: string;
    timestamp: Date;
    payload: any;
    metadata: Record<string, any>;
    propagation: {
        async: boolean;
        broadcast: boolean;
        persistent: boolean;
    };
}
export interface ProtocolAdapter {
    id: string;
    name: string;
    protocol: string;
    version: string;
    capabilities: string[];
    configuration: Record<string, any>;
    status: 'active' | 'inactive' | 'error';
    sendMessage?: (message: any) => Promise<any>;
}
export interface MessageQueue {
    id: string;
    name: string;
    type: 'fifo' | 'priority' | 'delay' | 'deadletter';
    maxSize: number;
    currentSize: number;
    messages: CrossToolMessage[];
    configuration: {
        persistent: boolean;
        durability: 'temporary' | 'durable';
        autoDelete: boolean;
    };
}
export interface CommunicationMetrics {
    messagesSent: number;
    messagesReceived: number;
    messagesFailedSent: number;
    messagesFailedReceived: number;
    averageLatency: number;
    throughput: number;
    errorRate: number;
    bandwidth: number;
    timestamp: Date;
}
export interface InterToolContext {
    sessionId: string;
    workflowId?: string;
    correlationId?: string;
    causationId?: string;
    traceId?: string;
    parentContext?: string;
    metadata: Record<string, any>;
    timeout?: number;
    priority: 'low' | 'normal' | 'high' | 'urgent';
    tags?: string[];
    annotations?: Record<string, any>;
}
export interface SynchronizationState {
    id: string;
    participants: string[];
    state: 'waiting' | 'synchronized' | 'timeout' | 'error';
    barrier: {
        expected: number;
        current: number;
        timeout?: number;
    };
    metadata: Record<string, any>;
    timestamp: Date;
}
export interface MetricsStrategy {
    collection: {
        methods: ('push' | 'pull' | 'streaming')[];
        intervals: Record<string, number>;
        batchSize: number;
        compression: boolean;
    };
    storage: {
        backend: 'prometheus' | 'influxdb' | 'cloudwatch' | 'datadog' | 'custom';
        retention: {
            raw: string;
            aggregated: string;
            historical: string;
        };
        partitioning: {
            strategy: 'time' | 'metric' | 'label' | 'hybrid';
            granularity: string;
        };
    };
    processing: {
        aggregation: string[];
        derivedMetrics: {
            name: string;
            formula: string;
            dependencies: string[];
        }[];
        alerts: {
            rules: string[];
            destinations: string[];
        };
    };
    visualization: {
        dashboards: string[];
        reports: string[];
        realTimeViews: string[];
    };
}
export interface AlertingStrategy {
    id?: string;
    name?: string;
    description?: string;
    rules: {
        id: string;
        name: string;
        condition: string;
        severity: 'info' | 'warning' | 'error' | 'critical';
        threshold: number;
        duration: string;
        labels: Record<string, string>;
    }[];
    channels: {
        type: 'email' | 'slack' | 'pagerduty' | 'webhook' | 'sms';
        configuration: Record<string, any>;
        filters: string[];
        escalation: {
            levels: string[];
            timeouts: number[];
        };
    }[];
    suppression: {
        rules: string[];
        timeWindows: string[];
        dependencies: string[];
    };
    aggregation: {
        groupBy: string[];
        timeWindow: string;
        maxAlerts: number;
    };
    applicableContexts?: string[];
    filteringRules?: any[];
    performance?: any;
    adaptationCapability?: {
        learningEnabled: boolean;
        adaptationRate: number;
        triggers: string[];
        rules: any[];
    };
}
export interface TracingInstrumentation {
    automatic: {
        enabled: boolean;
        frameworks: string[];
        libraries: string[];
        exclusions: string[];
    };
    manual: {
        decorators: boolean;
        contextPropagation: boolean;
        customSpans: boolean;
        annotations: boolean;
    };
    configuration: {
        serviceName: string;
        version: string;
        environment: string;
        tags: Record<string, string>;
    };
    propagation: {
        headers: string[];
        formats: ('b3' | 'jaeger' | 'ot' | 'w3c')[];
        baggage: boolean;
    };
}
export interface TracingSampling {
    strategy: 'always' | 'never' | 'probabilistic' | 'rate-limited' | 'adaptive';
    configuration: {
        rate?: number;
        maxTracesPerSecond?: number;
        rules?: {
            service: string;
            operation?: string;
            rate: number;
        }[];
    };
    adaptive: {
        enabled: boolean;
        targetLatency: number;
        adjustmentInterval: number;
        minSampleRate: number;
        maxSampleRate: number;
    };
}
export interface TraceProcessing {
    pipeline: {
        processors: string[];
        filters: string[];
        exporters: string[];
    };
    batching: {
        timeout: number;
        batchSize: number;
        maxExportBatchSize: number;
    };
    enrichment: {
        resourceDetection: boolean;
        attributeProcessing: boolean;
        spanProcessing: boolean;
    };
    compression: {
        enabled: boolean;
        algorithm: 'gzip' | 'snappy' | 'lz4';
        level: number;
    };
}
export interface TraceAnalysis {
    dependencies: {
        serviceMap: boolean;
        operationDependencies: boolean;
        criticalPath: boolean;
    };
    performance: {
        latencyAnalysis: boolean;
        throughputAnalysis: boolean;
        errorRateAnalysis: boolean;
        percentileCalculation: boolean;
    };
    anomalies: {
        detectionEnabled: boolean;
        algorithms: string[];
        sensitivity: number;
        alerting: boolean;
    };
    business: {
        customMetrics: string[];
        kpiTracking: boolean;
        businessEvents: string[];
    };
}
export interface QualityMetric {
    id: string;
    name: string;
    type: 'performance' | 'maintainability' | 'reliability' | 'usability' | 'security' | 'efficiency' | 'testability' | 'portability' | 'accessibility' | 'scalability' | 'availability' | 'compatibility' | 'documentation' | 'custom';
    category?: string;
    tags?: string[];
    value: number;
    unit: string;
    timestamp: Date;
    metadata?: Record<string, any>;
    threshold?: {
        min?: number;
        max?: number;
        target?: number;
    };
}
export interface QualityTrend {
    metric: QualityMetric;
    direction: 'improving' | 'declining' | 'stable' | 'volatile' | 'decreasing';
    slope: number;
    confidence: number;
    timeframe: {
        start: Date;
        end: Date;
    };
    dataPoints: Array<{
        timestamp: Date;
        value: number;
    }>;
    patterns?: string[];
    seasonality?: {
        period: string;
        amplitude: number;
    } | undefined;
    strength?: number;
    volatility?: number;
    metricType?: string;
    anomalies?: any[];
}
export interface QualityRisk {
    id: string;
    type: 'prediction' | 'correlation' | 'threshold' | 'anomaly' | 'pattern' | 'trend_degradation' | 'instability';
    severity: 'low' | 'medium' | 'high' | 'critical';
    description: string;
    affectedMetrics: string[];
    likelihood?: number;
    impact: number;
    probability?: number;
    timeframe: string;
    mitigationActions?: string[];
    mitigation?: {
        actions: string[];
        priority: string;
        estimatedEffort: string;
    };
    confidence?: number;
    source?: string;
    metadata?: Record<string, any>;
}
export interface PredictionModel {
    id: string;
    name: string;
    type: 'linear' | 'polynomial' | 'exponential' | 'arima' | 'neural_network' | 'ensemble';
    algorithm: string;
    accuracy: number;
    lastTrained: Date;
    parameters: Record<string, any>;
    applicableMetrics: string[];
    performance: {
        mse: number;
        mae: number;
        r2: number;
    };
    predict(data: number[]): Promise<{
        value: number;
        confidence: number;
        interval: [number, number];
    }>;
    version?: string;
    lastTraining?: Date;
    features?: string[];
}
export interface QualityAlertSubscription {
    id: string;
    userId?: string;
    projectId: string;
    metricTypes?: string[];
    conditions?: Array<{
        metric: string;
        operator: 'gt' | 'lt' | 'eq' | 'change';
        threshold: number;
    }>;
    channels?: ('email' | 'slack' | 'webhook')[];
    active?: boolean;
    created?: Date;
    lastTriggered?: Date;
    config?: QualityAlertConfig;
    createdAt?: Date;
    isActive?: boolean;
}
export interface QualityAnalysisConfig {
    projectId: string;
    timeRange: {
        start: Date;
        end: Date;
    };
    timeSpan?: number;
    metrics: string[];
    analysisTypes: ('trend' | 'anomaly' | 'correlation' | 'prediction')[];
    granularity: 'hourly' | 'daily' | 'weekly' | 'monthly';
    confidence: number;
    includeForecasting: boolean;
    forecastHorizon?: number;
    predictionHorizon?: number;
    alertThresholds?: Record<string, number>;
    customParameters?: Record<string, any>;
    cacheTtl?: number;
}
export interface OrganizationalMemoryService {
    getMemory(key: string): Promise<OrganizationalMemory | null>;
    storeMemory(key: string, memory: OrganizationalMemory): Promise<void>;
    updateMemory(key: string, updates: Partial<OrganizationalMemory>): Promise<void>;
    searchMemories(query: string): Promise<OrganizationalMemory[]>;
    getProjectMemories(projectId: string): Promise<OrganizationalMemory[]>;
    deleteMemory(key: string): Promise<void>;
}
export interface AgentSpecification {
    id: string;
    name: string;
    description: string;
    capabilities: string[];
    inputSchema: any;
    outputSchema: any;
    behaviorRules: string[];
    constraints: SafetyConstraints;
    dependencies: string[];
    version: string;
    metadata: Record<string, any>;
}
export interface ToolSpecification {
    id: string;
    name: string;
    description: string;
    function: string;
    capabilities: string[];
    parameters: any;
    returnType: any;
    sideEffects: string[];
    requirements: string[];
    constraints: SafetyConstraints;
    testCases: any[];
}
export interface CodeGeneratorSpecification {
    id: string;
    name: string;
    language: string;
    outputType: string;
    capabilities: string[];
    framework?: string;
    templates: Record<string, string>;
    generators: Record<string, any>;
    validators: any[];
    transformers: any[];
    optimizers: any[];
    outputFormat: string;
    constraints: SafetyConstraints;
}
export interface DSLSpecification {
    name: string;
    version: string;
    grammar: string;
    capabilities: string[];
    compileTarget?: string;
    semantics: Record<string, any>;
    compiler: any;
    interpreter: any;
    validationRules: string[];
    transformationRules: any[];
    optimization: any;
}
export interface WorkflowSpecification {
    id: string;
    name: string;
    description: string;
    steps: WorkflowStep[];
    dependencies: string[];
    inputs: any;
    outputs: any;
    errorHandling: any;
    rollbackStrategy: string;
    constraints: SafetyConstraints;
}
export interface WorkflowStep {
    id: string;
    name: string;
    type: 'agent' | 'tool' | 'decision' | 'parallel' | 'loop';
    specification: any;
    inputs: any;
    outputs: any;
    conditions: any[];
    errorHandling: any;
}
export interface RuntimeModification {
    id: string;
    type: 'code_injection' | 'behavior_modification' | 'capability_extension' | 'constraint_update';
    target: string;
    modification: any;
    safety: SafetyConstraints;
    rollback: any;
    verification: any[];
    timestamp: Date;
    author: string;
}
export interface SelfModifyingCodeSpecification {
    id: string;
    originalCode: string;
    modificationRules: any[];
    safetyChecks: any[];
    modificationHistory: RuntimeModification[];
    currentVersion: string;
    rollbackPoints: any[];
    constraints: SafetyConstraints;
    monitoring: any;
}
export interface SafetyConstraints {
    maxExecutionTime: number;
    maxMemoryUsage: number;
    allowedOperations: string[];
    forbiddenOperations: string[];
    accessControl: any;
    auditRequirements: string[];
    rollbackRequired: boolean;
    verificationRequired: boolean;
    humanApprovalRequired: boolean;
}
export interface GeneratedAgent {
    id: string;
    specification: AgentSpecification;
    generatedCode: string;
    compiledCode: any;
    runtime: any;
    status: 'generated' | 'compiled' | 'running' | 'error' | 'stopped';
    performance: any;
    logs: any[];
    errors: any[];
    created: Date;
    lastModified: Date;
}
export interface GeneratedTool {
    id: string;
    specification: ToolSpecification;
    generatedCode: string;
    compiledCode: any;
    runtime: any;
    status: 'generated' | 'compiled' | 'active' | 'error' | 'deprecated';
    usage: any;
    performance: any;
    tests: any[];
    created: Date;
    lastModified: Date;
}
export interface GeneratedWorkflow {
    id: string;
    specification: WorkflowSpecification;
    generatedCode: string;
    runtime: any;
    status: 'generated' | 'active' | 'paused' | 'error' | 'completed';
    execution: any;
    progress: number;
    logs: any[];
    created: Date;
    lastModified: Date;
}
export interface MetaProgrammingContext {
    projectId: string;
    targetLanguage: string;
    targetFramework?: string;
    availableLibraries: string[];
    constraints: SafetyConstraints;
    preferences: any;
    existingCode: any;
    requirements: any;
    metadata: Record<string, any>;
}
export interface CodeSelfModificationRequest {
    id: string;
    targetCode: string;
    modificationGoal: string;
    constraints: SafetyConstraints;
    context: MetaProgrammingContext;
    verificationRequired: boolean;
    rollbackStrategy: string;
    metadata: Record<string, any>;
}
export interface CodeSelfModificationResult {
    id: string;
    success: boolean;
    originalCode: string;
    modifiedCode: string;
    modifications: RuntimeModification[];
    verification: any;
    safety: any;
    performance: any;
    rollback: any;
    metadata: Record<string, any>;
}
export interface GeneratedCodeGenerator {
    id: string;
    specification: CodeGeneratorSpecification;
    generatedCode: string;
    implementation: any;
    runtime: any;
    status: 'generated' | 'active' | 'error' | 'deprecated';
    performance: any;
    tests: any[];
    created: Date;
    lastModified: Date;
    metadata: Record<string, any>;
}
export interface GeneratedDSL {
    id: string;
    specification: DSLSpecification;
    grammar: any;
    compiler: any;
    interpreter: any;
    runtime: any;
    status: 'generated' | 'active' | 'error' | 'deprecated';
    performance: any;
    tests: any[];
    created: Date;
    lastModified: Date;
    metadata: Record<string, any>;
}
export interface ModificationResult {
    id: string;
    success: boolean;
    target: string;
    modification: RuntimeModification;
    before: string;
    after: string;
    verification: any;
    safety: any;
    rollback: any;
    timestamp: Date;
    metadata: Record<string, any>;
}
export interface SelfModifyingCodeResult {
    id: string;
    success: boolean;
    originalCode: string;
    modifiedCode: string;
    modifications: ModificationResult[];
    safetyChecks: any[];
    verification: any;
    performance: any;
    rollback: any;
    timestamp: Date;
    metadata: Record<string, any>;
}
export interface AgentTemplate {
    id: string;
    name: string;
    description: string;
    category: string;
    template: string;
    variables: Record<string, any>;
    constraints: SafetyConstraints;
    examples: any[];
    documentation: string;
    version: string;
    created: Date;
    lastModified: Date;
}
export interface ToolTemplate {
    id: string;
    name: string;
    description: string;
    category: string;
    template: string;
    parameters: any;
    constraints: SafetyConstraints;
    examples: any[];
    documentation: string;
    version: string;
    created: Date;
    lastModified: Date;
}
export interface DSLEngine {
    id: string;
    name: string;
    type: string;
    specification: DSLSpecification;
    grammar: any;
    parser: any;
    compiler: any;
    interpreter: any;
    runtime: any;
    capabilities: string[];
    metadata: Record<string, any>;
}
export interface CodeGenerator {
    id: string;
    name: string;
    type: string;
    implementation: any;
    capabilities: string[];
    metadata: Record<string, any>;
}
export interface GeneratedArtifact {
    type: 'agent' | 'tool' | 'generator' | 'dsl' | 'workflow';
    id: string;
    specification: any;
    artifact: any;
    generatedAt: Date;
    metadata: Record<string, any>;
}
export interface PersonalizedProfile {
    id: string;
    userId: string;
    createdAt: Date;
    lastUpdated: Date;
    learningStyle: LearningStyle;
    cognitiveBiases: CognitiveBias[];
    communicationPrefs: CommunicationPreferences;
    preferencePatterns: PreferencePattern[];
    adaptiveConfig: AdaptiveAssistance;
    personalizationParams: PersonalizationParameters;
    experienceLevel: ExperienceLevel;
    workingStyle: WorkingStyle;
    toolPreferences: ToolPreferences;
    contextualAdaptations: ContextualAdaptation[];
    feedbackPreferences: FeedbackPreferences;
    performanceOptimization: PerformanceOptimization;
    privacySettings: PrivacySettings;
    adaptationHistory: AdaptationEvent[];
    metadata: ProfileMetadata;
}
export interface UserBehaviorAnalysis {
    userId: string;
    analysisId: string;
    timestamp: Date;
    behaviorPatterns: BehaviorPattern[];
    interactionFrequency: InteractionFrequency;
    taskCompletionPatterns: TaskCompletionPattern[];
    errorPatterns: ErrorPattern[];
    learningProgress: LearningProgress;
    adaptationRequirements: AdaptationRequirement[];
    confidenceScore: number;
    metadata: Record<string, any>;
}
export interface PreferencePattern {
    id: string;
    type: 'communication' | 'workflow' | 'tool' | 'feedback' | 'assistance';
    pattern: string;
    frequency: number;
    confidence: number;
    context: string[];
    triggers: string[];
    outcomes: string[];
    adaptations: string[];
}
export interface AdaptiveAssistance {
    id: string;
    userId: string;
    type: 'real-time' | 'contextual' | 'predictive' | 'proactive';
    configuration: AssistanceConfiguration;
    adaptationRules: AdaptationRule[];
    triggers: AssistanceTrigger[];
    responses: AssistanceResponse[];
    learningMechanisms: LearningMechanism[];
    performanceMetrics: AssistanceMetrics;
    status: 'active' | 'inactive' | 'learning' | 'adapting';
}
export interface LearningStyle {
    id: string;
    type: 'visual' | 'auditory' | 'kinesthetic' | 'reading' | 'multimodal';
    preferences: LearningPreferences;
    strengths: string[];
    challenges: string[];
    adaptationStrategies: string[];
    effectivenessMetrics: EffectivenessMetric[];
    confidence: number;
}
export interface CognitiveBias {
    id: string;
    type: string;
    description: string;
    severity: 'low' | 'medium' | 'high';
    impactAreas: string[];
    detectionConfidence: number;
    mitigationStrategies: string[];
    adaptationRequired: boolean;
}
export interface AssistancePersonalization {
    id?: string;
    userId: string;
    context?: any;
    profile?: any;
    adaptationNeeds?: any[];
    personalizedRecommendations?: any[];
    toolBehaviorConfig?: any;
    communicationAdaptation?: any;
    assistanceOptimization?: any;
    adaptationReasoning?: string;
    effectivenessMetrics?: any;
    fallbackStrategies?: any[];
    monitoringConfig?: any;
    metadata?: Record<string, any>;
    personalizationLevel: 'basic' | 'intermediate' | 'advanced' | 'expert';
    customizations: Customization[];
    adaptiveFeatures: AdaptiveFeature[];
    learningHistory: LearningHistoryItem[];
    optimizationGoals: OptimizationGoal[];
    performanceMetrics: PersonalizationMetrics;
}
export interface ProfileOptimization {
    profileId: string;
    optimizationType: 'performance' | 'efficiency' | 'satisfaction' | 'learning';
    optimizationGoals: OptimizationGoal[];
    currentMetrics: ProfileMetrics;
    targetMetrics: ProfileMetrics;
    optimizationActions: OptimizationAction[];
    timeline: OptimizationTimeline;
    results: OptimizationResult[];
}
export interface UserInteractionHistory {
    id: string;
    userId: string;
    timestamp: Date;
    interactionType: 'query' | 'command' | 'feedback' | 'correction' | 'preference';
    content: any;
    context: InteractionContext;
    outcome: InteractionOutcome;
    learningValue: number;
    adaptationTriggers: string[];
}
export interface PersonalizationMetrics {
    userId: string;
    profileId: string;
    timestamp: Date;
    satisfactionScore: number;
    efficiencyGains: number;
    learningProgress: number;
    adaptationSuccess: number;
    usagePatterns: UsagePattern[];
    performanceIndicators: PerformanceIndicator[];
    improvementAreas: ImprovementArea[];
}
export interface CommunicationPreferences {
    verbosity: 'concise' | 'detailed' | 'comprehensive';
    formality: 'casual' | 'professional' | 'academic';
    explanationStyle: 'step-by-step' | 'overview' | 'example-driven';
    feedbackTiming: 'immediate' | 'progressive' | 'summary';
}
export interface PersonalizationParameters {
    adaptationSpeed: 'slow' | 'moderate' | 'fast';
    confidenceThreshold: number;
    learningRate: number;
    contextualSensitivity: number;
    privacyLevel: 'minimal' | 'balanced' | 'maximum';
}
export interface ExperienceLevel {
    overall: 'beginner' | 'intermediate' | 'advanced' | 'expert';
    domains: Record<string, string>;
    confidence: number;
    growthRate: number;
}
export interface WorkingStyle {
    pace: 'methodical' | 'balanced' | 'rapid';
    approach: 'systematic' | 'exploratory' | 'goal-driven';
    collaboration: 'independent' | 'consultative' | 'collaborative';
    planning: 'detailed' | 'flexible' | 'adaptive';
}
export interface ToolPreferences {
    preferred: string[];
    avoided: string[];
    learningInterest: string[];
    proficiency: Record<string, number>;
}
export interface ContextualAdaptation {
    context: string;
    adaptations: string[];
    effectiveness: number;
    lastUsed: Date;
}
export interface FeedbackPreferences {
    frequency: 'minimal' | 'moderate' | 'frequent';
    detail: 'summary' | 'balanced' | 'comprehensive';
    format: 'text' | 'visual' | 'interactive';
    timing: 'immediate' | 'delayed' | 'scheduled';
}
export interface PerformanceOptimization {
    goals: string[];
    strategies: string[];
    metrics: Record<string, number>;
    progress: number;
}
export interface PrivacySettings {
    dataCollection: 'minimal' | 'standard' | 'comprehensive';
    sharing: 'none' | 'anonymized' | 'aggregated';
    retention: 'session' | 'short-term' | 'long-term';
    control: 'user' | 'system' | 'hybrid';
}
export interface AdaptationEvent {
    timestamp: Date;
    type: string;
    trigger: string;
    adaptation: string;
    success: boolean;
    impact: number;
}
export interface ProfileMetadata {
    profileVersion: string;
    dataPoints: number;
    confidenceLevel: number;
    adaptationCapability: string;
    learningCapability: string;
}
export interface BehaviorPattern {
    type: string;
    frequency: number;
    context: string[];
    triggers: string[];
}
export interface InteractionFrequency {
    daily: number;
    weekly: number;
    monthly: number;
    patterns: string[];
}
export interface TaskCompletionPattern {
    taskType: string;
    completionRate: number;
    averageTime: number;
    commonIssues: string[];
}
export interface ErrorPattern {
    errorType: string;
    frequency: number;
    contexts: string[];
    resolutionMethods: string[];
}
export interface LearningProgress {
    overallProgress: number;
    domainProgress: Record<string, number>;
    learningRate: number;
    retentionRate: number;
    moduleProgress?: Record<string, number>;
}
export interface AdaptationRequirement {
    type: string;
    priority: 'low' | 'medium' | 'high';
    description: string;
    implementationComplexity: number;
}
export interface AssistanceConfiguration {
    mode: string;
    sensitivity: number;
    responseTime: number;
    adaptationRate: number;
}
export interface AdaptationRule {
    condition: string;
    action: string;
    priority: number;
    effectiveness: number;
}
export interface AssistanceTrigger {
    type: string;
    condition: string;
    threshold: number;
    action: string;
}
export interface AssistanceResponse {
    trigger: string;
    responseType: string;
    content: any;
    effectiveness: number;
}
export interface LearningMechanism {
    type: string;
    configuration: any;
    effectiveness: number;
    adaptationRate: number;
}
export interface AssistanceMetrics {
    responsiveness: number;
    accuracy: number;
    userSatisfaction: number;
    adaptationSuccess: number;
}
export interface LearningPreferences {
    visualAids: boolean;
    stepByStep: boolean;
    examples: boolean;
    practice: boolean;
}
export interface EffectivenessMetric {
    metric: string;
    value: number;
    trend: 'improving' | 'stable' | 'declining';
    context: string;
}
export interface Customization {
    type: string;
    configuration: any;
    effectiveness: number;
    lastModified: Date;
}
export interface AdaptiveFeature {
    name: string;
    status: 'active' | 'inactive' | 'learning';
    effectiveness: number;
    configuration: any;
}
export interface LearningHistoryItem {
    timestamp: Date;
    concept: string;
    method: string;
    success: boolean;
    retention: number;
}
export interface OptimizationGoal {
    goal: string;
    priority: number;
    target: number;
    current: number;
    timeline: string;
}
export interface ProfileMetrics {
    efficiency: number;
    satisfaction: number;
    learningRate: number;
    adaptationSuccess: number;
}
export interface OptimizationAction {
    action: string;
    expectedImpact: number;
    effort: number;
    timeline: string;
}
export interface OptimizationResult {
    action: string;
    actualImpact: number;
    success: boolean;
    timestamp: Date;
}
export interface InteractionContext {
    sessionId: string;
    taskType: string;
    complexity: number;
    environment: string;
}
export interface InteractionOutcome {
    success: boolean;
    satisfaction: number;
    efficiency: number;
    learningGain: number;
}
export interface UsagePattern {
    pattern: string;
    frequency: number;
    context: string[];
    effectiveness: number;
}
export interface PerformanceIndicator {
    indicator: string;
    value: number;
    trend: 'up' | 'down' | 'stable';
    target: number;
}
export interface ImprovementArea {
    area: string;
    priority: number;
    recommendations: string[];
    expectedGain: number;
}
export type { QualityMetrics } from './ai-tool-integration.js';
export type { TimeRange } from './memory.js';
export interface QualityAlertConfig {
    alertName: string;
    thresholds: QualityThreshold[];
    conditions: string[];
    severity: 'low' | 'medium' | 'high' | 'critical';
    notificationChannels: string[];
    cooldownPeriod: number;
}
export interface QualityInsightsDashboard {
    widgets: DashboardWidget[];
    layout: DashboardLayout;
    refreshInterval: number;
    filters: DashboardFilter[];
    projectId?: string;
}
export interface DashboardWidget {
    id: string;
    type: 'chart' | 'metric' | 'alert' | 'trend';
    title: string;
    configuration: Record<string, any>;
    position: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
}
export interface DashboardLayout {
    columns: number;
    rows: number;
    spacing: number;
}
export interface DashboardFilter {
    field: string;
    value: any;
    operator: 'equals' | 'contains' | 'greater' | 'less';
}
export interface QualityPredictionPoint {
    timestamp: Date;
    value: number;
    confidence: number;
    upperBound: number;
    lowerBound: number;
    factors: string[];
}
export interface SeasonalityInfo {
    period: 'hourly' | 'daily' | 'weekly' | 'monthly' | 'quarterly';
    amplitude: number;
    phase: number;
    confidence: number;
}
export interface AIDecisionConflict {
    id: string;
    type: 'priority' | 'resource' | 'approach' | 'timing';
    conflictingRecommendations: ToolRecommendation[];
    severity: 'low' | 'medium' | 'high' | 'critical';
    context: Record<string, any>;
    metadata?: Record<string, any>;
}
export interface DecisionHierarchy {
    id: string;
    name: string;
    description: string;
    priority: number;
    criteria: DecisionCriteria[];
    rules: DecisionRule[];
    fallbackStrategy: string;
    metadata?: Record<string, any>;
    context?: any;
    availableTools?: any[];
    overrideRules?: any[];
    consensusThreshold?: number;
    domainExpertise?: any;
    toolDomainMapping?: any;
    dynamicWeights?: any;
    qualityMetrics?: any;
    validationCriteria?: any;
    decisionLevels?: any;
    conflictResolutionPath?: string;
    relationships?: any[];
    levels?: any[];
    adaptationRules?: {
        triggers: string[];
        actions: string[];
        conditions: Record<string, any>;
        learningRate: number;
    };
}
export interface DecisionRule {
    condition: string;
    action: string;
    priority: number;
}
export interface ToolRecommendation {
    tool: string;
    toolName?: string;
    confidence: number;
    reasoning: string;
    expectedOutcome: string;
    alternatives?: string[];
    context?: Record<string, any>;
    metadata?: Record<string, any>;
}
export interface DecisionWeight {
    criteria: string;
    weight: number;
    justification: string;
    context?: Record<string, any>;
}
export interface ConsensusMetrics {
    agreement: number;
    confidence: number;
    participantCount: number;
    convergenceTime: number;
    qualityScore: number;
}
export interface DecisionQuality {
    score: number;
    factors: string[];
    confidence: number;
    risks: string[];
    opportunities: string[];
}
export interface AIToolTrainingModule {
    id: string;
    name: string;
    description: string;
    targetSkills: string[];
    difficulty: 'beginner' | 'intermediate' | 'advanced';
    estimatedDuration: number;
    prerequisites: string[];
    content: TrainingContent[] | {
        theory?: string;
        practice?: string;
        assessment?: string;
    };
    toolName?: string;
    competencyLevel?: string;
    duration?: number;
    objectives?: string[];
    exercises?: string[];
    assessmentCriteria?: string[];
}
export interface TrainingContent {
    type: 'text' | 'code' | 'exercise' | 'quiz';
    content: string;
    metadata?: Record<string, any>;
}
export interface PersonalizedTraining {
    userId: string;
    modules: string[];
    progress: Record<string, number>;
    adaptations: AdaptationDecision[];
    schedule: TrainingSchedule;
    assessment?: any;
    learningGoals?: any;
    timeConstraints?: any;
    id?: string;
    learningAnalysis?: {
        complexity?: string;
        focusAreas?: string[];
        estimatedEffort?: string;
        preferredStyle?: string;
        [key: string]: any;
    };
    selectedModules?: string[];
    moduleSequence?: string[];
    adaptiveParams?: any;
    progressTracking?: any;
    milestones?: any[];
    estimatedDuration?: number;
    difficultyProgression?: any;
    practiceExercises?: any[];
    assessmentSchedule?: any;
    supportResources?: any[];
    feedback?: any;
    metadata?: any;
}
export interface TrainingSchedule {
    sessions: TrainingSession[];
    frequency: 'daily' | 'weekly' | 'biweekly';
    duration: number;
}
export interface TrainingSession {
    date: Date;
    modules: string[];
    completed: boolean;
    feedback?: string;
}
export interface AdaptationDecision {
    type: 'difficulty' | 'pace' | 'content' | 'approach';
    decision: string;
    reasoning: string;
    timestamp: Date;
}
export interface LearningPath {
    id: string;
    pathId: string;
    name: string;
    description: string;
    modules: string[];
    prerequisites: string[];
    estimatedDuration: number;
    difficulty: 'beginner' | 'intermediate' | 'advanced';
    milestones?: any[];
    estimatedCompletion?: Date;
    adaptivePacing?: any;
    personalization?: any;
    created?: Date;
    lastUpdated?: Date;
}
export interface SkillGap {
    skill: string;
    current: number;
    target: number;
    priority: 'low' | 'medium' | 'high';
    recommendations: string[];
}
export interface TrainingMetrics {
    completionRate: number;
    averageScore: number;
    timeSpent: number;
    skillImprovement: Record<string, number>;
    engagement: number;
}
export interface TrainingProtocol {
    id: string;
    name: string;
    description: string;
    steps: TrainingStep[];
    assessment: AssessmentCriteria[];
    toolName?: string;
    competencyLevels?: any;
    trainingModules?: any[];
    prerequisites?: string[];
    estimatedDuration?: number;
    difficultyProgression?: string;
    assessmentCriteria?: string[];
    successMetrics?: {
        completionRate?: number;
        performanceImprovement?: number;
        userSatisfaction?: number;
    };
}
export interface TrainingStep {
    order: number;
    name: string;
    description: string;
    type: 'learn' | 'practice' | 'assess';
    content: string;
    expectedDuration: number;
}
export interface AssessmentCriteria {
    name: string;
    weight: number;
    passingScore: number;
    evaluationMethod: string;
}
export interface TrainingRecommendation {
    moduleId: string;
    modules: string[];
    title: string;
    description: string;
    difficulty: 'beginner' | 'intermediate' | 'advanced';
    estimatedDuration: string;
    prerequisites: string[];
    objectives: string[];
    learningPath: string;
    priority: 'low' | 'medium' | 'high';
    reasoning: string;
    estimatedBenefit: number;
    relevance: number;
    adaptiveSettings?: any;
    progressTracking?: any;
}
export interface AgentAvailability {
    agentId: string;
    available: boolean;
    currentLoad: number;
    maxCapacity: number;
    estimatedFreeTime?: Date;
    capabilities: string[];
}
export interface CompetencyLevel {
    skill: string;
    level: number;
    confidence: number;
    lastAssessed: Date;
    evidence: string[];
    trends?: {
        direction: 'improving' | 'stable' | 'declining';
        velocity: number;
        confidence: number;
    };
    stability?: number;
}
export interface ExecutionPlan {
    id: string;
    tasks: ExecutionTask[];
    phases: ExecutionPhase[];
    dependencies: TaskDependency[];
    estimatedDuration: number;
    priority: 'low' | 'medium' | 'high';
    resources: string[];
}
export interface ExecutionPhase {
    id: string;
    name: string;
    description: string;
    tasks: string[];
    dependencies: string[];
    estimatedDuration: number;
    status: 'pending' | 'in_progress' | 'completed' | 'failed';
    parallel: boolean;
}
export interface ExecutionTask {
    id: string;
    name: string;
    description: string;
    agent: string;
    estimatedDuration: number;
    status: 'pending' | 'in_progress' | 'completed' | 'failed';
    dependencies: string[];
}
export interface TaskDependency {
    taskId: string;
    dependsOn: string;
    type: 'hard' | 'soft';
}
export interface TaskRequirements {
    skills: string[];
    resources: string[];
    constraints: Record<string, any>;
    priority: 'low' | 'medium' | 'high';
    deadline?: Date;
    tasks: string[];
}
export interface UserRequest {
    id: string;
    type: string;
    content: string;
    context: Record<string, any>;
    timestamp: Date;
    priority: 'low' | 'medium' | 'high';
    userId?: string;
}
export interface OrchestratorResponse {
    requestId: string;
    result: any;
    agents: string[];
    executionTime: number;
    success: boolean;
    errors?: string[];
    metadata?: Record<string, any>;
}
export interface AdaptiveFilter {
    id: string;
    name: string;
    description: string;
    rules: FilteringRule[];
    adaptationHistory: FilterAdaptation[];
    effectiveness: number;
    userId?: string;
    behaviorAnalysis?: any;
    preferencePatterns?: any;
    adaptiveRules?: any;
    fallbackStrategy?: any;
    validationCriteria?: any;
    personalizationParams?: Record<string, any>;
    learningRate?: number;
    dynamicWeights?: any;
    adaptationTriggers?: any[];
    confidenceLevel?: number;
    performanceMetrics?: any;
    updateFrequency?: number;
}
export interface FilteringRule {
    condition: string;
    action: 'include' | 'exclude' | 'modify';
    priority: number;
    confidence: number;
}
export interface FilterAdaptation {
    timestamp: Date;
    change: string;
    reason: string;
    effectiveness: number;
}
export interface FilteringCriteria {
    relevance: number;
    quality: number;
    timeliness: number;
    userPreference: number;
    contextMatch: number;
    maxResults?: number;
    filteringStrategy?: string;
    relevanceThreshold?: number;
    prioritizeTypes?: string[];
    contextWeights?: Record<string, number>;
    excludeTypes?: string[];
}
export interface FilteringMetrics {
    precision: number;
    recall: number;
    f1Score: number;
    userSatisfaction: number;
    processingTime: number;
    id?: string;
    filteringStrategy?: string;
    inputCount?: number;
    outputCount?: number;
    reductionRate?: number;
}
export interface FilteringResult {
    id?: string;
    original: any[];
    filtered: any[];
    removed: any[];
    confidence: number;
    reasoning: string[];
    filteredSuggestions?: any[];
    originalSuggestions?: any[];
    criteria?: any;
    context?: any;
    userFeedback?: any;
    learningInsights?: any;
    metadata?: Record<string, any>;
    metrics?: Record<string, any>;
    filteringSteps?: any[];
    relevanceScores?: any;
}
export interface SuggestionPriority {
    value: number;
    factors: string[];
    confidence: number;
    adjustments: PriorityAdjustment[];
}
export interface PriorityAdjustment {
    factor: string;
    impact: number;
    reasoning: string;
}
export interface RelevanceScore {
    value: number;
    components: Record<string, number>;
    confidence: number;
    explanation: string;
    overall?: number;
    contextual?: number;
    temporal?: number;
    personal?: number;
}
//# sourceMappingURL=index.d.ts.map