@msbayindir/context-rag 1.0.0-beta.1

package/dist/index.d.cts

@@ -0,0 +1,812 @@
+/**
+ * RAG Enhancement Types
+ *
+ * Hierarchical architecture for different RAG enhancement approaches.
+ * Supports Anthropic Contextual Retrieval, future Google Grounding, and custom handlers.
+ */
+interface ChunkData {
+    content: string;
+    searchContent: string;
+    displayContent: string;
+    chunkType: string;
+    page: number;
+    parentHeading?: string;
+}
+interface DocumentContext {
+    documentType?: string;
+    filename: string;
+    pageCount: number;
+    /** For LLM strategy: uploaded file URI (Gemini Files API) */
+    fileUri?: string;
+    /** For LLM strategy: full document text for context (Anthropic-style, max 15k chars) */
+    fullDocumentText?: string;
+}
+interface NoEnhancementConfig {
+    approach: 'none';
+}
+type AnthropicStrategy = 'none' | 'simple' | 'llm';
+interface AnthropicContextualConfig {
+    approach: 'anthropic_contextual';
+    strategy: AnthropicStrategy;
+    /** For 'simple': template pattern
+     * Available placeholders: {documentType}, {chunkType}, {page}, {parentHeading}
+     * Example: "[{documentType}] [{chunkType}] Page {page}"
+     */
+    template?: string;
+    /** For 'llm': context generation prompt */
+    contextPrompt?: string;
+    /** For 'llm': max tokens for generated context (default: 100) */
+    maxContextTokens?: number;
+    /** Chunk types to skip context generation for (default: ['HEADING', 'IMAGE_REF']) */
+    skipChunkTypes?: string[];
+    /** Max concurrent LLM calls (default: 5) */
+    concurrencyLimit?: number;
+    /** Enable caching to avoid duplicate API calls (default: true) */
+    enableCache?: boolean;
+}
+type GoogleGroundingStrategy = 'search' | 'factcheck';
+interface GoogleGroundingConfig {
+    approach: 'google_grounding';
+    strategy: GoogleGroundingStrategy;
+}
+interface EnhancementContext {
+    chunk: ChunkData;
+    doc: DocumentContext;
+}
+type CustomEnhancementHandler = (ctx: EnhancementContext) => Promise<string>;
+interface CustomEnhancementConfig {
+    approach: 'custom';
+    handler: CustomEnhancementHandler;
+    /** Chunk types to skip (optional) */
+    skipChunkTypes?: string[];
+}
+type RagEnhancementConfig = NoEnhancementConfig | AnthropicContextualConfig | GoogleGroundingConfig | CustomEnhancementConfig;
+
+/**
+ * Generic Prisma client type - allows any Prisma client instance
+ * This avoids requiring the user to generate Prisma client before using the library
+ */
+type PrismaClientLike = any;
+/**
+ * Batch processing configuration
+ */
+interface BatchConfig {
+    /** Number of pages per batch (default: 15) */
+    pagesPerBatch: number;
+    /** Maximum concurrent batch processing (default: 3) */
+    maxConcurrency: number;
+    /** Maximum retry attempts for failed batches (default: 3) */
+    maxRetries: number;
+    /** Initial retry delay in milliseconds (default: 1000) */
+    retryDelayMs: number;
+    /** Backoff multiplier for exponential retry (default: 2) */
+    backoffMultiplier: number;
+}
+/**
+ * Chunk configuration
+ */
+interface ChunkConfig {
+    /** Maximum tokens per chunk (default: 500) */
+    maxTokens: number;
+    /** Overlap tokens between chunks (default: 50) */
+    overlapTokens: number;
+}
+/**
+ * Rate limiting configuration
+ */
+interface RateLimitConfig {
+    /** Requests per minute limit (default: 60) */
+    requestsPerMinute: number;
+    /** Enable adaptive rate limiting (default: true) */
+    adaptive: boolean;
+}
+/**
+ * Logging configuration
+ */
+interface LogConfig {
+    /** Log level */
+    level: 'debug' | 'info' | 'warn' | 'error';
+    /** Enable structured JSON logging (default: true) */
+    structured: boolean;
+    /** Custom logger function */
+    customLogger?: (level: string, message: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * Generation configuration for Gemini API
+ */
+interface GenerationConfig {
+    /** Temperature for generation (0-2, default: 0.3) */
+    temperature: number;
+    /** Maximum output tokens (default: 8192) */
+    maxOutputTokens: number;
+}
+/**
+ * Main Context-RAG configuration
+ */
+interface ContextRAGConfig {
+    /** Prisma client instance */
+    prisma: PrismaClientLike;
+    /** Gemini API key */
+    geminiApiKey: string;
+    /** Gemini model to use (default: 'gemini-1.5-pro') */
+    model?: 'gemini-1.5-pro' | 'gemini-1.5-flash' | 'gemini-2.0-flash-exp' | 'gemini-pro' | 'gemini-2.5-pro' | 'gemini-3-pro-preview' | 'gemini-3-flash-preview';
+    /** Embedding model (default: 'text-embedding-004') */
+    embeddingModel?: string;
+    /** Generation configuration (temperature, maxOutputTokens) */
+    generationConfig?: Partial<GenerationConfig>;
+    /** Batch processing configuration */
+    batchConfig?: Partial<BatchConfig>;
+    /** Chunk configuration */
+    chunkConfig?: Partial<ChunkConfig>;
+    /** Rate limiting configuration */
+    rateLimitConfig?: Partial<RateLimitConfig>;
+    /** Logging configuration */
+    logging?: Partial<LogConfig>;
+    /** RAG Enhancement configuration (Contextual Retrieval, etc.) */
+    ragEnhancement?: RagEnhancementConfig;
+}
+/**
+ * Internal resolved configuration with all defaults applied
+ */
+interface ResolvedConfig {
+    prisma: PrismaClientLike;
+    geminiApiKey: string;
+    model: string;
+    embeddingModel: string;
+    generationConfig: GenerationConfig;
+    batchConfig: BatchConfig;
+    chunkConfig: ChunkConfig;
+    rateLimitConfig: RateLimitConfig;
+    logging: LogConfig;
+    ragEnhancement?: RagEnhancementConfig;
+}
+type ContextRAGOptions = Omit<ContextRAGConfig, 'prisma'>;
+
+/**
+ * Chunk type enumeration
+ * Defines the type of content within a chunk
+ */
+declare const ChunkTypeEnum: {
+    readonly TEXT: "TEXT";
+    readonly TABLE: "TABLE";
+    readonly LIST: "LIST";
+    readonly CODE: "CODE";
+    readonly HEADING: "HEADING";
+    readonly IMAGE_REF: "IMAGE_REF";
+    readonly QUOTE: "QUOTE";
+    readonly QUESTION: "QUESTION";
+    readonly MIXED: "MIXED";
+};
+type ChunkTypeEnumType = (typeof ChunkTypeEnum)[keyof typeof ChunkTypeEnum];
+/**
+ * Batch processing status enumeration
+ */
+declare const BatchStatusEnum: {
+    readonly PENDING: "PENDING";
+    readonly PROCESSING: "PROCESSING";
+    readonly RETRYING: "RETRYING";
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+};
+type BatchStatusEnumType = (typeof BatchStatusEnum)[keyof typeof BatchStatusEnum];
+/**
+ * Document processing status enumeration
+ */
+declare const DocumentStatusEnum: {
+    readonly PENDING: "PENDING";
+    readonly DISCOVERING: "DISCOVERING";
+    readonly AWAITING_APPROVAL: "AWAITING_APPROVAL";
+    readonly PROCESSING: "PROCESSING";
+    readonly COMPLETED: "COMPLETED";
+    readonly FAILED: "FAILED";
+    readonly PARTIAL: "PARTIAL";
+};
+type DocumentStatusEnumType = (typeof DocumentStatusEnum)[keyof typeof DocumentStatusEnum];
+/**
+ * Confidence level enumeration
+ */
+declare const ConfidenceLevelEnum: {
+    readonly HIGH: "HIGH";
+    readonly MEDIUM: "MEDIUM";
+    readonly LOW: "LOW";
+};
+type ConfidenceLevelEnumType = (typeof ConfidenceLevelEnum)[keyof typeof ConfidenceLevelEnum];
+/**
+ * Search mode enumeration
+ */
+declare const SearchModeEnum: {
+    readonly SEMANTIC: "semantic";
+    readonly KEYWORD: "keyword";
+    readonly HYBRID: "hybrid";
+};
+type SearchModeEnumType = (typeof SearchModeEnum)[keyof typeof SearchModeEnum];
+
+/**
+ * Chunk type alias for external use
+ */
+type ChunkType = ChunkTypeEnumType;
+/**
+ * Confidence metadata for chunks
+ */
+interface ConfidenceMetadata {
+    /** Numeric confidence score (0.0 - 1.0) */
+    score: number;
+    /** Categorical confidence level */
+    category: ConfidenceLevelEnumType;
+    /** Individual factors contributing to confidence */
+    factors?: {
+        textClarity?: number;
+        structureRecognition?: number;
+        tableAccuracy?: number;
+    };
+}
+/**
+ * Token usage tracking
+ */
+interface TokenUsage {
+    input: number;
+    output: number;
+    total: number;
+}
+/**
+ * Chunk metadata stored in JSON column
+ */
+interface ChunkMetadata {
+    /** Source page number (single page) */
+    page?: number;
+    /** Source page range */
+    pageRange?: {
+        start: number;
+        end: number;
+    };
+    /** Chunk type */
+    type: ChunkType;
+    /** Confidence information */
+    confidence: ConfidenceMetadata;
+    /** Token usage for this chunk */
+    tokens?: TokenUsage;
+    /** Processing duration in milliseconds */
+    processingDurationMs?: number;
+    /** Section or heading this chunk belongs to */
+    section?: string;
+    /** Keywords extracted from content */
+    keywords?: string[];
+    /** Whether parsed with structured SECTION markers */
+    parsedWithStructuredMarkers?: boolean;
+    /** Custom metadata added by user */
+    custom?: Record<string, unknown>;
+}
+/**
+ * Chunking strategy configuration
+ */
+interface ChunkStrategy {
+    /** Maximum tokens per chunk */
+    maxTokens: number;
+    /** Overlap tokens between chunks */
+    overlapTokens: number;
+    /** How to split the document */
+    splitBy: 'page' | 'section' | 'paragraph' | 'semantic';
+    /** Preserve table integrity (don't split tables) */
+    preserveTables?: boolean;
+    /** Preserve list integrity */
+    preserveLists?: boolean;
+    /** Extract headings as separate chunks */
+    extractHeadings?: boolean;
+}
+/**
+ * Vector chunk data structure
+ */
+interface VectorChunk {
+    id: string;
+    promptConfigId: string;
+    documentId: string;
+    chunkIndex: number;
+    chunkType: ChunkType;
+    /** Content optimized for vector search */
+    searchContent: string;
+    /** Rich Markdown content for display */
+    displayContent: string;
+    sourcePageStart: number;
+    sourcePageEnd: number;
+    confidenceScore: number;
+    metadata: ChunkMetadata;
+    createdAt: Date;
+}
+
+/**
+ * Discovery options
+ */
+interface DiscoveryOptions {
+    /** PDF file as buffer or file path */
+    file: Buffer | string;
+    /** Hint about expected document type */
+    documentTypeHint?: string;
+    /** Generate sample output for preview */
+    generateSample?: boolean;
+    /** Number of sample pages to analyze (default: 5) */
+    samplePages?: number;
+}
+/**
+ * Detected document element
+ */
+interface DetectedElement {
+    type: 'table' | 'list' | 'code' | 'image' | 'chart' | 'form' | 'heading';
+    count: number;
+    /** Example locations (page numbers) */
+    examples?: number[];
+}
+/**
+ * Discovery result from AI analysis
+ */
+interface DiscoveryResult {
+    /** Unique ID for this discovery session */
+    id: string;
+    /** Detected document type */
+    documentType: string;
+    /** Human-readable document type name */
+    documentTypeName: string;
+    /** Detected structural elements */
+    detectedElements: DetectedElement[];
+    /** Document-specific extraction instructions (NEW) */
+    specialInstructions: string[];
+    /** Example formats for consistent extraction (NEW) */
+    exampleFormats?: Record<string, string>;
+    /** AI-generated system prompt for ingestion (DEPRECATED - use specialInstructions) */
+    suggestedPrompt?: string;
+    /** Suggested chunking strategy */
+    suggestedChunkStrategy: ChunkStrategy;
+    /** AI confidence in this analysis (0.0 - 1.0) */
+    confidence: number;
+    /** Sample output if requested */
+    sampleOutput?: string;
+    /** Analysis reasoning */
+    reasoning: string;
+    /** Total pages in document */
+    pageCount: number;
+    /** File hash for idempotency */
+    fileHash: string;
+    /** Timestamps */
+    createdAt: Date;
+    expiresAt: Date;
+}
+/**
+ * Strategy approval options
+ */
+interface ApproveStrategyOptions {
+    /** Override the suggested prompt */
+    systemPrompt?: string;
+    /** Override document type */
+    documentType?: string;
+    /** Override chunk strategy */
+    chunkStrategy?: Partial<ChunkStrategy>;
+    /** Custom name for this config */
+    name?: string;
+    /** Change log / reason for modifications */
+    changeLog?: string;
+}
+
+/**
+ * Batch status during ingestion
+ */
+interface BatchStatus {
+    /** Current batch index (1-based) */
+    current: number;
+    /** Total number of batches */
+    total: number;
+    /** Batch status */
+    status: BatchStatusEnumType;
+    /** Page range being processed */
+    pageRange: {
+        start: number;
+        end: number;
+    };
+    /** Retry count if retrying */
+    retryCount?: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Progress callback type
+ */
+type ProgressCallback = (status: BatchStatus) => void;
+/**
+ * Ingestion options
+ */
+interface IngestOptions {
+    /** PDF file as buffer or file path */
+    file: Buffer | string;
+    /** Document type (must match a PromptConfig) */
+    documentType?: string;
+    /** Specific prompt config ID to use */
+    promptConfigId?: string;
+    /** Custom prompt override (creates temporary config) */
+    customPrompt?: string;
+    /** Custom filename (if file is buffer) */
+    filename?: string;
+    /** Experiment identifier for A/B testing different models
+     * e.g., "exp_flash_v1", "exp_pro_v2"
+     * Allows same PDF to be processed multiple times with different configs
+     */
+    experimentId?: string;
+    /** Progress callback */
+    onProgress?: ProgressCallback;
+    /** Skip if document already exists (based on hash + experimentId) */
+    skipExisting?: boolean;
+}
+/**
+ * Individual batch result
+ */
+interface BatchResult {
+    batchIndex: number;
+    status: BatchStatusEnumType;
+    chunksCreated: number;
+    tokenUsage: TokenUsage;
+    processingMs: number;
+    retryCount: number;
+    error?: string;
+}
+/**
+ * Ingestion result
+ */
+interface IngestResult {
+    /** Document ID */
+    documentId: string;
+    /** Final status */
+    status: DocumentStatusEnumType;
+    /** Total chunks created */
+    chunkCount: number;
+    /** Total batches processed */
+    batchCount: number;
+    /** Failed batch count */
+    failedBatchCount: number;
+    /** Total token usage */
+    tokenUsage: TokenUsage;
+    /** Total processing time in milliseconds */
+    processingMs: number;
+    /** Per-batch results */
+    batches: BatchResult[];
+    /** Warning messages (e.g., partial failures) */
+    warnings?: string[];
+}
+/**
+ * Document status query result
+ */
+interface DocumentStatus {
+    id: string;
+    filename: string;
+    status: DocumentStatusEnumType;
+    documentType?: string;
+    pageCount: number;
+    progress: {
+        totalBatches: number;
+        completedBatches: number;
+        failedBatches: number;
+        percentage: number;
+    };
+    tokenUsage?: TokenUsage;
+    processingMs?: number;
+    error?: string;
+    createdAt: Date;
+    completedAt?: Date;
+}
+/**
+ * Retry options for failed batches
+ */
+interface RetryOptions {
+    /** Only retry batches that failed with specific errors */
+    errorFilter?: string[];
+    /** Override max retries for this retry attempt */
+    maxRetries?: number;
+}
+
+/**
+ * Search mode type alias
+ */
+type SearchMode = SearchModeEnumType;
+/**
+ * Search filters
+ */
+interface SearchFilters {
+    /** Filter by document types */
+    documentTypes?: string[];
+    /** Filter by chunk types */
+    chunkTypes?: ChunkType[];
+    /** Minimum confidence score (0.0 - 1.0) */
+    minConfidence?: number;
+    /** Filter by specific document IDs */
+    documentIds?: string[];
+    /** Filter by page range */
+    pageRange?: {
+        start: number;
+        end: number;
+    };
+    /** Filter by prompt config IDs */
+    promptConfigIds?: string[];
+}
+/**
+ * Search options
+ */
+interface SearchOptions {
+    /** The search query */
+    query: string;
+    /** Search mode: semantic, keyword, or hybrid (default: hybrid) */
+    mode?: SearchMode;
+    /** Maximum number of results (default: 10) */
+    limit?: number;
+    /** Minimum similarity score threshold (0.0 - 1.0) */
+    minScore?: number;
+    /** Search filters */
+    filters?: SearchFilters;
+    /** Include explanation of why results matched */
+    includeExplanation?: boolean;
+    /** Boost results containing specific chunk types */
+    typeBoost?: Partial<Record<ChunkType, number>>;
+}
+/**
+ * Search result explanation
+ */
+interface SearchExplanation {
+    /** How the result matched */
+    matchType: 'semantic' | 'keyword' | 'both';
+    /** Terms that matched (for keyword search) */
+    matchedTerms?: string[];
+    /** Whether intent boosting was applied */
+    intentBoost?: boolean;
+    /** Boost reason if applied */
+    boostReason?: string;
+    /** Raw scores before normalization */
+    rawScores?: {
+        semantic?: number;
+        keyword?: number;
+    };
+}
+/**
+ * Individual search result
+ */
+interface SearchResult {
+    /** The matched chunk */
+    chunk: VectorChunk;
+    /** Relevance score (0.0 - 1.0) */
+    score: number;
+    /** Explanation of match (if requested) */
+    explanation?: SearchExplanation;
+}
+/**
+ * Search response metadata
+ */
+interface SearchMetadata {
+    /** Total results found (before limit) */
+    totalFound: number;
+    /** Processing time in milliseconds */
+    processingTimeMs: number;
+    /** Search mode used */
+    searchMode: SearchMode;
+    /** Query embedding token usage */
+    embeddingTokens?: number;
+}
+/**
+ * Full search response
+ */
+interface SearchResponse {
+    results: SearchResult[];
+    metadata: SearchMetadata;
+}
+
+/**
+ * Prompt configuration stored in database
+ */
+interface PromptConfig {
+    id: string;
+    /** Document type identifier (e.g., 'Medical', 'Legal') */
+    documentType: string;
+    /** Human-readable name */
+    name: string;
+    /** System prompt for AI processing */
+    systemPrompt: string;
+    /** Chunking strategy configuration */
+    chunkStrategy: ChunkStrategy;
+    /** Version number for this document type */
+    version: number;
+    /** Whether this config is active */
+    isActive: boolean;
+    /** Whether this is the default for the document type */
+    isDefault: boolean;
+    /** Who created this config: 'discovery' | 'manual' | user ID */
+    createdBy?: string;
+    /** Change log / reason for this version */
+    changeLog?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Input for creating a new prompt config
+ */
+interface CreatePromptConfig {
+    /** Document type identifier */
+    documentType: string;
+    /** Human-readable name */
+    name: string;
+    /** System prompt for AI processing */
+    systemPrompt: string;
+    /** Optional chunk strategy (defaults applied if not provided) */
+    chunkStrategy?: Partial<ChunkStrategy>;
+    /** Set as default for this document type */
+    setAsDefault?: boolean;
+    /** Change log / reason */
+    changeLog?: string;
+}
+/**
+ * Input for updating a prompt config
+ */
+interface UpdatePromptConfig {
+    /** New system prompt */
+    systemPrompt?: string;
+    /** New chunk strategy */
+    chunkStrategy?: Partial<ChunkStrategy>;
+    /** New name */
+    name?: string;
+    /** Change log / reason for update */
+    changeLog?: string;
+}
+/**
+ * Prompt config query filters
+ */
+interface PromptConfigFilters {
+    /** Filter by document type */
+    documentType?: string;
+    /** Only active configs */
+    activeOnly?: boolean;
+    /** Only default configs */
+    defaultOnly?: boolean;
+    /** Created by filter */
+    createdBy?: string;
+}
+
+/**
+ * Main Context-RAG engine class
+ *
+ * @example
+ * ```typescript
+ * import { ContextRAG } from 'context-rag';
+ * import { PrismaClient } from '@prisma/client';
+ *
+ * const prisma = new PrismaClient();
+ * const rag = new ContextRAG({
+ *   prisma,
+ *   geminiApiKey: process.env.GEMINI_API_KEY!,
+ * });
+ *
+ * // Ingest a document
+ * const result = await rag.ingest({ file: pdfBuffer });
+ *
+ * // Search
+ * const results = await rag.search({ query: 'your query' });
+ * ```
+ */
+declare class ContextRAG {
+    private readonly config;
+    private readonly logger;
+    private readonly rateLimiter;
+    private readonly ingestionEngine;
+    private readonly retrievalEngine;
+    private readonly discoveryEngine;
+    private readonly promptConfigRepo;
+    private readonly documentRepo;
+    private readonly chunkRepo;
+    constructor(userConfig: ContextRAGConfig);
+    /**
+     * Resolve user config with defaults
+     */
+    private resolveConfig;
+    /**
+     * Get the resolved configuration
+     */
+    getConfig(): ResolvedConfig;
+    /**
+     * Analyze a document and get AI-suggested processing strategy
+     */
+    discover(options: DiscoveryOptions): Promise<DiscoveryResult>;
+    /**
+     * Approve a discovery strategy and create a prompt config
+     */
+    approveStrategy(strategyId: string, overrides?: ApproveStrategyOptions): Promise<PromptConfig>;
+    /**
+     * Create a custom prompt configuration
+     */
+    createPromptConfig(config: CreatePromptConfig): Promise<PromptConfig>;
+    /**
+     * Get prompt configurations
+     */
+    getPromptConfigs(filters?: PromptConfigFilters): Promise<PromptConfig[]>;
+    /**
+     * Update a prompt configuration (creates new version)
+     */
+    updatePromptConfig(id: string, updates: UpdatePromptConfig): Promise<PromptConfig>;
+    /**
+     * Activate a specific prompt config version
+     */
+    activatePromptConfig(id: string): Promise<void>;
+    /**
+     * Ingest a document into the RAG system
+     */
+    ingest(options: IngestOptions): Promise<IngestResult>;
+    /**
+     * Get the status of a document processing job
+     */
+    getDocumentStatus(documentId: string): Promise<DocumentStatus>;
+    /**
+     * Retry failed batches for a document
+     */
+    retryFailedBatches(documentId: string, _options?: RetryOptions): Promise<IngestResult>;
+    /**
+     * Search for relevant content
+     */
+    search(options: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Search with full metadata response
+     */
+    searchWithMetadata(options: SearchOptions): Promise<SearchResponse>;
+    /**
+     * Delete a document and all its chunks
+     */
+    deleteDocument(documentId: string): Promise<void>;
+    /**
+     * Get system statistics
+     */
+    getStats(): Promise<{
+        totalDocuments: number;
+        totalChunks: number;
+        promptConfigs: number;
+        storageBytes: number;
+    }>;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<{
+        status: 'healthy' | 'degraded' | 'unhealthy';
+        database: boolean;
+        pgvector: boolean;
+    }>;
+}
+
+/**
+ * Base error class for Context-RAG
+ */
+declare class ContextRAGError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: string, details?: Record<string, unknown>);
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Configuration-related errors
+ */
+declare class ConfigurationError extends ContextRAGError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Ingestion-related errors
+ */
+declare class IngestionError extends ContextRAGError {
+    readonly batchIndex?: number;
+    readonly retryable: boolean;
+    constructor(message: string, options?: {
+        batchIndex?: number;
+        retryable?: boolean;
+        details?: Record<string, unknown>;
+    });
+}
+/**
+ * Search-related errors
+ */
+declare class SearchError extends ContextRAGError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Discovery-related errors
+ */
+declare class DiscoveryError extends ContextRAGError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+
+export { type BatchStatus, BatchStatusEnum, type ChunkMetadata, type ChunkStrategy, type ChunkType, ChunkTypeEnum, ConfigurationError, ContextRAG, type ContextRAGConfig, ContextRAGError, type ContextRAGOptions, type CreatePromptConfig, DiscoveryError, type DiscoveryOptions, type DiscoveryResult, type DocumentStatus, DocumentStatusEnum, type IngestOptions, type IngestResult, IngestionError, type PromptConfig, SearchError, type SearchFilters, type SearchMode, type SearchOptions, type SearchResult, type VectorChunk };