import type { InferMode, InferContext, InferStrategy } from "../core/InferContext";
import { Observable } from "../core/observability/Observable";
import { AgentEvent } from "../core/observability/event_validation";
export type ReActMode = 'react' | 'direct';
export interface ComplexityScore {
    score: number;
    reason: string;
    matches: Array<{
        pattern: string;
        weight: number;
        match: string;
    }>;
}
export declare abstract class ReActModeStrategy extends Observable implements InferStrategy {
    protected complexityThreshold: number;
    protected currentMode: InferMode;
    abstract evaluateMode(context: InferContext): Promise<ReActMode>;
    protected abstract getSelectionReason(context: InferContext): string;
    protected calculateComplexity(input: string): ComplexityScore;
    evaluateStrategyMode(context: InferContext): Promise<InferMode>;
    generateEvent(methodName: string, result: any, error?: any): Partial<AgentEvent>;
    getCurrentMode(): InferMode;
    /**
     * Maps internal mode to schema-defined strategy type
     */
    protected mapModeToStrategy(mode: ReActMode): string;
    protected getStrategySpecificInfo(context: InferContext): Record<string, any>;
}
export interface PatternConfig {
    reactPatterns?: Map<RegExp, number>;
    directPatterns?: Map<RegExp, number>;
    complexityThreshold?: number;
}
export declare class KeywordBasedStrategy extends ReActModeStrategy {
    private activeReactPatterns;
    private activeDirectPatterns;
    private defaultReactPatterns;
    private defaultDirectPatterns;
    private detector;
    private langPatterns;
    constructor(config?: PatternConfig);
    addLanguagePattern(language: string, pattern: PatternConfig): void;
    protected calculateComplexity(input: string): ComplexityScore;
    protected getStrategySpecificInfo(context: InferContext): Record<string, any>;
    setActivePatterns(language: string, patterns: PatternConfig): void;
    evaluateMode(context: InferContext): Promise<ReActMode>;
    protected getSelectionReason(context: InferContext): string;
    private detectLanguage;
}
export declare class AutoSwitchingStrategy extends ReActModeStrategy {
    private contextThreshold;
    private contextHistory;
    private lastTransition;
    constructor();
    evaluateMode(context: InferContext): Promise<ReActMode>;
    protected getSelectionReason(context: InferContext): string;
    protected getStrategySpecificInfo(context: InferContext): Record<string, any>;
    private calculateStabilityScore;
}
export declare class UserPreferenceStrategy extends ReActModeStrategy {
    private preference;
    private preferenceTimestamp;
    private preferenceSource;
    constructor(preference: ReActMode, source?: string);
    evaluateMode(context: InferContext): Promise<ReActMode>;
    protected getSelectionReason(context: InferContext): string;
    protected getStrategySpecificInfo(context: InferContext): Record<string, any>;
}
export declare class ReActModeSelector {
    private strategy;
    private mode;
    constructor(strategy: ReActModeStrategy);
    setStrategy(strategy: ReActModeStrategy): void;
    evaluateMode(context: InferContext): Promise<ReActMode>;
    getCurrentMode(): ReActMode;
}