supa-seed/dist/features/detection/override-validator.d.ts

A constraint-aware, framework-agnostic database seeding framework with deep PostgreSQL business logic discovery and MakerKit integration support

/**
 * Override Validation System for Epic 2: Smart Platform Detection Engine
 * Validates manual platform and domain overrides against auto-detection results
 * Part of Task 2.4.2: Create override validation utilities (FR-2.5)
 */
import type { FlexibleSeedConfig } from '../../core/types/config-types';
import type { UnifiedDetectionResult } from './detection-integration';
import type { PlatformArchitectureType, ContentDomainType, ConfidenceLevel } from './detection-types';
/**
 * Override validation result
 */
export interface OverrideValidationResult {
    /** Whether the overall validation passed */
    valid: boolean;
    /** Validation confidence score */
    confidence: number;
    /** Validation confidence level */
    confidenceLevel: ConfidenceLevel;
    /** Platform architecture validation */
    platformArchitecture: {
        hasOverride: boolean;
        overrideValue?: PlatformArchitectureType;
        detectedValue?: PlatformArchitectureType;
        conflictSeverity: 'none' | 'low' | 'medium' | 'high';
        recommendedAction: 'proceed' | 'warn' | 'review' | 'reject';
        validation: {
            valid: boolean;
            confidence: number;
            reasoning: string[];
            warnings: string[];
        };
    };
    /** Content domain validation */
    contentDomain: {
        hasOverride: boolean;
        overrideValue?: ContentDomainType;
        detectedValue?: ContentDomainType;
        conflictSeverity: 'none' | 'low' | 'medium' | 'high';
        recommendedAction: 'proceed' | 'warn' | 'review' | 'reject';
        validation: {
            valid: boolean;
            confidence: number;
            reasoning: string[];
            warnings: string[];
        };
    };
    /** Overall validation metadata */
    validation: {
        totalConflicts: number;
        highSeverityConflicts: number;
        validationTime: number;
        validationMethod: string;
        recommendations: string[];
        warnings: string[];
        errors: string[];
    };
}
/**
 * Override conflict types
 */
export interface OverrideConflict {
    type: 'platform_architecture_mismatch' | 'content_domain_mismatch' | 'configuration_inconsistency';
    severity: 'low' | 'medium' | 'high';
    description: string;
    overrideValue: string;
    detectedValue: string;
    detectionConfidence: number;
    suggestedResolution: string;
    autoFixAvailable: boolean;
}
/**
 * Override validation options
 */
export interface OverrideValidationOptions {
    /** Whether to enable strict validation mode */
    strictMode: boolean;
    /** Warning level for validation output */
    warningLevel: 'none' | 'basic' | 'detailed';
    /** Minimum confidence threshold to challenge overrides */
    confidenceThreshold: number;
    /** Whether to validate domain-specific configurations */
    validateDomainSpecific: boolean;
    /** Whether to check for configuration inconsistencies */
    checkConfigurationConsistency: boolean;
    /** Whether to suggest auto-fixes for conflicts */
    suggestAutoFixes: boolean;
}
/**
 * Main Override Validation Engine
 */
export declare class OverrideValidator {
    /**
     * Validate manual overrides against detection results
     */
    validateOverrides(config: FlexibleSeedConfig, detectionResults: UnifiedDetectionResult, options?: Partial<OverrideValidationOptions>): Promise<OverrideValidationResult>;
    /**
     * Validate platform architecture override
     */
    private validatePlatformArchitectureOverride;
    /**
     * Validate content domain override
     */
    private validateContentDomainOverride;
    /**
     * Validate domain-specific configurations
     */
    private validateDomainSpecificConfigurations;
    /**
     * Check if architecture override is logically consistent with detected patterns
     */
    private isArchitectureLogicallyConsistent;
    /**
     * Check if domain override is logically consistent with detected patterns
     */
    private isDomainLogicallyConsistent;
    /**
     * Generate validation recommendations
     */
    private generateValidationRecommendations;
    /**
     * Count total conflicts
     */
    private countConflicts;
    /**
     * Count high-severity conflicts
     */
    private countHighSeverityConflicts;
    /**
     * Get confidence level from score
     */
    private getConfidenceLevel;
    /**
     * Create failure result
     */
    private createFailureResult;
    /**
     * Merge options with defaults
     */
    private mergeWithDefaults;
}
/**
 * Utility functions for override validation
 */
export declare class OverrideValidationUtils {
    /**
     * Check if configuration has any manual overrides
     */
    static hasManualOverrides(config: FlexibleSeedConfig): boolean;
    /**
     * Extract override summary for logging
     */
    static getOverrideSummary(config: FlexibleSeedConfig): string;
    /**
     * Create default validation options
     */
    static getDefaultValidationOptions(): OverrideValidationOptions;
    /**
     * Format validation result for display
     */
    static formatValidationResult(result: OverrideValidationResult): string;
}
/**
 * Default override validation options
 */
export declare const DEFAULT_OVERRIDE_VALIDATION_OPTIONS: OverrideValidationOptions;
//# sourceMappingURL=override-validator.d.ts.map