@lov3kaizen/agentsea-ingest 0.5.1

package/dist/index.d.ts

@@ -0,0 +1,1558 @@
+type DocumentType = 'pdf' | 'docx' | 'html' | 'markdown' | 'txt' | 'csv' | 'xlsx' | 'pptx' | 'email' | 'epub' | 'json' | 'unknown';
+type ElementType = 'text' | 'title' | 'heading' | 'paragraph' | 'list' | 'list_item' | 'table' | 'image' | 'code' | 'quote' | 'link' | 'footnote' | 'header' | 'footer' | 'page_break' | 'unknown';
+interface DocumentMetadata {
+    filename?: string;
+    mimeType?: string;
+    title?: string;
+    author?: string;
+    createdAt?: Date;
+    modifiedAt?: Date;
+    pageCount?: number;
+    wordCount?: number;
+    characterCount?: number;
+    language?: string;
+    fileSize?: number;
+    sourceUrl?: string;
+    custom?: Record<string, unknown>;
+}
+interface ChunkMetadata {
+    index: number;
+    pageNumber?: number;
+    sectionPath?: string[];
+    startOffset?: number;
+    endOffset?: number;
+    elementType?: ElementType;
+    parentId?: string;
+    childIds?: string[];
+    custom?: Record<string, unknown>;
+}
+interface Chunk {
+    id: string;
+    documentId: string;
+    text: string;
+    tokenCount: number;
+    metadata: ChunkMetadata;
+    embedding?: number[];
+}
+interface Element {
+    type: ElementType;
+    text: string;
+    pageNumber?: number;
+    bbox?: BoundingBox;
+    metadata?: Record<string, unknown>;
+    children?: Element[];
+}
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface TableData {
+    id: string;
+    pageNumber?: number;
+    headers: string[];
+    rows: string[][];
+    raw?: unknown;
+    bbox?: BoundingBox;
+    caption?: string;
+}
+interface ImageData {
+    id: string;
+    pageNumber?: number;
+    width: number;
+    height: number;
+    format: string;
+    url?: string;
+    base64?: string;
+    ocrText?: string;
+    caption?: string;
+    altText?: string;
+    bbox?: BoundingBox;
+}
+interface EnrichmentData {
+    entities?: Entity[];
+    keywords?: string[];
+    summary?: string;
+    sentiment?: SentimentResult;
+    topics?: string[];
+    custom?: Record<string, unknown>;
+}
+interface Entity {
+    type: string;
+    value: string;
+    count: number;
+    positions?: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+interface SentimentResult {
+    label: 'positive' | 'negative' | 'neutral' | 'mixed';
+    score: number;
+    confidence?: number;
+}
+interface ProcessedDocument {
+    id: string;
+    type: DocumentType;
+    text: string;
+    metadata: DocumentMetadata;
+    elements: Element[];
+    chunks: Chunk[];
+    tables: TableData[];
+    images: ImageData[];
+    enrichment?: EnrichmentData;
+    processedAt: Date;
+    errors?: ProcessingError[];
+}
+interface ProcessingError {
+    stage: string;
+    message: string;
+    details?: unknown;
+}
+interface DocumentInput {
+    path?: string;
+    buffer?: Buffer;
+    url?: string;
+    filename?: string;
+    mimeType?: string;
+}
+
+interface ParserCapabilities {
+    text: boolean;
+    structure: boolean;
+    tables: boolean;
+    images: boolean;
+    metadata: boolean;
+    streaming: boolean;
+}
+interface ParserOptions {
+    extractImages?: boolean;
+    extractTables?: boolean;
+    extractMetadata?: boolean;
+    ocrEngine?: OCREngineInterface;
+    password?: string;
+    maxPages?: number;
+    pageRange?: {
+        start: number;
+        end: number;
+    };
+    custom?: Record<string, unknown>;
+}
+interface ParseResult {
+    type: DocumentType;
+    text: string;
+    elements: Element[];
+    tables: TableData[];
+    images: ImageData[];
+    metadata: DocumentMetadata;
+    warnings?: string[];
+}
+interface Parser {
+    readonly name: string;
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    canParse(mimeType: string, extension?: string): boolean;
+    parse(buffer: Buffer, options?: ParserOptions): Promise<ParseResult>;
+    parseStream?(stream: NodeJS.ReadableStream, options?: ParserOptions): AsyncIterableIterator<Element>;
+}
+interface OCREngineInterface {
+    recognize(image: Buffer): Promise<string>;
+}
+interface PDFParserOptions extends ParserOptions {
+    useNativeText?: boolean;
+    preserveFormatting?: boolean;
+    extractForms?: boolean;
+    extractAnnotations?: boolean;
+}
+interface DOCXParserOptions extends ParserOptions {
+    includeStyles?: boolean;
+    preserveNumbering?: boolean;
+    extractComments?: boolean;
+}
+interface HTMLParserOptions extends ParserOptions {
+    contentSelector?: string;
+    excludeSelectors?: string[];
+    extractLinks?: boolean;
+    baseUrl?: string;
+}
+interface MarkdownParserOptions extends ParserOptions {
+    gfm?: boolean;
+    extractFrontmatter?: boolean;
+    preserveCodeBlocks?: boolean;
+}
+interface CSVParserOptions extends ParserOptions {
+    delimiter?: string;
+    hasHeader?: boolean;
+    quote?: string;
+    encoding?: BufferEncoding;
+}
+interface ExcelParserOptions extends ParserOptions {
+    sheets?: string[] | number[];
+    includeFormulas?: boolean;
+    includeStyles?: boolean;
+}
+interface ParserRegistryConfig {
+    defaultOptions?: ParserOptions;
+    customParsers?: Parser[];
+    mimeTypeOverrides?: Record<string, Parser>;
+    registerBuiltIns?: boolean;
+}
+
+type ChunkingStrategy = 'fixed' | 'semantic' | 'recursive' | 'hierarchical' | 'sentence' | 'paragraph' | 'sliding_window' | 'custom';
+type TokenCounter = (text: string) => number;
+interface ChunkingOptions {
+    maxTokens?: number;
+    maxCharacters?: number;
+    overlap?: number;
+    overlapPercent?: number;
+    preserveElements?: boolean;
+    includeMetadata?: boolean;
+    tokenCounter?: TokenCounter;
+}
+interface FixedChunkingOptions extends ChunkingOptions {
+    splitOnWords?: boolean;
+    splitOnSentences?: boolean;
+}
+interface SemanticChunkingOptions extends ChunkingOptions {
+    similarityThreshold?: number;
+    embedFunction?: (text: string) => Promise<number[]>;
+    minChunkSize?: number;
+}
+interface RecursiveChunkingOptions extends ChunkingOptions {
+    separators?: string[];
+    keepSeparator?: boolean;
+    minChunkSize?: number;
+}
+interface HierarchicalChunkingOptions extends ChunkingOptions {
+    headingLevels?: number[];
+    includeParentContext?: boolean;
+    maxDepth?: number;
+}
+interface SentenceChunkingOptions extends ChunkingOptions {
+    minSentences?: number;
+    maxSentences?: number;
+    delimiters?: string[];
+}
+interface ParagraphChunkingOptions extends ChunkingOptions {
+    minParagraphs?: number;
+    maxParagraphs?: number;
+    separatorPattern?: RegExp;
+}
+interface SlidingWindowChunkingOptions extends ChunkingOptions {
+    windowSize: number;
+    stepSize: number;
+}
+interface Chunker {
+    readonly name: string;
+    readonly strategy: ChunkingStrategy;
+    chunk(text: string, options?: ChunkingOptions): Chunk[] | Promise<Chunk[]>;
+    chunkElements(elements: Element[], options?: ChunkingOptions): Chunk[] | Promise<Chunk[]>;
+    estimateChunks(text: string, options?: ChunkingOptions): number;
+}
+interface ChunkResult {
+    chunks: Chunk[];
+    totalChunks: number;
+    averageTokens: number;
+    overlapRatio: number;
+    processingTime: number;
+}
+interface OverlapConfig {
+    size: number;
+    unit: 'tokens' | 'characters';
+    includeContext?: boolean;
+}
+interface BoundaryDetector {
+    detectBoundaries(text: string): number[];
+    getBoundaryType(text: string, position: number): BoundaryType;
+}
+type BoundaryType = 'sentence' | 'paragraph' | 'section' | 'page' | 'element' | 'word' | 'none';
+interface ChunkIndex {
+    add(chunk: Chunk): void;
+    search(query: string, limit?: number): Chunk[];
+    findByMetadata(filter: Partial<ChunkMetadata>): Chunk[];
+    get(id: string): Chunk | undefined;
+    getAll(): Chunk[];
+}
+interface ChunkerRegistryConfig {
+    defaultOptions?: ChunkingOptions;
+    customChunkers?: Chunker[];
+    strategyOverrides?: Record<ChunkingStrategy, Chunker>;
+    registerBuiltIns?: boolean;
+}
+
+interface TableExtractionOptions {
+    detectMergedCells?: boolean;
+    preserveFormatting?: boolean;
+    detectHeaders?: boolean;
+    minRows?: number;
+    minColumns?: number;
+    outputFormat?: TableOutputFormat;
+}
+type TableOutputFormat = 'array' | 'csv' | 'json' | 'markdown' | 'html';
+interface ExtractedTable extends TableData {
+    confidence: number;
+    tableType?: 'data' | 'layout' | 'form';
+    structure?: TableStructure;
+}
+interface TableStructure {
+    headerRows: number;
+    headerColumns: number;
+    mergedCells?: MergedCellRegion[];
+    columnTypes?: ColumnType[];
+}
+interface MergedCellRegion {
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+}
+interface ColumnType {
+    index: number;
+    type: 'text' | 'number' | 'date' | 'currency' | 'percentage' | 'mixed';
+    format?: string;
+}
+interface ImageExtractionOptions {
+    minWidth?: number;
+    minHeight?: number;
+    outputFormat?: ImageOutputFormat;
+    quality?: number;
+    embeddedOnly?: boolean;
+    includeData?: boolean;
+    runOcr?: boolean;
+    generateCaptions?: boolean;
+}
+type ImageOutputFormat = 'png' | 'jpeg' | 'webp' | 'original';
+interface ExtractedImage extends ImageData {
+    confidence: number;
+    imageType?: ImageType;
+    colorAnalysis?: ColorAnalysis;
+    labels?: string[];
+}
+type ImageType = 'photo' | 'diagram' | 'chart' | 'screenshot' | 'logo' | 'icon' | 'illustration' | 'unknown';
+interface ColorAnalysis {
+    dominantColors: string[];
+    isGrayscale: boolean;
+    brightness: number;
+}
+interface MetadataExtractionOptions {
+    standard?: boolean;
+    custom?: boolean;
+    statistics?: boolean;
+    parseDates?: boolean;
+}
+interface ExtendedMetadata extends DocumentMetadata {
+    keywords?: string[];
+    subject?: string;
+    category?: string;
+    version?: string;
+    status?: string;
+    contributors?: string[];
+    publisher?: string;
+    copyright?: string;
+    customProperties?: Record<string, string | number | boolean | Date>;
+}
+interface DocumentStatistics {
+    pageCount: number;
+    wordCount: number;
+    characterCount: number;
+    characterCountNoSpaces: number;
+    paragraphCount: number;
+    sentenceCount: number;
+    lineCount: number;
+    tableCount: number;
+    imageCount: number;
+    readingTime: number;
+}
+interface LinkExtractionOptions {
+    internal?: boolean;
+    external?: boolean;
+    anchors?: boolean;
+    resolveRelative?: boolean;
+    baseUrl?: string;
+}
+interface ExtractedLink {
+    url: string;
+    text?: string;
+    title?: string;
+    type: 'internal' | 'external' | 'anchor' | 'mailto' | 'tel';
+    position?: LinkPosition;
+}
+interface LinkPosition {
+    pageNumber?: number;
+    elementIndex?: number;
+    startOffset?: number;
+    endOffset?: number;
+}
+interface FormField {
+    name: string;
+    type: 'text' | 'checkbox' | 'radio' | 'select' | 'textarea' | 'date' | 'number';
+    value?: string | boolean | number;
+    label?: string;
+    required?: boolean;
+    options?: string[];
+    bbox?: BoundingBox;
+}
+interface Annotation {
+    id: string;
+    type: 'highlight' | 'underline' | 'strikeout' | 'comment' | 'sticky_note';
+    text?: string;
+    content?: string;
+    author?: string;
+    createdAt?: Date;
+    pageNumber?: number;
+    bbox?: BoundingBox;
+}
+interface Extractor<T, O = unknown> {
+    readonly name: string;
+    extract(buffer: Buffer, options?: O): Promise<T[]>;
+    isSupported(mimeType: string): boolean;
+}
+interface TableExtractor extends Extractor<ExtractedTable, TableExtractionOptions> {
+    convertTo(table: ExtractedTable, format: TableOutputFormat): string;
+}
+interface ImageExtractor extends Extractor<ExtractedImage, ImageExtractionOptions> {
+    getImageBuffer(image: ExtractedImage): Promise<Buffer>;
+}
+interface MetadataExtractor extends Extractor<ExtendedMetadata, MetadataExtractionOptions> {
+    getStatistics(buffer: Buffer): Promise<DocumentStatistics>;
+}
+
+type OCREngineType = 'tesseract' | 'google_vision' | 'aws_textract' | 'azure_vision' | 'custom';
+interface OCRConfig {
+    engine: OCREngineType;
+    languages?: string[];
+    pageSegMode?: PageSegmentationMode;
+    engineConfig?: Record<string, unknown>;
+    preprocessing?: OCRPreprocessingOptions;
+    confidenceThreshold?: number;
+}
+type PageSegmentationMode = 'auto' | 'single_block' | 'single_column' | 'single_line' | 'single_word' | 'single_char' | 'sparse_text';
+interface OCRPreprocessingOptions {
+    deskew?: boolean;
+    denoise?: boolean;
+    binarize?: boolean;
+    binarizeThreshold?: number;
+    scale?: number;
+    enhanceContrast?: boolean;
+    removeBorders?: boolean;
+}
+interface OCRResult {
+    text: string;
+    confidence: number;
+    language?: string;
+    blocks?: OCRBlock[];
+    processingTime: number;
+    engine: OCREngineType;
+}
+interface OCRBlock {
+    type: OCRBlockType;
+    text: string;
+    confidence: number;
+    bbox: BoundingBox;
+    children?: OCRElement[];
+}
+type OCRBlockType = 'paragraph' | 'line' | 'word' | 'table' | 'figure' | 'unknown';
+interface OCRElement {
+    type: 'line' | 'word' | 'character';
+    text: string;
+    confidence: number;
+    bbox: BoundingBox;
+    font?: OCRFontInfo;
+}
+interface OCRFontInfo {
+    name?: string;
+    size?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    monospace?: boolean;
+}
+interface OCREngine {
+    readonly name: string;
+    readonly type: OCREngineType;
+    readonly supportedLanguages: string[];
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    recognize(image: Buffer, options?: OCROptions): Promise<OCRResult>;
+    recognizeUrl?(url: string, options?: OCROptions): Promise<OCRResult>;
+    recognizeBatch?(images: Buffer[], options?: OCROptions): Promise<OCRResult[]>;
+    detectTextRegions?(image: Buffer): Promise<BoundingBox[]>;
+    terminate(): Promise<void>;
+}
+interface OCROptions {
+    languages?: string[];
+    pageSegMode?: PageSegmentationMode;
+    includeDetails?: boolean;
+    preprocessing?: OCRPreprocessingOptions;
+    roi?: BoundingBox;
+}
+interface TesseractConfig {
+    dataPath?: string;
+    workerCount?: number;
+    cacheWorkers?: boolean;
+    oem?: 0 | 1 | 2 | 3;
+    psm?: number;
+    whitelist?: string;
+    blacklist?: string;
+}
+interface GoogleVisionConfig {
+    credentials?: string | Record<string, unknown>;
+    features?: GoogleVisionFeature[];
+    imageContext?: {
+        languageHints?: string[];
+        cropHintsParams?: {
+            aspectRatios: number[];
+        };
+    };
+}
+type GoogleVisionFeature = 'TEXT_DETECTION' | 'DOCUMENT_TEXT_DETECTION' | 'LABEL_DETECTION' | 'LOGO_DETECTION' | 'FACE_DETECTION';
+interface AWSTextractConfig {
+    region?: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    featureTypes?: ('TABLES' | 'FORMS' | 'QUERIES' | 'SIGNATURES' | 'LAYOUT')[];
+}
+interface AzureVisionConfig {
+    endpoint: string;
+    apiKey: string;
+    apiVersion?: string;
+    modelVersion?: 'latest' | '2022-04-30' | '2023-02-28-preview';
+}
+interface OCREngineFactoryConfig {
+    defaultEngine: OCREngineType;
+    engines?: {
+        tesseract?: TesseractConfig;
+        google_vision?: GoogleVisionConfig;
+        aws_textract?: AWSTextractConfig;
+        azure_vision?: AzureVisionConfig;
+    };
+}
+interface OCRQualityMetrics {
+    averageConfidence: number;
+    lowConfidenceWords: number;
+    noiseLevel: 'low' | 'medium' | 'high';
+    suggestions?: string[];
+}
+
+type CleaningOperation = 'normalize_whitespace' | 'remove_extra_whitespace' | 'normalize_unicode' | 'remove_control_chars' | 'fix_encoding' | 'remove_html_tags' | 'decode_html_entities' | 'remove_urls' | 'remove_emails' | 'remove_phone_numbers' | 'remove_special_chars' | 'lowercase' | 'uppercase' | 'trim' | 'remove_punctuation' | 'remove_numbers' | 'remove_stopwords' | 'stem' | 'lemmatize' | 'fix_hyphenation' | 'merge_lines' | 'remove_headers_footers' | 'remove_page_numbers' | 'deduplicate_lines' | 'custom';
+interface CleaningConfig {
+    operations: CleaningOperation[];
+    customOperations?: Record<string, CleaningHandler>;
+    preservePatterns?: RegExp[];
+    language?: string;
+    stopwords?: string[];
+}
+type CleaningHandler = (text: string, options?: CleaningOptions) => string;
+interface CleaningOptions {
+    preserveNewlines?: boolean;
+    preserveCase?: boolean;
+    minWordLength?: number;
+    maxNewlines?: number;
+    removePatterns?: RegExp[];
+    replacePatterns?: Array<{
+        pattern: RegExp;
+        replacement: string;
+    }>;
+    encoding?: BufferEncoding;
+    replacements?: Record<string, string>;
+}
+interface CleaningResult {
+    text: string;
+    originalLength: number;
+    cleanedLength: number;
+    operationsApplied: CleaningOperation[];
+    changes: CleaningChange[];
+    processingTime: number;
+}
+interface CleaningChange {
+    operation: CleaningOperation;
+    count: number;
+    samples?: string[];
+}
+interface TextNormalizer {
+    readonly name: string;
+    normalize(text: string, options?: NormalizationOptions): string;
+    needsNormalization(text: string): boolean;
+}
+interface NormalizationOptions {
+    unicodeForm?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
+    normalizeQuotes?: boolean;
+    normalizeDashes?: boolean;
+    normalizeEllipsis?: boolean;
+    removeAccents?: boolean;
+    toAscii?: boolean;
+}
+interface DeduplicationOptions {
+    threshold?: number;
+    scope?: 'exact' | 'fuzzy' | 'semantic';
+    hashAlgorithm?: 'md5' | 'sha256' | 'simhash' | 'minhash';
+    ngramSize?: number;
+    keep?: 'first' | 'last';
+    compareFields?: string[];
+}
+interface DeduplicationResult<T> {
+    unique: T[];
+    duplicates: DuplicateGroup<T>[];
+    duplicateCount: number;
+    processingTime: number;
+}
+interface DuplicateGroup<T> {
+    kept: T;
+    removed: T[];
+    similarities?: number[];
+}
+interface ContentFilter {
+    readonly name: string;
+    shouldFilter(content: string): boolean;
+    filter(content: string): string;
+    getFilterReason(content: string): string | null;
+}
+interface ContentFilterOptions {
+    filterProfanity?: boolean;
+    filterPII?: boolean;
+    customPatterns?: RegExp[];
+    replacement?: string;
+    mask?: boolean;
+    piiTypes?: PIIType[];
+}
+type PIIType = 'email' | 'phone' | 'ssn' | 'credit_card' | 'address' | 'name' | 'date_of_birth' | 'ip_address' | 'passport' | 'drivers_license';
+interface PIIDetectionResult {
+    instances: PIIInstance[];
+    totalFound: number;
+    riskLevel: 'none' | 'low' | 'medium' | 'high';
+}
+interface PIIInstance {
+    type: PIIType;
+    value: string;
+    position: {
+        start: number;
+        end: number;
+    };
+    confidence: number;
+}
+interface HeaderFooterOptions {
+    method: 'pattern' | 'position' | 'similarity';
+    patterns?: RegExp[];
+    positionThreshold?: number;
+    similarityThreshold?: number;
+    minOccurrences?: number;
+}
+interface DetectedHeaderFooter {
+    type: 'header' | 'footer';
+    content: string;
+    pages: number[];
+    confidence: number;
+}
+interface TextCleaner {
+    readonly name: string;
+    clean(text: string, config: CleaningConfig): CleaningResult;
+    applyOperation(text: string, operation: CleaningOperation, options?: CleaningOptions): string;
+    getAvailableOperations(): CleaningOperation[];
+}
+
+type EnrichmentType = 'entities' | 'keywords' | 'summary' | 'sentiment' | 'topics' | 'language' | 'classification' | 'embeddings' | 'relations' | 'custom';
+interface EnrichmentConfig {
+    enrichments: EnrichmentType[];
+    entities?: EntityExtractionConfig;
+    keywords?: KeywordExtractionConfig;
+    summary?: SummarizationConfig;
+    sentiment?: SentimentConfig;
+    topics?: TopicConfig;
+    classification?: ClassificationConfig;
+    embeddings?: EmbeddingConfig;
+    customHandlers?: Record<string, EnrichmentHandler>;
+}
+type EnrichmentHandler = (text: string, options?: unknown) => Promise<unknown>;
+interface EntityExtractionConfig {
+    types?: EntityType[];
+    useLLM?: boolean;
+    llmModel?: string;
+    mergeOverlapping?: boolean;
+    minConfidence?: number;
+    maxEntities?: number;
+    customPatterns?: Record<string, RegExp>;
+}
+type EntityType = 'PERSON' | 'ORGANIZATION' | 'LOCATION' | 'DATE' | 'TIME' | 'MONEY' | 'PERCENT' | 'EMAIL' | 'PHONE' | 'URL' | 'PRODUCT' | 'EVENT' | 'WORK_OF_ART' | 'LAW' | 'LANGUAGE' | 'QUANTITY' | 'ORDINAL' | 'CARDINAL' | 'CUSTOM';
+interface ExtendedEntity extends Entity {
+    entityType: EntityType;
+    confidence: number;
+    normalizedValue?: string;
+    wikiLink?: string;
+    description?: string;
+    relatedEntities?: string[];
+}
+interface KeywordExtractionConfig {
+    method?: KeywordExtractionMethod;
+    maxKeywords?: number;
+    minScore?: number;
+    includePhrases?: boolean;
+    maxPhraseLength?: number;
+    stopwords?: string[];
+    language?: string;
+}
+type KeywordExtractionMethod = 'tfidf' | 'textrank' | 'rake' | 'yake' | 'keybert' | 'llm' | 'frequency';
+interface ExtractedKeyword {
+    keyword: string;
+    score: number;
+    count: number;
+    isPhrase: boolean;
+    positions?: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+interface SummarizationConfig {
+    type?: SummaryType;
+    maxLength?: number;
+    lengthUnit?: 'words' | 'sentences' | 'characters';
+    model?: string;
+    focusAspects?: string[];
+    bulletPoints?: boolean;
+    targetAudience?: string;
+}
+type SummaryType = 'extractive' | 'abstractive' | 'hybrid' | 'key_points';
+interface SummaryResult {
+    text: string;
+    type: SummaryType;
+    compressionRatio: number;
+    keySentences?: string[];
+    topics?: string[];
+}
+interface SentimentConfig {
+    granularity?: 'document' | 'paragraph' | 'sentence';
+    aspects?: string[];
+    includeEmotions?: boolean;
+    model?: string;
+}
+interface ExtendedSentimentResult extends SentimentResult {
+    aspects?: Record<string, SentimentResult>;
+    emotions?: EmotionResult[];
+    segments?: SentimentSegment[];
+}
+interface EmotionResult {
+    emotion: EmotionType;
+    score: number;
+}
+type EmotionType = 'joy' | 'sadness' | 'anger' | 'fear' | 'surprise' | 'disgust' | 'trust' | 'anticipation' | 'neutral';
+interface SentimentSegment {
+    text: string;
+    sentiment: SentimentResult;
+    start: number;
+    end: number;
+}
+interface TopicConfig {
+    method?: TopicMethod;
+    numTopics?: number;
+    wordsPerTopic?: number;
+    predefinedTopics?: string[];
+    model?: string;
+}
+type TopicMethod = 'lda' | 'nmf' | 'bertopic' | 'llm' | 'zero_shot';
+interface TopicResult {
+    label: string;
+    score: number;
+    topWords?: string[];
+    isPredefined?: boolean;
+}
+interface ClassificationConfig {
+    labels: string[];
+    multiLabel?: boolean;
+    minConfidence?: number;
+    model?: string;
+    customPrompt?: string;
+}
+interface ClassificationResult {
+    labels: Array<{
+        label: string;
+        score: number;
+    }>;
+    primaryLabel: string;
+    confidence: number;
+}
+interface EmbeddingConfig {
+    model: string;
+    dimensions?: number;
+    normalize?: boolean;
+    batchSize?: number;
+}
+interface EmbeddingResult {
+    embedding: number[];
+    model: string;
+    tokenCount: number;
+}
+interface RelationConfig {
+    relationTypes?: string[];
+    useLLM?: boolean;
+    model?: string;
+}
+interface ExtractedRelation {
+    subject: ExtendedEntity;
+    relation: string;
+    object: ExtendedEntity;
+    confidence: number;
+    sourceText?: string;
+}
+interface Enricher {
+    readonly name: string;
+    readonly supportedTypes: EnrichmentType[];
+    enrich(text: string, config: EnrichmentConfig): Promise<EnrichmentData>;
+    supports(type: EnrichmentType): boolean;
+}
+interface EnrichmentResult extends EnrichmentData {
+    extendedEntities?: ExtendedEntity[];
+    extendedKeywords?: ExtractedKeyword[];
+    summaryResult?: SummaryResult;
+    extendedSentiment?: ExtendedSentimentResult;
+    topicResults?: TopicResult[];
+    classificationResults?: ClassificationResult;
+    embeddingResult?: EmbeddingResult;
+    relations?: ExtractedRelation[];
+    processingTime: number;
+}
+
+type StorageAdapterType = 'memory' | 'file' | 'sqlite' | 'postgres' | 'mongodb' | 'redis' | 'pinecone' | 'weaviate' | 'qdrant' | 'chroma' | 'custom';
+interface StorageConfig {
+    adapter: StorageAdapterType;
+    connectionString?: string;
+    database?: string;
+    documentsCollection?: string;
+    chunksCollection?: string;
+    options?: Record<string, unknown>;
+}
+interface DocumentStorage {
+    readonly name: string;
+    readonly type: StorageAdapterType;
+    initialize(): Promise<void>;
+    store(document: ProcessedDocument): Promise<string>;
+    storeBatch(documents: ProcessedDocument[]): Promise<string[]>;
+    get(id: string): Promise<ProcessedDocument | null>;
+    getBatch(ids: string[]): Promise<(ProcessedDocument | null)[]>;
+    update(id: string, updates: Partial<ProcessedDocument>): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteBatch(ids: string[]): Promise<void>;
+    list(options?: ListOptions): Promise<ListResult<ProcessedDocument>>;
+    search(query: DocumentQuery): Promise<ProcessedDocument[]>;
+    count(query?: DocumentQuery): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    close(): Promise<void>;
+}
+interface ChunkStorage {
+    readonly name: string;
+    readonly type: StorageAdapterType;
+    initialize(): Promise<void>;
+    store(chunk: Chunk): Promise<string>;
+    storeBatch(chunks: Chunk[]): Promise<string[]>;
+    get(id: string): Promise<Chunk | null>;
+    getBatch(ids: string[]): Promise<(Chunk | null)[]>;
+    getByDocumentId(documentId: string): Promise<Chunk[]>;
+    update(id: string, updates: Partial<Chunk>): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteByDocumentId(documentId: string): Promise<void>;
+    list(options?: ListOptions): Promise<ListResult<Chunk>>;
+    count(documentId?: string): Promise<number>;
+    close(): Promise<void>;
+}
+interface VectorStorage {
+    readonly name: string;
+    readonly type: StorageAdapterType;
+    readonly dimensions: number;
+    initialize(): Promise<void>;
+    store(chunk: Chunk): Promise<string>;
+    storeBatch(chunks: Chunk[]): Promise<string[]>;
+    search(vector: number[], options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    searchByText?(text: string, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    updateEmbedding(id: string, embedding: number[]): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteByDocumentId(documentId: string): Promise<void>;
+    getStats(): Promise<VectorIndexStats>;
+    close(): Promise<void>;
+}
+interface ListOptions {
+    limit?: number;
+    offset?: number;
+    cursor?: string;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    filter?: Record<string, unknown>;
+}
+interface ListResult<T> {
+    items: T[];
+    total: number;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+interface DocumentQuery {
+    text?: string;
+    type?: string | string[];
+    metadata?: Record<string, unknown>;
+    dateRange?: {
+        field: 'createdAt' | 'modifiedAt' | 'processedAt';
+        start?: Date;
+        end?: Date;
+    };
+    limit?: number;
+    offset?: number;
+}
+interface VectorSearchOptions {
+    topK?: number;
+    minScore?: number;
+    filter?: Record<string, unknown>;
+    includeEmbeddings?: boolean;
+    includeMetadata?: boolean;
+    namespace?: string;
+}
+interface VectorSearchResult {
+    id: string;
+    score: number;
+    chunk: Chunk;
+    distance?: number;
+}
+interface VectorIndexStats {
+    totalVectors: number;
+    dimensions: number;
+    indexType?: string;
+    memoryUsage?: number;
+    namespaces?: string[];
+}
+interface MemoryStorageOptions {
+    maxItems?: number;
+    ttl?: number;
+}
+interface FileStorageOptions {
+    baseDir: string;
+    format?: 'json' | 'msgpack';
+    createDirs?: boolean;
+    compression?: 'gzip' | 'none';
+}
+interface SQLiteStorageOptions {
+    path: string;
+    walMode?: boolean;
+    busyTimeout?: number;
+}
+interface PostgresStorageOptions {
+    connectionString: string;
+    schema?: string;
+    poolSize?: number;
+    ssl?: boolean;
+    enablePgvector?: boolean;
+}
+interface MongoDBStorageOptions {
+    connectionString: string;
+    database: string;
+    writeConcern?: 'majority' | number;
+    readPreference?: 'primary' | 'secondary' | 'nearest';
+}
+interface RedisStorageOptions {
+    url: string;
+    prefix?: string;
+    ttl?: number;
+    cluster?: boolean;
+}
+interface PineconeStorageOptions {
+    apiKey: string;
+    environment: string;
+    indexName: string;
+    namespace?: string;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface WeaviateStorageOptions {
+    url: string;
+    apiKey?: string;
+    className: string;
+    schema?: Record<string, unknown>;
+}
+interface QdrantStorageOptions {
+    url: string;
+    apiKey?: string;
+    collectionName: string;
+    dimensions: number;
+    distance?: 'Cosine' | 'Euclid' | 'Dot';
+}
+interface ChromaStorageOptions {
+    path: string;
+    collectionName: string;
+    embeddingFunction?: (texts: string[]) => Promise<number[][]>;
+}
+interface StorageFactoryConfig {
+    defaultAdapter: StorageAdapterType;
+    adapters?: {
+        memory?: MemoryStorageOptions;
+        file?: FileStorageOptions;
+        sqlite?: SQLiteStorageOptions;
+        postgres?: PostgresStorageOptions;
+        mongodb?: MongoDBStorageOptions;
+        redis?: RedisStorageOptions;
+        pinecone?: PineconeStorageOptions;
+        weaviate?: WeaviateStorageOptions;
+        qdrant?: QdrantStorageOptions;
+        chroma?: ChromaStorageOptions;
+    };
+}
+
+type PipelineStage = 'load' | 'parse' | 'extract' | 'clean' | 'chunk' | 'enrich' | 'embed' | 'store' | 'custom';
+interface PipelineConfig {
+    name?: string;
+    stages?: PipelineStage[];
+    parser?: ParserOptions;
+    extraction?: ExtractionConfig;
+    cleaning?: CleaningConfig;
+    chunking?: ChunkingConfig;
+    enrichment?: EnrichmentConfig;
+    embedding?: EmbeddingPipelineConfig;
+    storage?: StorageConfig;
+    ocr?: OCRConfig;
+    errorHandling?: ErrorHandlingConfig;
+    callbacks?: PipelineCallbacks;
+    customStages?: Record<string, CustomStageHandler>;
+}
+interface ExtractionConfig {
+    tables?: TableExtractionOptions;
+    images?: ImageExtractionOptions;
+    metadata?: MetadataExtractionOptions;
+}
+interface ChunkingConfig extends ChunkingOptions {
+    strategy: ChunkingStrategy;
+}
+interface EmbeddingPipelineConfig {
+    model: string;
+    provider?: string;
+    batchSize?: number;
+    embedChunks?: boolean;
+    embedSummary?: boolean;
+}
+interface ErrorHandlingConfig {
+    continueOnError?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+    onError?: (error: PipelineError) => void;
+    skipFailing?: boolean;
+}
+interface PipelineCallbacks {
+    onStageStart?: (stage: PipelineStage, documentId: string) => void;
+    onStageComplete?: (stage: PipelineStage, documentId: string, result: unknown) => void;
+    onStageError?: (stage: PipelineStage, documentId: string, error: Error) => void;
+    onDocumentStart?: (documentId: string, input: DocumentInput) => void;
+    onDocumentComplete?: (document: ProcessedDocument) => void;
+    onProgress?: (progress: PipelineProgress) => void;
+}
+type CustomStageHandler = (document: ProcessedDocument, context: PipelineContext) => Promise<ProcessedDocument>;
+interface PipelineContext {
+    config: PipelineConfig;
+    currentStage: PipelineStage;
+    stageResults: Map<PipelineStage, unknown>;
+    sharedData: Map<string, unknown>;
+    abortSignal?: AbortSignal;
+    logger?: PipelineLogger;
+}
+interface PipelineLogger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+interface PipelineProgress {
+    documentIndex: number;
+    totalDocuments: number;
+    currentStage: PipelineStage;
+    stageProgress: number;
+    overallProgress: number;
+    elapsedTime: number;
+    estimatedRemaining?: number;
+}
+interface PipelineError {
+    stage: PipelineStage;
+    documentId?: string;
+    message: string;
+    cause?: Error;
+    recoverable: boolean;
+    retryCount?: number;
+}
+interface PipelineResult {
+    documents: ProcessedDocument[];
+    successCount: number;
+    failedCount: number;
+    skippedCount: number;
+    totalChunks: number;
+    errors: PipelineError[];
+    processingTime: number;
+    stageTimings: Map<PipelineStage, number>;
+}
+interface Pipeline$1 {
+    readonly name: string;
+    readonly config: PipelineConfig;
+    process(input: DocumentInput): Promise<ProcessedDocument>;
+    processBatch(inputs: DocumentInput[]): Promise<PipelineResult>;
+    processStream(inputs: AsyncIterable<DocumentInput>): AsyncIterable<ProcessedDocument>;
+    addStage(name: string, handler: CustomStageHandler, after?: PipelineStage): void;
+    removeStage(stage: string): void;
+    getStageHandler(stage: string): CustomStageHandler | undefined;
+    validate(): PipelineValidationResult;
+    abort(): void;
+}
+interface PipelineValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+interface IngesterConfig extends PipelineConfig {
+    concurrency?: number;
+    defaultType?: string;
+    fileSizeLimit?: number;
+    supportedMimeTypes?: string[];
+    watchMode?: WatchModeConfig;
+}
+interface WatchModeConfig {
+    enabled: boolean;
+    paths: string[];
+    include?: string[];
+    exclude?: string[];
+    debounceDelay?: number;
+    processExisting?: boolean;
+}
+interface Ingester$1 extends Pipeline$1 {
+    ingestFile(path: string): Promise<ProcessedDocument>;
+    ingestUrl(url: string): Promise<ProcessedDocument>;
+    ingestBuffer(buffer: Buffer, filename?: string): Promise<ProcessedDocument>;
+    ingestDirectory(path: string, options?: DirectoryIngestOptions): Promise<PipelineResult>;
+    startWatching(): void;
+    stopWatching(): void;
+    getStatus(): IngesterStatus;
+}
+interface DirectoryIngestOptions {
+    recursive?: boolean;
+    include?: string[];
+    exclude?: string[];
+    maxFiles?: number;
+    sortBy?: 'name' | 'date' | 'size';
+}
+interface IngesterStatus {
+    isProcessing: boolean;
+    isWatching: boolean;
+    documentsProcessed: number;
+    documentsPending: number;
+    currentDocument?: string;
+    errorsCount: number;
+    uptime: number;
+}
+interface BatchOptions {
+    batchSize?: number;
+    concurrency?: number;
+    onProgress?: (processed: number, total: number) => void;
+    continueOnError?: boolean;
+}
+interface StreamOptions {
+    highWaterMark?: number;
+    bufferSize?: number;
+    timeout?: number;
+}
+interface PipelineBuilder$1 {
+    withParser(options: ParserOptions): this;
+    withExtraction(options: ExtractionConfig): this;
+    withCleaning(config: CleaningConfig): this;
+    withChunking(config: ChunkingConfig): this;
+    withEnrichment(config: EnrichmentConfig): this;
+    withEmbedding(config: EmbeddingPipelineConfig): this;
+    withStorage(config: StorageConfig): this;
+    withOCR(config: OCRConfig): this;
+    addCustomStage(name: string, handler: CustomStageHandler, after?: PipelineStage): this;
+    withErrorHandling(config: ErrorHandlingConfig): this;
+    withCallbacks(callbacks: PipelineCallbacks): this;
+    build(): Pipeline$1;
+}
+type DocumentEvent = {
+    type: 'document:loaded';
+    documentId: string;
+    metadata: DocumentMetadata;
+} | {
+    type: 'document:parsed';
+    documentId: string;
+    elementCount: number;
+} | {
+    type: 'document:extracted';
+    documentId: string;
+    tables: number;
+    images: number;
+} | {
+    type: 'document:cleaned';
+    documentId: string;
+    originalLength: number;
+    cleanedLength: number;
+} | {
+    type: 'document:chunked';
+    documentId: string;
+    chunkCount: number;
+} | {
+    type: 'document:enriched';
+    documentId: string;
+    enrichments: string[];
+} | {
+    type: 'document:embedded';
+    documentId: string;
+    embeddingCount: number;
+} | {
+    type: 'document:stored';
+    documentId: string;
+    storageId: string;
+} | {
+    type: 'document:completed';
+    document: ProcessedDocument;
+} | {
+    type: 'document:error';
+    documentId: string;
+    error: PipelineError;
+};
+interface PipelineEventEmitter {
+    on(event: DocumentEvent['type'], handler: (event: DocumentEvent) => void): void;
+    off(event: DocumentEvent['type'], handler: (event: DocumentEvent) => void): void;
+    once(event: DocumentEvent['type'], handler: (event: DocumentEvent) => void): void;
+    emit(event: DocumentEvent): void;
+}
+
+type EventHandler<T> = (event: T) => void;
+declare class IngestEventEmitter implements PipelineEventEmitter {
+    private listeners;
+    on(eventType: DocumentEvent['type'], handler: EventHandler<DocumentEvent>): void;
+    off(eventType: DocumentEvent['type'], handler: EventHandler<DocumentEvent>): void;
+    once(eventType: DocumentEvent['type'], handler: EventHandler<DocumentEvent>): void;
+    emit(event: DocumentEvent): void;
+    removeAllListeners(eventType?: DocumentEvent['type']): void;
+    listenerCount(eventType: DocumentEvent['type']): number;
+}
+declare function createEventEmitter(): PipelineEventEmitter;
+
+declare class ParserRegistry {
+    private parsers;
+    private mimeTypeOverrides;
+    private defaultOptions;
+    constructor(config?: ParserRegistryConfig);
+    register(parser: Parser): void;
+    unregister(name: string): void;
+    get(name: string): Parser | undefined;
+    findParser(mimeType?: string, extension?: string): Parser | undefined;
+    parse(buffer: Buffer, mimeType?: string, extension?: string, options?: ParserOptions): Promise<ParseResult>;
+    isSupported(mimeType?: string, extension?: string): boolean;
+    getAll(): Parser[];
+    getSupportedMimeTypes(): string[];
+    getSupportedExtensions(): string[];
+    static detectMimeType(extension: string): string | undefined;
+    static detectExtension(mimeType: string): string | undefined;
+    static getExtension(filename: string): string;
+}
+declare function createParserRegistry(config?: ParserRegistryConfig): ParserRegistry;
+
+declare class ChunkerRegistry {
+    private chunkers;
+    private defaultOptions;
+    constructor(config?: ChunkerRegistryConfig);
+    register(chunker: Chunker): void;
+    unregister(strategy: ChunkingStrategy): void;
+    get(strategy: ChunkingStrategy): Chunker | undefined;
+    chunk(text: string, strategy: ChunkingStrategy, options?: ChunkingOptions): Chunk[] | Promise<Chunk[]>;
+    chunkElements(elements: Element[], strategy: ChunkingStrategy, options?: ChunkingOptions): Chunk[] | Promise<Chunk[]>;
+    isSupported(strategy: ChunkingStrategy): boolean;
+    getAll(): Chunker[];
+    getSupportedStrategies(): ChunkingStrategy[];
+    setDefaultOptions(options: ChunkingOptions): void;
+    getDefaultOptions(): ChunkingOptions;
+}
+declare function createChunkerRegistry(config?: ChunkerRegistryConfig): ChunkerRegistry;
+
+declare class Pipeline implements Pipeline$1 {
+    readonly name: string;
+    readonly config: PipelineConfig;
+    private parserRegistry;
+    private chunkerRegistry;
+    private eventEmitter;
+    private customStages;
+    private stageOrder;
+    private aborted;
+    constructor(config?: PipelineConfig);
+    process(input: DocumentInput): Promise<ProcessedDocument>;
+    processBatch(inputs: DocumentInput[]): Promise<PipelineResult>;
+    processStream(inputs: AsyncIterable<DocumentInput>): AsyncIterable<ProcessedDocument>;
+    addStage(name: string, handler: CustomStageHandler, after?: PipelineStage): void;
+    removeStage(stage: string): void;
+    getStageHandler(stage: string): CustomStageHandler | undefined;
+    validate(): PipelineValidationResult;
+    abort(): void;
+    getEventEmitter(): IngestEventEmitter;
+    getParserRegistry(): ParserRegistry;
+    getChunkerRegistry(): ChunkerRegistry;
+    private executeStage;
+    private executeLoad;
+    private executeParse;
+    private executeExtract;
+    private executeClean;
+    private applyCleaningOperation;
+    private executeChunk;
+    private simpleChunk;
+    private estimateTokens;
+    private executeEnrich;
+    private executeEmbed;
+    private executeStore;
+    private createPipelineError;
+}
+declare function createPipeline(config?: PipelineConfig): Pipeline;
+
+declare class PipelineBuilder implements PipelineBuilder$1 {
+    private config;
+    private customStages;
+    withName(name: string): this;
+    withStages(stages: PipelineStage[]): this;
+    withParser(options: ParserOptions): this;
+    withExtraction(options: ExtractionConfig): this;
+    withCleaning(config: CleaningConfig): this;
+    withChunking(config: ChunkingConfig): this;
+    withEnrichment(config: EnrichmentConfig): this;
+    withEmbedding(config: EmbeddingPipelineConfig): this;
+    withStorage(config: StorageConfig): this;
+    withOCR(config: OCRConfig): this;
+    addCustomStage(name: string, handler: CustomStageHandler, after?: PipelineStage): this;
+    withErrorHandling(config: ErrorHandlingConfig): this;
+    withCallbacks(callbacks: PipelineCallbacks): this;
+    build(): Pipeline$1;
+    clone(): PipelineBuilder;
+}
+declare function createPipelineBuilder(): PipelineBuilder;
+declare const pipelines: {
+    simple(): PipelineBuilder;
+    full(): PipelineBuilder;
+    rag(): PipelineBuilder;
+    analysis(): PipelineBuilder;
+    ocr(): PipelineBuilder;
+};
+
+declare class Ingester extends Pipeline implements Ingester$1 {
+    private ingesterConfig;
+    private status;
+    private watcher;
+    private processedCount;
+    private pendingQueue;
+    private startTime;
+    constructor(config?: IngesterConfig);
+    ingestFile(path: string): Promise<ProcessedDocument>;
+    ingestUrl(url: string): Promise<ProcessedDocument>;
+    ingestBuffer(buffer: Buffer, filename?: string): Promise<ProcessedDocument>;
+    ingestDirectory(dirPath: string, options?: DirectoryIngestOptions): Promise<PipelineResult>;
+    startWatching(): void;
+    stopWatching(): void;
+    getStatus(): IngesterStatus;
+    process(input: DocumentInput): Promise<ProcessedDocument>;
+    private listFiles;
+    private matchPattern;
+    private validateFileSize;
+    private validateBufferSize;
+    private isSupportedMimeType;
+    private setupWatcher;
+}
+declare function createIngester(config?: IngesterConfig): Ingester;
+
+declare abstract class BaseParser implements Parser {
+    abstract readonly name: string;
+    abstract readonly supportedMimeTypes: string[];
+    abstract readonly supportedExtensions: string[];
+    abstract readonly capabilities: ParserCapabilities;
+    canParse(mimeType: string, extension?: string): boolean;
+    abstract parse(buffer: Buffer, options?: ParserOptions): Promise<ParseResult>;
+    parseStream?(stream: NodeJS.ReadableStream, options?: ParserOptions): AsyncIterableIterator<Element>;
+    protected createEmptyResult(type: DocumentType): ParseResult;
+    protected createElement(type: Element['type'], text: string, pageNumber?: number, metadata?: Record<string, unknown>): Element;
+    protected createTable(headers: string[], rows: string[][], pageNumber?: number, caption?: string): TableData;
+    protected createImage(width: number, height: number, format: string, options?: Partial<ImageData>): ImageData;
+    protected estimateWordCount(text: string): number;
+    protected estimateCharacterCount(text: string): number;
+    protected extractTextFromElements(elements: Element[]): string;
+    protected mergeMetadata(extracted: Partial<DocumentMetadata>, text: string): DocumentMetadata;
+}
+
+declare class PDFParser extends BaseParser {
+    readonly name = "pdf-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: PDFParserOptions): Promise<ParseResult>;
+    private createElements;
+    private detectElementType;
+    private parsePDFDate;
+    private renderPage;
+}
+declare function createPDFParser(): PDFParser;
+
+declare class DOCXParser extends BaseParser {
+    readonly name = "docx-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: DOCXParserOptions): Promise<ParseResult>;
+    private parseHtmlStructure;
+}
+declare function createDOCXParser(): DOCXParser;
+
+declare class HTMLParser extends BaseParser {
+    readonly name = "html-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: HTMLParserOptions): Promise<ParseResult>;
+    private extractMetadata;
+    private extractElements;
+    private extractTables;
+    private extractImages;
+    private extractText;
+}
+declare function createHTMLParser(): HTMLParser;
+
+declare class MarkdownParser extends BaseParser {
+    readonly name = "markdown-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: MarkdownParserOptions): Promise<ParseResult>;
+    private extractFrontmatter;
+    private extractElements;
+    private extractTables;
+    private extractImages;
+    private getImageFormat;
+    private extractText;
+}
+declare function createMarkdownParser(): MarkdownParser;
+
+declare class TextParser extends BaseParser {
+    readonly name = "text-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: ParserOptions): Promise<ParseResult>;
+    parseStream(stream: NodeJS.ReadableStream, _options?: ParserOptions): AsyncIterableIterator<Element>;
+    private extractElements;
+    private detectElementType;
+}
+declare function createTextParser(): TextParser;
+
+declare class CSVParser extends BaseParser {
+    readonly name = "csv-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: CSVParserOptions): Promise<ParseResult>;
+    parseStream(stream: NodeJS.ReadableStream, options?: CSVParserOptions): AsyncIterableIterator<Element>;
+    private detectDelimiter;
+    private parseCSV;
+    private parseRow;
+    private createTextRepresentation;
+    private createElements;
+}
+declare function createCSVParser(): CSVParser;
+
+declare class ExcelParser extends BaseParser {
+    readonly name = "excel-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: ExcelParserOptions): Promise<ParseResult>;
+}
+declare function createExcelParser(): ExcelParser;
+
+declare class JSONParser extends BaseParser {
+    readonly name = "json-parser";
+    readonly supportedMimeTypes: string[];
+    readonly supportedExtensions: string[];
+    readonly capabilities: ParserCapabilities;
+    parse(buffer: Buffer, options?: ParserOptions): Promise<ParseResult>;
+    private isJSONLines;
+    private parseJSONLines;
+    private extractElements;
+    private createTextRepresentation;
+    private extractTables;
+    private extractTablesFromArray;
+}
+declare function createJSONParser(): JSONParser;
+
+declare function getBuiltInParsers(): Parser[];
+declare function registerBuiltInParsers(register: (parser: Parser) => void): void;
+
+declare abstract class BaseChunker implements Chunker {
+    abstract readonly name: string;
+    abstract readonly strategy: ChunkingStrategy;
+    protected tokenCounter: TokenCounter;
+    constructor(tokenCounter?: TokenCounter);
+    abstract chunk(text: string, options?: ChunkingOptions): Chunk[] | Promise<Chunk[]>;
+    chunkElements(elements: Element[], options?: ChunkingOptions): Chunk[] | Promise<Chunk[]>;
+    estimateChunks(text: string, options?: ChunkingOptions): number;
+    protected createChunk(text: string, documentId: string, index: number, metadata?: Partial<ChunkMetadata>): Chunk;
+    protected extractTextFromElements(elements: Element[]): string;
+    protected findElementTypeForChunk(chunk: Chunk, elements: Element[]): Element['type'] | undefined;
+    protected splitAtSentenceBoundaries(text: string): string[];
+    protected splitAtParagraphBoundaries(text: string): string[];
+    protected mergeToTargetSize(texts: string[], maxTokens: number, separator?: string): string[];
+    protected applyOverlap(chunks: string[], overlapTokens: number): string[];
+}
+
+declare class FixedChunker extends BaseChunker {
+    readonly name = "fixed-chunker";
+    readonly strategy: "fixed";
+    chunk(text: string, options?: FixedChunkingOptions): Chunk[];
+}
+declare function createFixedChunker(): FixedChunker;
+
+declare class RecursiveChunker extends BaseChunker {
+    readonly name = "recursive-chunker";
+    readonly strategy: "recursive";
+    chunk(text: string, options?: RecursiveChunkingOptions): Chunk[];
+    private recursiveSplit;
+    private splitBySeparator;
+    private splitByCharacters;
+    private mergeSplits;
+}
+declare function createRecursiveChunker(): RecursiveChunker;
+
+declare class SentenceChunker extends BaseChunker {
+    readonly name = "sentence-chunker";
+    readonly strategy: "sentence";
+    chunk(text: string, options?: SentenceChunkingOptions): Chunk[];
+    private splitIntoSentences;
+    private groupSentences;
+    private applyOverlapSentences;
+}
+declare function createSentenceChunker(): SentenceChunker;
+
+declare class ParagraphChunker extends BaseChunker {
+    readonly name = "paragraph-chunker";
+    readonly strategy: "paragraph";
+    chunk(text: string, options?: ParagraphChunkingOptions): Chunk[];
+    private groupParagraphs;
+    private applyOverlapParagraphs;
+}
+declare function createParagraphChunker(): ParagraphChunker;
+
+declare class SemanticChunker extends BaseChunker {
+    readonly name = "semantic-chunker";
+    readonly strategy: "semantic";
+    chunk(text: string, options?: SemanticChunkingOptions): Promise<Chunk[]>;
+    private splitIntoSentences;
+    private findSemanticBreakpoints;
+    private cosineSimilarity;
+}
+declare function createSemanticChunker(): SemanticChunker;
+
+declare class HierarchicalChunker extends BaseChunker {
+    readonly name = "hierarchical-chunker";
+    readonly strategy: "hierarchical";
+    chunk(text: string, options?: HierarchicalChunkingOptions): Chunk[];
+    chunkElements(elements: Element[], options?: HierarchicalChunkingOptions): Chunk[];
+    private parseHierarchy;
+    private buildHierarchyFromElements;
+    private flattenToChunks;
+    private splitLargeSection;
+}
+declare function createHierarchicalChunker(): HierarchicalChunker;
+
+declare function getBuiltInChunkers(): Chunker[];
+declare function createChunker(strategy: ChunkingStrategy): Chunker;
+declare function registerBuiltInChunkers(register: (chunker: Chunker) => void): void;
+
+export { type AWSTextractConfig, type Annotation, type AzureVisionConfig, BaseChunker, BaseParser, type BatchOptions, type BoundaryDetector, type BoundaryType, type BoundingBox, CSVParser, type CSVParserOptions, type ChromaStorageOptions, type Chunk, type ChunkIndex, type ChunkMetadata, type ChunkResult, type ChunkStorage, type Chunker, ChunkerRegistry, type ChunkerRegistryConfig, type ChunkingConfig, type ChunkingOptions, type ChunkingStrategy, type ClassificationConfig, type ClassificationResult, type CleaningChange, type CleaningConfig, type CleaningHandler, type CleaningOperation, type CleaningOptions, type CleaningResult, type ColorAnalysis, type ColumnType, type ContentFilter, type ContentFilterOptions, type CustomStageHandler, DOCXParser, type DOCXParserOptions, type DeduplicationOptions, type DeduplicationResult, type DetectedHeaderFooter, type DirectoryIngestOptions, type DocumentEvent, type DocumentInput, type DocumentMetadata, type DocumentQuery, type DocumentStatistics, type DocumentStorage, type DocumentType, type DuplicateGroup, type Element, type ElementType, type EmbeddingConfig, type EmbeddingPipelineConfig, type EmbeddingResult, type EmotionResult, type EmotionType, type Enricher, type EnrichmentConfig, type EnrichmentData, type EnrichmentHandler, type EnrichmentResult, type EnrichmentType, type Entity, type EntityExtractionConfig, type EntityType, type ErrorHandlingConfig, ExcelParser, type ExcelParserOptions, type ExtendedEntity, type ExtendedMetadata, type ExtendedSentimentResult, type ExtractedImage, type ExtractedKeyword, type ExtractedLink, type ExtractedRelation, type ExtractedTable, type ExtractionConfig, type Extractor, type FileStorageOptions, FixedChunker, type FixedChunkingOptions, type FormField, type GoogleVisionConfig, type GoogleVisionFeature, HTMLParser, type HTMLParserOptions, type HeaderFooterOptions, HierarchicalChunker, type HierarchicalChunkingOptions, type ImageData, type ImageExtractionOptions, type ImageExtractor, type ImageOutputFormat, type ImageType, IngestEventEmitter, Ingester, type IngesterConfig, type IngesterStatus, JSONParser, type KeywordExtractionConfig, type KeywordExtractionMethod, type LinkExtractionOptions, type LinkPosition, type ListOptions, type ListResult, MarkdownParser, type MarkdownParserOptions, type MemoryStorageOptions, type MergedCellRegion, type MetadataExtractionOptions, type MetadataExtractor, type MongoDBStorageOptions, type NormalizationOptions, type OCRBlock, type OCRBlockType, type OCRConfig, type OCRElement, type OCREngine, type OCREngineFactoryConfig, type OCREngineInterface, type OCREngineType, type OCRFontInfo, type OCROptions, type OCRPreprocessingOptions, type OCRQualityMetrics, type OCRResult, type OverlapConfig, PDFParser, type PDFParserOptions, type PIIDetectionResult, type PIIInstance, type PIIType, type PageSegmentationMode, ParagraphChunker, type ParagraphChunkingOptions, type ParseResult, type Parser, type ParserCapabilities, type ParserOptions, ParserRegistry, type ParserRegistryConfig, type PineconeStorageOptions, Pipeline, PipelineBuilder, type PipelineCallbacks, type PipelineConfig, type PipelineContext, type PipelineError, type PipelineEventEmitter, type PipelineLogger, type PipelineProgress, type PipelineResult, type PipelineStage, type PipelineValidationResult, type PostgresStorageOptions, type ProcessedDocument, type ProcessingError, type QdrantStorageOptions, RecursiveChunker, type RecursiveChunkingOptions, type RedisStorageOptions, type RelationConfig, type SQLiteStorageOptions, SemanticChunker, type SemanticChunkingOptions, SentenceChunker, type SentenceChunkingOptions, type SentimentConfig, type SentimentResult, type SentimentSegment, type SlidingWindowChunkingOptions, type StorageAdapterType, type StorageConfig, type StorageFactoryConfig, type StreamOptions, type SummarizationConfig, type SummaryResult, type SummaryType, type TableData, type TableExtractionOptions, type TableExtractor, type TableOutputFormat, type TableStructure, type TesseractConfig, type TextCleaner, type TextNormalizer, TextParser, type TokenCounter, type TopicConfig, type TopicMethod, type TopicResult, type VectorIndexStats, type VectorSearchOptions, type VectorSearchResult, type VectorStorage, type WatchModeConfig, type WeaviateStorageOptions, createCSVParser, createChunker, createChunkerRegistry, createDOCXParser, createEventEmitter, createExcelParser, createFixedChunker, createHTMLParser, createHierarchicalChunker, createIngester, createJSONParser, createMarkdownParser, createPDFParser, createParagraphChunker, createParserRegistry, createPipeline, createPipelineBuilder, createRecursiveChunker, createSemanticChunker, createSentenceChunker, createTextParser, getBuiltInChunkers, getBuiltInParsers, pipelines, registerBuiltInChunkers, registerBuiltInParsers };