import { Readable } from 'stream';
import { DetectionResult, FileTypeDefinition } from './file-types-registry';
export interface FileTypeDetectorOptions {
    peekBytes?: number;
    checkMultipleOffsets?: boolean;
    maxOffset?: number;
}
export declare class FileTypeDetector {
    private fileTypes;
    private options;
    private magicBytesCache;
    private extensionCache;
    constructor(options?: FileTypeDetectorOptions);
    /**
     * Detect file type from a stream (PRIMARY METHOD - memory efficient)
     * @param stream - Readable stream to detect from
     * @returns Detection result or null if not detected
     */
    detectFromStream(stream: Readable): Promise<DetectionResult | null>;
    /**
     * Detect file type from an already-read buffer
     * @param buffer - Buffer to detect from
     * @returns Detection result or null if not detected
     */
    detectFromBuffer(buffer: Buffer): Promise<DetectionResult | null>;
    /**
     * Detect file type from extension only
     * @param extension - File extension (with or without dot)
     * @returns Array of possible detection results with lower confidence
     */
    detectFromExtension(extension: string): DetectionResult[];
    /**
     * Get all file types by category
     * @param category - Category name (e.g., 'image', 'video', 'archive')
     * @returns Array of file type definitions
     */
    getByCategory(category: string): FileTypeDefinition[];
    /**
     * Add a new file type dynamically
     * @param fileType - File type definition to add
     */
    addFileType(fileType: FileTypeDefinition): void;
    /**
     * Remove a file type by name
     * @param name - Name of the file type to remove
     */
    removeFileType(name: string): boolean;
    /**
     * Clear all caches
     */
    clearCache(): void;
    /**
     * Get all registered file types
     * @returns Array of all file type definitions
     */
    getAllFileTypes(): FileTypeDefinition[];
    /**
     * Check magic bytes at a specific offset
     * @private
     */
    private checkMagicBytesAtOffset;
    /**
     * Generate offsets to check based on buffer size
     * @private
     */
    private generateOffsets;
    /**
     * Enhance detection result with additional information
     * @private
     */
    private enhanceDetectionResult;
    /**
     * Detect file type with fallback to extension
     * @param input - Readable stream or Buffer
     * @param filename - Optional filename for extension fallback
     * @returns Detection result with attached stream for reuse (if input was stream)
     */
    detectWithFallback(input: Readable | Buffer, filename?: string): Promise<(DetectionResult & {
        _stream?: Readable;
    }) | null>;
    /**
     * Check if a buffer matches a specific file type
     * @param buffer - Buffer to check
     * @param fileTypeName - Name of the file type to check against
     * @returns True if matches, false otherwise
     */
    isFileType(buffer: Buffer, fileTypeName: string): boolean;
    /**
     * Get statistics about registered file types
     * @returns Statistics object
     */
    getStatistics(): {
        totalTypes: number;
        byCategory: Record<string, number>;
        byMimePrefix: Record<string, number>;
    };
}
export declare const defaultDetector: FileTypeDetector;
export declare function detectFromStream(stream: Readable): Promise<DetectionResult | null>;
export declare function detectFromBuffer(buffer: Buffer): Promise<DetectionResult | null>;
export declare function detectFromExtension(extension: string): DetectionResult[];