ocr-ai 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,355 @@
+/**
+ * Supported AI providers
+ */
+type AIProvider = 'gemini' | 'openai' | 'claude' | 'grok' | 'vertex';
+/**
+ * Output format for extraction
+ */
+type OutputFormat = 'text' | 'json';
+/**
+ * Supported file types
+ */
+type SupportedFileType = 'pdf' | 'image' | 'text';
+/**
+ * Configuration for a specific AI provider
+ */
+interface ProviderConfig {
+    apiKey: string;
+    model?: string;
+}
+/**
+ * Vertex AI specific configuration
+ */
+interface VertexConfig$1 {
+    project: string;
+    location: string;
+}
+/**
+ * Main configuration for ExtractaAI
+ */
+interface ExtractaConfig {
+    provider: AIProvider;
+    apiKey?: string;
+    model?: string;
+    /**
+     * Vertex AI configuration (required when provider is 'vertex')
+     */
+    vertexConfig?: VertexConfig$1;
+}
+/**
+ * Model-specific configuration parameters
+ */
+interface ModelConfig {
+    /**
+     * Controls randomness (0.0 = deterministic, 1.0+ = more random)
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens to generate in the response
+     */
+    maxTokens?: number;
+    /**
+     * Top-p (nucleus) sampling
+     */
+    topP?: number;
+    /**
+     * Top-k sampling (Gemini/Claude only)
+     */
+    topK?: number;
+    /**
+     * Stop sequences to end generation
+     */
+    stopSequences?: string[];
+}
+/**
+ * Options for extraction
+ */
+interface ExtractionOptions {
+    /**
+     * Output format: 'text' for plain text, 'json' for structured JSON
+     */
+    format?: OutputFormat;
+    /**
+     * JSON schema to validate/structure the output (only for format: 'json')
+     * Can be a JSON Schema object or a simple object describing the structure
+     */
+    schema?: Record<string, unknown>;
+    /**
+     * Custom prompt to guide the extraction
+     */
+    prompt?: string;
+    /**
+     * Language for extraction (default: 'auto')
+     */
+    language?: string;
+    /**
+     * Output file path (if you want to save to disk)
+     */
+    outputPath?: string;
+    /**
+     * Model-specific configuration (temperature, maxTokens, etc.)
+     */
+    modelConfig?: ModelConfig;
+}
+/**
+ * Result of text extraction
+ */
+interface TextExtractionResult {
+    success: true;
+    format: 'text';
+    content: string;
+    metadata: ExtractionMetadata;
+}
+/**
+ * Result of JSON extraction
+ */
+interface JsonExtractionResult<T = Record<string, unknown>> {
+    success: true;
+    format: 'json';
+    data: T;
+    metadata: ExtractionMetadata;
+}
+/**
+ * Error result
+ */
+interface ExtractionError {
+    success: false;
+    error: string;
+    code: string;
+}
+/**
+ * Combined extraction result type
+ */
+type ExtractionResult<T = Record<string, unknown>> = TextExtractionResult | JsonExtractionResult<T> | ExtractionError;
+/**
+ * Token usage information
+ */
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+/**
+ * Metadata about the extraction
+ */
+interface ExtractionMetadata {
+    provider: AIProvider;
+    model: string;
+    fileType: SupportedFileType;
+    fileName: string;
+    processingTimeMs: number;
+    tokens?: TokenUsage;
+}
+/**
+ * File information after loading
+ */
+interface FileInfo {
+    path: string;
+    name: string;
+    type: SupportedFileType;
+    mimeType: string;
+    size: number;
+    content: Buffer;
+    base64?: string;
+}
+/**
+ * Result from provider extraction including tokens
+ */
+interface ProviderResult<T = string> {
+    content: T;
+    tokens?: TokenUsage;
+}
+/**
+ * Interface that all AI providers must implement
+ */
+interface IAIProvider {
+    readonly name: AIProvider;
+    readonly model: string;
+    /**
+     * Extract text from a file
+     */
+    extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    /**
+     * Extract structured JSON from a file
+     */
+    extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    /**
+     * Check if the provider supports the given file type
+     */
+    supportsFileType(type: SupportedFileType): boolean;
+}
+
+/**
+ * Main class for document extraction using AI
+ */
+declare class ExtractaAI {
+    private provider;
+    private config;
+    constructor(config: ExtractaConfig);
+    /**
+     * Create a provider instance based on configuration
+     */
+    private createProvider;
+    /**
+     * Extract content from a file path or URL
+     */
+    extract(source: string, options?: ExtractionOptions): Promise<ExtractionResult>;
+    /**
+     * Extract content from a Buffer
+     */
+    extractFromBuffer(buffer: Buffer, fileName: string, options?: ExtractionOptions): Promise<ExtractionResult>;
+    /**
+     * Extract content from a base64 string
+     */
+    extractFromBase64(base64: string, fileName: string, options?: ExtractionOptions): Promise<ExtractionResult>;
+    /**
+     * Process the extraction based on format
+     */
+    private processExtraction;
+    /**
+     * Create an error result
+     */
+    private createErrorResult;
+    /**
+     * Get current provider name
+     */
+    getProvider(): AIProvider;
+    /**
+     * Get current model
+     */
+    getModel(): string;
+    /**
+     * Change the AI provider
+     */
+    setProvider(provider: AIProvider, apiKey: string, model?: string): void;
+}
+/**
+ * Factory function to create ExtractaAI instance
+ */
+declare function createExtractaAI(config: ExtractaConfig): ExtractaAI;
+
+/**
+ * Load a file from disk and prepare it for AI processing
+ */
+declare function loadFile(filePath: string): Promise<FileInfo>;
+/**
+ * Load a file from a Buffer
+ */
+declare function loadFileFromBuffer(buffer: Buffer, fileName: string, mimeType?: string): FileInfo;
+/**
+ * Load a file from base64 string
+ */
+declare function loadFileFromBase64(base64: string, fileName: string, mimeType?: string): FileInfo;
+/**
+ * Save content to a file
+ */
+declare function saveToFile(filePath: string, content: string | Buffer): Promise<void>;
+/**
+ * Get supported file extensions
+ */
+declare function getSupportedExtensions(): string[];
+/**
+ * Check if a file extension is supported
+ */
+declare function isExtensionSupported(ext: string): boolean;
+/**
+ * Check if a string is a URL
+ */
+declare function isUrl(str: string): boolean;
+/**
+ * Load a file from a URL
+ */
+declare function loadFileFromUrl(url: string): Promise<FileInfo>;
+
+/**
+ * Base class for AI providers with common functionality
+ */
+declare abstract class BaseProvider implements IAIProvider {
+    abstract readonly name: AIProvider;
+    abstract readonly model: string;
+    protected apiKey: string;
+    constructor(apiKey: string);
+    abstract extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    abstract extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    supportsFileType(type: SupportedFileType): boolean;
+    /**
+     * Build the text extraction prompt
+     */
+    protected buildTextPrompt(options?: ExtractionOptions): string;
+    /**
+     * Build the JSON extraction prompt
+     */
+    protected buildJsonPrompt(schema: Record<string, unknown>, options?: ExtractionOptions): string;
+    /**
+     * Parse JSON response from AI, handling potential formatting issues
+     */
+    protected parseJsonResponse<T>(response: string): T;
+}
+
+declare class GeminiProvider extends BaseProvider {
+    readonly name: AIProvider;
+    readonly model: string;
+    private client;
+    constructor(apiKey: string, model?: string);
+    extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    private buildGenerationConfig;
+    private extractTokenUsage;
+    private buildContent;
+}
+
+declare class OpenAIProvider extends BaseProvider {
+    readonly name: AIProvider;
+    readonly model: string;
+    private client;
+    constructor(apiKey: string, model?: string);
+    extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    private buildCompletionOptions;
+    private extractTokenUsage;
+    private buildMessages;
+}
+
+declare class ClaudeProvider extends BaseProvider {
+    readonly name: AIProvider;
+    readonly model: string;
+    private client;
+    constructor(apiKey: string, model?: string);
+    extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    private buildMessageOptions;
+    supportsFileType(type: SupportedFileType): boolean;
+    private extractTokenUsage;
+    private buildContent;
+    private getMediaType;
+}
+
+declare class GrokProvider extends BaseProvider {
+    readonly name: AIProvider;
+    readonly model: string;
+    private client;
+    constructor(apiKey: string, model?: string);
+    extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    private buildCompletionOptions;
+    private extractTokenUsage;
+    private buildMessages;
+}
+
+interface VertexConfig {
+    project: string;
+    location: string;
+}
+declare class VertexProvider extends BaseProvider {
+    readonly name: AIProvider;
+    readonly model: string;
+    private client;
+    constructor(config: VertexConfig, model?: string);
+    extractText(file: FileInfo, options?: ExtractionOptions): Promise<ProviderResult<string>>;
+    extractJson<T = Record<string, unknown>>(file: FileInfo, schema: Record<string, unknown>, options?: ExtractionOptions): Promise<ProviderResult<T>>;
+    private buildGenerationConfig;
+    private extractTokenUsage;
+    private buildContents;
+}
+
+export { type AIProvider, BaseProvider, ClaudeProvider, ExtractaAI, type ExtractaConfig, type ExtractionError, type ExtractionMetadata, type ExtractionOptions, type ExtractionResult, type FileInfo, GeminiProvider, GrokProvider, type IAIProvider, type JsonExtractionResult, type ModelConfig, OpenAIProvider, type OutputFormat, type ProviderConfig, type SupportedFileType, type TextExtractionResult, type TokenUsage, type VertexConfig$1 as VertexConfig, VertexProvider, createExtractaAI, getSupportedExtensions, isExtensionSupported, isUrl, loadFile, loadFileFromBase64, loadFileFromBuffer, loadFileFromUrl, saveToFile };