/**
 * @license
 * Copyright 2023 Nuraly, Laabidi Aymen
 * SPDX-License-Identifier: MIT
 */
import type { ChatbotProvider, ChatbotContext, ProviderCapabilities } from '../core/types.js';
import type { ChatbotFile } from '../chatbot.types.js';
export interface MockProviderConfig {
    /**
     * Response delay in milliseconds (simulates API latency)
     */
    delay?: number;
    /**
     * Enable streaming responses (character by character)
     */
    streaming?: boolean;
    /**
     * Streaming speed (characters per iteration)
     */
    streamingSpeed?: number;
    /**
     * Streaming interval in milliseconds
     */
    streamingInterval?: number;
    /**
     * Enable contextual responses (smarter responses based on keywords)
     */
    contextualResponses?: boolean;
    /**
     * Enable echo mode (echo back user's message)
     */
    echoMode?: boolean;
    /**
     * Custom responses to use instead of built-in ones
     */
    customResponses?: string[];
    /**
     * Error simulation rate (0-1, 0 = no errors, 1 = always error)
     */
    errorRate?: number;
    /**
     * Enable message history awareness
     */
    useHistory?: boolean;
    /**
     * Simulate tool calls before responding
     */
    simulateToolCalls?: boolean;
    /**
     * Tool names to simulate (default: ['search_web', 'get_weather', 'run_code'])
     */
    toolCallNames?: string[];
    /**
     * Delay per tool call in ms (default: 1500)
     */
    toolCallDelay?: number;
}
/**
 * Mock Provider for demo and testing purposes.
 * Simulates AI responses without requiring a real API.
 *
 * Features:
 * - Configurable response delay
 * - Streaming support (character-by-character)
 * - Contextual responses based on keywords
 * - Echo mode
 * - Custom responses
 * - Error simulation
 * - Message history awareness
 *
 * @example
 * ```typescript
 * const provider = new MockProvider({
 *   delay: 1000,
 *   streaming: true,
 *   contextualResponses: true
 * });
 *
 * const controller = new ChatbotCoreController({
 *   provider,
 *   ui: callbacks
 * });
 * ```
 */
export declare class MockProvider implements ChatbotProvider {
    readonly id = "mock-provider";
    readonly name = "Mock Provider";
    readonly capabilities: ProviderCapabilities;
    private config;
    private messageCount;
    private connected;
    /** Called when a tool/function call is detected */
    onToolCall?: (name: string) => void;
    /** Called when a tool/function call ends */
    onToolCallEnd?: () => void;
    constructor(config?: MockProviderConfig);
    connect(_config?: any): Promise<void>;
    disconnect(): Promise<void>;
    isConnected(): boolean;
    sendMessage(text: string, context?: ChatbotContext): AsyncIterator<string>;
    uploadFile(file: File): Promise<ChatbotFile>;
    private determineFileType;
    private generateResponse;
    private getContextualResponse;
    private getRandomResponse;
    private streamResponse;
    private delay;
    /**
     * Reset message count (useful for testing)
     */
    reset(): void;
    /**
     * Update configuration on the fly
     */
    updateConfig(config: Partial<MockProviderConfig>): void;
    /**
     * Get current configuration
     */
    getConfig(): Readonly<Required<MockProviderConfig>>;
}
/**
 * Pre-configured mock providers for common scenarios
 */
export declare const MockProviders: {
    /**
     * Fast responses, no streaming
     */
    fast: () => MockProvider;
    /**
     * Realistic API simulation with streaming
     */
    realistic: () => MockProvider;
    /**
     * Slow responses for testing loading states
     */
    slow: () => MockProvider;
    /**
     * Echo mode for debugging
     */
    echo: () => MockProvider;
    /**
     * Streaming mode for demo
     */
    streaming: () => MockProvider;
    /**
     * Error simulation for testing error handling
     */
    unreliable: () => MockProvider;
    /**
     * Custom responses
     */
    custom: (responses: string[]) => MockProvider;
};
//# sourceMappingURL=mock-provider.d.ts.map