/**
 * Adaptive Assessment Framework
 *
 * Implements adaptive testing with:
 * - IRT-based item selection (Maximum Fisher Information)
 * - Content balancing across skills
 * - Termination criteria (precision, item count, time)
 * - Real-time ability estimation
 *
 * @packageDocumentation
 */
import type { SkillId, QuestionId, Question, Assessment, IRTParameters, IRTAbilityEstimate, AdaptiveState, AdaptiveConfig, ItemSelection, TerminationCriteria } from '../types/index.js';
import { type IRTResponse } from './irt.js';
/**
 * Default adaptive configuration
 */
export declare const ADAPTIVE_DEFAULTS: Required<AdaptiveConfig>;
/**
 * Default termination criteria
 */
export declare const TERMINATION_DEFAULTS: Required<TerminationCriteria>;
/**
 * Question pool for adaptive testing
 */
export interface QuestionPool {
    /** Available questions */
    questions: Map<QuestionId, Question>;
    /** IRT parameters for questions (if calibrated) */
    irtParams: Map<QuestionId, IRTParameters>;
    /** Questions by skill */
    bySkill: Map<SkillId, QuestionId[]>;
    /** Exposure counts (for exposure control) */
    exposureCounts: Map<QuestionId, number>;
    /** Total administrations */
    totalAdministrations: number;
}
/**
 * Active adaptive session
 */
export interface AdaptiveSession {
    /** Session ID */
    id: string;
    /** Assessment being administered */
    assessmentId: string;
    /** Learner ID */
    learnerId: string;
    /** Question pool */
    pool: QuestionPool;
    /** Administered questions in order */
    administeredQuestions: QuestionId[];
    /** Responses */
    responses: IRTResponse[];
    /** Current ability estimate */
    abilityEstimate: IRTAbilityEstimate;
    /** Content coverage counts */
    contentCoverage: Map<SkillId, number>;
    /** Start time */
    startTime: Date;
    /** Configuration */
    config: Required<AdaptiveConfig>;
    /** Termination criteria */
    termination: Required<TerminationCriteria>;
    /** Current state */
    state: AdaptiveState;
}
/**
 * Adaptive Assessment Engine
 *
 * Manages adaptive testing sessions with intelligent item selection.
 *
 * @example
 * ```typescript
 * const engine = new AdaptiveEngine();
 *
 * // Create session
 * const session = engine.createSession(pool, assessment, 'learner-1');
 *
 * // Get next question
 * const next = engine.selectNextQuestion(session);
 * if (next) {
 *   // Present question to learner...
 *   session = engine.recordResponse(session, next.questionId, true);
 * }
 *
 * // Check if complete
 * if (engine.shouldTerminate(session)) {
 *   const result = engine.getResult(session);
 * }
 * ```
 */
export declare class AdaptiveEngine {
    private readonly irtEstimator;
    constructor();
    /**
     * Create a new adaptive session
     */
    createSession(pool: QuestionPool, assessment: Assessment, learnerId: string, config?: AdaptiveConfig, termination?: TerminationCriteria): AdaptiveSession;
    /**
     * Select the next question using the configured strategy
     */
    selectNextQuestion(session: AdaptiveSession): ItemSelection | null;
    /**
     * Record a response and update ability estimate
     */
    recordResponse(session: AdaptiveSession, questionId: QuestionId, correct: boolean): AdaptiveSession;
    /**
     * Check if assessment should terminate
     */
    shouldTerminate(session: AdaptiveSession): boolean;
    /**
     * Get reason for termination
     */
    private getTerminationReason;
    /**
     * Get eligible questions based on constraints
     */
    private getEligibleQuestions;
    /**
     * Maximum Fisher Information selection
     */
    private selectMFI;
    /**
     * Kullback-Leibler information selection
     * (Simplified implementation - selects based on KL divergence)
     */
    private selectKL;
    /**
     * Expected Bayesian Information selection
     */
    private selectEBI;
    /**
     * Minimum Expected Posterior Variance selection
     */
    private selectMEPV;
    /**
     * Get session result
     */
    getResult(session: AdaptiveSession): {
        abilityEstimate: IRTAbilityEstimate;
        score: number;
        itemCount: number;
        elapsedMinutes: number;
        contentCoverage: Map<SkillId, number>;
        terminationReason: string;
    };
}
/**
 * Create question pool from questions with IRT parameters
 */
export declare function createQuestionPool(questions: Question[], getIRTParams?: (q: Question) => IRTParameters | undefined): QuestionPool;
/**
 * Create an adaptive engine
 */
export declare function createAdaptiveEngine(): AdaptiveEngine;
//# sourceMappingURL=adaptive.d.ts.map