import { EventEmitter } from 'events';
import { AIToolType, SemanticInformation, PerformanceMetrics, QualityMetrics } from '../types';
export interface CommunicationProtocol {
    id: string;
    name: string;
    version: string;
    participants: AIToolType[];
    messageTypes: MessageType[];
    semanticSchemas: SemanticSchema[];
    validationRules: ValidationRule[];
    transformationRules: TransformationRule[];
    qualityAssurance: QualityAssuranceConfig;
    performanceConfig: PerformanceConfig;
}
export interface MessageType {
    type: string;
    description: string;
    structure: MessageStructure;
    requiredFields: string[];
    optionalFields: string[];
    semanticAnnotations: SemanticAnnotation[];
    validationSchema: any;
}
export interface MessageStructure {
    headers: Record<string, any>;
    payload: PayloadStructure;
    metadata: MetadataStructure;
    routing: RoutingStructure;
}
export interface PayloadStructure {
    dataType: 'text' | 'structured' | 'binary' | 'semantic' | 'hybrid';
    contentSchema: any;
    compressionAlgorithm?: string;
    encryptionLevel?: 'none' | 'basic' | 'advanced';
    semanticEmbedding?: SemanticEmbedding;
}
export interface MetadataStructure {
    timestamp: Date;
    source: AIToolType;
    target: AIToolType[];
    priority: 'low' | 'normal' | 'high' | 'critical';
    ttl: number;
    traceId: string;
    sessionId: string;
    requestId: string;
    context: ContextMetadata;
}
export interface RoutingStructure {
    delivery: 'direct' | 'broadcast' | 'multicast' | 'publish_subscribe';
    acknowledgment: 'none' | 'delivery' | 'processing' | 'completion';
    retryPolicy: RetryPolicy;
    fallbackStrategy: FallbackStrategy;
}
export interface ContextMetadata {
    projectDomain: string;
    taskComplexity: string;
    urgencyLevel: string;
    qualityRequirements: string;
    resourceConstraints: ResourceConstraint[];
    dependencies: string[];
}
export interface ResourceConstraint {
    type: 'time' | 'memory' | 'cpu' | 'network' | 'storage';
    limit: number;
    unit: string;
    enforced: boolean;
}
export interface RetryPolicy {
    maxAttempts: number;
    backoffStrategy: 'fixed' | 'exponential' | 'linear';
    baseDelay: number;
    maxDelay: number;
    jitter: boolean;
}
export interface FallbackStrategy {
    enabled: boolean;
    alternatives: string[];
    degradationMode: 'graceful' | 'fail_fast' | 'silent';
    notificationLevel: 'none' | 'warn' | 'error';
}
export interface SemanticSchema {
    namespace: string;
    version: string;
    entities: SemanticEntity[];
    relationships: SemanticRelationType[];
    constraints: SemanticConstraint[];
    inferenceRules: InferenceRule[];
}
export interface SemanticEntity {
    name: string;
    type: string;
    properties: EntityProperty[];
    synonyms: string[];
    context: string[];
    examples: any[];
}
export interface EntityProperty {
    name: string;
    dataType: string;
    cardinality: '1' | '0..1' | '1..*' | '0..*';
    constraints: PropertyConstraint[];
    semanticMeaning: string;
}
export interface PropertyConstraint {
    type: 'range' | 'pattern' | 'enum' | 'format' | 'custom';
    value: any;
    message: string;
}
export interface SemanticRelationType {
    name: string;
    sourceEntity: string;
    targetEntity: string;
    cardinality: string;
    inverse?: string;
    properties: EntityProperty[];
}
export interface SemanticConstraint {
    id: string;
    description: string;
    type: 'logical' | 'temporal' | 'spatial' | 'cardinality' | 'business';
    expression: string;
    severity: 'error' | 'warning' | 'info';
}
export interface InferenceRule {
    id: string;
    name: string;
    condition: string;
    conclusion: string;
    confidence: number;
    applicability: string[];
}
export interface ValidationRule {
    id: string;
    name: string;
    type: 'syntax' | 'semantic' | 'business' | 'performance' | 'security';
    condition: string;
    action: 'accept' | 'reject' | 'transform' | 'warn';
    parameters: Record<string, any>;
    errorMessage: string;
}
export interface TransformationRule {
    id: string;
    name: string;
    sourceFormat: string;
    targetFormat: string;
    transformation: TransformationFunction;
    preserveSemantics: boolean;
    qualityMetrics: string[];
}
export interface TransformationFunction {
    type: 'mapping' | 'enrichment' | 'aggregation' | 'filtering' | 'normalization';
    logic: string | ((input: any) => any);
    parameters: Record<string, any>;
    reversible: boolean;
}
export interface SemanticAnnotation {
    concept: string;
    property: string;
    value: any;
    confidence: number;
    source: string;
    timestamp: Date;
}
export interface SemanticEmbedding {
    model: string;
    version: string;
    dimensions: number;
    vector: number[];
    metadata: Record<string, any>;
}
export interface QualityAssuranceConfig {
    enabled: boolean;
    checks: QualityCheck[];
    thresholds: QualityThreshold[];
    monitoring: QualityMonitoring;
    reporting: QualityReporting;
}
export interface QualityCheck {
    name: string;
    type: 'completeness' | 'accuracy' | 'consistency' | 'timeliness' | 'relevance';
    implementation: string;
    weight: number;
    enabled: boolean;
}
export interface QualityThreshold {
    metric: string;
    minimum: number;
    target: number;
    action: 'warn' | 'block' | 'fallback';
}
export interface QualityMonitoring {
    enabled: boolean;
    interval: number;
    metrics: string[];
    alerting: AlertingConfig;
}
export interface AlertingConfig {
    enabled: boolean;
    channels: string[];
    severity: 'low' | 'medium' | 'high' | 'critical';
    aggregation: number;
}
export interface QualityReporting {
    enabled: boolean;
    frequency: 'realtime' | 'hourly' | 'daily' | 'weekly';
    recipients: string[];
    format: 'json' | 'html' | 'pdf';
}
export interface PerformanceConfig {
    latencyTargets: LatencyTarget[];
    throughputTargets: ThroughputTarget[];
    resourceLimits: ResourceLimit[];
    optimization: OptimizationConfig;
    monitoring: PerformanceMonitoring;
}
export interface LatencyTarget {
    operation: string;
    percentile: number;
    target: number;
    unit: 'ms' | 's';
}
export interface ThroughputTarget {
    operation: string;
    target: number;
    unit: 'ops/sec' | 'ops/min';
}
export interface ResourceLimit {
    resource: 'memory' | 'cpu' | 'network' | 'storage';
    limit: number;
    unit: string;
    action: 'throttle' | 'reject' | 'queue';
}
export interface OptimizationConfig {
    caching: CachingConfig;
    compression: CompressionConfig;
    batching: BatchingConfig;
    prefetching: PrefetchingConfig;
}
export interface CachingConfig {
    enabled: boolean;
    strategy: 'lru' | 'lfu' | 'ttl' | 'adaptive';
    maxSize: number;
    ttl: number;
    invalidationStrategy: string;
}
export interface CompressionConfig {
    enabled: boolean;
    algorithm: 'gzip' | 'brotli' | 'lz4' | 'adaptive';
    threshold: number;
    level: number;
}
export interface BatchingConfig {
    enabled: boolean;
    maxBatchSize: number;
    maxWaitTime: number;
    flushTriggers: string[];
}
export interface PrefetchingConfig {
    enabled: boolean;
    strategy: 'predictive' | 'pattern_based' | 'demand_driven';
    lookAhead: number;
    confidence: number;
}
export interface PerformanceMonitoring {
    enabled: boolean;
    metrics: PerformanceMetric[];
    profiling: ProfilingConfig;
}
export interface PerformanceMetric {
    name: string;
    type: 'counter' | 'gauge' | 'histogram' | 'timer';
    labels: string[];
    collection: 'push' | 'pull';
}
export interface ProfilingConfig {
    enabled: boolean;
    samplingRate: number;
    tools: string[];
    output: string;
}
export interface CommunicationMessage {
    id: string;
    type: string;
    structure: MessageStructure;
    semanticAnnotations: SemanticAnnotation[];
    qualityScore: number;
    processingHistory: ProcessingStep[];
    lifecycle: MessageLifecycle;
}
export interface ProcessingStep {
    processor: string;
    timestamp: Date;
    operation: string;
    duration: number;
    qualityImpact: number;
    transformations: string[];
    errors: ProcessingError[];
}
export interface ProcessingError {
    code: string;
    message: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    recoverable: boolean;
    timestamp: Date;
}
export interface MessageLifecycle {
    created: Date;
    sent: Date;
    received: Date;
    processed: Date;
    acknowledged?: Date;
    expired?: Date;
    status: 'created' | 'sent' | 'received' | 'processed' | 'acknowledged' | 'expired' | 'failed';
}
export interface CommunicationSession {
    sessionId: string;
    participants: ParticipantInfo[];
    protocol: string;
    startTime: Date;
    endTime?: Date;
    messageCount: number;
    qualityMetrics: SessionQualityMetrics;
    performanceMetrics: SessionPerformanceMetrics;
    configuration: SessionConfiguration;
}
export interface ParticipantInfo {
    tool: AIToolType;
    role: 'sender' | 'receiver' | 'processor' | 'observer';
    capabilities: string[];
    preferences: CommunicationPreferences;
    status: 'active' | 'idle' | 'busy' | 'offline';
}
export interface CommunicationPreferences {
    preferredFormats: string[];
    maxLatency: number;
    qualityVsSpeed: number;
    semanticDepth: 'shallow' | 'moderate' | 'deep';
    reliabilityLevel: 'best_effort' | 'reliable' | 'guaranteed';
}
export interface SessionQualityMetrics {
    overallQuality: number;
    semanticConsistency: number;
    messageCompleteness: number;
    transformationAccuracy: number;
    errorRate: number;
}
export interface SessionPerformanceMetrics {
    averageLatency: number;
    throughput: number;
    resourceUtilization: Record<string, number>;
    cacheHitRate: number;
    compressionRatio: number;
}
export interface SessionConfiguration {
    protocol: string;
    qualityLevel: 'basic' | 'enhanced' | 'premium';
    performanceProfile: 'power_saving' | 'balanced' | 'performance';
    semanticProcessing: boolean;
    retryEnabled: boolean;
    monitoringLevel: 'minimal' | 'standard' | 'detailed';
}
export declare class EnhancedCrossToolCommunicationService extends EventEmitter {
    private readonly logger;
    private protocols;
    private activeSessions;
    private messageQueue;
    private semanticStore;
    private qualityMetrics;
    private performanceMetrics;
    private communicationHistory;
    private messageCache;
    private transformationCache;
    private semanticCache;
    private defaultConfiguration;
    constructor();
    registerProtocol(protocol: CommunicationProtocol): Promise<void>;
    getProtocol(protocolId: string): Promise<CommunicationProtocol | null>;
    getAvailableProtocols(): Promise<CommunicationProtocol[]>;
    private validateProtocol;
    private validateMessageType;
    private validateSemanticSchema;
    private initializeProtocolResources;
    private initializeSemanticProcessing;
    private generateSemanticEmbedding;
    private initializeQualityAssurance;
    createCommunicationSession(participants: AIToolType[], protocolId: string, configuration?: Partial<SessionConfiguration>): Promise<string>;
    endCommunicationSession(sessionId: string): Promise<void>;
    private generateSessionId;
    private createParticipantInfo;
    private getToolCapabilities;
    private getDefaultCommunicationPreferences;
    private initializeSessionResources;
    private cleanupSessionResources;
    private archiveSession;
    sendMessage(sessionId: string, sourceToolLite: AIToolType, targetTools: AIToolType[], messageType: string, payload: any, options?: {
        priority?: 'low' | 'normal' | 'high' | 'critical';
        ttl?: number;
        acknowledgment?: boolean;
        semanticProcessing?: boolean;
    }): Promise<string>;
    receiveMessage(sessionId: string, targetTool: AIToolType): Promise<CommunicationMessage | null>;
    private processMessage;
    private generateMessageId;
    private createMessage;
    private determineDataType;
    private extractContentSchema;
    private generateTraceId;
    private extractContextMetadata;
    private getDefaultRetryPolicy;
    private getDefaultFallbackStrategy;
    private validateMessage;
    private hasField;
    private applyValidationRule;
    private evaluateValidationCondition;
    private applyValidationTransformation;
    private processSemanticAnnotations;
    private extractSemanticAnnotations;
    private analyzeEntityPresence;
    private generateMessageSemanticEmbedding;
    private applyMessageTransformations;
    private shouldApplyTransformation;
    private applyTransformation;
    private executeTransformationLogic;
    private performQualityChecks;
    private performQualityCheck;
    private checkCompleteness;
    private checkAccuracy;
    private checkConsistency;
    private checkTimeliness;
    private checkRelevance;
    private handleQualityThresholdViolation;
    private applyQualityFallback;
    private routeMessage;
    private routeToSingleTarget;
    private routeViaPublishSubscribe;
    private performMessageProcessing;
    private calculateQualityImpact;
    private startQualityMonitoring;
    private performQualityMonitoring;
    private aggregateQualityMetrics;
    private checkQualityAlerts;
    private sendQualityAlert;
    private startSessionMonitoring;
    private stopSessionMonitoring;
    private collectSessionMetrics;
    private getQueueSizes;
    private getSessionDurationMinutes;
    private calculateSessionQuality;
    private updatePerformanceMetrics;
    private setupOptimizationSystems;
    private setupMessageCaching;
    private setupTransformationCaching;
    private setupSemanticCaching;
    private cleanupMessageCache;
    private cleanupTransformationCache;
    private cleanupSemanticCache;
    private startOptimizationMonitoring;
    private performOptimizationAnalysis;
    private getCacheStatistics;
    private analyzeMessagePatterns;
    private updateOptimizationStrategies;
    private initializeStandardProtocols;
    private createBasicMessageStructure;
    private initializeQualityMetrics;
    private initializePerformanceMetrics;
    private initializeSessionQualityMetrics;
    private initializeSessionPerformanceMetrics;
    private initializeDefaultConfiguration;
    private startMonitoring;
    private performGlobalMonitoring;
    getActiveSessionsCount(): Promise<number>;
    getSessionInfo(sessionId: string): Promise<CommunicationSession | null>;
    getQueueStatus(): Promise<Record<string, number>>;
    getCommunicationStatistics(): Promise<{
        totalSessions: number;
        totalMessages: number;
        averageSessionDuration: number;
        qualityMetrics: QualityMetrics;
        performanceMetrics: PerformanceMetrics;
    }>;
    getSemanticInformation(key?: string): Promise<SemanticInformation[]>;
    optimizeProtocol(protocolId: string): Promise<void>;
    private analyzeProtocolUsage;
    private updateProtocolConfiguration;
}
//# sourceMappingURL=enhanced-cross-tool-communication.d.ts.map