/**
 * Extended Thinking Engine
 *
 * Enables deep, structured reasoning before generating responses.
 * Implements multiple reasoning strategies including:
 * - Chain-of-thought reasoning
 * - Self-consistency decoding
 * - Verification and contradiction detection
 * - Multi-path exploration
 *
 * Inspired by Claude's Extended Thinking and research on reasoning in LLMs.
 */
import { EventEmitter } from "events";
import { ThinkingDepth, ThinkingConfig, ThinkingResult } from "./types.js";
/**
 * Extended Thinking Engine
 */
export declare class ExtendedThinkingEngine extends EventEmitter {
    private client;
    private config;
    private currentSession;
    constructor(apiKey: string, baseURL?: string, config?: Partial<ThinkingConfig>);
    /**
     * Think deeply about a problem
     */
    think(problem: string, context?: string, depth?: ThinkingDepth): Promise<ThinkingResult>;
    /**
     * Quick think - minimal reasoning for simple problems
     */
    quickThink(problem: string, context?: string): Promise<ThinkingResult>;
    /**
     * Deep think - thorough reasoning for complex problems
     */
    deepThink(problem: string, context?: string): Promise<ThinkingResult>;
    /**
     * Generate the next thought in a chain
     */
    private generateThought;
    /**
     * Parse a thought from LLM response
     */
    private parseThought;
    /**
     * Verify a thought for logical consistency
     */
    private verifyThought;
    /**
     * Create a branch to explore an alternative reasoning path
     */
    private createBranch;
    /**
     * Synthesize final answer from all reasoning chains
     */
    private synthesize;
    /**
     * Check self-consistency across multiple reasoning chains
     */
    private checkSelfConsistency;
    /**
     * Parse synthesis response into result
     */
    private parseSynthesis;
    /**
     * Create result from self-consistency check
     */
    private createResultFromConsistency;
    /**
     * Create fallback result when synthesis fails
     */
    private createFallbackResult;
    /**
     * Check if thinking should continue
     */
    private shouldContinueThinking;
    /**
     * Check if a thought should be verified
     */
    private shouldVerify;
    /**
     * Check if should create a branch
     */
    private shouldBranch;
    /**
     * Create a contradiction thought
     */
    private createContradictionThought;
    /**
     * Helper methods
     */
    private createSession;
    private createChain;
    private getActiveChain;
    private selectNextChain;
    private createId;
    private formatThought;
    private getThoughtIcon;
    /**
     * Format result for display
     */
    formatResult(result: ThinkingResult): string;
    /**
     * Get/set configuration
     */
    getConfig(): ThinkingConfig;
    setConfig(config: Partial<ThinkingConfig>): void;
    setDepth(depth: ThinkingDepth): void;
}
/**
 * Create an extended thinking engine
 */
export declare function createExtendedThinkingEngine(apiKey: string, baseURL?: string, config?: Partial<ThinkingConfig>): ExtendedThinkingEngine;
export declare function getExtendedThinkingEngine(apiKey: string, baseURL?: string): ExtendedThinkingEngine;
export declare function resetExtendedThinkingEngine(): void;
