/**
 * Pipeline step: Generate Promptfoo configuration files.
 *
 * ALL modes route through the Plugin Registry. The step looks up the mode
 * handler via ctx.registry.getMode() and delegates compilation to it.
 *
 * Literacy mode has a variant strategy: baseline/agentic/observed/full.
 * When the variant is "full", the handler is called twice (baseline + agentic)
 * and three YAML files are written. Other modes produce one YAML file.
 */
import { type AppContext, type ModelsConfig, type PipelineState, type PipelineStep, type StepResult, type ValidationIssue } from "../../_vendor/ailf-core/index.d.ts";
export declare class GenerateConfigsStep implements PipelineStep {
    readonly name = "generate-configs";
    /** Task IDs from the last loadTasks call (pre-filter), for error messages. */
    private lastLoadedTaskIds;
    check(ctx: AppContext): ValidationIssue[];
    execute(ctx: AppContext, state: PipelineState): Promise<StepResult>;
    private compileLiteracyVariants;
    private compileSingleMode;
    /**
     * Load tasks via ctx.taskSource — the single adapter wired by the
     * composition root for every taskSourceType (W0146). FetchDocsStep
     * and GenerateConfigsStep MUST go through the same adapter so configs
     * reference context files that were actually fetched.
     *
     * Filtering by area/task/tag is delegated to the adapter:
     * ContentLakeTaskSource pushes it into the GROQ query;
     * RepoTaskSource applies it in-memory.
     */
    private loadTasks;
    /**
     * Build a descriptive error message when no tasks match the current filters.
     * Distinguishes between "no tasks exist" and "tasks exist but filters exclude them".
     */
    private buildNoTasksError;
    /**
     * Compile all tasks through a handler, merging results.
     * For literacy mode, ctx can carry evalMode as an extension.
     */
    private compileAll;
    private checkLiteracyPostconditions;
    cacheInputs(ctx: AppContext): string[];
    cacheContext(ctx: AppContext): string[];
}
/**
 * Merge multiple compile results into one.
 *
 * Note: `providers` and `prompts` are taken from the first result only.
 * This is correct for single-mode compilation where all tasks share the
 * same provider set. Cross-mode merging with per-task provider overrides
 * would need deduplication here.
 */
/**
 * Apply `PipelineRequest.models` to the loaded model cohort (W0281).
 *
 * Returns one of three outcomes:
 *   - `unfiltered` — caller didn't pin any models; pass through.
 *   - `filtered`   — at least one requested ID matched the cohort; unknown
 *                    IDs are reported via a structured warning so callers
 *                    can detect typos.
 *   - `no-match`   — every requested ID is unknown. Caller wired this
 *                    step into a failure path so the rejection reason
 *                    surfaces on the job's `error` field, not silently.
 */
export type FilterModelsResult = {
    kind: "unfiltered";
    models: ModelsConfig;
} | {
    kind: "filtered";
    models: ModelsConfig;
} | {
    kind: "no-match";
    reason: string;
};
export declare function filterModelsByRequest(loaded: ModelsConfig, requested: string[] | undefined, logger: import("@sanity/ailf-core").Logger): FilterModelsResult;
