/**
 * Extended Thinking Mode Types
 *
 * Defines types for the extended thinking system that enables
 * deep, structured reasoning before generating responses.
 *
 * Inspired by:
 * - Claude's Extended Thinking
 * - Chain-of-Thought prompting
 * - Self-consistency decoding
 */
/**
 * Thinking depth levels
 */
export type ThinkingDepth = "minimal" | "standard" | "extended" | "deep";
/**
 * A single thought in the thinking process
 */
export interface Thought {
    id: string;
    type: ThoughtType;
    content: string;
    confidence: number;
    reasoning?: string;
    evidence?: string[];
    alternatives?: string[];
    timestamp: number;
}
/**
 * Types of thoughts
 */
export type ThoughtType = "observation" | "analysis" | "hypothesis" | "verification" | "contradiction" | "synthesis" | "conclusion" | "uncertainty" | "question" | "action_plan";
/**
 * A reasoning chain - sequence of connected thoughts
 */
export interface ReasoningChain {
    id: string;
    thoughts: Thought[];
    status: "in_progress" | "completed" | "abandoned";
    conclusion?: string;
    confidence: number;
    branches?: ReasoningChain[];
}
/**
 * Thinking session containing multiple chains
 */
export interface ThinkingSession {
    id: string;
    problem: string;
    context?: string;
    depth: ThinkingDepth;
    chains: ReasoningChain[];
    activeChainId: string | null;
    startTime: number;
    endTime?: number;
    finalAnswer?: ThinkingResult;
    metadata: Record<string, unknown>;
}
/**
 * Result of extended thinking
 */
export interface ThinkingResult {
    answer: string;
    reasoning: string;
    confidence: number;
    thinkingTime: number;
    thoughtCount: number;
    chainsExplored: number;
    keyInsights: string[];
    uncertainties: string[];
    alternativeAnswers?: AlternativeAnswer[];
}
/**
 * An alternative answer considered
 */
export interface AlternativeAnswer {
    answer: string;
    confidence: number;
    reasoning: string;
    whyNotChosen: string;
}
/**
 * Configuration for extended thinking
 */
export interface ThinkingConfig {
    depth: ThinkingDepth;
    maxThoughts: number;
    maxChains: number;
    maxTime: number;
    temperature: number;
    selfConsistency: boolean;
    explorationRate: number;
    verificationEnabled: boolean;
    streamThinking: boolean;
    model?: string;
}
/**
 * Default configurations per depth
 */
export declare const THINKING_DEPTH_CONFIG: Record<ThinkingDepth, Partial<ThinkingConfig>>;
/**
 * Default configuration
 */
export declare const DEFAULT_THINKING_CONFIG: ThinkingConfig;
/**
 * Thinking prompts for different thought types
 */
export declare const THINKING_PROMPTS: Record<ThoughtType, string>;
/**
 * Events emitted during thinking
 */
export interface ThinkingEvents {
    "thinking:start": {
        session: ThinkingSession;
    };
    "thinking:thought": {
        thought: Thought;
        chain: ReasoningChain;
    };
    "thinking:chain:start": {
        chain: ReasoningChain;
    };
    "thinking:chain:complete": {
        chain: ReasoningChain;
    };
    "thinking:branch": {
        parent: ReasoningChain;
        branch: ReasoningChain;
    };
    "thinking:verification": {
        thought: Thought;
        verified: boolean;
    };
    "thinking:complete": {
        result: ThinkingResult;
    };
    "thinking:stream": {
        content: string;
    };
}
/**
 * Verification result
 */
export interface VerificationResult {
    thought: Thought;
    verified: boolean;
    confidence: number;
    issues?: string[];
    corrections?: string[];
}
/**
 * Self-consistency result
 */
export interface SelfConsistencyResult {
    answers: Array<{
        answer: string;
        confidence: number;
        reasoning: string;
    }>;
    consensusAnswer: string;
    consensusConfidence: number;
    disagreements: string[];
}
