export type PatternCategory = 'architectural' | 'design' | 'implementation' | 'testing' | 'deployment' | 'security' | 'performance';
export interface PatternDiscoveryConfig {
    enabled: boolean;
    maxResults: number;
    timeout: number;
    caching: boolean;
}
export interface PatternSearchQuery {
    query: string;
    category?: PatternCategory;
    language?: string;
    framework?: string;
}
export interface DiscoveredPattern {
    id: string;
    title: string;
    description: string;
    category: PatternCategory;
    language?: string;
    framework?: string;
    code?: string;
    url?: string;
    quality: number;
    relevance: number;
}
export interface PatternRecommendation {
    pattern: DiscoveredPattern;
    reason: string;
    confidence: number;
    priority: 'low' | 'medium' | 'high';
}
export interface PatternSearchResult {
    query: PatternSearchQuery;
    patterns: DiscoveredPattern[];
    recommendations: PatternRecommendation[];
    total: number;
    duration: number;
}
export interface AdvancedPatternDiscoveryConfig {
    base: PatternDiscoveryConfig;
    multiTierCaching: {
        enabled: boolean;
        l1CacheSize: number;
        l2CacheSize: number;
        l3CacheEnabled: boolean;
        compressionEnabled: boolean;
        encryptionEnabled: boolean;
    };
    machineLearning: {
        enablePatternClassification: boolean;
        enableRelevanceScoring: boolean;
        enableAutoTagging: boolean;
        modelUpdateFrequency: number;
        trainingDataRetention: number;
    };
    performance: {
        maxConcurrentSearches: number;
        searchBatching: boolean;
        adaptiveTimeout: boolean;
        preemptiveSearching: boolean;
        resultStreaming: boolean;
    };
    analytics: {
        enableDetailedMetrics: boolean;
        enableUserBehaviorTracking: boolean;
        enablePerformanceMonitoring: boolean;
        enableCostTracking: boolean;
        reportingInterval: number;
    };
}
export interface AdvancedPatternSearchQuery extends PatternSearchQuery {
    optimization: {
        preferCachedResults: boolean;
        enableParallelSearch: boolean;
        enableResultStreaming: boolean;
        maxSearchTime: number;
        qualityThreshold: number;
    };
    userContext: {
        userId?: string;
        skillLevel: 'beginner' | 'intermediate' | 'advanced' | 'expert';
        preferredSources: string[];
        previousSearches: string[];
        learningGoals: string[];
    };
    businessContext: {
        projectDeadline?: Date;
        budgetConstraints?: string;
        teamSize?: number;
        riskTolerance: 'low' | 'medium' | 'high';
        complianceRequirements?: string[];
    };
}
export interface PatternAnalysisResult {
    pattern: DiscoveredPattern;
    analysis: {
        technicalFeasibility: TechnicalFeasibilityAnalysis;
        businessValue: BusinessValueAnalysis;
        riskAssessment: RiskAssessment;
        implementationPlan: ImplementationPlan;
        competitorAnalysis?: CompetitorAnalysis;
    };
    recommendations: PatternRecommendation[];
    alternatives: DiscoveredPattern[];
}
export interface TechnicalFeasibilityAnalysis {
    overallScore: number;
    factors: {
        technicalComplexity: number;
        resourceRequirements: number;
        skillRequirements: number;
        integrationComplexity: number;
        maintenanceComplexity: number;
    };
    blockers: TechnicalBlocker[];
    prerequisites: TechnicalPrerequisite[];
    estimatedEffort: EffortEstimate;
}
export interface BusinessValueAnalysis {
    overallValue: number;
    valueFactors: {
        developmentSpeed: number;
        codeQuality: number;
        maintainability: number;
        scalability: number;
        teamProductivity: number;
    };
    roi: {
        estimatedSavings: string;
        paybackPeriod: string;
        confidenceLevel: number;
    };
    strategicAlignment: number;
}
export interface RiskAssessment {
    overallRisk: 'low' | 'medium' | 'high' | 'critical';
    riskFactors: {
        technicalRisk: number;
        businessRisk: number;
        securityRisk: number;
        complianceRisk: number;
        adoptionRisk: number;
    };
    risks: Risk[];
    mitigationStrategies: MitigationStrategy[];
    contingencyPlans: ContingencyPlan[];
}
export interface ImplementationPlan {
    phases: ImplementationPhase[];
    timeline: Timeline;
    resources: ResourceRequirement[];
    dependencies: Dependency[];
    milestones: Milestone[];
    successCriteria: SuccessCriterion[];
}
export interface CompetitorAnalysis {
    competitorPatterns: CompetitorPattern[];
    marketTrends: MarketTrend[];
    adoptionRates: AdoptionRate[];
    benchmarks: Benchmark[];
}
export interface TechnicalBlocker {
    id: string;
    description: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    category: 'technical' | 'resource' | 'skill' | 'integration';
    resolution: string;
    estimatedResolutionTime: string;
}
export interface TechnicalPrerequisite {
    id: string;
    type: 'skill' | 'tool' | 'infrastructure' | 'process';
    description: string;
    criticality: 'required' | 'recommended' | 'optional';
    acquisitionPlan: string;
    estimatedTime: string;
}
export interface EffortEstimate {
    planning: string;
    development: string;
    testing: string;
    deployment: string;
    training: string;
    total: string;
    confidence: number;
}
export interface Risk {
    id: string;
    category: 'technical' | 'business' | 'security' | 'compliance' | 'adoption';
    description: string;
    probability: number;
    impact: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
    owner?: string;
}
export interface MitigationStrategy {
    riskId: string;
    strategy: string;
    actions: string[];
    effectiveness: number;
    cost: string;
    timeline: string;
}
export interface ContingencyPlan {
    trigger: string;
    description: string;
    actions: string[];
    resources: string[];
    timeline: string;
}
export interface ImplementationPhase {
    id: string;
    name: string;
    description: string;
    order: number;
    duration: string;
    dependencies: string[];
    deliverables: string[];
    risks: string[];
    successCriteria: string[];
}
export interface Timeline {
    startDate: Date;
    endDate: Date;
    phases: {
        phaseId: string;
        startDate: Date;
        endDate: Date;
        status: 'planned' | 'in_progress' | 'completed' | 'blocked';
    }[];
    criticalPath: string[];
    bufferTime: string;
}
export interface ResourceRequirement {
    type: 'human' | 'technical' | 'financial';
    description: string;
    quantity: number;
    duration: string;
    cost?: string;
    availability: 'available' | 'partial' | 'unavailable';
}
export interface Dependency {
    id: string;
    type: 'technical' | 'business' | 'external';
    description: string;
    dependsOn: string;
    criticality: 'critical' | 'high' | 'medium' | 'low';
    status: 'met' | 'in_progress' | 'blocked';
}
export interface Milestone {
    id: string;
    name: string;
    description: string;
    targetDate: Date;
    dependencies: string[];
    successCriteria: string[];
    deliverables: string[];
}
export interface SuccessCriterion {
    id: string;
    description: string;
    measurable: boolean;
    metric?: string;
    target?: any;
    validationMethod: string;
}
export interface CompetitorPattern {
    competitor: string;
    pattern: string;
    adoptionLevel: 'experimental' | 'pilot' | 'production' | 'deprecated';
    advantages: string[];
    disadvantages: string[];
    sourceUrl?: string;
}
export interface MarketTrend {
    trend: string;
    direction: 'increasing' | 'stable' | 'decreasing';
    timeframe: string;
    impact: 'low' | 'medium' | 'high';
    confidence: number;
}
export interface AdoptionRate {
    pattern: string;
    industry: string;
    percentage: number;
    timeframe: string;
    source: string;
}
export interface Benchmark {
    metric: string;
    value: number;
    unit: string;
    context: string;
    source: string;
    confidence: number;
}
export interface PatternDiscoveryAnalytics {
    searchMetrics: SearchMetrics;
    patternMetrics: PatternMetrics;
    userMetrics: UserMetrics;
    performanceMetrics: PerformanceMetrics;
    businessMetrics: BusinessMetrics;
}
export interface SearchMetrics {
    totalSearches: number;
    uniqueSearches: number;
    avgSearchTime: number;
    searchSuccessRate: number;
    popularCategories: CategoryMetric[];
    searchTrends: SearchTrend[];
    cacheHitRate: number;
}
export interface PatternMetrics {
    totalPatterns: number;
    avgQualityScore: number;
    avgRelevanceScore: number;
    patternsByCategory: CategoryMetric[];
    topPatterns: PatternPopularity[];
    qualityTrends: QualityTrend[];
    validationStats: ValidationStats;
}
export interface UserMetrics {
    activeUsers: number;
    avgSessionTime: number;
    searchesPerUser: number;
    userSatisfaction: number;
    skillLevelDistribution: SkillLevelMetric[];
    engagementTrends: EngagementTrend[];
}
export interface PerformanceMetrics {
    avgResponseTime: number;
    cachePerformance: CachePerformance;
    errorRate: number;
    systemLoad: SystemLoadMetric[];
    resourceUtilization: ResourceUtilization;
}
export interface BusinessMetrics {
    costPerSearch: number;
    valueGenerated: number;
    productivityGains: number;
    adoptionRate: number;
    roi: number;
}
export interface CategoryMetric {
    category: string;
    count: number;
    percentage: number;
    trend: 'up' | 'down' | 'stable';
}
export interface SearchTrend {
    period: string;
    searches: number;
    uniqueUsers: number;
    avgQuality: number;
}
export interface PatternPopularity {
    patternId: string;
    title: string;
    views: number;
    implementations: number;
    rating: number;
}
export interface QualityTrend {
    period: string;
    avgQuality: number;
    avgRelevance: number;
    validationRate: number;
}
export interface ValidationStats {
    totalValidations: number;
    successRate: number;
    avgValidationTime: number;
    validationsByTool: Record<string, number>;
}
export interface SkillLevelMetric {
    skillLevel: string;
    count: number;
    percentage: number;
    avgSatisfaction: number;
}
export interface EngagementTrend {
    period: string;
    activeUsers: number;
    avgSessionTime: number;
    returnRate: number;
}
export interface CachePerformance {
    hitRate: number;
    missRate: number;
    avgHitTime: number;
    avgMissTime: number;
    evictionRate: number;
}
export interface SystemLoadMetric {
    timestamp: Date;
    cpuUsage: number;
    memoryUsage: number;
    diskUsage: number;
    networkUsage: number;
}
export interface ResourceUtilization {
    peak: ResourceSnapshot;
    average: ResourceSnapshot;
    current: ResourceSnapshot;
}
export interface ResourceSnapshot {
    cpu: number;
    memory: number;
    disk: number;
    network: number;
    timestamp: Date;
}
export type PatternDiscoveryEvent = PatternSearchEvent | PatternValidationEvent | PatternUsageEvent | SystemEvent | UserEvent;
export interface PatternSearchEvent {
    type: 'pattern_search';
    timestamp: Date;
    userId?: string;
    query: PatternSearchQuery;
    result: PatternSearchResult;
    performance: {
        duration: number;
        cacheHit: boolean;
        toolsUsed: string[];
    };
}
export interface PatternValidationEvent {
    type: 'pattern_validation';
    timestamp: Date;
    patternId: string;
    validationType: 'cross_tool' | 'user_feedback' | 'automated';
    result: 'valid' | 'invalid' | 'outdated';
    details: Record<string, any>;
}
export interface PatternUsageEvent {
    type: 'pattern_usage';
    timestamp: Date;
    userId?: string;
    patternId: string;
    action: 'view' | 'implement' | 'rate' | 'share';
    metadata: Record<string, any>;
}
export interface SystemEvent {
    type: 'system_event';
    timestamp: Date;
    eventType: 'cache_cleanup' | 'strategy_optimization' | 'performance_alert' | 'error';
    severity: 'info' | 'warning' | 'error' | 'critical';
    message: string;
    metadata: Record<string, any>;
}
export interface UserEvent {
    type: 'user_event';
    timestamp: Date;
    userId: string;
    action: 'login' | 'logout' | 'profile_update' | 'preference_change';
    metadata: Record<string, any>;
}
export interface PatternDiscoveryIntegrationConfig {
    aiToolIntegration: {
        enabled: boolean;
        crossValidation: boolean;
        orchestrationTimeout: number;
        fallbackBehavior: 'disable' | 'warn' | 'continue';
    };
    mcpIntegration: {
        timeoutMs: number;
        retryAttempts: number;
        enableFallback: boolean;
        preferredServers: string[];
    };
    cachingIntegration: {
        provider: 'memory' | 'redis' | 'hybrid';
        configuration: Record<string, any>;
        encryptionEnabled: boolean;
    };
    analyticsIntegration: {
        provider: 'internal' | 'external';
        configuration: Record<string, any>;
        realTimeEnabled: boolean;
    };
}
export interface PatternExportConfig {
    format: 'json' | 'yaml' | 'markdown' | 'pdf';
    includeMetadata: boolean;
    includeAnalytics: boolean;
    includeValidation: boolean;
    filterCriteria?: {
        categories?: PatternCategory[];
        qualityThreshold?: number;
        dateRange?: {
            start: Date;
            end: Date;
        };
    };
}
export interface PatternImportConfig {
    source: 'file' | 'url' | 'api';
    format: 'json' | 'yaml' | 'csv';
    validation: {
        enabled: boolean;
        strictMode: boolean;
        customRules?: ValidationRule[];
    };
    mergeStrategy: 'replace' | 'merge' | 'skip';
}
export interface ValidationRule {
    field: string;
    rule: 'required' | 'format' | 'range' | 'custom';
    parameters: Record<string, any>;
    message: string;
}
//# sourceMappingURL=exa-pattern-discovery.d.ts.map