import type { AnalyticsStoreAdapter } from "./index.js";
export type RecommendationAnalystMode = "deterministic" | "ai-assisted";
export type AnalystVerdict = "support" | "oppose" | "insufficient_evidence";
export interface AnalystRoute {
    readonly routeId: string;
    readonly displayName?: string;
    readonly remoteModelId?: string;
    readonly enabled?: boolean;
    readonly available?: boolean;
}
export interface AnalystPacket {
    readonly recommendationId: string;
    readonly poolId: string;
    readonly candidateRouteId: string;
    readonly currentOrder: readonly string[];
    readonly window?: {
        readonly from?: string;
        readonly to?: string;
    };
    readonly metrics: Readonly<Record<string, unknown>>;
    readonly scoreComponents: readonly Readonly<Record<string, unknown>>[];
    readonly basis: readonly string[];
}
export interface AnalystResult {
    readonly recommendationId: string;
    readonly routeId: string;
    readonly analyzedAt: string;
    readonly inputFingerprint: string;
    readonly verdict: AnalystVerdict;
    readonly suggestedMove?: string;
    readonly reasoningFactors: readonly string[];
    readonly caveats: readonly string[];
    readonly explanation: string;
}
export interface AnalystAnalysisRecord extends AnalystResult {
    readonly stale?: boolean;
}
export interface RecommendationAnalystSettings {
    readonly mode: RecommendationAnalystMode;
    readonly routeId?: string;
}
export interface RecommendationAnalystStatus {
    readonly state: "idle" | "running" | "completed" | "failed";
    readonly mode: RecommendationAnalystMode;
    readonly routeId?: string;
    readonly lastAnalysisAt?: string;
    readonly latest?: AnalystAnalysisRecord;
    readonly message?: string;
}
export interface AnalystExecutionRequest {
    readonly routeId: string;
    readonly packet: AnalystPacket;
}
export interface RecommendationAnalystOptions {
    readonly store?: AnalyticsStoreAdapter;
    readonly routeProvider?: () => readonly AnalystRoute[] | Promise<readonly AnalystRoute[]>;
    readonly packetProvider?: (recommendationId?: string) => AnalystPacket | Promise<AnalystPacket>;
    readonly execute?: (request: AnalystExecutionRequest) => unknown | Promise<unknown>;
    readonly now?: () => string;
    readonly maxPacketBytes?: number;
}
export declare function analystInputFingerprint(packet: AnalystPacket): string;
export declare function validateAnalystPacket(value: unknown, maxBytes?: number): AnalystPacket;
export declare function validateAnalystResult(value: unknown, request: AnalystExecutionRequest, now: string): AnalystResult;
export declare class RecommendationAnalystService {
    private readonly options;
    private settings;
    private status;
    private readonly now;
    constructor(options?: RecommendationAnalystOptions);
    getSettings(): RecommendationAnalystSettings;
    setSettings(settings: RecommendationAnalystSettings): RecommendationAnalystSettings;
    getStatus(): RecommendationAnalystStatus;
    listVerificationRoutes(): Promise<readonly AnalystRoute[]>;
    listAnalyses(): readonly AnalystAnalysisRecord[];
    isStale(record: AnalystAnalysisRecord, packet: AnalystPacket): boolean;
    analyze(request: {
        readonly mode: RecommendationAnalystMode;
        readonly routeId: string;
        readonly packet?: AnalystPacket;
        readonly recommendationId?: string;
    }): Promise<RecommendationAnalystStatus>;
}
export declare const createRecommendationAnalyst: (options?: RecommendationAnalystOptions) => RecommendationAnalystService;