import { AICapabilities, AIInterface, AIMessage, AIModel, AIResponse, AnthropicOptions, ChatOptions, CompletionOptions, EmbeddingOptions, EmbeddingResponse, ImageDescriptionOptions, ImageEmbeddingOptions, ImageGenerationOptions, ImageGenerationResponse, MessageOptions, TTSOptions, TTSResponse, VideoGenerationJob, VideoGenerationOptions, VideoGenerationResult, VideoGenerationStatusResult, Voice, VoiceCloneOptions, VoiceDesignOptions, VoiceListOptions } from '../types';
/**
 * Anthropic Claude provider implementation that handles all interactions with Anthropic's API.
 * Supports Claude models, streaming, vision capabilities, and function calling.
 * Does not support embeddings (use OpenAI or another provider for embeddings).
 */
export declare class AnthropicProvider implements AIInterface {
    private options;
    private client;
    /**
     * Creates a new Anthropic provider instance
     * @param options - Configuration options for the Anthropic provider
     */
    constructor(options: AnthropicOptions);
    private initializeClientSync;
    /**
     * Ensures the Anthropic client is initialized by dynamically importing the SDK
     * @throws {AIError} When the Anthropic SDK cannot be loaded
     * @private
     */
    private ensureClient;
    /**
     * Generate a chat completion using Claude models
     * @param messages - Array of conversation messages
     * @param options - Optional configuration for the chat completion
     * @returns Promise resolving to the AI response with content and metadata
     * @throws {AIError} When the API request fails or SDK is not available
     *
     * @example
     * ```typescript
     * const response = await provider.chat([
     *   { role: 'system', content: 'You are a helpful assistant.' },
     *   { role: 'user', content: 'Explain quantum computing' }
     * ], {
     *   model: 'claude-3-5-sonnet-20241022',
     *   maxTokens: 1000
     * });
     * ```
     */
    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIResponse>;
    complete(prompt: string, options?: CompletionOptions): Promise<AIResponse>;
    /**
     * Simple message interface for single-turn interactions with optional history
     *
     * @param text - The message text to send
     * @param options - Configuration options including history, model, etc.
     * @returns Promise resolving to the response content string
     *
     * @example
     * ```typescript
     * // Simple usage
     * const response = await provider.message('Hello!');
     *
     * // With history
     * const response = await provider.message('What was my question?', {
     *   history: [
     *     { role: 'user', content: 'What is 2+2?' },
     *     { role: 'assistant', content: '4' }
     *   ]
     * });
     * ```
     */
    message(text: string, options?: MessageOptions): Promise<string>;
    embed(_text: string | string[], _options?: EmbeddingOptions): Promise<EmbeddingResponse>;
    embedImage(_image: string | Buffer, _options?: ImageEmbeddingOptions): Promise<EmbeddingResponse>;
    describeImage(_image: string | Buffer, _prompt?: string, _options?: ImageDescriptionOptions): Promise<string>;
    generateImage(_prompt: string, _options?: ImageGenerationOptions): Promise<ImageGenerationResponse>;
    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<string>;
    countTokens(text: string): Promise<number>;
    getModels(): Promise<AIModel[]>;
    getCapabilities(): Promise<AICapabilities>;
    submitVideoGenerationJob(_options: VideoGenerationOptions): Promise<VideoGenerationJob>;
    getVideoGenerationJob(_handle: VideoGenerationJob): Promise<VideoGenerationStatusResult>;
    fetchVideoGenerationResult(_handle: VideoGenerationJob): Promise<VideoGenerationResult>;
    cancelVideoGenerationJob(_handle: VideoGenerationJob): Promise<void>;
    validateVideoGenerationAccess(): Promise<boolean>;
    synthesizeSpeech(_text: string, _options?: TTSOptions): Promise<TTSResponse>;
    streamSpeech(_text: string, _options?: TTSOptions): AsyncIterable<Buffer>;
    cloneVoice(_options: VoiceCloneOptions): Promise<Voice>;
    designVoice(_options: VoiceDesignOptions): Promise<Voice>;
    getVoices(_options?: VoiceListOptions): Promise<Voice[]>;
    private mapMessagesToAnthropic;
    private mapToolChoice;
    private mapFinishReason;
    private mapError;
}
//# sourceMappingURL=anthropic.d.ts.map