export interface GeminiMessage {
    role: "user" | "assistant" | "system";
    content: string;
}
export interface GeminiGenerationConfig {
    temperature?: number;
    maxTokens?: number;
    topP?: number;
    topK?: number;
    stopSequences?: string[];
}
export interface GeminiResponse {
    content: string;
    text?: string;
    model: string;
    finishReason?: string;
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
}
export interface GeminiVisualResponse {
    html: string;
    screenshot?: string;
    metadata: {
        model: string;
        timestamp: string;
        prompt: string;
    };
}
import { AIClient, AIClientOptions, AgentContext, GenerationResult } from "../interfaces/AIClient";
/**
 * Gemini API Client using official Google Generative AI SDK
 * Supports text generation, multimodal interaction, and visual generation
 */
export declare class GeminiClient implements AIClient {
    readonly clientType: "direct-api";
    readonly supportsTools = false;
    readonly supportsStreaming = false;
    private apiKey?;
    private genAI?;
    private model;
    private readonly MODELS;
    constructor();
    /**
     * Initialize SDK client
     */
    private initializeClient;
    /**
     * Get Gemini API key from environment
     */
    private getApiKey;
    /**
     * Check if Gemini client has a valid API key
     */
    hasApiKey(): boolean;
    /**
     * Set API key for Gemini API
     */
    setApiKey(apiKey: string): void;
    /**
     * Check connection to Gemini API
     */
    checkConnection(): Promise<boolean>;
    /**
     * Get GitHub token for text backups
     */
    private getGitHubToken;
    /**
     * Generate text completion using Gemini or GitHub Models (Fallback/Cost-Saving)
     */
    generateText(prompt: string, options?: AIClientOptions): Promise<string>;
    /**
     * Generate text and return full GenerationResult including token usage.
     * Use this when you need token counts for cost tracking.
     */
    generateTextResult(prompt: string, options?: AIClientOptions): Promise<GenerationResult>;
    /**
     * Internal generation logic that returns rich response
     */
    private executeGenerateText;
    /**
     * Convert simplified messages to SDK Content format
     */
    private convertMessagesToContent;
    /**
     * Generate visual screen (HTML + optional screenshot) using Gemini + nanobanana
     */
    generateVisualScreen(prompt: string, context?: {
        prd?: string;
        brand?: string;
        flows?: string;
        sampleData?: any;
    }, config?: GeminiGenerationConfig & {
        includeScreenshot?: boolean;
    }): Promise<GeminiVisualResponse>;
    private buildVisualPrompt;
    private extractHtml;
    /**
     * Generate component using Gemini
     */
    generateComponent(prompt: string, context?: AgentContext, options?: AIClientOptions): Promise<string>;
    /**
     * Generate component refinement using Gemini
     */
    generateComponentRefinement(componentCode: string, prompt: string, context?: AgentContext, options?: AIClientOptions): Promise<string>;
    /**
     * Generate text from image (Vision implementation of interface)
     */
    generateVisionText(prompt: string, imagePath: string, options?: AIClientOptions): Promise<string>;
    private generateScreenshot;
    /**
     * List available models
     */
    listModels(): Promise<string[]>;
    /**
     * Generate image using Gemini (Implement via Imagen or specific multimodal if available)
     * Note: Currently implemented as a placeholder for agentic fulfillment.
     */
    generateImage(prompt: string, outputPath: string, options?: AIClientOptions): Promise<string>;
    /**
     * Cleanup resources
     */
    cleanup(): Promise<void>;
    /**
     * Generate text from image input (multimodal)
     */
    generateFromImage(prompt: string, imagePath: string, config?: GeminiGenerationConfig & {
        systemPrompt?: string;
    }): Promise<GeminiResponse>;
    private getMimeType;
}
//# sourceMappingURL=geminiClient.d.ts.map