import { AgentConfig, ReasoningStep } from '../types/index.js';
type ReasoningChain = {
    id: string;
    steps: ReasoningStep[];
    context: any;
    result?: any;
};
type ReasoningContext = {
    problem: string;
    constraints: any[];
    goals: any[];
    resources: any[];
    startTime?: number;
    dataQuality?: number;
};
type ReasoningRequest = {
    id: string;
    problemId: string;
    type: string;
    problem: string;
    context: ReasoningContext;
    priority: 'low' | 'medium' | 'high' | 'critical';
    domain: string;
    constraints: any[];
    objectives?: any[];
    data?: any;
    timeLimit?: number;
    requestedBy?: string;
    expectedOutcome?: any;
};
type ReasoningResult = {
    id: string;
    problemId: string;
    chain: ReasoningChain;
    conclusion: string;
    confidence: number;
    evidence: any[];
    hypotheses?: any[];
    success?: boolean;
    verification?: ReasoningVerification;
    duration?: number;
    qualityScore?: number;
    decomposition?: any;
};
type DecisionTree = {
    id?: string;
    nodes: any[];
    paths: any[];
    optimal_path: any[];
    edges?: any[];
    root?: string;
    leaves?: any[];
    decisions?: any[];
    criteria?: any[];
    constraints?: any[];
    optimization?: any;
    validation?: any;
    metrics?: any;
    metadata?: any;
};
type ReasoningVerification = {
    id?: string;
    valid: boolean;
    errors: string[];
    suggestions: string[];
    contradictions?: any[];
    quality?: any;
    confidence?: number;
    score?: number;
    overallConfidence?: number;
};
type ProbabilisticReasoning = {
    id?: string;
    probabilities: Record<string, number>;
    distribution: any;
    confidence: number;
    priorBeliefs?: any[];
    evidence?: any[];
    hypotheses?: any[];
    priorProbabilities?: any;
    likelihoods?: any;
    posteriorProbabilities?: any;
    monteCarloSamples?: any[];
    credibleIntervals?: any;
    sensitivityAnalysis?: any;
    modelComparison?: any;
    recommendations?: any;
    metadata?: any;
};
export declare class AutonomousReasoningEngineService {
    private config;
    private logger;
    private executionEngine;
    constructor(config: AgentConfig);
    executeReasoning(request: ReasoningRequest): Promise<ReasoningResult>;
    private buildReasoningChain;
    private executeReasoningSteps;
    private verifyReasoning;
    buildOptimizedDecisionTree(choices: any[]): Promise<DecisionTree>;
    executeReasoningWorkflow(request: AutonomousDevelopmentRequest): Promise<AutonomousDevelopmentResult>;
    private analyzeComplexity;
    private optimizePerformance;
    performProbabilisticReasoning(priorKnowledge: any[], evidenceData: any[], riskHypotheses: any[]): Promise<ProbabilisticReasoning>;
}
export declare class AutonomousWorkflowOrchestrator {
    private executionEngine;
    private reasoningEngine;
    private evolutionEngine;
    private metaProgrammingEngine;
    private crossProjectIntelligence;
    private logger;
    constructor(config: AgentConfig);
    executeAutonomousDevelopment(request: AutonomousDevelopmentRequest): Promise<AutonomousDevelopmentResult>;
    private analyzeRequirements;
    private generateCode;
    private executeAndValidate;
    private selfHealAndOptimize;
    private evolveAndLearn;
    private shareKnowledge;
    private generateDevelopmentPlan;
    private extractQualityTargets;
    private generateServiceCode;
    private generateTypesCode;
    private generateTestCode;
    private generateDocumentation;
    private toPascalCase;
    private assessCodeQuality;
    private assessMaintainability;
    private calculateQualityMetrics;
    private calculateOverallConfidence;
    private assessAutonomyLevel;
    private calculateComplexityScore;
    private calculateQualityImprovement;
    private assessFinalCodeQuality;
    private optimizePerformance;
    private generateRecommendations;
    private initializeOrchestrator;
    generateResolutionStrategies(conflicts: any[]): Promise<any>;
    applyResolutionStrategies(strategies: any[], context: any): Promise<any>;
    validateResolutions(resolutions: any[]): Promise<any>;
    calculatePriorProbabilities(data: any): Promise<any>;
    calculateLikelihoods(observations: any): Promise<any>;
    applyBayesTheorem(priors: any, likelihoods: any): Promise<any>;
    performMonteCarloSampling(parameters: any): Promise<any>;
}
interface AutonomousDevelopmentRequest {
    projectId: string;
    problemId?: string;
    type?: string;
    description: string;
    domain?: string;
    priority?: 'low' | 'medium' | 'high' | 'critical';
    timeLimit?: number;
    constraints?: any[];
    objectives?: any[];
    qualityTargets?: {
        testCoverage?: number;
        codeQuality?: number;
        securityScore?: number;
        performance?: string;
        maintainability?: string;
    };
    contextData?: any[];
    priorKnowledge?: any[];
    evidenceData?: any[];
    riskHypotheses?: any[];
    architecturalChoices?: any[];
    decisionCriteria?: any[];
}
interface AutonomousDevelopmentResult {
    projectId: string;
    success: boolean;
    error?: string;
    phases: {
        reasoning?: any;
        codeGeneration?: any;
        execution?: any;
        healing?: any;
        evolution?: any;
        knowledge?: any;
    };
    generatedCode: any[];
    testSuite: any;
    qualityMetrics: any;
    evolutionImprovements: any[];
    crossProjectLearnings: any[];
    totalExecutionTime: number;
    confidence: number;
    recommendations: string[];
    metadata: any;
}
export {};
//# sourceMappingURL=autonomous-reasoning-engine.d.ts.map