@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/types/processor.d.ts

@@ -1,993 +0,0 @@
-/**
- * File Processor Types
- *
- * Single source of truth for ALL file processing type definitions.
- * All processor infrastructure, registry, and SDK types are defined here.
- *
- * @module processors/base/types
- */
-import type { FileErrorCode } from "../processors/errors/FileErrorCode.js";
-/**
- * Generic file information - provider agnostic.
- * Replaces Slack-specific SlackFileInfo with a universal interface.
- *
- * @example
- * ```typescript
- * const fileInfo: FileInfo = {
- *   id: 'doc-123',
- *   name: 'report.pdf',
- *   mimetype: 'application/pdf',
- *   size: 1024000,
- *   url: 'https://example.com/files/report.pdf',
- * };
- * ```
- */
-export type FileInfo = {
-    /** Unique identifier for the file */
-    id: string;
-    /** Original filename */
-    name: string;
-    /** MIME type of the file */
-    mimetype: string;
-    /** File size in bytes */
-    size: number;
-    /** Download URL (optional - use when file needs to be fetched) */
-    url?: string;
-    /** Direct file content (optional - use when file is already in memory) */
-    buffer?: Buffer;
-    /** Extensibility - additional provider-specific metadata */
-    metadata?: Record<string, unknown>;
-};
-/**
- * Configuration for file processors.
- * Defines constraints and defaults for a specific file type processor.
- */
-export type FileProcessorConfig = {
-    /** Maximum file size in megabytes */
-    maxSizeMB: number;
-    /** Download/processing timeout in milliseconds */
-    timeoutMs: number;
-    /** List of supported MIME types */
-    supportedMimeTypes: string[];
-    /** List of supported file extensions (with leading dot) */
-    supportedExtensions: string[];
-    /** Human-readable name for this file type (e.g., 'image', 'PDF') */
-    fileTypeName: string;
-    /** Default filename when original name is not available */
-    defaultFilename: string;
-};
-/**
- * Base interface for processed file data.
- * All specific processed types should extend this interface.
- */
-export type ProcessedFileBase = {
-    /** File content as a Buffer */
-    buffer: Buffer;
-    /** MIME type of the processed content */
-    mimetype: string;
-    /** Size of the processed content in bytes */
-    size: number;
-    /** Filename (may be normalized or sanitized) */
-    filename: string;
-};
-/**
- * Structured file processing error with user-friendly messaging.
- * This is the canonical error type used across all processor infrastructure.
- */
-export type FileProcessingError = {
-    /** Error code from FileErrorCode enum */
-    code: FileErrorCode | string;
-    /** Technical error message */
-    message: string;
-    /** User-friendly error message */
-    userMessage: string;
-    /** Suggested action to resolve the error */
-    suggestedAction?: string;
-    /** Whether this error is potentially retryable */
-    retryable?: boolean;
-    /** Additional context/details about the error */
-    details?: Record<string, unknown>;
-    /** Technical details (usually from original error) */
-    technicalDetails?: string;
-    /** Original error that caused this failure */
-    originalError?: Error;
-};
-/**
- * Generic result type for internal operations.
- * Used for validation and download operations that don't return ProcessedFileBase.
- */
-export type ProcessorOperationResult<T = void> = {
-    /** Whether the operation was successful */
-    success: boolean;
-    /** Operation result data (present when success is true) */
-    data?: T;
-    /** Error information (present when success is false) */
-    error?: FileProcessingError;
-};
-/**
- * Result of a file processing operation.
- * Uses discriminated union pattern for type-safe error handling.
- *
- * @example
- * ```typescript
- * const result = await processor.processFile(fileInfo);
- * if (result.success) {
- *   console.log('Processed:', result.data.filename);
- * } else {
- *   console.error('Error:', result.error.userMessage);
- * }
- * ```
- */
-export type ProcessorFileProcessingResult<T extends ProcessedFileBase = ProcessedFileBase> = {
-    /** Whether the processing was successful */
-    success: boolean;
-    /** Processed file data (present when success is true) */
-    data?: T;
-    /** Error information (present when success is false) */
-    error?: FileProcessingError;
-};
-/**
- * Configuration for retry behavior on transient failures.
- * Implements exponential backoff with optional custom retry predicate.
- */
-export type ProcessorRetryConfig = {
-    /** Maximum number of retry attempts */
-    maxRetries: number;
-    /** Base delay between retries in milliseconds */
-    baseDelayMs: number;
-    /** Maximum delay between retries in milliseconds */
-    maxDelayMs: number;
-    /** Optional custom function to determine if an error is retryable */
-    retryOn?: (error: Error) => boolean;
-};
-/**
- * Options for file processing operations.
- * Allows customization of download behavior and retry logic.
- */
-export type ProcessOptions = {
-    /** Authentication headers for download requests */
-    authHeaders?: Record<string, string>;
-    /** Override default timeout (in milliseconds) */
-    timeout?: number;
-    /** Retry configuration for transient failures */
-    retryConfig?: ProcessorRetryConfig;
-};
-/**
- * Default retry configuration for file downloads.
- * Uses exponential backoff: 1s, 2s, 4s (capped at maxDelayMs)
- */
-export declare const DEFAULT_RETRY_CONFIG: ProcessorRetryConfig;
-/** Default timeout for text file downloads (30 seconds) */
-export declare const DEFAULT_TEXT_TIMEOUT_MS = 30000;
-/** Default maximum size for text files (10 MB) */
-export declare const DEFAULT_TEXT_MAX_SIZE_MB = 10;
-/** Default timeout for image file downloads (30 seconds) */
-export declare const DEFAULT_IMAGE_TIMEOUT_MS = 30000;
-/** Default maximum size for image files (10 MB) */
-export declare const DEFAULT_IMAGE_MAX_SIZE_MB = 10;
-/**
- * Information about a successfully processed file.
- */
-export type ProcessedFileInfo = {
-    /** File identifier */
-    fileId: string;
-    /** Filename */
-    filename: string;
-    /** MIME type */
-    mimetype: string;
-    /** Size in bytes */
-    size: number;
-    /** Type of processor used */
-    processorType: string;
-};
-/**
- * Information about a file that failed to process.
- */
-export type FailedFileInfo = {
-    /** File identifier */
-    fileId: string;
-    /** Filename */
-    filename: string;
-    /** MIME type */
-    mimetype: string;
-    /** Size in bytes */
-    size: number;
-    /** Error that caused the failure */
-    error: FileProcessingError;
-};
-/**
- * Information about a file that was skipped.
- */
-export type SkippedFileInfo = {
-    /** File identifier */
-    fileId: string;
-    /** Filename */
-    filename: string;
-    /** MIME type */
-    mimetype: string;
-    /** Size in bytes */
-    size: number;
-    /** Reason for skipping */
-    reason: string;
-    /** Suggested alternative action */
-    suggestedAlternative?: string;
-};
-/**
- * Warning about a file (non-fatal issue).
- */
-export type FileWarning = {
-    /** File identifier */
-    fileId: string;
-    /** Filename */
-    filename: string;
-    /** Warning message */
-    message: string;
-};
-/**
- * Summary of batch file processing operations.
- */
-export type BatchProcessingSummary<T extends ProcessedFileBase = ProcessedFileBase> = {
-    /** Total number of files attempted */
-    totalFiles: number;
-    /** Successfully processed files */
-    processedFiles: ProcessedFileInfo[];
-    /** Files that failed to process */
-    failedFiles: FailedFileInfo[];
-    /** Files that were skipped (e.g., unsupported format) */
-    skippedFiles: SkippedFileInfo[];
-    /** Non-fatal warnings */
-    warnings: FileWarning[];
-    /** Processed results (parallel array with processedFiles) */
-    results: T[];
-};
-/**
- * Result of finding a matching processor for a file.
- * Includes both the processor and metadata about the match quality.
- *
- * Note: `processor` is typed as `unknown` here to avoid circular dependency
- * on BaseFileProcessor. The registry module uses the properly typed version.
- */
-export type ProcessorMatch<_T extends ProcessedFileBase = ProcessedFileBase> = {
-    /** Name of the matched processor */
-    name: string;
-    /** The processor instance */
-    processor: unknown;
-    /** Priority level of this processor */
-    priority: number;
-    /**
-     * Confidence score for the match (0-100).
-     * Higher values indicate better match quality:
-     * - 100: Exact MIME type match
-     * - 80: MIME type prefix match (e.g., "image/*")
-     * - 60: File extension match
-     * - 40: Generic/fallback match
-     */
-    confidence: number;
-};
-/**
- * Options for registry operations.
- * Controls behavior when registering processors.
- */
-export type RegistryOptions = {
-    /**
-     * Allow registering processors with duplicate names.
-     * If false (default), an error is thrown on duplicate names.
-     */
-    allowDuplicates?: boolean;
-    /**
-     * Overwrite existing processor with the same name.
-     * Takes precedence over allowDuplicates.
-     */
-    overwriteExisting?: boolean;
-};
-/**
- * Detailed error information for unsupported file types.
- * Provides helpful suggestions for the user.
- */
-export type UnsupportedFileError = {
-    /** Error code for programmatic handling */
-    code: "NO_PROCESSOR_FOUND" | "PROCESSING_FAILED";
-    /** Human-readable error message */
-    message: string;
-    /** Original filename */
-    filename: string;
-    /** MIME type of the file */
-    mimetype: string;
-    /** Helpful suggestion for the user */
-    suggestion: string;
-    /** List of supported file types */
-    supportedTypes: string[];
-};
-/**
- * Result of processing a file through the registry.
- * Includes type information for tracking which processor was used.
- */
-export type RegistryProcessResult<T = unknown> = {
-    /** Type/name of the processor that handled the file */
-    type: string;
-    /** Processed data (null if processing failed) */
-    data: T | null;
-    /** Error information if processing failed */
-    error?: UnsupportedFileError;
-};
-/**
- * Priority levels for file processors.
- * Lower number = higher priority = matched first.
- *
- * This priority system ensures that:
- * - SVG files are processed as text (not images) since many AI providers don't support SVG format
- * - More specific processors match before generic ones
- * - Document types are processed in a logical order
- */
-export declare const PROCESSOR_PRIORITIES: {
-    /** SVG files - processed as text before image processing */
-    readonly SVG: 5;
-    /** Image files - AI vision processing */
-    readonly IMAGE: 10;
-    /** PDF documents */
-    readonly PDF: 20;
-    /** CSV/tabular data */
-    readonly CSV: 30;
-    /** Markdown files - structured text */
-    readonly MARKDOWN: 40;
-    /** JSON data files */
-    readonly JSON: 50;
-    /** YAML configuration/data files */
-    readonly YAML: 60;
-    /** XML data files */
-    readonly XML: 70;
-    /** HTML web content */
-    readonly HTML: 80;
-    /** Excel spreadsheets */
-    readonly EXCEL: 90;
-    /** Legacy .doc files */
-    readonly DOC: 95;
-    /** Word documents (.docx) */
-    readonly WORD: 100;
-    /** Plain text files */
-    readonly TEXT: 110;
-    /** Source code files */
-    readonly SOURCE_CODE: 120;
-    /** Configuration files */
-    readonly CONFIG: 130;
-    /** RTF documents */
-    readonly RTF: 140;
-    /** OpenDocument format files */
-    readonly OPENDOCUMENT: 150;
-    /** Video files */
-    readonly VIDEO: 160;
-    /** Audio files */
-    readonly AUDIO: 170;
-    /** Archive files */
-    readonly ARCHIVE: 180;
-};
-/**
- * Type for processor priority keys
- */
-export type ProcessorPriorityKey = keyof typeof PROCESSOR_PRIORITIES;
-/**
- * Type for processor priority values
- */
-export type ProcessorPriorityValue = (typeof PROCESSOR_PRIORITIES)[ProcessorPriorityKey];
-/**
- * Information about a registered processor.
- * Used for discovery and documentation.
- */
-export type ProcessorInfo = {
-    /** Unique name for the processor */
-    name: string;
-    /** Human-readable description */
-    description: string;
-    /** List of supported MIME types */
-    supportedMimeTypes: string[];
-    /** List of supported file extensions */
-    supportedExtensions: string[];
-    /** Priority level (lower = higher priority) */
-    priority?: number;
-};
-/**
- * Error message template with user-friendly messaging and retry information.
- * Re-exported from errors module for convenience.
- */
-export { FileErrorCode } from "../processors/errors/FileErrorCode.js";
-/**
- * Processed SVG result.
- * Extends ProcessedFileBase with SVG-specific fields.
- */
-export type ProcessedSvg = ProcessedFileBase & {
-    /** Sanitized SVG content as text for AI processing */
-    textContent: string;
-    /** Original raw content (only included if sanitization modified the content) */
-    rawContent?: string;
-    /** Whether sanitization was applied to the content */
-    sanitized: boolean;
-    /** Security warnings found during processing */
-    securityWarnings: string[];
-};
-/**
- * Processed XML file result.
- */
-export type ProcessedXml = ProcessedFileBase & {
-    /** Original XML content */
-    content: string;
-    /** Parsed XML content (as JavaScript object) */
-    parsed: unknown;
-    /** Whether the XML is syntactically valid */
-    valid: boolean;
-    /** Error message if XML is invalid */
-    errorMessage?: string;
-    /** Name of the root element */
-    rootElement?: string;
-};
-/**
- * Processed Markdown result.
- */
-export type ProcessedMarkdown = ProcessedFileBase & {
-    /** Original Markdown content */
-    content: string;
-    /** Total number of lines in the document */
-    lineCount: number;
-    /** Whether the document contains fenced code blocks */
-    hasCodeBlocks: boolean;
-    /** Whether the document contains Markdown tables */
-    hasTables: boolean;
-    /** List of headings extracted from the document */
-    headings: string[];
-};
-/**
- * Processed source code result.
- */
-export type ProcessedSourceCode = ProcessedFileBase & {
-    /** The source code content (may be truncated) */
-    content: string;
-    /** Detected programming language (e.g., "TypeScript", "Python") */
-    language: string;
-    /** Number of lines in the content */
-    lineCount: number;
-    /** Whether the content was truncated due to line limit */
-    truncated: boolean;
-    /** Character encoding used to decode the file */
-    encoding: string;
-};
-/**
- * Processed configuration file result.
- */
-export type ProcessedConfig = ProcessedFileBase & {
-    /** The configuration file content with redacted sensitive values */
-    content: string;
-    /** Detected configuration format */
-    format: "env" | "ini" | "toml" | "properties" | "unknown";
-    /** Extracted key-value pairs (with sensitive values redacted) */
-    keyValues: Record<string, string>;
-    /** List of keys that were redacted for security */
-    redactedKeys: string[];
-};
-/**
- * Processed OpenDocument result.
- */
-export type ProcessedOpenDocument = ProcessedFileBase & {
-    /** Extracted text content */
-    textContent: string;
-    /** Document format type */
-    format: "odt" | "ods" | "odp" | "unknown";
-    /** Number of paragraphs/text elements found */
-    paragraphCount: number;
-    /** Whether content was truncated */
-    truncated: boolean;
-};
-/**
- * Processed JSON file result.
- */
-export type ProcessedJson = ProcessedFileBase & {
-    /** Pretty-printed JSON content (or original content if invalid) */
-    content: string;
-    /** Original raw content before pretty-printing */
-    rawContent: string;
-    /** Parsed JSON object/array/value */
-    parsed: unknown;
-    /** Whether the JSON is syntactically valid */
-    valid: boolean;
-    /** Error message if JSON is invalid */
-    errorMessage?: string;
-    /** Number of top-level keys (for objects) */
-    keyCount?: number;
-    /** Length of the array (for arrays) */
-    arrayLength?: number;
-    /** Whether content was truncated */
-    truncated: boolean;
-};
-/**
- * Processed plain text file result.
- */
-export type ProcessedText = ProcessedFileBase & {
-    /** Text content (may be truncated if file is too large) */
-    content: string;
-    /** Total number of lines in the original file */
-    lineCount: number;
-    /** Total number of words in the original file */
-    wordCount: number;
-    /** Character encoding used to decode the file */
-    encoding: string;
-    /** Whether the content was truncated due to size limits */
-    truncated: boolean;
-};
-/**
- * Processed HTML file result.
- */
-export type ProcessedHtml = ProcessedFileBase & {
-    /** Original HTML content */
-    content: string;
-    /** Text extracted from HTML (all tags stripped) */
-    textContent: string;
-    /** Whether the HTML contains script tags */
-    hasScripts: boolean;
-    /** Whether the HTML contains style tags */
-    hasStyles: boolean;
-    /** Page title extracted from title tag, if present */
-    title?: string;
-    /** Whether the HTML contains potentially dangerous content (XSS vectors) */
-    hasDangerousContent: boolean;
-};
-/**
- * Processed YAML file result.
- */
-export type ProcessedYaml = ProcessedFileBase & {
-    /** Original YAML content */
-    content: string;
-    /** Parsed YAML content (as JavaScript object) */
-    parsed: unknown;
-    /** Whether the YAML is syntactically valid */
-    valid: boolean;
-    /** Error message if YAML is invalid */
-    errorMessage?: string;
-    /** YAML content converted to JSON string for AI consumption */
-    asJson: string | null;
-};
-/**
- * Structural types for fluent-ffmpeg probe data.
- * Defined here so the optional fluent-ffmpeg package is not required at typecheck time.
- */
-export type FfprobeStream = {
-    codec_type?: string;
-    codec_name?: string;
-    width?: number;
-    height?: number;
-    r_frame_rate?: string;
-    avg_frame_rate?: string;
-    bit_rate?: number | string;
-    channels?: number;
-    sample_rate?: number | string;
-    tags?: Record<string, string | number>;
-    [key: string]: unknown;
-};
-export type FfprobeData = {
-    streams: FfprobeStream[];
-    format: {
-        duration?: number;
-        size?: number | string;
-        bit_rate?: number | string;
-        tags?: Record<string, string | number>;
-        [key: string]: unknown;
-    };
-};
-/**
- * Structural types for exceljs objects.
- * Defined here so the optional exceljs package is not required at typecheck time.
- */
-export type ExcelJSCell = {
-    value: CellValue;
-};
-export type ExcelJSRow = {
-    values: (CellValue | undefined)[];
-    eachCell: (opts: {
-        includeEmpty: boolean;
-    }, callback: (cell: ExcelJSCell, colNumber: number) => void) => void;
-};
-export type ExcelJSWorksheet = {
-    name: string;
-    rowCount: number;
-    eachRow: {
-        (callback: (row: ExcelJSRow, rowNumber: number) => void): void;
-        (opts: {
-            includeEmpty: boolean;
-        }, callback: (row: ExcelJSRow, rowNumber: number) => void): void;
-    };
-    getRow: (rowNumber: number) => ExcelJSRow;
-};
-export type ExcelJSWorkbook = {
-    worksheets: ExcelJSWorksheet[];
-    getWorksheet: (name: string) => ExcelJSWorksheet | undefined;
-    xlsx: {
-        load: (buffer: ArrayBuffer) => Promise<void>;
-    };
-};
-/**
- * Single worksheet extracted from an Excel file.
- */
-export type ExcelWorksheet = {
-    /** Name of the worksheet (tab name in Excel) */
-    name: string;
-    /** Row data as a 2D array. Each inner array represents a row. */
-    rows: (string | number | boolean | null)[][];
-    /** Headers extracted from the first row */
-    headers: string[];
-    /** Number of rows extracted (may be less than actual if truncated) */
-    rowCount: number;
-    /** Number of columns (based on headers or first row) */
-    columnCount: number;
-};
-/**
- * Processed Excel file result.
- */
-export type ProcessedExcel = ProcessedFileBase & {
-    /** Array of processed worksheets */
-    worksheets: ExcelWorksheet[];
-    /** Number of sheets processed (may be less than total if truncated) */
-    sheetCount: number;
-    /** Total number of rows across all worksheets */
-    totalRows: number;
-    /** Whether any data was truncated due to limits */
-    truncated: boolean;
-    /** Names of sheets that were truncated */
-    truncatedSheets: string[];
-};
-/**
- * Processed Word document result.
- */
-export type ProcessedWord = ProcessedFileBase & {
-    /** Extracted plain text content from the Word document */
-    textContent: string;
-    /** HTML representation of the Word document */
-    htmlContent: string;
-    /** Warnings from mammoth extraction (e.g., unsupported elements) */
-    warnings: string[];
-};
-/**
- * Processed RTF document result.
- */
-export type ProcessedRtf = ProcessedFileBase & {
-    /** Extracted plain text content from the RTF document */
-    textContent: string;
-    /** Raw RTF content (preserved for debugging/analysis) */
-    rawContent: string;
-};
-/**
- * Type guard function signature for JSON parsing.
- */
-export type JsonTypeGuard<T> = (parsed: unknown) => parsed is T;
-/**
- * Registration entry for a file processor.
- */
-export type ProcessorRegistration<T extends ProcessedFileBase = ProcessedFileBase> = {
-    name: string;
-    priority: number;
-    processor: import("../processors/base/index.js").BaseFileProcessor<T>;
-    isSupported: (mimetype: string, filename: string) => boolean;
-    description?: string;
-    aliases?: string[];
-};
-/**
- * Processed audio file result.
- * Extends ProcessedFileBase with audio-specific metadata, tags, and transcript info.
- */
-export type ProcessedAudio = ProcessedFileBase & {
-    /** LLM-friendly text representation of the audio file metadata and tags */
-    textContent: string;
-    /** Audio stream metadata (codec, duration, bitrate, etc.) */
-    metadata: {
-        duration: number;
-        durationFormatted: string;
-        codec: string;
-        codecProfile?: string;
-        bitrate?: number;
-        sampleRate?: number;
-        channels?: number;
-        bitsPerSample?: number;
-        lossless: boolean;
-        fileSize: number;
-    };
-    /** Extracted ID3/Vorbis/APE tags */
-    tags: {
-        title?: string;
-        artist?: string;
-        album?: string;
-        year?: number;
-        genre?: string[];
-        track?: {
-            no: number | null;
-            of: number | null;
-        };
-        comment?: string;
-        composer?: string;
-    };
-    transcript?: string;
-    hasTranscript: boolean;
-    transcriptionProvider?: string;
-    /**
-     * Why transcription produced nothing, when it did (#416). Absent on success.
-     * Lets a caller distinguish "this audio has no speech" from "the transcription
-     * backend was never reachable", which previously looked identical.
-     */
-    transcriptionSkippedReason?: string;
-    coverArt?: Buffer;
-};
-/**
- * Processed video result.
- * Extends ProcessedFileBase with video-specific fields including metadata,
- * extracted keyframes, subtitle text, and a pre-formatted textContent block
- * suitable for sending to an LLM.
- */
-export type ProcessedVideo = ProcessedFileBase & {
-    textContent: string;
-    keyframes: Buffer[];
-    metadata: {
-        duration: number;
-        durationFormatted: string;
-        width: number;
-        height: number;
-        codec: string;
-        fps: number;
-        bitrate: number;
-        audioCodec?: string;
-        audioChannels?: number;
-        audioSampleRate?: number;
-        subtitleTracks: number;
-        fileSize: number;
-    };
-    subtitleText?: string;
-    hasKeyframes: boolean;
-    frameCount: number;
-};
-/**
- * Supported archive format identifiers.
- */
-export type ArchiveFormat = "zip" | "tar" | "tar.gz" | "tar.bz2" | "gz" | "bz2" | "xz" | "zst" | "rar" | "7z";
-/**
- * Outcome of decompressing a single-stream archive (.bz2, .xz, .zst).
- *
- * A plain `Buffer | null` collapsed two very different failures into one: a
- * machine that has no `xz` installed and a `.xz` file that is corrupt both
- * returned null, and the caller reported both as "the command is unavailable on
- * this machine" — actively misleading for the second. The reason is carried so
- * the message can match the fact.
- */
-export type ArchiveDecompressionResult = {
-    readonly status: "ok";
-    readonly buffer: Buffer;
-} | {
-    readonly status: "tool-unavailable";
-} | {
-    readonly status: "too-large";
-} | {
-    readonly status: "failed";
-};
-/**
- * Outcome of reading one ZIP entry under an explicit output bound.
- *
- * Separate from {@link ArchiveDecompressionResult} because the failures differ:
- * a single-stream archive can fail for want of an external tool, while a ZIP
- * entry can instead use a compression method this reader does not implement.
- * Collapsing them would force one caller to handle a state it can never see.
- *
- * `too-large` is a distinct outcome rather than a corrupt-file error because it
- * is a verdict about our limit, not about the archive: the entry may be
- * perfectly well-formed, and telling the user it is damaged would send them to
- * re-create a file that was never broken.
- */
-/**
- * The slice of an adm-zip entry the bounded reader depends on.
- *
- * Structural rather than adm-zip's own `IZipEntry` so the reader states what it
- * actually needs — the compressed bytes and the header fields it refuses to
- * trust — instead of importing a library type it would then have to satisfy in
- * full when building a test double.
- */
-export type BoundedZipEntry = {
-    getCompressedData: () => Buffer;
-    header: {
-        method: number;
-        crc: number;
-    };
-};
-export type ArchiveEntryReadResult = {
-    readonly status: "ok";
-    readonly buffer: Buffer;
-} | {
-    readonly status: "too-large";
-} | {
-    readonly status: "unsupported-method";
-} | {
-    readonly status: "corrupt";
-};
-/**
- * Metadata about an individual entry within an archive.
- */
-export type ArchiveEntry = {
-    name: string;
-    uncompressedSize: number;
-    compressedSize: number;
-    isDirectory: boolean;
-};
-/**
- * Processed archive result.
- * Extends ProcessedFileBase with archive-specific metadata, entry listing,
- * and any security warnings encountered during processing.
- */
-export type ProcessedArchive = ProcessedFileBase & {
-    textContent: string;
-    archiveMetadata: {
-        format: ArchiveFormat;
-        totalEntries: number;
-        totalUncompressedSize: number;
-        totalCompressedSize: number;
-    };
-    entries: ArchiveEntry[];
-    securityWarnings: string[];
-};
-/**
- * Options for CLI file processing
- */
-export type CliFileProcessingOptions = {
-    /** Verbose output - shows processing details */
-    verbose?: boolean;
-    /** Processor to use (bypasses auto-detection) */
-    processor?: string;
-    /** Output format: json, text, or raw */
-    outputFormat?: "json" | "text" | "raw";
-};
-/**
- * Result of CLI file processing
- */
-export type CliProcessingResult = {
-    /** Whether processing succeeded */
-    success: boolean;
-    /** Name of the processor that was used */
-    processorUsed: string | null;
-    /** Formatted output string */
-    output: string;
-    /** Error message if processing failed */
-    error?: string;
-};
-/**
- * Information about a supported file type
- */
-export type SupportedFileTypeInfo = {
-    /** Processor name */
-    name: string;
-    /** Priority (lower = processed first) */
-    priority: number;
-    /** Supported file extensions */
-    extensions: string[];
-    /** Supported MIME types */
-    mimeTypes: string[];
-    /** Optional description */
-    description?: string;
-};
-/**
- * Error message template with user-friendly messaging and retry information.
- */
-export type ProcessorErrorMessageTemplate = {
-    /** Technical error message */
-    message: string;
-    /** User-friendly error message */
-    userMessage: string;
-    /** Suggested action to resolve the error */
-    suggestedAction: string;
-    /** Whether this error is potentially retryable */
-    retryable: boolean;
-};
-/**
- * Options for processing files through the registry.
- * Extends base ProcessOptions with registry-specific options.
- *
- * @example
- * ```typescript
- * const options: FileProcessingOptions = {
- *   // Base options
- *   authHeaders: { Authorization: "Bearer token" },
- *   timeout: 60000,
- *
- *   // Registry-specific options
- *   preferredProcessor: "pdf",      // Use specific processor
- *   allowFallback: true,            // Allow fallback if no processor found
- *   maxFiles: 50,                   // Limit batch processing
- * };
- * ```
- */
-export type FileProcessingOptions = ProcessOptions & {
-    /** Preferred processor name (bypasses auto-detection) */
-    preferredProcessor?: string;
-    /** Whether to fall back to default processing if no processor found */
-    allowFallback?: boolean;
-    /** Maximum number of files to process (default: 100) */
-    maxFiles?: number;
-};
-/**
- * Result of processing multiple files through the registry.
- * Categorizes files into successful, failed, and skipped.
- *
- * @example
- * ```typescript
- * const result = await processBatchWithRegistry(files);
- *
- * // Handle successful files
- * for (const { fileInfo, processorName, result } of result.successful) {
- *   console.log(`${fileInfo.name}: processed by ${processorName}`);
- * }
- *
- * // Handle failed files
- * for (const { fileInfo, error } of result.failed) {
- *   console.error(`${fileInfo.name}: ${error}`);
- * }
- *
- * // Handle skipped files
- * for (const { fileInfo, reason } of result.skipped) {
- *   console.warn(`${fileInfo.name}: ${reason}`);
- * }
- * ```
- */
-export type BatchFileProcessingResult = {
-    /** Successfully processed files */
-    successful: Array<{
-        fileInfo: FileInfo;
-        processorName: string;
-        result: ProcessorFileProcessingResult<ProcessedFileBase>;
-    }>;
-    /** Files that failed to process */
-    failed: Array<{
-        fileInfo: FileInfo;
-        error: string;
-    }>;
-    /** Files that were skipped (no processor found or over limit) */
-    skipped: Array<{
-        fileInfo: FileInfo;
-        reason: string;
-    }>;
-};
-/** Alias for ExcelJS.CellValue to avoid leaking exceljs types across files. */
-export type CellValue = import("exceljs").CellValue;
-/** Summary of file processing operations. */
-export type FileProcessingSummary = {
-    totalFiles: number;
-    processedFiles: Array<{
-        filename: string;
-        size?: number;
-        type?: string;
-    }>;
-    failedFiles: Array<{
-        filename: string;
-        error: FileProcessingError;
-    }>;
-    skippedFiles: Array<{
-        filename: string;
-        reason: string;
-        suggestedAlternative?: string;
-    }>;
-    warnings: Array<{
-        filename: string;
-        message: string;
-    }>;
-};
-/** Serialized error representation with full context. */
-export type SerializedError = {
-    errorId: string;
-    errorFingerprint: string;
-    errorType: string;
-    message: string;
-    stack?: string;
-    stackFrames?: string[];
-    statusCode?: number;
-    isOperational?: boolean;
-    isRetryable?: boolean;
-    code?: string;
-    metadata?: Record<string, unknown>;
-    cause?: SerializedError;
-    timestamp: string;
-};
-/** Options for error serialization. */
-export type SerializeOptions = {
-    includeStack?: boolean;
-    maxDepth?: number;
-    filterStacks?: boolean;
-    context?: Record<string, unknown>;
-};