/**
 * OpenAI Chat Completion API compatible request
 */
export interface ChatCompletionRequest {
    model: string;
    messages: Array<{
        role: 'system' | 'user' | 'assistant';
        content: string;
    }>;
    max_tokens?: number;
    temperature?: number;
    top_p?: number;
    frequency_penalty?: number;
    presence_penalty?: number;
    stop?: string | string[];
    stream?: boolean;
}
/**
 * OpenAI Chat Completion API compatible response
 */
export interface ChatCompletionResponse {
    id: string;
    object: 'chat.completion';
    created: number;
    model: string;
    choices: Array<{
        index: number;
        message: {
            role: 'assistant';
            content: string;
        };
        finish_reason: 'stop' | 'length' | 'content_filter';
    }>;
    usage: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
}
/**
 * Mock response configuration
 */
export interface MockResponse {
    id: string;
    trigger: {
        modelPattern?: string;
        messagePattern?: string;
        exact?: boolean;
    };
    response: {
        content: string;
        tokens: {
            prompt: number;
            completion: number;
        };
        latencyMs?: number;
        errorRate?: number;
    };
    metadata?: {
        scenario: string;
        description: string;
        tags: string[];
    };
}
/**
 * Test scenario for automated testing
 */
export interface TestScenario {
    id: string;
    name: string;
    description: string;
    requests: ChatCompletionRequest[];
    expectedResponses: Partial<ChatCompletionResponse>[];
    validations: Array<{
        type: 'response_time' | 'token_count' | 'content_match' | 'cache_hit';
        threshold?: number;
        pattern?: string;
        expected?: boolean;
    }>;
}
/**
 * Test execution result
 */
export interface TestResult {
    scenarioId: string;
    passed: boolean;
    errors: string[];
    metrics: {
        totalRequests: number;
        avgResponseTime: number;
        cacheHitRate: number;
        totalTokens: number;
    };
    timestamp: Date;
}
/**
 * Mock LLM provider that mimics OpenAI's API for testing and development
 */
export declare class MockLLMProvider {
    private mockResponses;
    private testScenarios;
    private requestHistory;
    constructor();
    /**
     * Process chat completion request (OpenAI compatible)
     */
    createChatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
    /**
     * Find mock response matching the request
     */
    private findMatchingResponse;
    /**
     * Check if text matches pattern
     */
    private matchesPattern;
    /**
     * Add custom mock response
     */
    addMockResponse(mockResponse: MockResponse): void;
    /**
     * Load default mock responses for common scenarios
     */
    private loadDefaultResponses;
    /**
     * Add test scenario
     */
    addTestScenario(scenario: TestScenario): void;
    /**
     * Run automated test scenario
     */
    runTestScenario(scenarioId: string): Promise<TestResult>;
    /**
     * Validate response against criteria
     */
    private validateResponse;
    /**
     * Run all test scenarios
     */
    runAllTestScenarios(): Promise<TestResult[]>;
    /**
     * Get request history
     */
    getRequestHistory(limit?: number): typeof this.requestHistory;
    /**
     * Get test scenarios
     */
    getTestScenarios(): TestScenario[];
    /**
     * Get mock responses
     */
    getMockResponses(): MockResponse[];
    /**
     * Clear history (for testing)
     */
    clear(): void;
    /**
     * Load default test scenarios
     */
    loadDefaultTestScenarios(): void;
}
export declare const globalMockLLMProvider: MockLLMProvider;
//# sourceMappingURL=mock-llm-provider.d.ts.map