import { ProjectPattern, BestPracticeRecord, OrganizationalInsight, ProjectContext, ProjectCharacteristics, LearningScope, ProjectDomain, ActionableRecommendation } from '../types';
import { OrganizationalMemoryService } from './organizational-memory';
import { BestPracticeEvolutionService } from './best-practice-evolution';
export declare class CrossProjectIntelligenceService {
    private organizationalMemory;
    private bestPracticeEvolution;
    private domainOrchestration;
    private conflictResolution;
    private projectRegistry;
    private patternNetwork;
    private intelligenceIndex;
    private sharingChannels;
    private collaborationGraph;
    private crossProjectMetrics;
    private intelligenceQueue;
    private similarityEngine;
    constructor(organizationalMemory: OrganizationalMemoryService, bestPracticeEvolution: BestPracticeEvolutionService);
    registerProject(projectContext: ProjectContext, projectMetadata: ProjectMetadata): Promise<ProjectProfile>;
    sharePatterns(sourceProjectId: string, patterns: ProjectPattern[], targetScope?: LearningScope): Promise<PatternSharingResult>;
    discoverRelevantKnowledge(projectId: string, queryContext: KnowledgeQuery): Promise<KnowledgeDiscoveryResult>;
    facilitateCollaboration(initiatorProjectId: string, targetProjectId: string, collaborationType: CollaborationType, context: CollaborationContext): Promise<CollaborationSession>;
    analyzeCrossProjectTrends(timeframe: {
        startDate: Date;
        endDate: Date;
    }, scope?: LearningScope): Promise<CrossProjectTrendAnalysis>;
    getIntelligenceRecommendations(projectId: string, recommendationType?: RecommendationType): Promise<IntelligenceRecommendation[]>;
    private initializeCrossProjectIntelligence;
    private startIntelligenceEngine;
    private findSimilarProjects;
    private findRelevantTargetProjects;
    private analyzePatternCompatibility;
    private predictPatternAdoption;
    private generateProjectId;
    private generateCollaborationId;
    private isProjectInScope;
    private getComplexityScore;
    private createEmptyPatternNetwork;
    private createEmptyIntelligenceIndex;
    private createEmptyCollaborationGraph;
    private createEmptyCrossProjectMetrics;
    private logIntelligenceEvent;
    private updateCollaborationGraph;
    private initializeSharingOpportunities;
    private calculatePatternRelevance;
    private identifyCollaborationOpportunities;
    private updatePatternNetwork;
    private createSharingNotification;
    private calculateSharingImpact;
    private searchPatternsAcrossProjects;
    private rankPatternsByRelevance;
    private findApplicablePractices;
    private findSimilarProjectsForKnowledge;
    private generateCrossProjectInsights;
    private recommendCollaborations;
    private calculateDiscoveryConfidence;
    private updateIntelligenceIndex;
    private calculateCollaborationSuccessRate;
    private analyzeCollaborationCompatibility;
    private generateCollaborationTimeline;
    private defineCollaborationObjectives;
    private assessCollaborationRisks;
    createCollaborationWorkspace(data: any): Promise<any>;
    sendCollaborationInvitation(data: any): Promise<any>;
    analyzeAdoptionTrends(scope: any): Promise<any>;
    analyzeInnovationTrends(scope: any): Promise<any>;
    analyzeCollaborationTrends(scope: any): Promise<any>;
    analyzeKnowledgeTrends(scope: any): Promise<any>;
    identifyEmergingPatterns(data: any): Promise<any>;
    identifyDecliningPatterns(data: any): Promise<any>;
    identifyHotTopics(data: any): Promise<any>;
    performNetworkAnalysis(data: any): Promise<any>;
    private generateTrendPredictions;
    private generateTrendRecommendations;
    private generateKnowledgeRecommendations;
    private generateCollaborationRecommendations;
    private generatePatternRecommendations;
    private generatePracticeRecommendations;
    private prioritizeRecommendations;
    private processIntelligenceQueue;
    private updateSimilarityMappings;
    private optimizeCollaborationMatching;
    private refreshKnowledgeIndex;
    private identifyCompatibilityRisks;
    private identifyCompatibilityBenefits;
    private generateAdoptionRecommendations;
    private calculatePredictionConfidence;
}
interface ProjectProfile {
    id: string;
    context: ProjectContext;
    characteristics: ProjectCharacteristics;
    metadata: ProjectMetadata;
    registeredAt: Date;
    lastUpdated: Date;
    activityLevel: 'active' | 'inactive' | 'archived';
    patterns: string[];
    collaborations: string[];
    sharedKnowledge: string[];
    contributions: ProjectContributions;
    reputation: ProjectReputation;
}
interface ProjectMetadata {
    name: string;
    description: string;
    teamId?: string;
    organizationId?: string;
    visibility: 'public' | 'internal' | 'private';
    tags: string[];
    contacts: ProjectContact[];
    status: 'active' | 'maintenance' | 'deprecated';
}
interface ProjectContact {
    role: 'lead' | 'developer' | 'architect' | 'pm';
    name: string;
    email: string;
    expertise: string[];
}
interface ProjectContributions {
    patternsShared: number;
    practicesAdopted: number;
    insightsGenerated: number;
    collaborationsInitiated: number;
}
interface ProjectReputation {
    qualityScore: number;
    innovationScore: number;
    collaborationScore: number;
    reliabilityScore: number;
}
interface PatternSharingResult {
    sourceProjectId: string;
    patternsShared: number;
    targetProjects: string[];
    adoptionPredictions: AdoptionPrediction[];
    collaborationOpportunities: CollaborationOpportunity[];
    impactEstimate: ImpactEstimate;
    timestamp: Date;
}
interface AdoptionPrediction {
    projectId: string;
    patterns: string[];
    adoptionLikelihood: number;
    timeToAdoption: number;
    expectedBenefits: ExpectedBenefit[];
    barriers: AdoptionBarrier[];
    recommendations: ActionableRecommendation[];
    confidence: number;
}
interface ExpectedBenefit {
    type: string;
    description: string;
    estimatedValue: number;
    timeframe: number;
}
interface AdoptionBarrier {
    type: string;
    description: string;
    severity: 'low' | 'medium' | 'high';
    mitigation: string[];
}
interface CollaborationOpportunity {
    type: CollaborationType;
    description: string;
    projects: string[];
    potential: number;
    effort: 'low' | 'medium' | 'high';
    timeline: string;
}
interface ImpactEstimate {
    potentialAdopters: number;
    estimatedValue: number;
    riskFactors: string[];
}
interface KnowledgeQuery {
    type: 'pattern' | 'practice' | 'expertise' | 'collaboration' | 'general';
    keywords: string[];
    domain?: ProjectDomain;
    language?: string;
    framework?: string;
    context: string;
    filters: QueryFilter[];
}
interface QueryFilter {
    field: string;
    operator: 'equals' | 'contains' | 'greater_than' | 'less_than';
    value: any;
}
interface KnowledgeDiscoveryResult {
    projectId: string;
    query: KnowledgeQuery;
    relevantPatterns: ProjectPattern[];
    applicablePractices: BestPracticeRecord[];
    similarProjects: ProjectProfile[];
    crossProjectInsights: OrganizationalInsight[];
    recommendedCollaborations: CollaborationRecommendation[];
    confidence: number;
    timestamp: Date;
}
interface CollaborationRecommendation {
    type: CollaborationType;
    targetProject: string;
    rationale: string;
    benefits: string[];
    requirements: string[];
    effort: 'low' | 'medium' | 'high';
    success_probability: number;
}
type CollaborationType = 'knowledge_sharing' | 'code_sharing' | 'joint_development' | 'mentoring' | 'code_review' | 'architecture_review' | 'problem_solving';
interface CollaborationContext {
    description: string;
    objectives: string[];
    constraints: string[];
    timeline: string;
    resources: string[];
}
interface CollaborationSession {
    id: string;
    type: CollaborationType;
    initiatorProject: string;
    targetProject: string;
    context: CollaborationContext;
    compatibility: any;
    status: 'proposed' | 'accepted' | 'active' | 'completed' | 'cancelled';
    timeline: any;
    objectives: string[];
    deliverables: any[];
    participants: any[];
    communications: any[];
    metrics: {
        progressScore: number;
        satisfactionScore: number;
        valueGenerated: number;
        knowledgeTransferred: number;
    };
    risks: any[];
    createdAt: Date;
    updatedAt: Date;
}
interface CrossProjectTrendAnalysis {
    timeframe: {
        startDate: Date;
        endDate: Date;
    };
    scope: LearningScope;
    trendCategories: {
        adoption: any;
        innovation: any;
        collaboration: any;
        knowledge: any;
    };
    emergingPatterns: any[];
    declininingPatterns: any[];
    hotTopics: any[];
    networkAnalysis: any;
    predictions: any[];
    recommendations: any[];
    confidence: number;
    generatedAt: Date;
}
type RecommendationType = 'knowledge' | 'collaboration' | 'patterns' | 'practices';
interface IntelligenceRecommendation {
    id: string;
    type: RecommendationType;
    title: string;
    description: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    effort: 'low' | 'medium' | 'high';
    impact: 'low' | 'medium' | 'high';
    confidence: number;
    actions: ActionableRecommendation[];
    evidence: string[];
    relatedProjects: string[];
    timestamp: Date;
}
export {};
//# sourceMappingURL=cross-project-intelligence.d.ts.map