import type { IncomingHttpHeaders } from "node:http";
import type { RequestAttribution } from "@velum-labs/routekit-contracts";
import { type AutoRoutingDecision, type AnyPublishedRoutingActivation, type RequestRoutingRequirements, type RoutingCandidateDecision, type RoutingObjectivePolicy } from "@velum-labs/routekit-eval-contracts";
import type { RoutingModelAvailability, RoutingScoreConstraints } from "@velum-labs/routekit-eval-core";
import type { RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
import { Effect } from "effect";
import type { RequestDecomposerService } from "../services/request-decomposer/service.js";
import { type RequestDialectV3 } from "./task-context.js";
declare const RoutingPolicyReadError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "RoutingPolicyReadError";
} & Readonly<A>;
export declare class RoutingPolicyReadError extends RoutingPolicyReadError_base<{
    readonly profileId: string;
    readonly message: string;
    readonly cause?: unknown;
}> {
}
/** Read-only online projection of the authoritative routing activation. */
export type CompositionalRoutingPolicyReader = Readonly<{
    getActivation(profileName?: string, repositoryRoot?: string): Effect.Effect<AnyPublishedRoutingActivation | undefined, RoutingPolicyReadError, RouteKitPlatform>;
}>;
export declare function compositionalRoutingPolicyReaderFromActivation(activation: AnyPublishedRoutingActivation | undefined): CompositionalRoutingPolicyReader;
export declare function authoritativeRoutingActivation(reader: CompositionalRoutingPolicyReader, profileName?: string, repositoryRoot?: string): Effect.Effect<AnyPublishedRoutingActivation | undefined, RoutingPolicyReadError, RouteKitPlatform>;
declare const AutoRoutingUnavailableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "AutoRoutingUnavailableError";
} & Readonly<A>;
export declare class AutoRoutingUnavailableError extends AutoRoutingUnavailableError_base<{
    readonly profileId: string | undefined;
    readonly message: string;
    readonly cause?: unknown;
}> {
}
declare const EvalAutoRoutingForbiddenError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
    readonly _tag: "EvalAutoRoutingForbiddenError";
} & Readonly<A>;
export declare class EvalAutoRoutingForbiddenError extends EvalAutoRoutingForbiddenError_base<{
    readonly message: string;
}> {
}
export type CompositionalRoutingObservation = Readonly<{
    status: "decided";
    decision: AutoRoutingDecision;
    classifierCallId?: string;
}> | Readonly<{
    status: "failed";
    message: string;
    candidates?: readonly RoutingCandidateDecision[];
}>;
export type CompositionalRoutingRuntime = Readonly<{
    policyReader?: CompositionalRoutingPolicyReader;
    classifier?: RequestDecomposerService;
    availableModels: readonly RoutingModelAvailability[];
    objective: RoutingObjectivePolicy;
    maximumUnknownWeight: number;
    constraints?: RoutingScoreConstraints;
    onObservation?(observation: CompositionalRoutingObservation): void;
}>;
export declare function compositionalRoutingAttribution(observation: Extract<CompositionalRoutingObservation, {
    status: "decided";
}>): NonNullable<RequestAttribution["compositional_routing"]>;
export declare function isAutoRoutingModel(model: unknown): boolean;
export declare function evalPolicyBypassRequested(headers: IncomingHttpHeaders): boolean;
export declare function evalRequestAttribution(headers: IncomingHttpHeaders): NonNullable<RequestAttribution["eval"]> | undefined;
/** Reject eval traffic that would fall through to the auto-router. */
export declare function evalAutoRouterRejection(headers: IncomingHttpHeaders, model: unknown): string | undefined;
/**
 * Resolve `model: "auto"` against the model-by-dimension evidence matrix.
 */
export declare function resolveCompositionalAutoRoutingModel(options: Readonly<{
    headers: IncomingHttpHeaders;
    model: string | undefined;
    requestText?: string;
    requirements: RequestRoutingRequirements;
    policyReader?: CompositionalRoutingPolicyReader;
    classifier?: RequestDecomposerService;
    availableModels: readonly RoutingModelAvailability[];
    objective: RoutingObjectivePolicy;
    maximumUnknownWeight: number;
    constraints?: RoutingScoreConstraints;
    profileName?: string;
    onDecision?(decision: AutoRoutingDecision, classifierCallId?: string): void;
}>): Effect.Effect<string | undefined, AutoRoutingUnavailableError | EvalAutoRoutingForbiddenError, RouteKitPlatform>;
/** Apply the authoritative dimension-decomposition and evidence-matrix auto-router. */
export declare function resolveConfiguredAutoRoutingModel(options: Readonly<{
    headers: IncomingHttpHeaders;
    model: string | undefined;
    requestText?: string;
    requestBody?: unknown;
    dialect?: RequestDialectV3;
    requirements: RequestRoutingRequirements;
    onCompositionalObservation?(observation: CompositionalRoutingObservation): void;
    compositionalRouting?: CompositionalRoutingRuntime;
}>): Effect.Effect<string | undefined, AutoRoutingUnavailableError | EvalAutoRoutingForbiddenError, RouteKitPlatform>;
export {};