/**
 * Cross-Language SOLID Analyzer
 * Enhanced SOLID principle analysis that works across multiple languages
 * using the cross-language entity model
 */
import { CrossLanguageEntity, CrossReference } from '../../types/crossLanguage.js';
import { Violation } from '../../types.js';
export interface CrossLanguageSOLIDConfig {
    maxResponsibilities: number;
    maxDependencies: number;
    maxInterfaceMembers: number;
    maxComplexity: number;
    maxParameters: number;
    checkAbstractions: boolean;
    checkPolymorphism: boolean;
    enableCrossLanguageAnalysis: boolean;
    minCrossLanguageViolationConfidence: number;
    /** Function name substrings that suggest switch-like dispatch patterns (open-closed principle).
     *  English defaults — non-English codebases should override. */
    switchLikeNames: string[];
}
export interface CrossLanguageSOLIDViolation extends Violation {
    principle: 'SRP' | 'OCP' | 'LSP' | 'ISP' | 'DIP';
    entityId: string;
    entityName: string;
    entityType: string;
    language: string;
    crossLanguageIssue: boolean;
    relatedEntities?: Array<{
        id: string;
        name: string;
        language: string;
        relationship: string;
    }>;
    responsibilityCount?: number;
    dependencyCount?: number;
    memberCount?: number;
    confidence: number;
}
export declare class CrossLanguageSOLIDAnalyzer {
    private config;
    constructor(config?: Partial<CrossLanguageSOLIDConfig>);
    /**
     * Analyze SOLID principles across multiple languages
     */
    analyze(entities: CrossLanguageEntity[], references: CrossReference[]): Promise<CrossLanguageSOLIDViolation[]>;
    /**
     * Single Responsibility Principle - Enhanced for cross-language
     */
    private analyzeSingleResponsibility;
    /**
     * Open/Closed Principle - Cross-language switch detection
     */
    private analyzeOpenClosed;
    /**
     * Liskov Substitution Principle - Cross-language inheritance analysis
     */
    private analyzeLiskovSubstitution;
    /**
     * Interface Segregation Principle - Cross-language interface analysis
     */
    private analyzeInterfaceSegregation;
    /**
     * Dependency Inversion Principle - Cross-language abstraction analysis
     */
    private analyzeDependencyInversion;
    /**
     * Cross-Language specific SOLID violations
     */
    private analyzeCrossLanguageSOLID;
    /**
     * Count responsibilities considering cross-language factors
     */
    private countResponsibilities;
    /**
     * Detect polymorphism opportunities across languages
     */
    private detectPolymorphismOpportunities;
    /**
     * Find cross-language inheritance hierarchies
     */
    private findCrossLanguageHierarchies;
    /**
     * Build hierarchy from inheritance relationships
     */
    private buildHierarchy;
    /**
     * Analyze hierarchy for LSP violations
     */
    private analyzeHierarchyForLSP;
    /**
     * Analyze interface usage across languages
     */
    private analyzeInterfaceUsage;
    /**
     * Analyze dependencies for DIP violations
     */
    private analyzeDependencies;
    /**
     * Check if entity is concrete type
     */
    private isConcreteType;
    /**
     * Detect API boundary violations
     */
    private detectAPIBoundaryViolations;
    /**
     * Detect responsibility leakage across languages
     */
    private detectResponsibilityLeakage;
    /**
     * Detect distributed interface violations
     */
    private detectDistributedInterfaceViolations;
    private generateSRPSuggestion;
    private generateOCPSuggestion;
    private generateISPSuggestion;
    private generateDIPSuggestion;
}
//# sourceMappingURL=CrossLanguageSOLIDAnalyzer.d.ts.map