/**
 * Execution Anthropic Package
 *
 * Anthropic provider implementation for LLM execution.
 *
 * @packageDocumentation
 */

import { Model as AnthropicModel } from '@anthropic-ai/sdk/resources/messages/messages.js';

export { AnthropicModel }

/**
 * Anthropic Provider implementation
 */
declare class AnthropicProvider implements Provider {
    readonly name = "anthropic";
    /**
     * Check if this provider supports a given model
     */
    supportsModel(model: Model): boolean;
    /**
     * Execute a request against Anthropic
     */
    execute(request: Request_2, options?: ExecutionOptions): Promise<ProviderResponse>;
    /**
     * Execute a request with streaming response
     */
    executeStream(request: Request_2, options?: ExecutionOptions): AsyncIterable<StreamChunk>;
}
export { AnthropicProvider }
export default AnthropicProvider;

export declare const CLAUDE_HAIKU_LATEST: "claude-haiku-4-5";

/** Stable API identifiers for the latest generation (see Anthropic models documentation). */
export declare const CLAUDE_OPUS_LATEST: "claude-opus-4-6";

export declare const CLAUDE_SONNET_LATEST: "claude-sonnet-4-6";

/**
 * Create a new Anthropic provider instance
 */
export declare function createAnthropicProvider(): AnthropicProvider;

/**
 * Default model when the request and options omit `model`.
 * Uses the current flagship Sonnet; override with `ExecutionOptions.model` or `Request.model`.
 */
export declare const DEFAULT_ANTHROPIC_MODEL: "claude-sonnet-4-6";

export declare interface ExecutionOptions {
    apiKey?: string;
    model?: string;
    temperature?: number;
    maxTokens?: number;
    timeout?: number;
    retries?: number;
}

export declare interface Message {
    role: 'user' | 'assistant' | 'system' | 'developer' | 'tool';
    content: string | string[] | null;
    name?: string;
}

export declare type Model = string;

export declare interface Provider {
    readonly name: string;
    execute(request: Request_2, options?: ExecutionOptions): Promise<ProviderResponse>;
    executeStream?(request: Request_2, options?: ExecutionOptions): AsyncIterable<StreamChunk>;
    supportsModel?(model: Model): boolean;
}

export declare interface ProviderResponse {
    content: string;
    model: string;
    usage?: {
        inputTokens: number;
        outputTokens: number;
    };
    toolCalls?: Array<{
        id: string;
        type: 'function';
        function: {
            name: string;
            arguments: string;
        };
    }>;
}

declare interface Request_2 {
    messages: Message[];
    model: Model;
    responseFormat?: any;
    validator?: any;
    tools?: ToolDefinition[];
    addMessage(message: Message): void;
}
export { Request_2 as Request }

export declare interface StreamChunk {
    type: StreamChunkType;
    text?: string;
    toolCall?: {
        id?: string;
        index?: number;
        name?: string;
        argumentsDelta?: string;
    };
    usage?: {
        inputTokens: number;
        outputTokens: number;
        cacheCreationInputTokens?: number;
        cacheReadInputTokens?: number;
    };
}

export declare type StreamChunkType = 'text' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_end' | 'usage' | 'done';

export declare interface ToolDefinition {
    name: string;
    description: string;
    parameters: ToolParameterSchema;
}

export declare interface ToolParameterSchema {
    type: 'object';
    properties: Record<string, {
        type: string;
        description?: string;
        enum?: string[];
        items?: {
            type: string;
        };
        default?: any;
    }>;
    required?: string[];
    additionalProperties?: boolean;
}

/**
 * Package version
 */
export declare const VERSION = "0.0.1";

export { }