claritykit-svelte/dist/components/bms/UserFeedbackCapture/types.d.ts

A comprehensive Svelte component library focused on accessibility, ADHD-optimized design, developer experience, and full SSR compatibility

import type { HTMLAttributes } from 'svelte/elements';
export type FeedbackType = 'general' | 'bug' | 'feature' | 'workflow' | 'performance' | 'usability';
export type FeedbackCategory = 'usability' | 'performance' | 'accuracy' | 'workflow' | 'integration' | 'suggestion';
export type FeedbackSeverity = 'low' | 'medium' | 'high';
export type FeedbackUrgency = 'low' | 'medium' | 'high';
export type FeedbackStatus = 'submitted' | 'reviewed' | 'in-progress' | 'resolved' | 'closed';
export type Priority = 'low' | 'medium' | 'high';
export type Impact = 'low' | 'medium' | 'high';
export type ImplementationStatus = 'pending' | 'in-progress' | 'completed' | 'rejected';
export type LearningCategory = 'pattern-detection' | 'user-behavior' | 'system-optimization' | 'workflow-improvement' | 'success-pattern' | 'implementation';
export interface FeedbackEntry {
    id: string;
    type: FeedbackType;
    category: FeedbackCategory;
    title: string;
    description: string;
    severity: FeedbackSeverity;
    urgency: FeedbackUrgency;
    rating?: number;
    context: {
        currentWorkflow?: string;
        stepInProcess?: string;
        agentsInvolved?: string[];
        expectedOutcome?: string;
        actualOutcome?: string;
        timeSpent?: number;
        errorMessages?: string[];
        userActions?: string[];
    };
    tags: string[];
    attachments: string[];
    createdAt: Date;
    updatedAt?: Date;
    resolvedAt?: Date;
    status: FeedbackStatus;
    assignedTo?: string;
    priority?: Priority;
    userId: string;
    userAgent?: string;
    sessionId?: string;
    resolution?: {
        summary: string;
        changes: string[];
        resolvedBy: string;
        followUpRequired: boolean;
        estimatedImpact: string;
    };
    impact?: {
        usersAffected: number;
        workflowsImpacted: string[];
        businessValue: 'low' | 'medium' | 'high';
    };
}
export interface WorkflowAssessment {
    id: string;
    workflowName: string;
    overallRating: number;
    efficiency: number;
    accuracy: number;
    userExperience: number;
    reliability?: number;
    strengths: string[];
    weaknesses: string[];
    specificIssues: string[];
    improvementAreas: string[];
    additionalComments: string;
    usageFrequency?: 'daily' | 'weekly' | 'monthly' | 'rarely';
    userExpertiseLevel?: 'beginner' | 'intermediate' | 'advanced';
    taskComplexity?: 'simple' | 'moderate' | 'complex';
    metrics?: {
        averageCompletionTime: number;
        successRate: number;
        errorRate: number;
        stepCount: number;
        userSatisfactionScore: number;
    };
    createdAt: Date;
    assessmentDuration?: number;
    userId: string;
    workflowVersion?: string;
    comparison?: {
        previousRating?: number;
        improvementAreas?: string[];
        regressionAreas?: string[];
    };
}
export interface ImprovementSuggestion {
    id: string;
    title: string;
    description: string;
    category: FeedbackCategory;
    priority: Priority;
    impact: Impact;
    scope: 'feature' | 'workflow' | 'system' | 'ui' | 'performance';
    estimatedEffort: 'small' | 'medium' | 'large' | 'extra-large';
    status: ImplementationStatus;
    relatedFeedback: string[];
    relatedWorkflows?: string[];
    affectedUsers?: number;
    implementationStarted?: Date;
    implementationCompleted?: Date;
    implementationNotes?: string[];
    successCriteria?: {
        metrics: string[];
        targets: Record<string, number>;
        measurementPeriod: number;
    };
    createdAt: Date;
    createdBy: string;
    lastUpdated?: Date;
    businessJustification?: {
        problemStatement: string;
        proposedSolution: string;
        expectedBenefits: string[];
        riskAssessment: string;
        alternativeSolutions?: string[];
    };
    technicalRequirements?: {
        components: string[];
        dependencies: string[];
        breakingChanges: boolean;
        backwardCompatibility: boolean;
        testingRequirements: string[];
    };
}
export interface LearningInsight {
    id: string;
    title: string;
    description: string;
    category: LearningCategory;
    confidence: number;
    applicability: 'user-specific' | 'workflow-specific' | 'system-wide' | 'context-dependent';
    sourceType: 'feedback-analysis' | 'pattern-detection' | 'workflow-assessment' | 'improvement-tracking' | 'user-behavior';
    sourceId: string;
    relatedFeedback?: string[];
    patterns?: {
        type: 'temporal' | 'behavioral' | 'performance' | 'error' | 'success';
        frequency: number;
        significance: 'low' | 'medium' | 'high';
        description: string;
    }[];
    implementationSuggestions: string[];
    preventionStrategies?: string[];
    optimizationOpportunities?: string[];
    validationStatus?: 'pending' | 'validated' | 'invalidated';
    impactMeasurement?: {
        before: Record<string, number>;
        after: Record<string, number>;
        improvement: Record<string, number>;
    };
    generatedAt: Date;
    validatedAt?: Date;
    implementedAt?: Date;
    contextFactors?: {
        userSegment?: string[];
        workflowTypes?: string[];
        timeOfDay?: string;
        systemLoad?: 'low' | 'medium' | 'high';
        userExperience?: 'beginner' | 'intermediate' | 'expert';
    };
}
export interface UserFeedbackCaptureProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * Collection of all feedback entries
     */
    feedbackEntries?: FeedbackEntry[];
    /**
     * Workflow assessment results
     */
    workflowAssessments?: WorkflowAssessment[];
    /**
     * Generated improvement suggestions
     */
    improvementSuggestions?: ImprovementSuggestion[];
    /**
     * Learning insights from feedback analysis
     */
    learningInsights?: LearningInsight[];
    /**
     * Show feedback submission form
     * @default true
     */
    showFeedbackForm?: boolean;
    /**
     * Show workflow assessment interface
     * @default true
     */
    showWorkflowAssessment?: boolean;
    /**
     * Show improvement tracking section
     * @default true
     */
    showImprovementTracking?: boolean;
    /**
     * Show learning insights section
     * @default true
     */
    showLearningInsights?: boolean;
    /**
     * Enable real-time quick feedback
     * @default true
     */
    enableRealTimeFeedback?: boolean;
    /**
     * Available feedback categories
     */
    feedbackCategories?: FeedbackCategory[];
    /**
     * Callback when feedback is submitted
     */
    onFeedbackSubmitted?: (feedback: FeedbackEntry) => void;
    /**
     * Callback when workflow is assessed
     */
    onWorkflowAssessed?: (assessment: WorkflowAssessment) => void;
    /**
     * Callback when improvement is implemented
     */
    onImprovementImplemented?: (suggestion: ImprovementSuggestion) => void;
    /**
     * Callback when learning insight is generated
     */
    onLearningGenerated?: (insight: LearningInsight) => void;
    /**
     * Callback when feedback status changes
     */
    onFeedbackStatusChanged?: (feedbackId: string, status: FeedbackStatus) => void;
    /**
     * Callback when improvement suggestion status changes
     */
    onSuggestionStatusChanged?: (suggestionId: string, status: ImplementationStatus) => void;
}
export interface FeedbackAnalyzer {
    /**
     * Analyze feedback patterns
     */
    analyzePatterns: (feedbackEntries: FeedbackEntry[], timeframe?: {
        start: Date;
        end: Date;
    }) => Promise<FeedbackPattern[]>;
    /**
     * Generate insights from feedback
     */
    generateInsights: (feedbackEntries: FeedbackEntry[]) => Promise<LearningInsight[]>;
    /**
     * Classify feedback sentiment
     */
    classifySentiment: (feedback: FeedbackEntry) => Promise<{
        sentiment: 'positive' | 'neutral' | 'negative';
        confidence: number;
        emotions: string[];
    }>;
    /**
     * Extract action items from feedback
     */
    extractActionItems: (feedback: FeedbackEntry) => Promise<{
        urgentActions: string[];
        improvementActions: string[];
        investigationNeeded: string[];
    }>;
    /**
     * Predict feedback impact
     */
    predictImpact: (feedback: FeedbackEntry) => Promise<{
        userImpact: 'low' | 'medium' | 'high';
        businessImpact: 'low' | 'medium' | 'high';
        technicalComplexity: 'low' | 'medium' | 'high';
        implementationPriority: Priority;
    }>;
}
export interface FeedbackPattern {
    id: string;
    type: 'frequency' | 'severity' | 'category' | 'workflow' | 'temporal';
    description: string;
    occurrences: number;
    significance: 'low' | 'medium' | 'high';
    trend: {
        direction: 'increasing' | 'decreasing' | 'stable';
        rate: number;
        timeframe: string;
    };
    affectedAreas: {
        workflows: string[];
        features: string[];
        userSegments: string[];
    };
    recommendations: {
        immediate: string[];
        shortTerm: string[];
        longTerm: string[];
    };
    detectedAt: Date;
    confidence: number;
}
export interface WorkflowOptimizer {
    /**
     * Analyze workflow performance
     */
    analyzeWorkflowPerformance: (assessments: WorkflowAssessment[]) => Promise<WorkflowPerformanceReport>;
    /**
     * Generate optimization suggestions
     */
    generateOptimizations: (workflowName: string, assessments: WorkflowAssessment[]) => Promise<ImprovementSuggestion[]>;
    /**
     * Compare workflow versions
     */
    compareWorkflowVersions: (workflowName: string, version1: string, version2: string) => Promise<WorkflowComparison>;
    /**
     * Predict workflow success
     */
    predictWorkflowSuccess: (workflowConfig: any) => Promise<{
        successProbability: number;
        riskFactors: string[];
        mitigationSuggestions: string[];
    }>;
}
export interface WorkflowPerformanceReport {
    workflowName: string;
    timeframe: {
        start: Date;
        end: Date;
    };
    performance: {
        averageRating: number;
        efficiency: number;
        accuracy: number;
        userExperience: number;
        consistency: number;
    };
    trends: {
        overall: 'improving' | 'stable' | 'declining';
        efficiency: 'improving' | 'stable' | 'declining';
        accuracy: 'improving' | 'stable' | 'declining';
        userExperience: 'improving' | 'stable' | 'declining';
    };
    issues: {
        recurring: string[];
        emerging: string[];
        resolved: string[];
    };
    userSegments: {
        segment: string;
        performance: number;
        satisfaction: number;
        issueCount: number;
    }[];
    recommendations: {
        priority: Priority;
        action: string;
        expectedImpact: Impact;
        effort: 'small' | 'medium' | 'large';
    }[];
}
export interface WorkflowComparison {
    workflowName: string;
    version1: string;
    version2: string;
    performance: {
        metric: string;
        version1Value: number;
        version2Value: number;
        change: number;
        significance: 'significant' | 'minor' | 'insignificant';
    }[];
    improvements: string[];
    regressions: string[];
    neutralChanges: string[];
    userFeedback: {
        preferred: string;
        confidence: number;
        reasons: string[];
    };
    recommendation: {
        preferredVersion: string;
        reasoning: string;
        rolloutStrategy?: string;
    };
}
export interface ImprovementTracker {
    /**
     * Track implementation progress
     */
    trackProgress: (suggestionId: string) => Promise<{
        status: ImplementationStatus;
        progress: number;
        milestones: ImplementationMilestone[];
        blockers: string[];
        nextSteps: string[];
    }>;
    /**
     * Measure improvement impact
     */
    measureImpact: (suggestionId: string, beforeMetrics: Record<string, number>, afterMetrics: Record<string, number>) => Promise<ImpactMeasurement>;
    /**
     * Generate implementation plan
     */
    generateImplementationPlan: (suggestion: ImprovementSuggestion) => Promise<ImplementationPlan>;
    /**
     * Validate improvement success
     */
    validateSuccess: (suggestionId: string, successCriteria: Record<string, number>) => Promise<{
        successful: boolean;
        achievedCriteria: string[];
        missedCriteria: string[];
        recommendations: string[];
    }>;
}
export interface ImplementationMilestone {
    id: string;
    title: string;
    description: string;
    targetDate: Date;
    completedDate?: Date;
    status: 'pending' | 'in-progress' | 'completed' | 'blocked';
    dependencies: string[];
    deliverables: string[];
}
export interface ImpactMeasurement {
    suggestionId: string;
    measurementPeriod: {
        start: Date;
        end: Date;
    };
    metrics: {
        name: string;
        before: number;
        after: number;
        change: number;
        significance: 'significant' | 'marginal' | 'insignificant';
        direction: 'positive' | 'negative' | 'neutral';
    }[];
    overall: {
        successScore: number;
        impact: Impact;
        confidence: number;
    };
    userFeedback: {
        satisfactionChange: number;
        adoptionRate: number;
        userComments: string[];
    };
    businessValue: {
        timesSaved: number;
        errorReduction: number;
        productivityGain: number;
        userSatisfactionImprovement: number;
    };
}
export interface ImplementationPlan {
    suggestionId: string;
    title: string;
    phases: {
        name: string;
        duration: number;
        resources: string[];
        deliverables: string[];
        dependencies: string[];
        risks: string[];
    }[];
    timeline: {
        start: Date;
        end: Date;
        milestones: ImplementationMilestone[];
    };
    resources: {
        personnel: string[];
        tools: string[];
        budget?: number;
    };
    riskMitigation: {
        risk: string;
        probability: 'low' | 'medium' | 'high';
        impact: Impact;
        mitigation: string;
    }[];
    successMetrics: {
        metric: string;
        baseline: number;
        target: number;
        measurementMethod: string;
    }[];
}
export interface LearningEngine {
    /**
     * Generate learning insights from data
     */
    generateLearnings: (data: {
        feedback: FeedbackEntry[];
        assessments: WorkflowAssessment[];
        improvements: ImprovementSuggestion[];
    }) => Promise<LearningInsight[]>;
    /**
     * Validate learning insights
     */
    validateInsights: (insights: LearningInsight[]) => Promise<{
        validated: LearningInsight[];
        rejected: LearningInsight[];
        needingMoreData: LearningInsight[];
    }>;
    /**
     * Apply learnings to improve system
     */
    applyLearnings: (insights: LearningInsight[]) => Promise<{
        applied: string[];
        scheduled: string[];
        rejected: string[];
    }>;
    /**
     * Generate knowledge base entries
     */
    generateKnowledgeBase: (insights: LearningInsight[]) => Promise<KnowledgeEntry[]>;
}
export interface KnowledgeEntry {
    id: string;
    title: string;
    content: string;
    category: 'best-practice' | 'common-issue' | 'optimization' | 'pattern' | 'solution';
    applicability: {
        workflows: string[];
        userTypes: string[];
        contexts: string[];
    };
    evidence: {
        sourceInsights: string[];
        validationData: any[];
        confidence: number;
    };
    recommendations: {
        actions: string[];
        preventions: string[];
        optimizations: string[];
    };
    createdAt: Date;
    lastUpdated: Date;
    version: string;
    usage: {
        viewCount: number;
        applicationCount: number;
        successRate: number;
    };
}
export interface UserBehaviorAnalyzer {
    /**
     * Analyze user feedback patterns
     */
    analyzeFeedbackBehavior: (userId: string, feedbackHistory: FeedbackEntry[]) => Promise<UserFeedbackProfile>;
    /**
     * Predict user satisfaction
     */
    predictSatisfaction: (userId: string, workflowName: string, context: any) => Promise<{
        satisfactionScore: number;
        confidence: number;
        factors: string[];
        recommendations: string[];
    }>;
    /**
     * Identify user needs
     */
    identifyUserNeeds: (feedbackEntries: FeedbackEntry[]) => Promise<UserNeed[]>;
    /**
     * Segment users by feedback patterns
     */
    segmentUsers: (feedbackData: FeedbackEntry[]) => Promise<UserSegment[]>;
}
export interface UserFeedbackProfile {
    userId: string;
    feedbackFrequency: 'low' | 'medium' | 'high';
    feedbackQuality: 'low' | 'medium' | 'high';
    patterns: {
        preferredFeedbackTypes: FeedbackType[];
        commonCategories: FeedbackCategory[];
        typicalSeverity: FeedbackSeverity;
        averageDetailLevel: 'brief' | 'moderate' | 'detailed';
    };
    satisfaction: {
        averageRating: number;
        trend: 'improving' | 'stable' | 'declining';
        volatility: 'low' | 'medium' | 'high';
    };
    engagement: {
        feedbackSubmissionRate: number;
        assessmentParticipation: number;
        improvementTracking: number;
    };
    expertise: {
        level: 'beginner' | 'intermediate' | 'advanced';
        areas: string[];
        growthRate: number;
    };
}
export interface UserNeed {
    id: string;
    description: string;
    category: 'functionality' | 'performance' | 'usability' | 'integration' | 'support';
    priority: Priority;
    evidence: {
        feedbackCount: number;
        userCount: number;
        urgencyScore: number;
        businessImpact: Impact;
    };
    solution: {
        type: 'feature' | 'improvement' | 'documentation' | 'training';
        description: string;
        effort: 'small' | 'medium' | 'large';
        timeline: string;
    };
    validation: {
        userVotes: number;
        expertReview: 'pending' | 'approved' | 'rejected';
        feasibilityScore: number;
    };
}
export interface UserSegment {
    id: string;
    name: string;
    description: string;
    userCount: number;
    characteristics: {
        feedbackPatterns: string[];
        satisfactionLevels: string[];
        usagePatterns: string[];
        painPoints: string[];
    };
    needs: {
        primary: string[];
        secondary: string[];
        emerging: string[];
    };
    recommendations: {
        features: string[];
        improvements: string[];
        support: string[];
    };
}
//# sourceMappingURL=types.d.ts.map