import { type ClassifierConfigV3 as ClassifierConfigV3Type, type CompositionPolicyConfigV3 as CompositionPolicyConfigV3Type, type IndependentDimensionScoresV3 as IndependentDimensionScoresV3Type, type RequestDecomposition as RequestDecompositionType, type RequestRoutingRequirements, type RoutingBasisV3 as RoutingBasisV3Type } from "@velum-labs/routekit-eval-contracts";
import { type ClassificationMetricsV3 } from "@velum-labs/routekit-eval-core";
import { type RequestDialectV3, simulateCompositionalRequestV3 } from "@velum-labs/routekit-gateway/routing";
import { type RegistryModelPricing } from "@velum-labs/routekit-registry";
import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
import { Effect, FileSystem, Path } from "effect";
import type { EvalLabClassifyResult, EvalLabCompareResult } from "./eval-lab-contracts.js";
export type { EvalLabClassifyPlan, EvalLabClassifyResult, EvalLabComparePlan, EvalLabCompareResult, EvalLabCompareRow } from "./eval-lab-contracts.js";
export type ClassifierLabPresetV3 = "quality-v1" | "quality-snippets-offline-v1" | "context-16k-offline-v1";
export type EffectiveClassifierLabVariantV3 = {
    preset: ClassifierLabPresetV3;
    classifierImplementation: "luna-direct-v1";
    classifierModel: string;
    basisDigest: string;
    context: ClassifierConfigV3Type["context"];
    contextSerializerVersion: "task-context-v1";
    repositoryFacetDetail: ClassifierConfigV3Type["repositoryFacetDetail"];
    dimensionDefinitionBundle: ClassifierConfigV3Type["dimensionDefinitionBundle"];
    basisRendererVersion: "routing-basis-v1";
    definitionOrder: ClassifierConfigV3Type["definitionOrder"];
    promptProcedure: "direct";
    structuredOutputMode: "json-schema-strict-v1";
    reasoningEffort: ClassifierConfigV3Type["reasoningEffort"];
    maxCompletionTokens: number;
    timeoutMs: number;
    malformedRetries: 0 | 1;
    policy: CompositionPolicyConfigV3Type;
    promptDigest: string;
    correctionPromptDigest: string;
    responseSchemaDigest: string;
    classifierConfigurationDigest: string;
    policyDigest: string;
    labVariantDigest: string;
    execution: {
        possible: true;
        expectedPaidCalls: 0;
        target: "not-resolved";
    };
};
export declare function effectiveClassifierLabVariantV3(basis: RoutingBasisV3Type, preset: ClassifierLabPresetV3, classifierModel?: string): EffectiveClassifierLabVariantV3;
export declare function evalLabConfigCommand(input: {
    basisPath: string;
    preset: ClassifierLabPresetV3;
    classifierModel?: string;
}): Effect.Effect<EffectiveClassifierLabVariantV3, unknown, RouteKitPlatform>;
export declare function classifierConfigFromVariant(variant: EffectiveClassifierLabVariantV3): ClassifierConfigV3Type;
export declare function resolveModelPricing(model: string): RegistryModelPricing | undefined;
export declare function estimateCostUsd(pricing: RegistryModelPricing, inputTokens: number, outputTokens: number): number;
export type EvalLabClassifySource = {
    readonly kind: "request";
    readonly value: string;
} | {
    readonly kind: "request-file";
    readonly path: string;
} | {
    readonly kind: "conversation-file";
    readonly path: string;
} | {
    readonly kind: "stdin";
};
export type EvalLabClassifyBudgets = {
    maxPrimaryCalls?: number;
    maxAttempts?: number;
    maxTotalInputTokens?: number;
    maxTotalOutputTokens?: number;
    maximumPricedExposureUsd?: number;
    acknowledgeUnpricedExposure: boolean;
};
export declare function evalLabClassifyCommand(input: {
    basisPath: string;
    source: EvalLabClassifySource;
    dialect: RequestDialectV3;
    preset: ClassifierLabPresetV3;
    classifierModel?: string;
    execute: boolean;
    budgets: EvalLabClassifyBudgets;
    outputPath?: string;
}): Effect.Effect<EvalLabClassifyResult, unknown, RouteKitPlatform>;
export type EvalLabCompareBudgets = EvalLabClassifyBudgets;
export declare function evalLabCompareCommand(input: {
    basisPath: string;
    datasetPath: string;
    presets: readonly ClassifierLabPresetV3[];
    classifierModel?: string;
    repetitions: number;
    concurrency: number;
    execute: boolean;
    budgets: EvalLabCompareBudgets;
    outputPath?: string;
}): Effect.Effect<EvalLabCompareResult, unknown, RouteKitPlatform>;
export type EvalLabSimulationResult = {
    activationDigest: string;
    basisDigest: string;
    classificationConfigurationDigest: string;
    policy: CompositionPolicyConfigV3Type;
    policyDigest: string;
    activeDimensionIds: readonly string[];
    weights: readonly {
        dimensionId: string;
        weight: number;
    }[];
    candidates: ReturnType<typeof simulateCompositionalRequestV3>["candidates"];
    selectedModel: string;
    fallbackModels: readonly string[];
    fallbackReason?: string;
    modelCalls: 0;
};
export declare function evalLabSimulateCommand(input: {
    activationPath: string;
    classificationPath: string;
    policy?: Partial<CompositionPolicyConfigV3Type>;
    requirements: RequestRoutingRequirements;
}): Effect.Effect<EvalLabSimulationResult, unknown, RouteKitPlatform>;
export type EvalLabReplayDimensionDifference = {
    dimensionId: string;
    v2Weight?: number;
    v3Score?: number;
    v3AdaptedWeight?: number;
};
export type EvalLabReplayCaseResult = {
    caseId: string;
    dialect?: RequestDialectV3;
    contextType?: string;
    v2: {
        unknownWeight: number;
        weights: RequestDecompositionType["weights"];
        selectedModel: string;
        fallbackModels: readonly string[];
        fallbackReason?: string;
    };
    v3: {
        unknownProbability: number;
        rawScores: IndependentDimensionScoresV3Type["scores"];
        activeDimensionIds: readonly string[];
        weights: readonly {
            dimensionId: string;
            weight: number;
        }[];
        selectedModel: string;
        fallbackModels: readonly string[];
        fallbackReason?: string;
    };
    comparison: {
        selectedModelAgreement: boolean;
        fallbackAgreement: boolean;
        dimensionDifferences: readonly EvalLabReplayDimensionDifference[];
        measuredWinner?: string;
        v2RoutingRegret?: number;
        v3RoutingRegret?: number;
    };
};
export type EvalLabReplayAggregate = {
    caseCount: number;
    selectedModelAgreementCount: number;
    selectedModelAgreementRate: number;
    fallbackDisagreementCount: number;
    v2FallbackCount: number;
    v3FallbackCount: number;
    outcomeCaseCount: number;
    v2MeasuredWinnerCount: number;
    v3MeasuredWinnerCount: number;
    v2MeanRoutingRegret?: number;
    v3MeanRoutingRegret?: number;
};
export type EvalLabReplayResult = {
    version: 1;
    datasetDigest: string;
    v2ActivationRevisionDigest: string;
    v3ActivationRevisionDigest: string;
    v2BasisDigest: string;
    v3BasisDigest: string;
    cases: readonly EvalLabReplayCaseResult[];
    aggregate: EvalLabReplayAggregate;
    modelCalls: 0;
};
export declare function evalLabReplayCommand(input: {
    v2ActivationPath: string;
    v3ActivationPath: string;
    datasetPath: string;
    outputPath?: string;
}): Effect.Effect<EvalLabReplayResult, unknown, FileSystem.FileSystem | Path.Path>;
export type EvalLabDatasetRole = "development" | "validation" | "final";
export type EvalLabSweepCell = ClassificationMetricsV3 & {
    unknownThreshold: number;
    activeDimensionThreshold: number;
};
export type EvalLabSweepResult = {
    datasetRole: EvalLabDatasetRole;
    datasetDigest: string;
    predictionCount: number;
    labelCount: number;
    invalidPredictionCount: number;
    invalidLabelCount: number;
    cells: readonly EvalLabSweepCell[];
    chosen?: EvalLabSweepCell;
    modelCalls: 0;
};
export declare function evalLabSweepCommand(input: {
    predictionsPath: string;
    labelsPath: string;
    datasetRole: EvalLabDatasetRole;
    unknownThresholds: readonly number[];
    activeDimensionThresholds: readonly number[];
    chooseBest: boolean;
}): Effect.Effect<EvalLabSweepResult, unknown, RouteKitPlatform>;