import { EventEmitter } from 'events';
import { A as AIStream } from './AIStream-BwgeGI-N.js';
import { M as Message, d as Usage } from './streaming.d-Cj-pZLSI.js';
import { P as PerformanceMetrics } from './common.d-iR60eBef.js';

/**
 * RLHF (Reinforcement Learning from Human Feedback) Types
 *
 * Type definitions for RLHF logging system
 */
/**
 * Feedback type enumeration
 */
declare enum FeedbackType {
    /** Binary thumbs up/down feedback */
    BINARY = "binary",
    /** Rating scale (1-5 stars) */
    RATING = "rating",
    /** Text comment feedback */
    TEXT = "text",
    /** Multi-dimensional ratings */
    MULTI_DIMENSIONAL = "multi_dimensional",
    /** Comparative feedback between multiple responses */
    COMPARATIVE = "comparative"
}
/**
 * Binary feedback values
 */
declare enum BinaryFeedback {
    THUMBS_UP = "thumbs_up",
    THUMBS_DOWN = "thumbs_down"
}
/**
 * Storage backend types
 */
declare enum StorageBackend {
    /** ZeroDB cloud storage */
    ZERODB = "zerodb",
    /** Local file storage */
    LOCAL = "local",
    /** Custom storage implementation */
    CUSTOM = "custom",
    /** In-memory storage (testing only) */
    MEMORY = "memory"
}
/**
 * Export format types
 */
declare enum ExportFormat {
    JSON = "json",
    CSV = "csv",
    JSONL = "jsonl",
    PARQUET = "parquet"
}
/**
 * Binary feedback data
 */
interface BinaryFeedbackData {
    value: BinaryFeedback;
    timestamp: Date;
}
/**
 * Rating feedback data (1-5 scale)
 */
interface RatingFeedbackData {
    rating: number;
    maxRating?: number;
    comment?: string;
    timestamp: Date;
}
/**
 * Text feedback data
 */
interface TextFeedbackData {
    comment: string;
    sentiment?: 'positive' | 'negative' | 'neutral';
    timestamp: Date;
}
/**
 * Multi-dimensional rating data
 */
interface MultiDimensionalFeedbackData {
    dimensions: {
        [dimensionName: string]: number;
    };
    weights?: {
        [dimensionName: string]: number;
    };
    overallComment?: string;
    timestamp: Date;
}
/**
 * Comparative feedback data
 */
interface ComparativeFeedbackData {
    preferredResponseId: string;
    comparedResponseIds: string[];
    reason?: string;
    confidenceLevel?: number;
    timestamp: Date;
}
/**
 * Generic feedback data union
 */
type FeedbackData = BinaryFeedbackData | RatingFeedbackData | TextFeedbackData | MultiDimensionalFeedbackData | ComparativeFeedbackData;
/**
 * User feedback record
 */
interface Feedback {
    /** Unique feedback ID */
    id: string;
    /** Associated interaction ID */
    interactionId: string;
    /** Feedback type */
    type: FeedbackType;
    /** Feedback data */
    data: FeedbackData;
    /** User ID (optional) */
    userId?: string;
    /** Session ID */
    sessionId?: string;
    /** Additional metadata */
    metadata?: Record<string, any>;
    /** Timestamp */
    timestamp: Date;
    /** Feedback source (web, mobile, api, etc.) */
    source?: string;
}
/**
 * AI interaction log
 */
interface InteractionLog {
    /** Unique interaction ID */
    id: string;
    /** User prompt/input */
    prompt: string;
    /** AI response/output */
    response: string;
    /** Model used */
    model?: string;
    /** Model parameters */
    modelParams?: {
        temperature?: number;
        maxTokens?: number;
        topP?: number;
        [key: string]: any;
    };
    /** Latency in milliseconds */
    latency?: number;
    /** Token usage */
    tokenUsage?: {
        prompt: number;
        completion: number;
        total: number;
    };
    /** User ID (optional) */
    userId?: string;
    /** Session ID */
    sessionId?: string;
    /** Context/conversation history */
    context?: Array<{
        role: 'user' | 'assistant' | 'system';
        content: string;
    }>;
    /** Additional metadata */
    metadata?: Record<string, any>;
    /** Timestamp */
    timestamp: Date;
    /** Associated feedback IDs */
    feedbackIds?: string[];
}
/**
 * Feedback session
 */
