@neuroequality/neuroadapt-ai/dist/streaming/content-adapter.d.ts

AI-powered accessibility personalization for neurodivergent users

import { EventEmitter } from 'eventemitter3';
import { StreamChunk, AdaptationSuggestion } from '../types/common.js';

/**
 * Events emitted by ContentAdapter
 */
export interface ContentAdapterEvents {
    'content-processed': (result: ProcessedContent) => void;
    'adaptation-suggested': (suggestion: AdaptationSuggestion) => void;
    'chunk-processed': (chunk: ProcessedChunk) => void;
    'processing-complete': (summary: ProcessingSummary) => void;
    'error': (error: Error) => void;
}
/**
 * Configuration for content adaptation
 */
export interface ContentAdapterConfig {
    chunkSize?: number;
    processingDelay?: number;
    enableRealTimeAnalysis?: boolean;
    adaptationThreshold?: number;
    maxConcurrentChunks?: number;
    retryAttempts?: number;
}
/**
 * Processed content result
 */
export interface ProcessedContent {
    id: string;
    originalContent: string;
    adaptedContent: string;
    adaptations: string[];
    confidence: number;
    processingTime: number;
    metadata?: Record<string, unknown>;
}
/**
 * Processed chunk information
 */
export interface ProcessedChunk {
    id: string;
    chunkIndex: number;
    content: string;
    adaptations: string[];
    confidence: number;
    timestamp: number;
}
/**
 * Processing summary
 */
export interface ProcessingSummary {
    totalChunks: number;
    processedChunks: number;
    failedChunks: number;
    totalAdaptations: number;
    averageConfidence: number;
    totalProcessingTime: number;
    suggestedImprovements: string[];
}
/**
 * ContentAdapter provides real-time content adaptation and streaming processing
 */
export declare class ContentAdapter extends EventEmitter<ContentAdapterEvents> {
    private config;
    private processingQueue;
    private activeProcessing;
    private adaptationCache;
    private processingStats;
    constructor(config?: ContentAdapterConfig);
    /**
     * Process content with user preferences
     */
    processContent(content: string, preferences: Record<string, unknown>, context?: Record<string, unknown>): Promise<ProcessedContent>;
    /**
     * Process streaming content chunks
     */
    processStreamChunks(chunks: AsyncGenerator<StreamChunk, void, unknown>, preferences: Record<string, unknown>, context?: Record<string, unknown>): Promise<void>;
    /**
     * Add content to processing queue
     */
    queueContent(content: string, preferences: Record<string, unknown>, context?: Record<string, unknown>): string;
    /**
     * Get processing statistics
     */
    getProcessingStats(): ProcessingSummary;
    /**
     * Clear adaptation cache
     */
    clearCache(): void;
    /**
     * Get cache information
     */
    getCacheInfo(): {
        size: number;
        keys: string[];
    };
    /**
     * Stop processing and clean up
     */
    destroy(): void;
    private generateContentId;
    private adaptContent;
    private applyHighContrastAdaptation;
    private applyMotionReductionAdaptation;
    private applyFontSizeAdaptation;
    private applyContentChunking;
    private applyLanguageSimplification;
    private detectAppliedAdaptations;
    private calculateConfidence;
    private shouldProcessBuffer;
    private processChunk;
    private startProcessingLoop;
    private processQueue;
    private processQueueItem;
    private createEmptyStats;
}
//# sourceMappingURL=content-adapter.d.ts.map