import type { RouteKitEvalGatewayCallEvent } from "@velum-labs/routekit-eval-service";
import type { EvalClassifierObservation, EvalExecutionPlan, EvalNamedEvent, EvalRunCleanup, EvalRunLedger, EvalRunTarget } from "@velum-labs/routekit-eval-setup";
import type { CostServiceShape } from "@velum-labs/routekit-registry";
import { Effect, FileSystem, Redacted, Ref } from "effect";
import { HttpClient } from "effect/unstable/http";
export type QualificationObservedCall = {
    readonly callId?: string;
    readonly role: "candidate" | "judge";
    readonly model: string;
    readonly measurement?: EvalClassifierObservation["measurement"];
};
export declare const qualificationGatewayCallObserver: <E = never, R = never>(observed: Ref.Ref<readonly QualificationObservedCall[]>, onIssued?: (call: QualificationObservedCall) => Effect.Effect<void, E, R>) => ((event: RouteKitEvalGatewayCallEvent) => Effect.Effect<void, E, R>);
export type QualificationEventContext = {
    readonly runId: string;
    readonly dimensionId: string;
    readonly caseId: string;
};
export declare const qualificationNamedEventObserver: <E, R>(context: QualificationEventContext, append: (event: EvalNamedEvent) => Effect.Effect<void, E, R>) => {
    readonly observeIssued: (call: QualificationObservedCall) => Effect.Effect<void, E, R>;
    readonly events: () => readonly EvalNamedEvent[];
};
export declare const observeQualificationCalls: (client: HttpClient.HttpClient, observed: Ref.Ref<readonly QualificationObservedCall[]>) => HttpClient.HttpClient;
export declare const includeQualificationObservedCalls: (ledger: EvalRunLedger, observed: readonly QualificationObservedCall[], costService: CostServiceShape) => Effect.Effect<EvalRunLedger>;
export type QualificationTarget = {
    readonly gatewayUrl: string;
    readonly bearerCredential: Redacted.Redacted<string>;
    readonly target: EvalRunTarget;
    readonly inspectCall?: (callId: string) => Effect.Effect<EvalClassifierObservation["measurement"], Error, HttpClient.HttpClient>;
};
export type BoundedEvalSessionTargetInput = {
    readonly operationId: string;
    readonly purpose: "authoring" | "qualification";
    readonly allowedModels: readonly string[];
    readonly limits: {
        readonly calls: number;
        readonly inputTokens: number;
        readonly outputTokens: number;
        readonly perCallOutputTokens: number;
        readonly wallTimeMs: number;
    };
    readonly expiresInSeconds: number;
};
export type QualificationTargetInput = {
    readonly operationId: string;
    readonly plan: EvalExecutionPlan;
    readonly gatewayUrl?: string;
    readonly tokenFile?: string;
};
export declare const makeQualificationCleanupRef: Effect.Effect<Ref.Ref<EvalRunCleanup>>;
/**
 * Shared bounded data-plane target for eval-owned model calls.
 *
 * It preflights the complete model allowlist once, opens the session before
 * any attributed call, and always closes through acquire/use/release.
 */
export declare function withBoundedEvalSessionTarget<A, E, R>(input: BoundedEvalSessionTargetInput, cleanup: Ref.Ref<EvalRunCleanup>, use: (target: QualificationTarget) => Effect.Effect<A, E, R>): Effect.Effect<A, E | Error, R>;
export declare function withQualificationTarget<A, E, R>(input: QualificationTargetInput, cleanup: Ref.Ref<EvalRunCleanup>, use: (target: QualificationTarget) => Effect.Effect<A, E, R>): Effect.Effect<A, E | Error, R | FileSystem.FileSystem>;