interface FeedbackSession {
    /** Session ID */
    id: string;
    /** User ID (optional) */
    userId?: string;
    /** Session start time */
    startTime: Date;
    /** Session end time */
    endTime?: Date;
    /** Interaction IDs in this session */
    interactionIds: string[];
    /** Feedback IDs in this session */
    feedbackIds: string[];
    /** Session metadata */
    metadata?: Record<string, any>;
}
/**
 * Aggregated feedback statistics
 */
interface FeedbackStats {
    /** Total interactions logged */
    totalInteractions: number;
    /** Total feedback received */
    totalFeedback: number;
    /** Feedback rate (feedback/interactions) */
    feedbackRate: number;
    /** Binary feedback stats */
    binary?: {
        thumbsUp: number;
        thumbsDown: number;
        ratio: number;
    };
    /** Rating stats */
    rating?: {
        average: number;
        median: number;
        distribution: {
            [rating: number]: number;
        };
        count: number;
    };
    /** Text feedback stats */
    text?: {
        count: number;
        averageLength: number;
        sentimentDistribution?: {
            positive: number;
            negative: number;
            neutral: number;
        };
    };
    /** Multi-dimensional stats */
    multiDimensional?: {
        count: number;
        dimensionAverages: {
            [dimension: string]: number;
        };
    };
    /** Comparative stats */
    comparative?: {
        count: number;
        averageConfidence?: number;
    };
    /** Time range */
    timeRange: {
        start: Date;
        end: Date;
    };
    /** Feedback by type */
    byType: {
        [key in FeedbackType]?: number;
    };
}
/**
 * Storage backend interface
 */
interface IStorageBackend {
    /** Initialize storage backend */
    initialize(): Promise<void>;
    /** Store interaction log */
    storeInteraction(interaction: InteractionLog): Promise<void>;
    /** Store feedback */
    storeFeedback(feedback: Feedback): Promise<void>;
    /** Store multiple interactions (batch) */
    storeInteractionsBatch(interactions: InteractionLog[]): Promise<void>;
    /** Store multiple feedback items (batch) */
    storeFeedbackBatch(feedback: Feedback[]): Promise<void>;
    /** Get interaction by ID */
    getInteraction(id: string): Promise<InteractionLog | null>;
    /** Get feedback by ID */
    getFeedback(id: string): Promise<Feedback | null>;
    /** Get feedback for interaction */
    getFeedbackForInteraction(interactionId: string): Promise<Feedback[]>;
    /** Get interactions in time range */
    getInteractions(startTime: Date, endTime: Date, limit?: number): Promise<InteractionLog[]>;
    /** Get feedback in time range */
    getFeedbackInRange(startTime: Date, endTime: Date, limit?: number): Promise<Feedback[]>;
    /** Calculate feedback statistics */
    calculateStats(startTime?: Date, endTime?: Date): Promise<FeedbackStats>;
    /** Export feedback data */
    exportData(format: ExportFormat, startTime?: Date, endTime?: Date): Promise<string | Buffer>;
    /** Close storage backend */
    close(): Promise<void>;
}
/**
 * RLHF Logger configuration
 */
