@flexabrain/mcp-server/dist/types/schematic.d.ts

Advanced electrical schematic analysis MCP server with rail engineering expertise

/**
 * FlexaBrain MCP Server - Schematic Analysis Type Definitions
 *
 * This file contains type definitions for electrical schematic analysis,
 * including OCR results, analysis outputs, and recommendation structures.
 */
import { ElectricalComponent, Connection, ValidationResult, CircuitPath, PowerFlow, GroundingSystem, SchematicType, SafetyLevel, ValidationIssue } from './electrical.js';
export interface OCRWord {
    text: string;
    confidence: number;
    bbox: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
}
export interface OCRResult {
    text: string;
    confidence: number;
    words: OCRWord[];
    processing_time: number;
    language: string;
}
export interface ImagePreprocessingResult {
    processed_image_path: string;
    original_dimensions: {
        width: number;
        height: number;
    };
    processed_dimensions: {
        width: number;
        height: number;
    };
    applied_filters: string[];
    enhancement_quality: number;
}
export interface ComponentRecognitionResult {
    components: ElectricalComponent[];
    total_components: number;
    recognized_components: number;
    overall_confidence: number;
    processing_time: number;
    unrecognized_text: string[];
}
export interface ConnectionAnalysisResult {
    connections: Connection[];
    circuit_paths: CircuitPath[];
    total_connections: number;
    processing_time: number;
    topology_complexity: 'SIMPLE' | 'MODERATE' | 'COMPLEX' | 'VERY_COMPLEX';
}
export interface CircuitTopology {
    power_sources: ElectricalComponent[];
    loads: ElectricalComponent[];
    protection_devices: ElectricalComponent[];
    control_circuits: CircuitPath[];
    signal_circuits: CircuitPath[];
    grounding_system: GroundingSystem;
    power_flows: PowerFlow[];
    power_factor?: number;
    load_balance?: number;
    validation_results: ValidationResult;
}
export declare enum RecommendationType {
    SAFETY = "safety",
    MAINTENANCE = "maintenance",
    PERFORMANCE = "performance",
    COMPLIANCE = "compliance",
    COST_OPTIMIZATION = "cost_optimization",
    ENERGY_EFFICIENCY = "energy_efficiency"
}
export declare enum RecommendationPriority {
    CRITICAL = "critical",
    HIGH = "high",
    MEDIUM = "medium",
    LOW = "low",
    INFORMATIONAL = "informational"
}
export interface Recommendation {
    id: string;
    type: RecommendationType;
    priority: RecommendationPriority;
    category: string;
    title: string;
    description: string;
    details?: string;
    action: string;
    component_ids?: string[];
    estimated_cost?: 'LOW' | 'MEDIUM' | 'HIGH' | 'VERY_HIGH';
    expected_benefit?: string;
    payback_period?: string;
    roi_estimate?: number;
    timeline?: string;
    frequency?: {
        value: number;
        unit: 'days' | 'weeks' | 'months' | 'years';
    };
    standards?: string[];
    regulations?: string[];
    risk_if_ignored?: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    safety_impact?: SafetyLevel;
}
export interface ExpertRecommendations {
    recommendations: Recommendation[];
    summary: {
        total_recommendations: number;
        critical_count: number;
        high_priority_count: number;
        estimated_total_cost: string;
        estimated_total_savings: string;
    };
    next_actions: {
        immediate: Recommendation[];
        short_term: Recommendation[];
        long_term: Recommendation[];
    };
}
export interface SafetyAnalysis {
    overall_safety_level: SafetyLevel;
    arc_flash_hazards: {
        present: boolean;
        components: string[];
        estimated_energy: number;
        ppe_category: number;
    };
    electrical_shock_hazards: {
        present: boolean;
        voltage_levels: number[];
        components: string[];
    };
    ground_fault_risks: {
        present: boolean;
        unprotected_circuits: string[];
        recommendations: string[];
    };
    fire_hazards: {
        present: boolean;
        overloaded_circuits: string[];
        inadequate_protection: string[];
    };
    safety_recommendations: Recommendation[];
}
export interface ComplianceReport {
    overall_compliance: number;
    standards_checked: string[];
    compliant_items: {
        standard: string;
        item: string;
        status: 'COMPLIANT';
        notes?: string;
    }[];
    non_compliant_items: {
        standard: string;
        item: string;
        status: 'NON_COMPLIANT';
        violation: string;
        recommendation: string;
        priority: RecommendationPriority;
    }[];
    requires_review: {
        standard: string;
        item: string;
        status: 'REQUIRES_REVIEW';
        reason: string;
        expert_needed: boolean;
    }[];
}
export interface MaintenanceGuidance {
    component_schedules: {
        component_id: string;
        component_type: string;
        next_inspection: Date;
        next_testing?: Date;
        next_calibration?: Date;
        next_overhaul?: Date;
        estimated_replacement?: Date;
    }[];
    priority_actions: {
        action: string;
        component_ids: string[];
        urgency: 'IMMEDIATE' | 'URGENT' | 'SCHEDULED' | 'ROUTINE';
        estimated_duration: string;
        estimated_cost: string;
    }[];
    maintenance_recommendations: Recommendation[];
}
export interface PerformanceAnalysis {
    efficiency_metrics: {
        overall_efficiency: number;
        power_factor: number;
        load_balance: number;
        harmonic_distortion?: number;
    };
    optimization_opportunities: {
        energy_savings_potential: number;
        cost_reduction_potential: number;
        reliability_improvement: string[];
    };
    performance_recommendations: Recommendation[];
}
export interface SchematicAnalysis {
    image_path: string;
    schematic_type: SchematicType;
    analysis_timestamp: Date;
    processing_time: number;
    image_preprocessing: ImagePreprocessingResult;
    ocr_results: OCRResult;
    component_recognition: ComponentRecognitionResult;
    components: ElectricalComponent[];
    connection_analysis: ConnectionAnalysisResult;
    circuit_topology: CircuitTopology;
    safety_analysis: SafetyAnalysis;
    compliance_report: ComplianceReport;
    maintenance_guidance: MaintenanceGuidance;
    performance_analysis: PerformanceAnalysis;
    expert_recommendations: ExpertRecommendations;
    overall_confidence: number;
    analysis_quality: 'EXCELLENT' | 'GOOD' | 'ACCEPTABLE' | 'POOR';
    limitations: string[];
    assumptions: string[];
    analyzer_version: string;
    rail_expertise_applied: boolean;
    standards_version: string;
}
export interface AnalysisRequest {
    image_path: string;
    schematic_type?: SchematicType;
    analysis_depth?: 'basic' | 'standard' | 'comprehensive';
    focus_areas?: ('safety' | 'compliance' | 'performance' | 'maintenance')[];
    custom_standards?: string[];
    rail_system_context?: {
        system_type: 'METRO' | 'LIGHT_RAIL' | 'HEAVY_RAIL' | 'HIGH_SPEED' | 'FREIGHT';
        voltage_system: string;
        region: string;
        applicable_standards: string[];
    };
}
export interface BatchAnalysisRequest {
    schematics: AnalysisRequest[];
    output_format: 'JSON' | 'PDF' | 'HTML';
    generate_summary: boolean;
    comparison_analysis: boolean;
}
export interface BatchAnalysisResult {
    analyses: SchematicAnalysis[];
    summary: {
        total_schematics: number;
        successful_analyses: number;
        failed_analyses: number;
        common_issues: ValidationIssue[];
        overall_recommendations: Recommendation[];
    };
    comparison?: {
        design_consistency: number;
        standard_compliance: number;
        common_patterns: string[];
        variations: string[];
    };
}
export interface AnalysisError {
    code: string;
    message: string;
    details?: string;
    component_id?: string;
    recovery_suggestions: string[];
}
export interface AnalysisWarning {
    code: string;
    message: string;
    component_id?: string;
    impact: 'LOW' | 'MEDIUM' | 'HIGH';
}
export interface AnalysisResult {
    success: boolean;
    analysis?: SchematicAnalysis;
    errors?: AnalysisError[];
    warnings?: AnalysisWarning[];
    processing_stats: {
        total_time: number;
        ocr_time: number;
        analysis_time: number;
        validation_time: number;
    };
}
//# sourceMappingURL=schematic.d.ts.map