@neuroequality/neuroadapt-ai/dist/advanced/real-time-optimization.d.ts

AI-powered accessibility personalization for neurodivergent users

import { EventEmitter } from 'eventemitter3';

export interface OptimizationTarget {
    metric: string;
    currentValue: number;
    targetValue: number;
    priority: 'low' | 'medium' | 'high' | 'critical';
    constraints: OptimizationConstraint[];
}
export interface OptimizationConstraint {
    parameter: string;
    minValue: number;
    maxValue: number;
    weight: number;
}
export interface OptimizationResult {
    parametersAdjusted: Record<string, number>;
    improvementScore: number;
    convergenceTime: number;
    iterationsRequired: number;
    stabilityMetric: number;
}
export interface RealTimeMetrics {
    timestamp: Date;
    userId: string;
    metrics: {
        taskCompletionTime: number;
        errorRate: number;
        cognitiveLoad: number;
        userSatisfaction: number;
        accessibilityScore: number;
        usabilityIndex: number;
    };
    context: {
        device: string;
        environment: string;
        timeOfDay: number;
        userState: string;
    };
}
export interface OptimizationStrategy {
    name: string;
    algorithm: 'gradient_descent' | 'genetic_algorithm' | 'simulated_annealing' | 'particle_swarm' | 'bayesian';
    parameters: Record<string, any>;
    converged: boolean;
    performance: number;
}
/**
 * Real-time Optimization System for continuous accessibility improvements
 */
export declare class RealTimeOptimizer extends EventEmitter {
    private config;
    private optimizationTargets;
    private metricsHistory;
    private currentStrategies;
    private optimizationLoop;
    private isOptimizing;
    constructor(config?: {
        optimizationInterval: number;
        convergenceThreshold: number;
        maxIterations: number;
        adaptationRate: number;
        stabilityWindow: number;
    });
    /**
     * Initialize optimization strategies
     */
    private initializeOptimizationStrategies;
    /**
     * Start real-time optimization
     */
    startOptimization(): void;
    /**
     * Stop real-time optimization
     */
    stopOptimization(): void;
    /**
     * Add optimization target
     */
    addOptimizationTarget(target: OptimizationTarget): void;
    /**
     * Remove optimization target
     */
    removeOptimizationTarget(metric: string): void;
    /**
     * Add real-time metrics
     */
    addMetrics(metrics: RealTimeMetrics): void;
    /**
     * Run single optimization cycle
     */
    private runOptimizationCycle;
    /**
     * Optimize single target using best available strategy
     */
    private optimizeTarget;
    /**
     * Gradient Descent optimization implementation
     */
    private gradientDescentOptimization;
    /**
     * Genetic Algorithm optimization implementation
     */
    private geneticAlgorithmOptimization;
    /**
     * Simulated Annealing optimization implementation
     */
    private simulatedAnnealingOptimization;
    /**
     * Particle Swarm optimization implementation
     */
    private particleSwarmOptimization;
    /**
     * Bayesian optimization implementation
     */
    private bayesianOptimization;
    private selectBestStrategy;
    private getCurrentMetrics;
    private calculateGradient;
    private evaluateObjective;
    private applyConstraints;
    private calculateImprovementScore;
    private calculateStabilityMetric;
    private evaluateOptimizationPerformance;
    private adaptOptimizationStrategies;
    private finetuneParameters;
    private getDefaultParameters;
    private initializePopulation;
    private evaluatePopulationFitness;
    private isConverged;
    private createNewGeneration;
    private generateNeighborSolution;
    private calculateEnergy;
    private initializeParticleSwarm;
    private findGlobalBest;
    private updateParticleVelocity;
    private updateParticlePosition;
    private updateParticleBest;
    private isBetterSolution;
    private isSwarmConverged;
    private sampleFromConstraints;
    private fitGaussianProcess;
    private optimizeAcquisitionFunction;
    private isBayesianConverged;
}
export default RealTimeOptimizer;
//# sourceMappingURL=real-time-optimization.d.ts.map