interface RLHFConfig {
    /** Storage backend type */
    backend: StorageBackend;
    /** Backend-specific configuration */
    backendConfig?: {
        /** ZeroDB configuration */
        zerodb?: {
            projectId: string;
            apiKey?: string;
            tableName?: string;
            vectorTableName?: string;
        };
        /** Local file storage configuration */
        local?: {
            dataDir: string;
            compress?: boolean;
            maxFileSize?: number;
            rotateFiles?: boolean;
        };
        /** Custom backend configuration */
        custom?: {
            implementation: IStorageBackend;
            config?: Record<string, any>;
        };
        /** Memory storage configuration */
        memory?: {
            maxEntries?: number;
        };
    };
    /** Enable batch logging */
    enableBatching?: boolean;
    /** Batch size */
    batchSize?: number;
    /** Batch flush interval (ms) */
    batchFlushInterval?: number;
    /** Enable compression */
    enableCompression?: boolean;
    /** Auto-generate interaction IDs */
    autoGenerateIds?: boolean;
    /** Enable session tracking */
    enableSessionTracking?: boolean;
    /** Default session timeout (ms) */
    sessionTimeout?: number;
    /** Enable anonymous feedback */
    allowAnonymous?: boolean;
    /** Custom metadata to include in all logs */
    defaultMetadata?: Record<string, any>;
    /** Enable debug logging */
    debug?: boolean;
}
/**
 * Batch operation
 */
interface BatchOperation {
    type: 'interaction' | 'feedback';
    data: InteractionLog | Feedback;
    timestamp: Date;
}
/**
 * Export options
 */
interface ExportOptions {
    /** Export format */
    format: ExportFormat;
    /** Start time filter */
    startTime?: Date;
    /** End time filter */
    endTime?: Date;
    /** Include interactions */
    includeInteractions?: boolean;
    /** Include feedback */
    includeFeedback?: boolean;
    /** Filter by feedback type */
    feedbackTypes?: FeedbackType[];
    /** Filter by user ID */
    userId?: string;
    /** Filter by session ID */
    sessionId?: string;
    /** Maximum records to export */
    limit?: number;
    /** Include metadata */
    includeMetadata?: boolean;
    /** Pretty print (JSON only) */
    prettyPrint?: boolean;
}
/**
 * Feedback filter options
 */
interface FeedbackFilter {
    /** Start time */
    startTime?: Date;
    /** End time */
    endTime?: Date;
    /** Feedback types */
    types?: FeedbackType[];
    /** User ID */
    userId?: string;
    /** Session ID */
    sessionId?: string;
    /** Interaction IDs */
    interactionIds?: string[];
    /** Minimum rating (for rating feedback) */
    minRating?: number;
    /** Maximum rating (for rating feedback) */
    maxRating?: number;
    /** Feedback source */
    source?: string;
    /** Limit */
    limit?: number;
    /** Offset */
    offset?: number;
}
/**
 * Analytics query result
 */
interface AnalyticsResult {
    /** Query metadata */
    query: {
        startTime?: Date;
        endTime?: Date;
        filters?: FeedbackFilter;
    };
    /** Statistics */
    stats: FeedbackStats;
    /** Trends over time */
    trends?: {
        interval: 'hour' | 'day' | 'week' | 'month';
        data: Array<{
            timestamp: Date;
            stats: Partial<FeedbackStats>;
        }>;
    };
    /** Top issues/complaints (from text feedback) */
    topIssues?: Array<{
        issue: string;
        count: number;
        sentiment: 'negative' | 'neutral';
    }>;
    /** Generated timestamp */
    generatedAt: Date;
}

/**
 * RLHFLogger - Reinforcement Learning from Human Feedback Logger
 *
 * Comprehensive logging system for capturing user feedback and AI interactions
 * to improve model performance through RLHF.
 */

/**
 * Main RLHF Logger class
 */
