/**
 * ThinkHive SDK v3.0 - Conversation Evaluation API
 *
 * API for multi-turn conversation evaluation
 */
export type AggregateMethod = 'worst' | 'average' | 'weighted' | 'final_turn' | 'majority';
export interface SessionTrace {
    id: string;
    sessionId: string;
    turnNumber: number;
    userMessage: string;
    agentResponse: string;
    timestamp: string;
    metadata?: Record<string, unknown>;
}
export interface TurnEvaluation {
    traceId: string;
    turnNumber: number;
    passed: boolean;
    score: number;
    reasoning: string;
}
export interface ConversationEvalResult {
    sessionId: string;
    criterionId: string;
    turnCount: number;
    turnResults: TurnEvaluation[];
    aggregatePassed: boolean;
    aggregateScore: number;
    aggregateMethod: AggregateMethod;
    reasoning: string;
    metadata?: Record<string, unknown>;
}
export interface EvaluateConversationOptions {
    sessionId: string;
    criterionId: string;
    options?: {
        aggregateMethod?: AggregateMethod;
        minTurns?: number;
        maxTurns?: number;
    };
}
export interface AggregationMethodInfo {
    id: AggregateMethod;
    name: string;
    description: string;
    useCase: string;
}
/**
 * Conversation Evaluation API client for multi-turn evaluation
 */
export declare const conversationEval: {
    /**
     * Get traces for a conversation session
     *
     * @example
     * ```typescript
     * const traces = await conversationEval.getSessionTraces('session_123');
     * console.log(`Conversation has ${traces.length} turns`);
     * ```
     */
    getSessionTraces(sessionId: string): Promise<SessionTrace[]>;
    /**
     * Run conversation-level evaluation
     *
     * @example
     * ```typescript
     * const result = await conversationEval.evaluate({
     *   sessionId: 'session_123',
     *   criterionId: 'criterion_456',
     *   options: {
     *     aggregateMethod: 'average',
     *     minTurns: 2,
     *   },
     * });
     * console.log(`Conversation score: ${result.aggregateScore}`);
     * ```
     */
    evaluate(options: EvaluateConversationOptions): Promise<ConversationEvalResult>;
    /**
     * Get available aggregation methods with descriptions
     *
     * @example
     * ```typescript
     * const methods = await conversationEval.getAggregationMethods();
     * for (const method of methods) {
     *   console.log(`${method.name}: ${method.description}`);
     * }
     * ```
     */
    getAggregationMethods(): Promise<AggregationMethodInfo[]>;
};
/**
 * Calculate worst-turn aggregation
 *
 * @param turnResults - Array of turn evaluation results
 * @returns Aggregated result using worst turn logic
 *
 * @example
 * ```typescript
 * const result = aggregateWorst(turnResults);
 * // Fails if any turn fails
 * ```
 */
export declare function aggregateWorst(turnResults: TurnEvaluation[] | number[]): number | {
    passed: boolean;
    score: number;
};
/**
 * Calculate average aggregation
 *
 * Accepts TurnEvaluation[] or simple number[]:
 * - aggregateAverage(turnResults)  — returns {passed, score}
 * - aggregateAverage([0.6, 0.8])   — returns 0.7
 *
 * @param turnResults - Array of turn evaluation results or numbers
 * @returns Aggregated result
 */
export declare function aggregateAverage(turnResults: TurnEvaluation[] | number[]): number | {
    passed: boolean;
    score: number;
};
/**
 * Calculate weighted average aggregation (later turns weighted more)
 *
 * @param turnResults - Array of turn evaluation results
 * @returns Aggregated result using weighted average logic
 *
 * @example
 * ```typescript
 * const result = aggregateWeighted(turnResults);
 * // Later turns have higher weight
 * ```
 */
export declare function aggregateWeighted(turnResults: TurnEvaluation[]): {
    passed: boolean;
    score: number;
};
/**
 * Calculate final-turn aggregation
 *
 * @param turnResults - Array of turn evaluation results
 * @returns Aggregated result using only the final turn
 *
 * @example
 * ```typescript
 * const result = aggregateFinalTurn(turnResults);
 * // Only final turn matters
 * ```
 */
export declare function aggregateFinalTurn(turnResults: TurnEvaluation[]): {
    passed: boolean;
    score: number;
};
/**
 * Calculate majority vote aggregation
 *
 * @param turnResults - Array of turn evaluation results
 * @returns Aggregated result using majority vote logic
 *
 * @example
 * ```typescript
 * const result = aggregateMajority(turnResults);
 * // Passes if majority of turns pass
 * ```
 */
export declare function aggregateMajority(turnResults: TurnEvaluation[]): {
    passed: boolean;
    score: number;
};
/**
 * Get appropriate aggregation function for a method
 *
 * @param method - Aggregation method name
 * @returns Aggregation function
 */
export declare function getAggregator(method: AggregateMethod): (turnResults: TurnEvaluation[]) => {
    passed: boolean;
    score: number;
};
/**
 * Find problematic turns in a conversation
 *
 * @param result - Conversation evaluation result
 * @param scoreThreshold - Minimum acceptable score (default 70)
 * @returns Array of problematic turn results
 */
export declare function getProblematicTurns(result: ConversationEvalResult, scoreThreshold?: number): TurnEvaluation[];
/**
 * Calculate conversation quality trend
 *
 * @param result - Conversation evaluation result
 * @returns Trend analysis
 */
export declare function analyzeConversationTrend(result: ConversationEvalResult): {
    direction: 'improving' | 'declining' | 'stable';
    firstHalfAvg: number;
    secondHalfAvg: number;
};