/**
 * VISION & MULTIMODAL SUPPORT
 * Image analysis, OCR, format conversion, metadata extraction
 */
export declare enum ImageFormat {
    JPEG = "jpeg",
    PNG = "png",
    GIF = "gif",
    WEBP = "webp",
    BMP = "bmp"
}
export declare enum ImageSource {
    URL = "url",
    BASE64 = "base64",
    FILE = "file"
}
export interface ImageContent {
    type: 'image';
    source: ImageSource;
    data: string;
    format?: ImageFormat;
    width?: number;
    height?: number;
    size_bytes?: number;
    metadata?: Record<string, unknown>;
}
export interface TextContent {
    type: 'text';
    text: string;
}
export type MultimodalContent = TextContent | ImageContent;
export interface VisionRequest {
    model: string;
    messages: Array<{
        role: string;
        content: MultimodalContent[];
    }>;
    max_tokens?: number;
    detail?: 'low' | 'high' | 'auto';
}
export interface ImageMetadata {
    format: ImageFormat;
    width: number;
    height: number;
    size_bytes: number;
    aspect_ratio: number;
    color_depth?: number;
    has_alpha?: boolean;
}
export declare class VisionManager {
    private supported_formats;
    /**
     * Create image content from URL
     */
    fromURL(url: string, detail?: 'low' | 'high' | 'auto'): ImageContent;
    /**
     * Create image content from base64
     */
    fromBase64(base64: string, format: ImageFormat, detail?: 'low' | 'high' | 'auto'): ImageContent;
    /**
     * Create image content from file
     */
    fromFile(file_path: string, detail?: 'low' | 'high' | 'auto'): Promise<ImageContent>;
    /**
     * Validate image
     */
    validate(image: ImageContent): {
        valid: boolean;
        error?: string;
    };
    /**
     * Extract metadata from image
     */
    extractMetadata(image: ImageContent): Promise<ImageMetadata>;
    /**
     * Estimate token cost for image
     */
    estimateTokens(image: ImageContent, detail?: 'low' | 'high'): number;
    /**
     * Detect image format from file path or data
     */
    private detectFormat;
}
export declare class MultimodalMessageBuilder {
    private content;
    /**
     * Add text
     */
    addText(text: string): this;
    /**
     * Add image from URL
     */
    addImageURL(url: string, detail?: 'low' | 'high' | 'auto'): this;
    /**
     * Add image from base64
     */
    addImageBase64(base64: string, format: ImageFormat, detail?: 'low' | 'high' | 'auto'): this;
    /**
     * Build content array
     */
    build(): MultimodalContent[];
    /**
     * Clear content
     */
    clear(): this;
}
export declare class ImageProcessor {
    /**
     * Resize image - returns image with updated dimensions metadata
     * For actual pixel manipulation, integrate sharp or jimp library
     */
    resize(image: ImageContent, max_width: number, max_height: number): Promise<ImageContent>;
    /**
     * Convert image format - returns image with updated format metadata
     * For actual format conversion, integrate sharp or jimp library
     */
    convert(image: ImageContent, target_format: ImageFormat): Promise<ImageContent>;
    /**
     * Compress image - returns image with quality metadata
     * For actual compression, integrate sharp or jimp library
     */
    compress(image: ImageContent, quality: number): Promise<ImageContent>;
    /**
     * Extract text from image using OCR
     * Returns empty string - integrate Tesseract.js or Cloud Vision API for real OCR
     */
    extractText(image: ImageContent): Promise<string>;
}
export declare class VisionFormatConverter {
    /**
     * Convert to OpenAI format
     */
    toOpenAI(content: MultimodalContent[]): unknown[];
    /**
     * Convert to Anthropic format
     */
    toAnthropic(content: MultimodalContent[]): unknown[];
    /**
     * Convert to Google format
     */
    toGoogle(content: MultimodalContent[]): unknown[];
    /**
     * Convert from provider-specific format
     */
    fromProviderFormat(format: 'openai' | 'anthropic' | 'google', data: unknown): MultimodalContent[];
}
//# sourceMappingURL=vision-manager.d.ts.map