declare class RLHFLogger {
    private config;
    private storage;
    private batchQueue;
    private batchTimer?;
    private currentSession?;
    private sessionTimer?;
    private initialized;
    /**
     * Create a new RLHFLogger instance
     */
    constructor(config: RLHFConfig);
    /**
     * Normalize configuration with defaults
     */
    private normalizeConfig;
    /**
     * Create storage backend based on configuration
     */
    private createStorageBackend;
    /**
     * Initialize the logger
     */
    initialize(): Promise<void>;
    /**
     * Log an AI interaction
     */
    logInteraction(prompt: string, response: string, metadata?: {
        model?: string;
        modelParams?: Record<string, any>;
        latency?: number;
        tokenUsage?: {
            prompt: number;
            completion: number;
            total: number;
        };
        userId?: string;
        sessionId?: string;
        context?: Array<{
            role: 'user' | 'assistant' | 'system';
            content: string;
        }>;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Log binary feedback (thumbs up/down)
     */
    logBinaryFeedback(interactionId: string, value: BinaryFeedback, metadata?: {
        userId?: string;
        sessionId?: string;
        source?: string;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Log rating feedback (1-5 stars)
     */
    logRating(interactionId: string, rating: number, comment?: string, metadata?: {
        maxRating?: number;
        userId?: string;
        sessionId?: string;
        source?: string;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Log text feedback (comments)
     */
    logTextFeedback(interactionId: string, comment: string, sentiment?: 'positive' | 'negative' | 'neutral', metadata?: {
        userId?: string;
        sessionId?: string;
        source?: string;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Log multi-dimensional feedback
     */
    logMultiDimensionalFeedback(interactionId: string, dimensions: {
        [dimensionName: string]: number;
    }, options?: {
        weights?: {
            [dimensionName: string]: number;
        };
        overallComment?: string;
        userId?: string;
        sessionId?: string;
        source?: string;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Log comparative feedback
     */
    logComparativeFeedback(preferredResponseId: string, comparedResponseIds: string[], options?: {
        reason?: string;
        confidenceLevel?: number;
        userId?: string;
        sessionId?: string;
        source?: string;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Generic feedback logging method
     */
    logFeedback(interactionId: string, type: FeedbackType, data: FeedbackData, metadata?: {
        userId?: string;
        sessionId?: string;
        source?: string;
        [key: string]: any;
    }): Promise<string>;
    /**
     * Get feedback statistics
     */
    getFeedbackStats(startTime?: Date, endTime?: Date): Promise<FeedbackStats>;
    /**
     * Get interaction by ID
     */
    getInteraction(interactionId: string): Promise<InteractionLog | null>;
    /**
     * Get feedback by ID
     */
    getFeedback(feedbackId: string): Promise<Feedback | null>;
    /**
     * Get all feedback for an interaction
     */
    getFeedbackForInteraction(interactionId: string): Promise<Feedback[]>;
    /**
     * Get interactions in time range
     */
    getInteractions(startTime: Date, endTime: Date, limit?: number): Promise<InteractionLog[]>;
    /**
     * Get feedback in time range
     */
    getFeedbackInRange(startTime: Date, endTime: Date, limit?: number): Promise<Feedback[]>;
    /**
     * Export feedback data
     */
    exportFeedback(format: ExportFormat, options?: Omit<ExportOptions, 'format'>): Promise<string | Buffer>;
    /**
     * Query and analyze feedback
     */
    queryFeedback(filter: FeedbackFilter): Promise<Feedback[]>;
    /**
     * Get analytics results
     */
    getAnalytics(filter?: FeedbackFilter): Promise<AnalyticsResult>;
    /**
     * Flush batch queue manually
     */
    flush(): Promise<void>;
    /**
     * Start a new feedback session
     */
    startSession(userId?: string, metadata?: Record<string, any>): string;
    /**
     * End current feedback session
     */
    endSession(): FeedbackSession | null;
    /**
     * Get current session
     */
    getCurrentSession(): FeedbackSession | null;
    /**
     * Close the logger and cleanup
     */
    close(): Promise<void>;
    /**
     * Add operation to batch queue
     */
    private addToBatch;
    /**
     * Start batch timer
     */
    private startBatchTimer;
    /**
     * Reset session timeout timer
     */
    private resetSessionTimer;
    /**
     * Debug logging
     */
    private log;
}
/**
 * Create a new RLHFLogger instance
 */
declare function createRLHFLogger(config: RLHFConfig): RLHFLogger;

/**
 * TypeScript types for RLHF auto-instrumentation
 */

/**
 * Configuration for RLHF instrumentation
 */
interface InstrumentationConfig {
    /**
     * Enable/disable instrumentation
     * @default true
     */
    enabled?: boolean;
    /**
     * Automatically capture prompt-response pairs
     * @default true
     */
    captureInteractions?: boolean;
    /**
     * Automatically capture user feedback
     * @default true
     */
    captureFeedback?: boolean;
    /**
     * Automatically capture performance metrics
     * @default true
     */
    captureMetrics?: boolean;
    /**
     * Automatically capture error events
     * @default true
     */
    captureErrors?: boolean;
    /**
     * Automatically capture usage patterns
     * @default true
     */
    captureUsagePatterns?: boolean;
    /**
     * Collect contextual data (user agent, timestamps, etc.)
     * @default true
     */
    collectContext?: boolean;
    /**
     * Custom context data to include
     */
    customContext?: Record<string, any>;
    /**
     * Sample rate for instrumentation (0-1)
     * @default 1.0
     */
    sampleRate?: number;
    /**
     * Maximum number of interactions to buffer
     * @default 1000
     */
    maxBufferSize?: number;
    /**
     * Callback when buffer is full
     */
    onBufferFull?: (interactions: CapturedInteraction[]) => void;
    /**
     * Callback when interaction is captured
     */
    onInteractionCaptured?: (interaction: CapturedInteraction) => void;
    /**
     * Callback when feedback is captured
     */
    onFeedbackCaptured?: (feedback: FeedbackEvent) => void;
    /**
     * Storage backend for captured data
     * @default 'memory'
     */
    storage?: 'memory' | 'local' | 'remote';
    /**
     * Remote endpoint for sending captured data
     */
    remoteEndpoint?: string;
    /**
     * Batch size for remote uploads
     * @default 10
     */
    batchSize?: number;
    /**
     * Flush interval in milliseconds
     * @default 60000
     */
    flushInterval?: number;
}
/**
 * Captured interaction data
 */
interface CapturedInteraction {
    /**
     * Unique interaction ID
     */
    id: string;
    /**
     * Session ID
     */
    sessionId: string;
    /**
     * User prompt/input
     */
    prompt: Message;
    /**
     * AI response/output
     */
    response: Message;
    /**
     * Context at time of interaction
     */
    context: ContextData;
    /**
     * Performance metrics
     */
    metrics: PerformanceMetrics;
    /**
     * Usage statistics
     */
    usage?: Usage;
    /**
     * Feedback on this interaction
     */
    feedback?: FeedbackEvent[];
    /**
     * Error information if any
     */
    error?: ErrorEvent;
    /**
     * Timestamp when captured
     */
    timestamp: number;
    /**
     * Custom metadata
     */
    metadata?: Record<string, any>;
}
/**
 * Context data collected during interaction
 */
interface ContextData {
    /**
     * User agent string
     */
    userAgent?: string;
    /**
     * Device type
     */
    deviceType?: 'desktop' | 'mobile' | 'tablet' | 'unknown';
    /**
     * Browser/platform information
     */
    platform?: string;
    /**
     * Language preference
     */
    language?: string;
    /**
     * Timezone
     */
    timezone?: string;
    /**
     * Screen resolution
     */
    screenResolution?: string;
    /**
     * Referrer
     */
    referrer?: string;
    /**
     * Page URL
     */
    url?: string;
    /**
     * User ID (if available)
     */
    userId?: string;
    /**
     * Application version
     */
    appVersion?: string;
    /**
     * Environment (dev, staging, prod)
     */
    environment?: string;
    /**
     * Custom context fields
     */
    custom?: Record<string, any>;
}

/**
 * User feedback event
 */
interface FeedbackEvent {
    /**
     * Feedback ID
     */
    id: string;
    /**
     * Interaction ID this feedback is for
     */
    interactionId: string;
    /**
     * Feedback type
     */
    type: 'thumbs-up' | 'thumbs-down' | 'rating' | 'text' | 'custom';
    /**
     * Feedback value (rating, boolean, text, etc.)
     */
    value: number | boolean | string | any;
    /**
     * Optional feedback comment
     */
    comment?: string;
    /**
     * Timestamp when feedback was given
     */
    timestamp: number;
    /**
     * User who gave feedback (if available)
     */
    userId?: string;
    /**
     * Custom metadata
     */
    metadata?: Record<string, any>;
}
/**
 * Error event captured during interaction
 */
interface ErrorEvent {
    /**
     * Error message
     */
    message: string;
    /**
     * Error stack trace
     */
    stack?: string;
    /**
     * Error code
     */
    code?: string;
    /**
     * Error type/name
     */
    type: string;
    /**
     * HTTP status code if applicable
     */
    statusCode?: number;
    /**
     * Timestamp when error occurred
     */
    timestamp: number;
    /**
     * Is error recoverable
     */
    recoverable?: boolean;
    /**
     * Custom metadata
     */
    metadata?: Record<string, any>;
}
/**
 * Instrumentation metrics
 */
interface InstrumentationMetrics {
    /**
     * Total interactions captured
     */
    totalInteractions: number;
    /**
     * Total feedback events captured
     */
    totalFeedback: number;
    /**
     * Total errors captured
     */
    totalErrors: number;
    /**
     * Current buffer size
     */
    bufferSize: number;
    /**
     * Interactions per session
     */
    interactionsPerSession: Map<string, number>;
    /**
     * Average response time
     */
    averageResponseTime: number;
    /**
     * Average tokens per interaction
     */
    averageTokensPerInteraction: number;
    /**
     * Feedback rate (feedback/interactions)
     */
    feedbackRate: number;
    /**
     * Error rate (errors/interactions)
     */
    errorRate: number;
    /**
     * Positive feedback rate
     */
    positiveFeedbackRate: number;
    /**
     * Negative feedback rate
     */
    negativeFeedbackRate: number;
    /**
     * Started at timestamp
     */
    startedAt: number;
    /**
     * Last interaction timestamp
     */
    lastInteractionAt?: number;
    /**
     * Last flush timestamp
     */
    lastFlushAt?: number;
    /**
     * Remote uploads count
     */
    remoteUploads?: number;
    /**
     * Failed uploads count
     */
    failedUploads?: number;
}
/**
 * Instrumentation event types
 */
type InstrumentationEventType = 'interaction-captured' | 'feedback-captured' | 'error-captured' | 'buffer-full' | 'flushed' | 'enabled' | 'disabled' | 'metrics-updated';
/**
 * Instrumentation event data
 */
interface InstrumentationEvent {
    type: InstrumentationEventType;
    data: any;
    timestamp: number;
}
/**
 * Custom instrumentor function
 */
type CustomInstrumentor = (interaction: CapturedInteraction) => CapturedInteraction | null;
/**
 * Middleware hook for instrumentation
 */
type InstrumentationMiddleware = (interaction: CapturedInteraction, next: () => void) => void;
/**
 * Storage interface for captured data
 */
interface InstrumentationStorage {
    /**
     * Store an interaction
     */
    store(interaction: CapturedInteraction): Promise<void>;
    /**
     * Retrieve interactions
     */
    retrieve(filter?: InteractionFilter): Promise<CapturedInteraction[]>;
    /**
     * Clear stored interactions
     */
    clear(): Promise<void>;
    /**
     * Get storage size
     */
    size(): Promise<number>;
}
/**
 * Filter for retrieving interactions
 */
interface InteractionFilter {
    /**
     * Session ID
     */
    sessionId?: string;
    /**
     * Date range start
     */
    startDate?: number;
    /**
     * Date range end
     */
    endDate?: number;
    /**
     * Has feedback
     */
    hasFeedback?: boolean;
    /**
     * Has errors
     */
    hasError?: boolean;
    /**
     * Limit results
     */
    limit?: number;
    /**
     * Offset for pagination
     */
    offset?: number;
}

/**
 * RLHF Auto-Instrumentation
 *
 * Automatically captures AI stream interactions, feedback events,
 * and contextual data for Reinforcement Learning from Human Feedback (RLHF).
 */

/**
 * RLHFInstrumentation class
 *
 * Provides automatic instrumentation for AI streams to capture
 * interactions, feedback, and metrics for RLHF training.
 */
declare class RLHFInstrumentation extends EventEmitter {
    private config;
    private enabled;
    private sessionId;
    private buffer;
    private metrics;
    private customInstrumentors;
    private middleware;
    private flushTimer?;
    private activeInteractions;
    /**
     * Create a new RLHF instrumentation instance
     */
    constructor(config?: InstrumentationConfig);
    /**
     * Instrument an AI stream for automatic capture
     */
    instrument(stream: AIStream): AIStream;
    /**
     * Manually capture an interaction
     */
    captureInteraction(event: {
        prompt: Message;
        response: Message;
        usage?: Usage;
        error?: Error;
    }): CapturedInteraction | null;
    /**
     * Capture user feedback
     */
    captureFeedback(feedback: Omit<FeedbackEvent, 'id' | 'timestamp'>): void;
    /**
     * Collect contextual data
     */
    collectContext(): ContextData;
    /**
     * Enable instrumentation
     */
    enable(): void;
    /**
     * Disable instrumentation
     */
    disable(): void;
    /**
     * Get instrumentation metrics
     */
    getMetrics(): InstrumentationMetrics;
    /**
     * Get captured interactions
     */
    getInteractions(filter?: InteractionFilter): CapturedInteraction[];
    /**
     * Clear all captured data
     */
    clear(): void;
    /**
     * Flush buffered interactions
     */
    flush(): Promise<void>;
    /**
     * Add custom instrumentor
     */
    addInstrumentor(instrumentor: CustomInstrumentor): void;
    /**
     * Add middleware
     */
    addMiddleware(middleware: InstrumentationMiddleware): void;
    /**
     * Remove custom instrumentor
     */
    removeInstrumentor(instrumentor: CustomInstrumentor): void;
    /**
     * Remove middleware
     */
    removeMiddleware(middleware: InstrumentationMiddleware): void;
    /**
     * Handle message event from stream
     */
    private handleMessage;
    /**
     * Handle token event from stream
     */
    private handleToken;
    /**
     * Handle usage event from stream
     */
    private handleUsage;
    /**
     * Handle error event from stream
     */
    private handleError;
    /**
     * Handle streaming start event
     */
    private handleStreamingStart;
    /**
     * Handle streaming end event
     */
    private handleStreamingEnd;
    /**
     * Handle reset event
     */
    private handleReset;
    /**
     * Find the most recent active interaction
     */
    private findActiveInteraction;
    /**
     * Complete an interaction
     */
    private completeInteraction;
    /**
     * Store interaction in buffer
     */
    private storeInteraction;
    /**
     * Handle buffer full event
     */
    private handleBufferFull;
    /**
     * Calculate performance metrics
     */
    private calculateMetrics;
    /**
     * Create error event from Error object
     */
    private createErrorEvent;
    /**
     * Update average metrics
     */
    private updateAverageMetrics;
    /**
     * Update error rate
     */
    private updateErrorRate;
    /**
     * Update feedback metrics
     */
    private updateFeedbackMetrics;
    /**
     * Start flush timer
     */
    private startFlushTimer;
    /**
     * Upload interactions to remote endpoint
     */
    private uploadToRemote;
    /**
     * Detect device type from user agent
     */
    private detectDeviceType;
    /**
     * Generate unique ID
     */
    private generateId;
    /**
     * Generate session ID
     */
    private generateSessionId;
    /**
     * Clean up resources
     */
    destroy(): void;
}
/**
 * Create a new instrumentation instance
 */
declare function createInstrumentation(config?: InstrumentationConfig): RLHFInstrumentation;

/**
 * Memory Storage Backend
 *
 * In-memory storage backend for RLHF logging (primarily for testing)
 */

interface MemoryStorageConfig {
    maxEntries?: number;
}
/**
 * In-memory storage backend implementation
 */
declare class MemoryStorage implements IStorageBackend {
    private config;
    private interactions;
    private feedback;
    private interactionsByTime;
    private feedbackByTime;
    private initialized;
    constructor(config?: MemoryStorageConfig);
    initialize(): Promise<void>;
    storeInteraction(interaction: InteractionLog): Promise<void>;
    storeFeedback(feedback: Feedback): Promise<void>;
    storeInteractionsBatch(interactions: InteractionLog[]): Promise<void>;
    storeFeedbackBatch(feedback: Feedback[]): Promise<void>;
    getInteraction(id: string): Promise<InteractionLog | null>;
    getFeedback(id: string): Promise<Feedback | null>;
    getFeedbackForInteraction(interactionId: string): Promise<Feedback[]>;
    getInteractions(startTime: Date, endTime: Date, limit?: number): Promise<InteractionLog[]>;
    getFeedbackInRange(startTime: Date, endTime: Date, limit?: number): Promise<Feedback[]>;
    calculateStats(startTime?: Date, endTime?: Date): Promise<FeedbackStats>;
    exportData(format: ExportFormat, startTime?: Date, endTime?: Date): Promise<string | Buffer>;
    close(): Promise<void>;
    /**
     * Get all interactions (for testing)
     */
    getAllInteractions(): InteractionLog[];
    /**
     * Get all feedback (for testing)
     */
    getAllFeedback(): Feedback[];
    /**
     * Clear all data (for testing)
     */
    clear(): void;
    /**
     * Compute statistics from feedback and interactions
     */
    private computeStats;
    /**
     * Convert feedback to CSV format
     */
    private convertToCSV;
}

/**
 * ZeroDB Storage Backend
 *
 * Storage backend implementation using ZeroDB for RLHF logging
 */

interface ZeroDBConfig {
    projectId: string;
    apiKey?: string;
    tableName?: string;
    vectorTableName?: string;
}
/**
 * ZeroDB storage backend implementation
 */
declare class ZeroDBStorage implements IStorageBackend {
    private config;
    private initialized;
    constructor(config: ZeroDBConfig);
    initialize(): Promise<void>;
    storeInteraction(interaction: InteractionLog): Promise<void>;
    storeFeedback(feedback: Feedback): Promise<void>;
    storeInteractionsBatch(interactions: InteractionLog[]): Promise<void>;
    storeFeedbackBatch(feedback: Feedback[]): Promise<void>;
    getInteraction(_id: string): Promise<InteractionLog | null>;
    getFeedback(_id: string): Promise<Feedback | null>;
    getFeedbackForInteraction(_interactionId: string): Promise<Feedback[]>;
    getInteractions(_startTime: Date, _endTime: Date, _limit?: number): Promise<InteractionLog[]>;
    getFeedbackInRange(_startTime: Date, _endTime: Date, _limit?: number): Promise<Feedback[]>;
    calculateStats(startTime?: Date, endTime?: Date): Promise<FeedbackStats>;
    exportData(format: ExportFormat, startTime?: Date, endTime?: Date): Promise<string | Buffer>;
    close(): Promise<void>;
    /**
     * Compute statistics from feedback and interactions
     */
    private computeStats;
    /**
     * Convert feedback to CSV format
     */
    private convertToCSV;
}

export { type AnalyticsResult as A, type BatchOperation as B, type CapturedInteraction as C, type InteractionFilter as D, type ExportOptions as E, type FeedbackData as F, type InteractionLog as I, MemoryStorage as M, RLHFLogger as R, StorageBackend as S, type TextFeedbackData as T, ZeroDBStorage as Z, RLHFInstrumentation as a, type RLHFConfig as b, type Feedback as c, type FeedbackSession as d, type FeedbackStats as e, type IStorageBackend as f, type FeedbackFilter as g, FeedbackType as h, type InstrumentationConfig as i, type InstrumentationEvent as j, type ContextData as k, type FeedbackEvent as l, type ErrorEvent as m, type InstrumentationMetrics as n, ExportFormat as o, BinaryFeedback as p, type BinaryFeedbackData as q, type RatingFeedbackData as r, type MultiDimensionalFeedbackData as s, type ComparativeFeedbackData as t, createRLHFLogger as u, createInstrumentation as v, type InstrumentationEventType as w, type CustomInstrumentor as x, type InstrumentationMiddleware as y, type InstrumentationStorage as z };