/**
 * `runRLCampaign` — top-level orchestrator that runs the matrix and
 * produces every RL-ready artifact in one call.
 *
 * Wires:
 *   1. `runEvalCampaign` for the matrix run (capture, integrity, hooks)
 *   2. `extractVerifiableReward` over each run, separating deterministic
 *      from probabilistic reward sources for the trainer
 *   3. `extractPreferences` to produce DPO/PPO/KTO triples
 *   4. `evaluateInterimReleaseConfidence` over paired deltas (anytime-valid)
 *   5. `rubricPredictiveValidity` against an outcome store, when provided
 *   6. `detectRewardHacking` as a standing hygiene check
 *   7. Trainer-format export rows ready for prime-rl / TRL / verl
 *
 * The output `RLCampaignResult` is a single, audit-ready artifact: every
 * stage's output is in there. The consumer's downstream fits in a single
 * line: pass `result.preferences` to their DPO trainer, `result.grpoRows`
 * to GRPO, `result.runs` plus `result.rewardSignals` to a custom RL loop.
 */
import { type EvalCampaignOptions, type EvalCampaignResult } from '../eval-campaign';
import type { OutcomeStore } from '../meta-eval/outcome-store';
import { type RubricPredictiveValidityReport } from '../meta-eval/rubric-predictive-validity';
import { type InterimReleaseConfidence } from '../sequential';
import { type DpoExportRow, type DpoLookups, type GrpoExportRow, type GrpoLookups, type SftExportRow, type SftLookups } from './exporters';
import { type ExtractPreferencesOptions, type PreferenceExtractionReport } from './preferences';
import { type RewardHackingReport } from './reward-hacking';
import { type VerifiableReward, type VerifiableRewardExtractionOptions } from './verifiable-reward';
export interface RunRLCampaignOptions<V> extends EvalCampaignOptions<V> {
    /** Preference-extraction options. Default uses paired-by-scenario-and-seed with min-margin 0.05. */
    preferences?: ExtractPreferencesOptions;
    /** Verifiable-reward extraction options. */
    verifiableReward?: VerifiableRewardExtractionOptions;
    /** Outcome store + metric names — when supplied, runs `rubricPredictiveValidity` post-campaign. */
    outcomeStore?: OutcomeStore;
    outcomeMetrics?: string[];
    /** Anytime-valid sequential evaluation options. */
    sequential?: {
        alpha?: number;
        bound?: number;
        rope?: {
            low: number;
            high: number;
        };
    };
    /** Trainer-format export lookups. When provided, the orchestrator builds the corresponding rows. */
    trainerExport?: {
        dpo?: DpoLookups;
        grpo?: GrpoLookups;
        sft?: SftLookups;
    };
}
export interface RLCampaignResult<V> {
    campaign: EvalCampaignResult;
    /** Per-run verifiable reward (deterministic when available, probabilistic fallback otherwise). */
    rewardSignals: Array<{
        runId: string;
        reward: VerifiableReward | null;
    }>;
    /** Preference extraction report. */
    preferences: PreferenceExtractionReport;
    /** Anytime-valid interim verdict over the paired deltas (vs comparator). */
    interimConfidence: InterimReleaseConfidence | null;
    /** Standing reward-hacking hygiene check. */
    rewardHacking: RewardHackingReport;
    /** Predictive validity, when an outcome store was supplied. */
    predictiveValidity: RubricPredictiveValidityReport | null;
    /** Trainer-export rows, populated only for the formats the caller requested via `trainerExport`. */
    trainerRows: {
        dpo?: DpoExportRow[];
        grpo?: GrpoExportRow[];
        sft?: SftExportRow[];
    };
    /**
     * One-line top-level summary the consumer can log.
     */
    summary: string;
    /**
     * Convenience type-tag — consumers can branch on `result.kind`.
     */
    kind: 'agent-eval-rl-campaign';
    unusedVariant?: V;
}
export declare function runRLCampaign<V>(opts: RunRLCampaignOptions<V>): Promise<RLCampaignResult<V>>;
export { runEvalCampaign } from '../eval-campaign';
//# sourceMappingURL=rl-campaign.d.ts.map