/**
 * Embedding Pipeline for LLM Browser (V-002)
 *
 * Connects EmbeddingProvider to VectorStore for indexing patterns and skills.
 * Handles ingestion, batch processing, and migration of existing data.
 */
import { EmbeddingProvider } from './embedding-provider.js';
import { VectorStore } from './vector-store.js';
import type { EmbeddedStore } from './embedded-store.js';
/**
 * Learned pattern structure (from EmbeddedStore)
 */
export interface LearnedPattern {
    id?: string;
    urlPattern: string;
    method?: string;
    description?: string;
    contentMapping?: Record<string, unknown>;
    confidence?: number;
    domain?: string;
    lastUsed?: number;
    successCount?: number;
    failureCount?: number;
    embeddingId?: string;
    embeddingVersion?: number;
}
/**
 * Skill structure (from EmbeddedStore)
 */
export interface Skill {
    id?: string;
    name: string;
    description?: string;
    domain?: string;
    steps?: SkillStep[];
    embeddingId?: string;
    embeddingVersion?: number;
}
interface SkillStep {
    action: string;
    description?: string;
}
/**
 * Configuration for the embedding pipeline
 */
export interface EmbeddingPipelineOptions {
    /** Path to the vector database */
    vectorDbPath: string;
    /** Batch size for processing (default: 50) */
    batchSize?: number;
    /** Whether to auto-index new patterns (default: true) */
    autoIndex?: boolean;
    /** Embedding model version (default: 1) */
    embeddingVersion?: number;
}
/**
 * Statistics from indexing operations
 */
export interface IndexStats {
    indexed: number;
    failed: number;
    skipped: number;
    totalTimeMs: number;
}
/**
 * Result of indexing a single entity
 */
export interface IndexResult {
    id: string;
    success: boolean;
    error?: string;
}
/**
 * EmbeddingPipeline - Manages the flow of data from patterns/skills to vector store
 */
export declare class EmbeddingPipeline {
    private embeddingProvider;
    private vectorStore;
    private initialized;
    private readonly vectorDbPath;
    private readonly batchSize;
    private readonly autoIndex;
    private readonly embeddingVersion;
    constructor(options: EmbeddingPipelineOptions);
    /**
     * Check if the pipeline can be initialized (dependencies available)
     */
    static isAvailable(): Promise<boolean>;
    /**
     * Initialize the pipeline
     */
    initialize(): Promise<void>;
    /**
     * Ensure the pipeline is initialized
     */
    private ensureInitialized;
    /**
     * Index a single pattern
     */
    indexPattern(pattern: LearnedPattern): Promise<IndexResult>;
    /**
     * Index a single skill
     */
    indexSkill(skill: Skill): Promise<IndexResult>;
    /**
     * Index multiple patterns in batch
     */
    indexPatterns(patterns: LearnedPattern[]): Promise<IndexStats>;
    /**
     * Index multiple skills in batch
     */
    indexSkills(skills: Skill[]): Promise<IndexStats>;
    /**
     * Generic batch processor for patterns and skills
     */
    private _processBatch;
    /**
     * Process a batch of patterns
     */
    private processBatch;
    /**
     * Process a batch of skills
     */
    private processSkillBatch;
    /**
     * Migrate existing patterns from EmbeddedStore to vector store
     */
    migrateFromStore(store: EmbeddedStore): Promise<IndexStats>;
    /**
     * Reindex patterns that have stale embeddings
     */
    reindexStale(store: EmbeddedStore, currentVersion?: number): Promise<IndexStats>;
    /**
     * Delete an embedding by ID
     */
    deleteEmbedding(id: string): Promise<boolean>;
    /**
     * Delete embeddings by domain
     */
    deleteByDomain(domain: string): Promise<number>;
    /**
     * Get vector store statistics
     */
    getStats(): Promise<{
        patterns: number;
        skills: number;
        total: number;
    }>;
    /**
     * Get the vector store instance for direct queries
     */
    getVectorStore(): VectorStore | null;
    /**
     * Get the embedding provider for direct embeddings
     */
    getEmbeddingProvider(): EmbeddingProvider | null;
    /**
     * Close the pipeline and release resources
     */
    close(): Promise<void>;
}
/**
 * Convert a pattern to embedding text
 */
export declare function patternToEmbeddingText(pattern: LearnedPattern): string;
/**
 * Convert a skill to embedding text
 */
export declare function skillToEmbeddingText(skill: Skill): string;
/**
 * Create an EmbeddingPipeline instance
 */
export declare function createEmbeddingPipeline(options: EmbeddingPipelineOptions): EmbeddingPipeline;
export {};
//# sourceMappingURL=embedding-pipeline.d.ts.map