import type { HTMLAttributes } from 'svelte/elements';
export interface ActivityInterest {
    id: string;
    name: string;
    category: string;
    description: string;
    engagementScore: number;
    skillLevel: number;
    discoveredAt: Date;
    confidenceLevel: number;
    attributes: {
        social: boolean;
        physical: boolean;
        creative: boolean;
        analytical: boolean;
        educational: boolean;
        competitive: boolean;
        collaborative: boolean;
        timeCommitment: number;
    };
    relatedActivities: string[];
    seasonality: string[];
    equipmentRequired: boolean;
    costLevel: number;
    lifeAreaAlignment: {
        'health-wellness': number;
        'home-admin': number;
        'learning-development': number;
        'relationships-social': number;
        'work-career': number;
        'hobbies-recreation': number;
    };
    growthPotential?: {
        skillCeiling: number;
        learningCurve: 'gentle' | 'moderate' | 'steep';
        communitySize: 'small' | 'medium' | 'large';
        resourceAvailability: 'limited' | 'moderate' | 'abundant';
    };
    motivationFactors?: {
        intrinsic: string[];
        extrinsic: string[];
        social: string[];
    };
}
export interface InterestPattern {
    id: string;
    type: 'temporal' | 'social' | 'environmental' | 'emotional' | 'skill-based';
    name: string;
    description: string;
    confidence: number;
    strength: number;
    discoveredAt: Date;
    frequency: 'daily' | 'weekly' | 'monthly' | 'seasonal' | 'sporadic' | 'consistent';
    relatedInterests: string[];
    triggers: string[];
    predictiveFactors: Array<{
        factor: string;
        weight: number;
    }>;
    recommendations: string[];
    stability: 'emerging' | 'stable' | 'declining';
    evolution?: {
        previousPatterns: string[];
        possibleEvolutions: string[];
    };
}
export interface EngagementPrediction {
    id: string;
    activityType: string;
    predictedEngagement: number;
    confidence: number;
    timeframe: 'next_week' | 'next_month' | 'next_quarter' | 'long_term';
    basedOnInterests: string[];
    factors: Array<{
        name: string;
        impact: number;
    }>;
    suggestedActivities: string[];
    recommendations: string[];
    potentialBarriers: string[];
    mitigationStrategies: string[];
    predictionAccuracy?: number;
    actualEngagement?: number;
}
export interface CrossDomainSynthesis {
    id: string;
    title: string;
    description: string;
    domains: string[];
    confidence: number;
    impact: number;
    discoveredAt: Date;
    relatedInterests: string[];
    insights: string[];
    opportunities: Array<{
        title: string;
        description: string;
        feasibility: number;
        impact: number;
        effort: 'low' | 'moderate' | 'high';
    }>;
    agentRecommendations: Array<{
        agent: 'architect' | 'scholar' | 'activities' | 'loop-diagnostic';
        recommendation: string;
        priority: number;
    }>;
    actionPlan: string[];
    implementationProgress?: {
        startDate: Date;
        currentStage: string;
        completedActions: string[];
        measuredImpact?: number;
    };
}
export interface ActivitiesAgentConfig {
    confidenceThreshold: number;
    minEngagementScore: number;
    maxSuggestions: number;
    enableCrossDomainSynthesis: boolean;
    patternDetectionSensitivity?: 'low' | 'medium' | 'high';
    predictionTimeframe?: 'short' | 'medium' | 'long';
    synthesisDepth?: 'basic' | 'comprehensive';
    learningStyle?: {
        preferredComplexity: 'simple' | 'moderate' | 'complex';
        pacePreference: 'slow' | 'moderate' | 'fast';
        supportLevel: 'independent' | 'guided' | 'collaborative';
    };
}
export interface ActivitiesInterestDiscoveryProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * Discovered interests from analysis
     */
    discoveredInterests?: ActivityInterest[];
    /**
     * Identified behavioral patterns
     */
    interestPatterns?: InterestPattern[];
    /**
     * Engagement predictions for future activities
     */
    engagementPredictions?: EngagementPrediction[];
    /**
     * Cross-domain synthesis insights
     */
    crossDomainSyntheses?: CrossDomainSynthesis[];
    /**
     * Show pattern analysis section
     * @default true
     */
    showPatternAnalysis?: boolean;
    /**
     * Show engagement prediction section
     * @default true
     */
    showEngagementPrediction?: boolean;
    /**
     * Show cross-domain synthesis section
     * @default true
     */
    showCrossDomainSynthesis?: boolean;
    /**
     * Enable interest tracking and learning
     * @default true
     */
    enableInterestTracking?: boolean;
    /**
     * Enable pattern learning and evolution
     * @default true
     */
    enablePatternLearning?: boolean;
    /**
     * Activities agent configuration
     */
    activitiesAgentConfig?: ActivitiesAgentConfig;
    /**
     * Callback when new interest is discovered
     */
    onInterestDiscovered?: (interest: ActivityInterest) => void;
    /**
     * Callback when pattern is identified
     */
    onPatternIdentified?: (pattern: InterestPattern) => void;
    /**
     * Callback when engagement is predicted
     */
    onEngagementPredicted?: (prediction: EngagementPrediction) => void;
    /**
     * Callback when synthesis is generated
     */
    onSynthesisGenerated?: (synthesis: CrossDomainSynthesis) => void;
    /**
     * Callback when interest is updated
     */
    onInterestUpdated?: (interest: ActivityInterest) => void;
    /**
     * Callback when pattern evolves
     */
    onPatternEvolved?: (oldPattern: InterestPattern, newPattern: InterestPattern) => void;
}
export interface ActivitiesAgent {
    /**
     * Analyze activities and discover interests
     */
    analyzeActivities: (activities: string[], context: ActivityAnalysisContext) => Promise<ActivityInterest[]>;
    /**
     * Identify behavioral patterns in interests
     */
    identifyPatterns: (interests: ActivityInterest[], historicalData?: InterestHistory[]) => Promise<InterestPattern[]>;
    /**
     * Predict engagement for potential activities
     */
    predictEngagement: (interests: ActivityInterest[], patterns: InterestPattern[], targetActivities: string[]) => Promise<EngagementPrediction[]>;
    /**
     * Generate cross-domain synthesis
     */
    generateSynthesis: (interests: ActivityInterest[], lifeAreaData: any) => Promise<CrossDomainSynthesis[]>;
    /**
     * Recommend new activities based on interests
     */
    recommendActivities: (profile: InterestProfile) => Promise<ActivityRecommendation[]>;
    /**
     * Learn from engagement feedback
     */
    learnFromFeedback: (predictions: EngagementPrediction[], actualOutcomes: EngagementOutcome[]) => Promise<void>;
}
export interface ActivityAnalysisContext {
    currentLifePhase: 'student' | 'working' | 'retired' | 'transition';
    availableTime: number;
    budget: 'minimal' | 'moderate' | 'flexible';
    physicalCapabilities: string[];
    location: 'urban' | 'suburban' | 'rural';
    socialPreferences: 'solo' | 'small_group' | 'large_group' | 'mixed';
    timeConstraints: string[];
    physicalConstraints: string[];
    resourceConstraints: string[];
    personalGoals: string[];
    skillDevelopmentGoals: string[];
    wellnessGoals: string[];
}
export interface InterestHistory {
    interestId: string;
    engagementOverTime: Array<{
        date: Date;
        score: number;
        context: string;
    }>;
    skillProgression: Array<{
        date: Date;
        level: number;
        milestone?: string;
    }>;
    socialConnections: Array<{
        type: 'mentor' | 'peer' | 'community';
        impact: number;
        description: string;
    }>;
}
export interface InterestProfile {
    interests: ActivityInterest[];
    patterns: InterestPattern[];
    preferences: {
        complexity: 'simple' | 'moderate' | 'complex';
        novelty: 'familiar' | 'mixed' | 'novel';
        timeCommitment: 'short' | 'medium' | 'long';
        socialLevel: 'solo' | 'small_group' | 'large_group';
    };
    constraints: {
        time: number;
        budget: number;
        location: string;
        equipment: string[];
    };
    goals: {
        skill: string[];
        wellness: string[];
        social: string[];
        creative: string[];
    };
}
export interface ActivityRecommendation {
    activity: string;
    category: string;
    description: string;
    matchScore: number;
    confidence: number;
    basedOnInterests: string[];
    basedOnPatterns: string[];
    timeCommitment: {
        perSession: number;
        frequency: string;
        totalWeekly: number;
    };
    requirements: {
        skill: number;
        equipment: string[];
        cost: number;
        location: string[];
    };
    benefits: {
        physical: number;
        mental: number;
        social: number;
        creative: number;
        skill: number;
    };
    nextSteps: string[];
    resources: Array<{
        type: 'website' | 'book' | 'course' | 'community' | 'equipment';
        name: string;
        url?: string;
        description: string;
    }>;
    commonChallenges: string[];
    mitigationStrategies: string[];
}
export interface EngagementOutcome {
    predictionId: string;
    actualActivity: string;
    actualEngagement: number;
    participationRate: number;
    completionRate: number;
    continuationIntent: number;
    positiveFactors: string[];
    negativeFactors: string[];
    surprises: string[];
    skillsGained: string[];
    connectionsFormed: number;
    resourcesUsed: string[];
    interestEvolution: 'increased' | 'decreased' | 'stable';
    relatedInterestsImpacted: string[];
}
export interface CrossAgentIntegration {
    /**
     * Architect agent - integrate interests into life planning
     */
    architectIntegration: (interests: ActivityInterest[], synthesis: CrossDomainSynthesis[]) => Promise<ArchitecturalRecommendation[]>;
    /**
     * Scholar agent - semantic analysis of interests
     */
    scholarIntegration: (interests: ActivityInterest[]) => Promise<SemanticConnections[]>;
    /**
     * Loop Diagnostic agent - behavioral pattern insights
     */
    loopDiagnosticIntegration: (patterns: InterestPattern[]) => Promise<BehavioralInsight[]>;
    /**
     * Life Area Crew Manager - coordinate with domain experts
     */
    lifeAreaIntegration: (interests: ActivityInterest[], lifeArea: string) => Promise<DomainSpecificRecommendations>;
}
export interface ArchitecturalRecommendation {
    type: 'schedule_integration' | 'goal_alignment' | 'resource_allocation' | 'lifestyle_change';
    priority: number;
    description: string;
    implementation: string[];
    expectedBenefit: string;
    timeframe: string;
}
export interface SemanticConnections {
    concept: string;
    relatedInterests: string[];
    semanticSimilarity: number;
    connectionType: 'direct' | 'indirect' | 'metaphorical';
    insights: string[];
}
export interface BehavioralInsight {
    pattern: string;
    behavioralMechanism: string;
    systemFactors: string[];
    compassionateReframing: string;
    supportStrategies: string[];
}
export interface DomainSpecificRecommendations {
    lifeArea: string;
    recommendations: Array<{
        action: string;
        rationale: string;
        difficulty: 'easy' | 'moderate' | 'challenging';
        impact: 'low' | 'medium' | 'high';
    }>;
    crossover: Array<{
        targetArea: string;
        synergy: string;
        implementation: string;
    }>;
}
export interface InterestDataManager {
    /**
     * Save interest discovery session
     */
    saveSession: (interests: ActivityInterest[], patterns: InterestPattern[], metadata: SessionMetadata) => Promise<string>;
    /**
     * Load historical interest data
     */
    loadHistory: (userId: string) => Promise<InterestHistory[]>;
    /**
     * Update interest based on feedback
     */
    updateInterest: (interestId: string, updates: Partial<ActivityInterest>) => Promise<ActivityInterest>;
    /**
     * Track pattern evolution
     */
    trackPatternEvolution: (patternId: string, newData: any) => Promise<InterestPattern>;
    /**
     * Export interest profile
     */
    exportProfile: (userId: string) => Promise<InterestProfile>;
    /**
     * Import interest data
     */
    importData: (data: any) => Promise<void>;
}
export interface SessionMetadata {
    sessionId: string;
    userId: string;
    timestamp: Date;
    analysisType: 'discovery' | 'pattern_update' | 'prediction' | 'synthesis';
    confidence: number;
    dataQuality: number;
    agentVersion: string;
}
export interface InterestAnalytics {
    /**
     * Generate interest evolution report
     */
    generateEvolutionReport: (timeframe: {
        start: Date;
        end: Date;
    }) => Promise<EvolutionReport>;
    /**
     * Analyze engagement trends
     */
    analyzeEngagementTrends: (interests: string[]) => Promise<EngagementTrend[]>;
    /**
     * Calculate pattern stability
     */
    calculatePatternStability: (patterns: InterestPattern[]) => Promise<PatternStabilityReport>;
    /**
     * Generate synthesis impact assessment
     */
    assessSynthesisImpact: (syntheses: CrossDomainSynthesis[]) => Promise<SynthesisImpactReport>;
}
export interface EvolutionReport {
    timeframe: {
        start: Date;
        end: Date;
    };
    newInterests: number;
    evolvedInterests: number;
    droppedInterests: number;
    stabilityScore: number;
    diversityScore: number;
    engagementTrend: 'increasing' | 'stable' | 'decreasing';
    insights: string[];
}
export interface EngagementTrend {
    interestId: string;
    trend: 'increasing' | 'stable' | 'decreasing';
    rate: number;
    predictedFuture: number;
    confidence: number;
    influencingFactors: string[];
}
export interface PatternStabilityReport {
    overallStability: number;
    stablePatterns: string[];
    emergingPatterns: string[];
    decliningPatterns: string[];
    patternLifecycle: Record<string, {
        age: number;
        strength: number;
        trajectory: 'growing' | 'stable' | 'weakening';
    }>;
}
export interface SynthesisImpactReport {
    implementedSyntheses: number;
    measuredImpacts: Array<{
        synthesisId: string;
        expectedImpact: number;
        actualImpact: number;
        variance: number;
    }>;
    successFactors: string[];
    challengeFactors: string[];
    overallEffectiveness: number;
    recommendations: string[];
}
//# sourceMappingURL=types.d.ts.map