@juspay/neurolink/dist/rag/ChunkerFactory.d.ts

The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002

/**
 * Chunker Factory
 *
 * Factory for creating chunker instances with configuration.
 * Follows the BaseFactory pattern for consistent lifecycle management.
 */
import { BaseFactory } from "../core/infrastructure/index.js";
import type { Chunker, ChunkerConfig, ChunkerMetadata, ChunkingStrategy } from "../types/index.js";
/**
 * Chunker Factory
 *
 * Creates chunker instances based on strategy with configuration support.
 * Uses lazy loading via dynamic imports to avoid circular dependencies.
 */
export declare class ChunkerFactory extends BaseFactory<Chunker, ChunkerConfig> {
    private static instance;
    private metadataMap;
    private constructor();
    /**
     * Get singleton instance
     */
    static getInstance(): ChunkerFactory;
    /**
     * Reset singleton (for testing)
     */
    static resetInstance(): void;
    /**
     * Register all default chunkers
     */
    protected registerAll(): Promise<void>;
    /**
     * Register a chunker with metadata and aliases
     */
    registerChunker(strategy: ChunkingStrategy | string, factory: (config?: ChunkerConfig) => Promise<Chunker>, metadata: ChunkerMetadata): void;
    /**
     * Create a chunker by strategy name or alias
     */
    createChunker(strategyOrAlias: string, config?: ChunkerConfig): Promise<Chunker>;
    /**
     * Get metadata for a chunker.
     *
     * Awaits registration first. `metadataMap` and the alias map are populated by
     * `registerAll()`, which only runs via the async `ensureInitialized()` — and
     * the only place that awaited it was `create()`. So on a fresh process this
     * returned `undefined` for every strategy until something happened to build a
     * chunker first, and returned real metadata after. Order-dependent, silent,
     * and `undefined` rather than a throw.
     *
     * `createChunker()` and `getAvailableStrategies()` were already async for
     * exactly this reason; these readers were the ones that had not caught up.
     */
    getChunkerMetadata(strategyOrAlias: string): Promise<ChunkerMetadata | undefined>;
    /**
     * Get default configuration for a chunker
     */
    getDefaultConfig(strategyOrAlias: string): Promise<ChunkerConfig | undefined>;
    /**
     * Get available chunking strategies (not including aliases)
     */
    getAvailableStrategies(): Promise<ChunkingStrategy[]>;
    /**
     * Get all aliases mapped to their strategies
     */
    getStrategyAliases(): Promise<Map<string, string>>;
    /**
     * Check if a strategy exists
     */
    hasStrategy(strategyOrAlias: string): Promise<boolean>;
    /**
     * Get chunkers suitable for a use case
     */
    getChunkersForUseCase(useCase: string): Promise<ChunkingStrategy[]>;
    /**
     * Get all chunker metadata
     */
    getAllMetadata(): Promise<Map<string, ChunkerMetadata>>;
    /**
     * Clear factory and metadata
     */
    clear(): void;
}
/**
 * Global chunker factory singleton
 */
export declare const chunkerFactory: ChunkerFactory;
/**
 * Convenience function to create a chunker
 */
export declare function createChunker(strategyOrAlias: string, config?: ChunkerConfig): Promise<Chunker>;
/**
 * Convenience function to get available strategies
 */
export declare function getAvailableStrategies(): Promise<ChunkingStrategy[]>;
/**
 * Convenience function to get chunker metadata
 */
export declare function getChunkerMetadata(strategyOrAlias: string): Promise<ChunkerMetadata | undefined>;
/**
 * Convenience function to get default config
 */
export declare function getDefaultConfig(strategyOrAlias: string): Promise<ChunkerConfig | undefined>;