@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/index.d.ts

@@ -0,0 +1,647 @@
+import { E as EmbeddingProviderType, M as ModelInfo, a as EmbeddingModel } from './index-DWddsKRi.js';
+export { B as BaseProvider, s as BatchEmbeddingRequest, C as CohereProvider, n as CohereProviderConfig, z as CustomProviderConfig, r as EmbeddingRequest, H as HuggingFaceProvider, q as HuggingFaceProviderConfig, j as LocalEmbeddingFn, L as LocalProvider, p as LocalProviderConfig, k as LocalProviderOptions, b as ModelRegistry, O as OpenAIProvider, l as OpenAIProviderConfig, x as ProviderCapabilities, P as ProviderConfig, u as ProviderError, y as ProviderFactoryOptions, v as ProviderHealth, w as ProviderMetrics, t as ProviderResponse, R as RateLimitInfo, T as TokenUsage, V as VoyageProvider, o as VoyageProviderConfig, d as createCohereProvider, i as createHuggingFaceProvider, f as createLocalProvider, g as createMockProvider, c as createOpenAIProvider, h as createRandomProvider, e as createVoyageProvider, m as modelRegistry } from './index-DWddsKRi.js';
+import EventEmitter from 'eventemitter3';
+import { E as EmbeddingVector, a as EmbeddingResult, b as EmbeddingOptions, B as BatchEmbeddingOptions, c as BatchEmbeddingResult, d as EmbeddedChunk, S as SearchOptions, e as SearchResult, D as DocumentEmbeddingOptions, f as EmbeddingStats } from './embedding.types-CCgPVxt1.js';
+export { h as BatchProgress, C as ChunkMetadata, g as EmbeddingModelInfo, i as SimilarityMetric } from './embedding.types-CCgPVxt1.js';
+import { C as ChunkingStrategyType, a as ChunkingOptions, b as Chunk } from './index-DMaQRn2w.js';
+export { B as BaseChunker, l as ChunkingMetadata, u as ChunkingResult, v as ChunkingStats, w as ChunkingStrategyConfig, g as CodeChunker, r as CodeChunkingOptions, x as CustomChunkingFn, F as FixedChunker, n as FixedChunkingOptions, M as MarkdownChunker, q as MarkdownChunkingOptions, P as ParagraphChunkingOptions, R as RecursiveChunker, p as RecursiveChunkingOptions, S as SemanticChunker, o as SemanticChunkingOptions, t as SentenceChunkingOptions, y as TextSplitterFn, T as TokenCounterFn, k as chunk, j as createChunker, h as createCodeChunker, c as createFixedChunker, f as createMarkdownChunker, e as createRecursiveChunker, i as createSemanticChunker, d as defaultTokenCounter, m as mergeSmallChunks, s as splitLargeChunks } from './index-DMaQRn2w.js';
+export { BaseCache, BatchCacheLookupResult, CacheBackendType, CacheCleanupOptions, CacheCleanupResult, CacheEntryInfo, CacheEvictionPolicy, CacheExportFormat, CacheImportOptions, CacheKeyOptions, CacheLookupResult, CacheOptions, CacheStats, CacheWarmupOptions, CachedEmbedding, MemoryCache, MemoryCacheOptions, RedisCache, RedisCacheOptions, SQLiteCache, SQLiteCacheOptions, TierConfig, TieredCache, TieredCacheOptions, createCache, createMemoryCache, createRedisCache, createSQLiteCache, createStandardTieredCache, createTieredCache } from './caching/index.js';
+export { BaseStore, ChromaStore, ChromaStoreConfig, CollectionInfo, DeleteOptions, DeleteResult, DistanceMetric, IndexInfo, MemoryStore, MemoryStoreConfig, MilvusStoreConfig, PgVectorStoreConfig, PineconeStore, PineconeStoreConfig, QdrantStore, QdrantStoreConfig, StoreConfig, StoreFactoryOptions, StoreHealth, StoreQueryOptions, StoreQueryResult, StoreStats, StoredVector, UpsertOptions, UpsertResult, VectorRecord, VectorStoreType, WeaviateStoreConfig, createChromaStore, createMemoryStore, createPineconeStore, createQdrantStore, createStore } from './stores/index.js';
+
+interface EmbeddingVersion {
+    id: string;
+    name: string;
+    provider: EmbeddingProviderType;
+    model: string;
+    dimensions: number;
+    description?: string;
+    createdAt: number;
+    active: boolean;
+    deprecated: boolean;
+    deprecationReason?: string;
+    replacement?: string;
+    modelInfo?: ModelInfo;
+    metadata?: Record<string, unknown>;
+}
+interface VersionRegistryEntry {
+    version: EmbeddingVersion;
+    documentCount: number;
+    chunkCount: number;
+    firstUsed: number;
+    lastUsed: number;
+}
+interface VersionComparisonResult {
+    source: EmbeddingVersion;
+    target: EmbeddingVersion;
+    compatible: boolean;
+    dimensionChange: number;
+    providerChanged: boolean;
+    migrationRequired: boolean;
+    migrationComplexity: 'low' | 'medium' | 'high';
+    estimatedMigrationTimeMinutes?: number;
+    notes: string[];
+}
+interface MigrationPlan {
+    id: string;
+    name: string;
+    sourceVersion: string;
+    targetVersion: string;
+    steps: MigrationStep[];
+    totalItems: number;
+    estimatedDurationMinutes: number;
+    createdAt: number;
+    status: MigrationPlanStatus;
+    validation?: MigrationValidation;
+    metadata?: Record<string, unknown>;
+}
+type MigrationPlanStatus = 'draft' | 'validated' | 'ready' | 'in_progress' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface MigrationStep {
+    id: string;
+    type: MigrationStepType;
+    description: string;
+    order: number;
+    status: MigrationStepStatus;
+    itemCount: number;
+    processedCount: number;
+    config?: Record<string, unknown>;
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+}
+type MigrationStepType = 'backup' | 'validate_source' | 're_embed' | 'transform' | 'upsert' | 'verify' | 'cleanup' | 'rollback';
+type MigrationStepStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped';
+interface MigrationValidation {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    validatedAt: number;
+}
+interface MigrationProgress {
+    migrationId: string;
+    currentStep: string;
+    overallProgress: number;
+    stepProgress: number;
+    itemsProcessed: number;
+    totalItems: number;
+    itemsPerSecond: number;
+    estimatedRemainingSeconds: number;
+    errors: number;
+    startedAt: number;
+    status: MigrationPlanStatus;
+}
+interface MigrationResult {
+    migrationId: string;
+    success: boolean;
+    sourceVersion: string;
+    targetVersion: string;
+    itemsMigrated: number;
+    itemsFailed: number;
+    durationMs: number;
+    startedAt: number;
+    completedAt: number;
+    errors: MigrationError[];
+    rolledBack: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface MigrationError {
+    itemId: string;
+    stepId: string;
+    message: string;
+    code?: string;
+    retryable: boolean;
+    timestamp: number;
+}
+interface MigrationOptions {
+    batchSize?: number;
+    concurrency?: number;
+    continueOnError?: boolean;
+    maxErrors?: number;
+    validate?: boolean;
+    backup?: boolean;
+    backupPath?: string;
+    dryRun?: boolean;
+    onProgress?: (progress: MigrationProgress) => void;
+    onStep?: (step: MigrationStep) => void;
+    onError?: (error: MigrationError) => void;
+}
+interface RollbackOptions {
+    toStep?: string;
+    useBackup?: boolean;
+    backupPath?: string;
+    force?: boolean;
+}
+interface VersionUpgradePath {
+    from: string;
+    to: string;
+    steps: string[];
+    direct: boolean;
+    complexity: 'low' | 'medium' | 'high';
+    breakingChanges: string[];
+}
+interface VersionRegistryOptions {
+    storagePath?: string;
+    autoRegister?: boolean;
+    trackUsage?: boolean;
+    maxVersions?: number;
+}
+interface VersionChangeEvent {
+    type: 'created' | 'activated' | 'deprecated' | 'deleted';
+    versionId: string;
+    previousVersion?: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+
+type QualityMetricType = 'coherence' | 'diversity' | 'coverage' | 'stability' | 'retrieval_accuracy' | 'semantic_similarity' | 'cluster_quality';
+interface QualityScore {
+    metric: QualityMetricType;
+    score: number;
+    interpretation: 'poor' | 'fair' | 'good' | 'excellent';
+    threshold: number;
+    passed: boolean;
+    sampleSize: number;
+    computedAt: number;
+    details?: Record<string, unknown>;
+}
+interface QualityReport {
+    id: string;
+    name: string;
+    model: string;
+    version?: string;
+    scores: QualityScore[];
+    overallScore: number;
+    overallInterpretation: 'poor' | 'fair' | 'good' | 'excellent';
+    recommendations: string[];
+    createdAt: number;
+    sampleCount: number;
+    metadata?: Record<string, unknown>;
+}
+interface DriftDetectionResult {
+    driftDetected: boolean;
+    severity: 'none' | 'low' | 'medium' | 'high' | 'critical';
+    driftScore: number;
+    affectedDimensionsPercent: number;
+    meanShift: number;
+    varianceChange: number;
+    distributionComparison: DistributionComparison;
+    detectedAt: number;
+    referenceTimestamp: number;
+    currentTimestamp: number;
+    recommendations: string[];
+    details?: Record<string, unknown>;
+}
+interface DistributionComparison {
+    klDivergence: number;
+    jsDivergence: number;
+    wassersteinDistance: number;
+    meanCosineSimilarity: number;
+    dimensionStats?: DimensionStats[];
+}
+interface DimensionStats {
+    dimension: number;
+    referenceMean: number;
+    currentMean: number;
+    meanChange: number;
+    referenceVariance: number;
+    currentVariance: number;
+    varianceChange: number;
+    significantChange: boolean;
+}
+interface ReferenceDistribution {
+    id: string;
+    model: string;
+    version?: string;
+    sampleCount: number;
+    mean: EmbeddingVector;
+    variance: EmbeddingVector;
+    covariance?: number[][];
+    createdAt: number;
+    validUntil?: number;
+    metadata?: Record<string, unknown>;
+}
+interface DriftMonitorConfig {
+    checkInterval?: number;
+    sampleSize?: number;
+    driftThreshold?: number;
+    alertSeverity?: 'low' | 'medium' | 'high' | 'critical';
+    autoUpdateBaseline?: boolean;
+    baselineUpdateInterval?: number;
+    onAlert?: (result: DriftDetectionResult) => void;
+}
+interface QualityEvaluationOptions {
+    metrics?: QualityMetricType[];
+    sampleSize?: number;
+    referenceEmbeddings?: EmbeddingVector[];
+    referenceTexts?: string[];
+    groundTruth?: GroundTruthData;
+    thresholds?: Record<QualityMetricType, number>;
+}
+interface GroundTruthData {
+    pairs: Array<{
+        query: string;
+        relevantDocs: string[];
+        irrelevantDocs?: string[];
+    }>;
+    labels?: Array<{
+        text: string;
+        label: string;
+    }>;
+}
+interface CoherenceDetails {
+    intraClusterCoherence: number;
+    topicCoherence: number;
+    semanticConsistency: number;
+}
+interface DiversityDetails {
+    uniqueCoverage: number;
+    pairwiseDiversity: number;
+    clusterSpread: number;
+}
+interface RetrievalAccuracyDetails {
+    precisionAtK: Record<number, number>;
+    recallAtK: Record<number, number>;
+    mrr: number;
+    ndcg: number;
+}
+interface ClusterQualityDetails {
+    silhouetteScore: number;
+    calinskiHarabaszIndex: number;
+    daviesBouldinIndex: number;
+    numClusters: number;
+}
+interface QualityAlert {
+    id: string;
+    type: 'quality_degradation' | 'drift_detected' | 'threshold_breach';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    message: string;
+    metric?: QualityMetricType;
+    currentValue?: number;
+    thresholdValue?: number;
+    createdAt: number;
+    acknowledged: boolean;
+    acknowledgedAt?: number;
+    metadata?: Record<string, unknown>;
+}
+interface QualityMonitoringOptions {
+    enabled?: boolean;
+    checkInterval?: number;
+    metrics?: QualityMetricType[];
+    thresholds?: Record<QualityMetricType, number>;
+    onAlert?: (alert: QualityAlert) => void;
+    onReport?: (report: QualityReport) => void;
+}
+interface BenchmarkResult {
+    name: string;
+    model: string;
+    dataset: string;
+    metrics: Record<string, number>;
+    latency: {
+        p50: number;
+        p95: number;
+        p99: number;
+        mean: number;
+    };
+    throughput: number;
+    totalItems: number;
+    durationMs: number;
+    timestamp: number;
+}
+
+type PipelineType = 'batch' | 'stream' | 'document' | 'custom';
+type PipelineStatus = 'idle' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+interface PipelineConfig {
+    name: string;
+    type: PipelineType;
+    batchSize?: number;
+    concurrency?: number;
+    retry?: RetryConfig;
+    chunking?: ChunkingPipelineConfig;
+    caching?: boolean;
+    qualityChecks?: boolean;
+    progressInterval?: number;
+    metadata?: Record<string, unknown>;
+}
+interface ChunkingPipelineConfig {
+    strategy: ChunkingStrategyType;
+    options: ChunkingOptions;
+    preProcess?: (text: string) => string;
+    postProcess?: (chunks: Chunk[]) => Chunk[];
+}
+interface RetryConfig {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    jitter?: boolean;
+    retryOnCodes?: number[];
+    retryCondition?: (error: Error) => boolean;
+}
+interface PipelineInput {
+    id?: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+interface PipelineOutput {
+    id: string;
+    inputId: string;
+    result: EmbeddingResult;
+    chunks?: Chunk[];
+    processingTimeMs: number;
+    metadata?: Record<string, unknown>;
+}
+interface BatchPipelineOptions extends EmbeddingOptions {
+    batchSize?: number;
+    concurrency?: number;
+    continueOnError?: boolean;
+    onProgress?: (progress: PipelineProgress) => void;
+    onItem?: (output: PipelineOutput) => void;
+    onError?: (error: PipelineError) => void;
+}
+interface StreamPipelineOptions extends EmbeddingOptions {
+    bufferSize?: number;
+    flushInterval?: number;
+    highWaterMark?: number;
+    backpressureStrategy?: 'pause' | 'drop' | 'buffer';
+    maxBufferSize?: number;
+}
+interface DocumentPipelineOptions extends BatchPipelineOptions {
+    documentId?: string;
+    source?: string;
+    type?: string;
+    chunkingStrategy?: ChunkingStrategyType;
+    chunkingOptions?: ChunkingOptions;
+    store?: boolean;
+    storeNamespace?: string;
+}
+interface PipelineProgress {
+    pipelineId: string;
+    status: PipelineStatus;
+    totalItems: number;
+    processedItems: number;
+    failedItems: number;
+    progressPercent: number;
+    itemsPerSecond: number;
+    elapsedMs: number;
+    estimatedRemainingMs: number;
+    currentBatch?: number;
+    totalBatches?: number;
+}
+interface PipelineError {
+    id: string;
+    inputId?: string;
+    message: string;
+    code?: string;
+    retryCount: number;
+    willRetry: boolean;
+    timestamp: number;
+    stack?: string;
+}
+interface PipelineResult {
+    pipelineId: string;
+    status: PipelineStatus;
+    outputs: PipelineOutput[];
+    totalProcessed: number;
+    totalFailed: number;
+    totalTokens: number;
+    durationMs: number;
+    errors: PipelineError[];
+    metrics: PipelineMetrics;
+}
+interface PipelineMetrics {
+    totalItems: number;
+    successfulItems: number;
+    failedItems: number;
+    retriedItems: number;
+    totalTokens: number;
+    cacheHits: number;
+    cacheMisses: number;
+    avgLatencyMs: number;
+    p50LatencyMs: number;
+    p95LatencyMs: number;
+    p99LatencyMs: number;
+    throughput: number;
+    estimatedCostUSD: number;
+}
+interface PipelineEvent {
+    type: PipelineEventType;
+    pipelineId: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+type PipelineEventType = 'started' | 'progress' | 'batch_completed' | 'item_completed' | 'item_failed' | 'paused' | 'resumed' | 'completed' | 'failed' | 'cancelled';
+interface PipelineCheckpoint {
+    id: string;
+    pipelineId: string;
+    processedIds: string[];
+    failedIds: string[];
+    lastProcessedIndex: number;
+    progress: PipelineProgress;
+    createdAt: number;
+    data?: Record<string, unknown>;
+}
+interface StreamItem<T = unknown> {
+    id: string;
+    data: T;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+interface StreamResult {
+    streamId: string;
+    itemsProcessed: number;
+    itemsFailed: number;
+    durationMs: number;
+    throughput: number;
+}
+interface PipelineBuilderOptions {
+    defaultBatchSize?: number;
+    defaultConcurrency?: number;
+    defaultRetry?: RetryConfig;
+    checkpointing?: boolean;
+    checkpointInterval?: number;
+}
+
+interface EmbeddingManagerConfig {
+    defaultModel?: string;
+    defaultProvider?: string;
+    caching?: boolean;
+    batchSize?: number;
+    concurrency?: number;
+    retry?: {
+        maxRetries?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+    };
+}
+interface EmbeddingManagerEvents {
+    'embed:start': [text: string, options?: EmbeddingOptions];
+    'embed:complete': [result: EmbeddingResult];
+    'embed:error': [error: Error, text: string];
+    'batch:start': [texts: string[], options?: BatchEmbeddingOptions];
+    'batch:progress': [progress: {
+        completed: number;
+        total: number;
+    }];
+    'batch:complete': [result: BatchEmbeddingResult];
+    'batch:error': [error: Error];
+    'cache:hit': [key: string];
+    'cache:miss': [key: string];
+}
+interface EmbeddingCache {
+    get(key: string): Promise<EmbeddingResult | undefined>;
+    set(key: string, result: EmbeddingResult, ttl?: number): Promise<void>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+interface EmbeddingChunker {
+    chunk(text: string, options?: Record<string, unknown>): Promise<Array<{
+        text: string;
+        metadata: Record<string, unknown>;
+    }>>;
+}
+interface EmbeddingStore {
+    upsert(chunks: EmbeddedChunk[], namespace?: string): Promise<{
+        upsertedCount: number;
+    }>;
+    query(vector: EmbeddingVector, options?: SearchOptions): Promise<SearchResult[]>;
+    delete(ids: string[], namespace?: string): Promise<{
+        deletedCount: number;
+    }>;
+}
+declare class EmbeddingManager extends EventEmitter<EmbeddingManagerEvents> {
+    private config;
+    private modelRegistry;
+    private cache;
+    private chunker;
+    private store;
+    private stats;
+    constructor(config?: EmbeddingManagerConfig);
+    private createInitialStats;
+    registerModel(model: EmbeddingModel, isDefault?: boolean): this;
+    setCache(cache: EmbeddingCache): this;
+    setChunker(chunker: EmbeddingChunker): this;
+    setStore(store: EmbeddingStore): this;
+    private getModel;
+    embed(text: string, options?: EmbeddingOptions): Promise<EmbeddingResult>;
+    embedBatch(texts: string[], options?: BatchEmbeddingOptions): Promise<BatchEmbeddingResult>;
+    embedDocument(text: string, options?: DocumentEmbeddingOptions): Promise<EmbeddedChunk[]>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    similarity(text1: string, text2: string): Promise<number>;
+    getStats(): EmbeddingStats;
+    resetStats(): void;
+    getModels(): Array<{
+        provider: string;
+        name: string;
+        dimensions: number;
+    }>;
+    private updateStats;
+    private estimateCost;
+}
+declare function createEmbeddingManager(config?: EmbeddingManagerConfig): EmbeddingManager;
+
+declare function contentHash(text: string, algorithm?: 'md5' | 'sha1' | 'sha256'): string;
+declare function cacheKey(text: string, model: string, prefix?: string): string;
+declare function estimateTokens(text: string): number;
+declare function splitByChars(text: string, maxChars: number, overlap?: number): string[];
+declare function splitBySeparator(text: string, separator: string | RegExp): string[];
+declare function batch<T>(items: T[], batchSize: number): T[][];
+declare function withConcurrency<T, R>(items: T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<R[]>;
+declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+    retryCondition?: (error: Error) => boolean;
+}): Promise<T>;
+declare function sleep(ms: number): Promise<void>;
+declare function deferred<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+};
+declare function percentile(values: number[], p: number): number;
+declare function mean(values: number[]): number;
+declare function variance(values: number[]): number;
+declare function stdDev(values: number[]): number;
+declare function normalize(value: number, min: number, max: number): number;
+declare function clamp(value: number, min: number, max: number): number;
+declare function generateId(prefix?: string): string;
+declare function deepClone<T>(obj: T): T;
+declare function measureTime<T>(fn: () => Promise<T>): Promise<{
+    result: T;
+    durationMs: number;
+}>;
+declare function formatBytes(bytes: number): string;
+declare function formatDuration(ms: number): string;
+declare function createEventEmitter<T extends Record<string, unknown[]>>(): {
+    on<K extends keyof T>(event: K, listener: (...args: T[K]) => void): () => void;
+    off<K extends keyof T>(event: K, listener: (...args: T[K]) => void): void;
+    emit<K extends keyof T>(event: K, ...args: T[K]): void;
+    removeAllListeners<K extends keyof T>(event?: K): void;
+};
+
+interface VersionRegistryEvents {
+    'version:created': [version: EmbeddingVersion];
+    'version:activated': [version: EmbeddingVersion, previous?: EmbeddingVersion];
+    'version:deprecated': [version: EmbeddingVersion, reason: string];
+    'version:deleted': [versionId: string];
+    change: [event: VersionChangeEvent];
+}
+declare class VersionRegistry extends EventEmitter<VersionRegistryEvents> {
+    private versions;
+    private activeVersion;
+    private options;
+    constructor(options?: VersionRegistryOptions);
+    register(version: Omit<EmbeddingVersion, 'id' | 'createdAt'>): EmbeddingVersion;
+    get(id: string): EmbeddingVersion | undefined;
+    getActive(): EmbeddingVersion | undefined;
+    activate(id: string): void;
+    deprecate(id: string, reason: string, replacement?: string): void;
+    delete(id: string): boolean;
+    list(): EmbeddingVersion[];
+    findByProvider(provider: EmbeddingProviderType): EmbeddingVersion[];
+    findByModel(model: string): EmbeddingVersion[];
+    compare(sourceId: string, targetId: string): VersionComparisonResult;
+    getUpgradePath(fromId: string, toId: string): VersionUpgradePath;
+    trackUsage(id: string, documents?: number, chunks?: number): void;
+    getUsageStats(id: string): VersionRegistryEntry | undefined;
+    private pruneOldVersions;
+    private emitChange;
+    export(): {
+        versions: VersionRegistryEntry[];
+        activeVersion: string | null;
+    };
+    import(data: {
+        versions: VersionRegistryEntry[];
+        activeVersion: string | null;
+    }): void;
+}
+declare function createVersionRegistry(options?: VersionRegistryOptions): VersionRegistry;
+
+interface DriftDetectorEvents {
+    'drift:detected': [result: DriftDetectionResult];
+    'drift:alert': [alert: QualityAlert];
+    'baseline:updated': [distribution: ReferenceDistribution];
+}
+declare class DriftDetector extends EventEmitter<DriftDetectorEvents> {
+    private reference;
+    private config;
+    private monitorInterval?;
+    private sampleBuffer;
+    constructor(config?: DriftMonitorConfig);
+    setReference(embeddings: EmbeddingVector[], model: string, version?: string): ReferenceDistribution;
+    getReference(): ReferenceDistribution | null;
+    detect(currentEmbeddings: EmbeddingVector[]): DriftDetectionResult;
+    private compareDistributions;
+    private calculateDriftScore;
+    private determineSeverity;
+    private generateRecommendations;
+    private shouldAlert;
+    private emitAlert;
+    addSample(embedding: EmbeddingVector): void;
+    startMonitoring(): void;
+    stopMonitoring(): void;
+}
+declare function createDriftDetector(config?: DriftMonitorConfig): DriftDetector;
+
+export { BatchEmbeddingOptions, BatchEmbeddingResult, type BatchPipelineOptions, type BenchmarkResult, Chunk, ChunkingOptions, type ChunkingPipelineConfig, ChunkingStrategyType, type ClusterQualityDetails, type CoherenceDetails, type DimensionStats, type DistributionComparison, type DiversityDetails, DocumentEmbeddingOptions, type DocumentPipelineOptions, type DriftDetectionResult, DriftDetector, type DriftMonitorConfig, EmbeddedChunk, type EmbeddingCache, type EmbeddingChunker, EmbeddingManager, type EmbeddingManagerConfig, type EmbeddingManagerEvents, EmbeddingModel, EmbeddingOptions, EmbeddingProviderType, EmbeddingResult, EmbeddingStats, type EmbeddingStore, EmbeddingVector, type EmbeddingVersion, type GroundTruthData, type MigrationError, type MigrationOptions, type MigrationPlan, type MigrationPlanStatus, type MigrationProgress, type MigrationResult, type MigrationStep, type MigrationStepStatus, type MigrationStepType, type MigrationValidation, ModelInfo, type PipelineBuilderOptions, type PipelineCheckpoint, type PipelineConfig, type PipelineError, type PipelineEvent, type PipelineEventType, type PipelineInput, type PipelineMetrics, type PipelineOutput, type PipelineProgress, type PipelineResult, type PipelineStatus, type PipelineType, type QualityAlert, type QualityEvaluationOptions, type QualityMetricType, type QualityMonitoringOptions, type QualityReport, type QualityScore, type ReferenceDistribution, type RetrievalAccuracyDetails, type RetryConfig, type RollbackOptions, SearchOptions, SearchResult, type StreamItem, type StreamPipelineOptions, type StreamResult, type VersionChangeEvent, type VersionComparisonResult, VersionRegistry, type VersionRegistryEntry, type VersionRegistryOptions, type VersionUpgradePath, batch, cacheKey, clamp, contentHash, createDriftDetector, createEmbeddingManager, createEventEmitter, createVersionRegistry, deepClone, deferred, estimateTokens, formatBytes, formatDuration, generateId, mean, measureTime, normalize, percentile, retry, sleep, splitByChars, splitBySeparator, stdDev, variance, withConcurrency };