adpa-enterprise-framework-automation/dist/modules/pmbokValidation/ValidationFactory.d.ts

Modular, standards-compliant Node.js/TypeScript automation framework for enterprise requirements, project, and data management. Provides CLI and API for BABOK v3, PMBOK 7th Edition, and DMBOK 2.0 (in progress). Production-ready Express.js API with TypeSpe

/**
 * Validation Processing Factory
 *
 * Core orchestrator for the ADPA Quality Assurance Engine validation system.
 * Manages the execution of multiple validators and aggregates results into
 * comprehensive compliance reports.
 *
 * This factory provides the main interface for running validation checks
 * and follows the same architectural pattern as the DocumentGenerator's
 * ProcessorFactory for consistency and maintainability.
 *
 * @version 1.0.0
 * @author ADPA Quality Assurance Engine Team
 * @created June 2025
 */
import { IValidator, ValidationConfig, ValidationResult } from './interfaces/IValidator.js';
/**
 * Comprehensive validation report aggregating all validator results
 */
export interface ComprehensiveValidationReport {
    /** Overall validation summary */
    summary: {
        totalValidators: number;
        passedValidators: number;
        failedValidators: number;
        overallScore: number;
        maxPossibleScore: number;
        overallPassed: boolean;
        executionTimeMs: number;
        timestamp: Date;
    };
    /** Results from individual validators */
    validatorResults: ValidationResult[];
    /** Aggregated issues by severity */
    issuesSummary: {
        critical: string[];
        warning: string[];
        info: string[];
    };
    /** Aggregated strengths */
    strengths: string[];
    /** Aggregated recommendations */
    recommendations: string[];
    /** Consistency score for cross-document validation */
    consistencyScore: number;
    /** Document-specific scores */
    documentScores: Record<string, {
        score: number;
        maxScore: number;
        issues: string[];
        strengths: string[];
    }>;
    /** PMBOK compliance assessment */
    pmbokCompliance: {
        score: number;
        isCompliant: boolean;
        missingElements: string[];
        documentQuality: Record<string, any>;
    };
}
/**
 * Options for validation execution
 */
export interface ValidationExecutionOptions {
    /** Whether to run validations in parallel */
    parallel?: boolean;
    /** Maximum number of concurrent validations */
    maxConcurrency?: number;
    /** Whether to stop on first critical failure */
    stopOnCriticalFailure?: boolean;
    /** Whether to include detailed analysis */
    includeDetailedAnalysis?: boolean;
    /** Specific validators to run (if not provided, runs all applicable) */
    validatorIds?: string[];
    /** Tags to filter validators */
    tags?: string[];
    /** Minimum score threshold for overall compliance */
    complianceThreshold?: number;
}
/**
 * Main validation processing factory
 */
export declare class ValidationFactory {
    private registry;
    constructor();
    /**
     * Run comprehensive validation on the provided documents
     * @param config Validation configuration
     * @param options Execution options
     * @returns Comprehensive validation report
     */
    runComprehensiveValidation(config: ValidationConfig, options?: ValidationExecutionOptions): Promise<ComprehensiveValidationReport>;
    /**
     * Run a specific validator
     * @param validatorId The validator ID to run
     * @param config Validation configuration
     * @returns Validation result
     */
    runValidator(validatorId: string, config: ValidationConfig): Promise<ValidationResult | null>;
    /**
     * Get available validators for the given document types
     * @param documentTypes Document types to check
     * @returns Array of applicable validators
     */
    getApplicableValidators(documentTypes: string[]): IValidator[];
    /**
     * Register a new validator
     * @param validator The validator to register
     * @param options Registration options
     */
    registerValidator(validator: IValidator, options?: {
        enabled?: boolean;
        version?: string;
        tags?: string[];
        metadata?: Record<string, any>;
    }): void;
    /**
     * Get registry statistics
     */
    getStats(): {
        totalValidators: number;
        enabledValidators: number;
        disabledValidators: number;
        totalTags: number;
        validatorsByPriority: Record<number, number>;
    };
    /**
     * List all registered validators
     */
    listValidators(): void;
    /**
     * Run validators in parallel
     */
    private runValidatorsInParallel;
    /**
     * Run validators sequentially
     */
    private runValidatorsSequentially;
    /**
     * Safely run a validator with error handling
     */
    private runValidatorSafely;
    /**
     * Aggregate validation results into comprehensive report
     */
    private aggregateResults;
}
//# sourceMappingURL=ValidationFactory.d.ts.map