import type { AutoModelPreference } from './copilot-identity.ts';
import { z } from 'zod';
import type { AutoSelectionExplanation } from './auto-model-routing.ts';
import type { AutoAllocationSummary } from './auto-allocation-evidence.ts';
export declare const TurnSelectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    mode: z.ZodLiteral<"unknown">;
}, z.core.$strict>, z.ZodObject<{
    mode: z.ZodLiteral<"manual">;
}, z.core.$strict>, z.ZodObject<{
    mode: z.ZodLiteral<"auto">;
    preference: z.ZodEnum<{
        balance: "balance";
        efficiency: "efficiency";
        intelligence: "intelligence";
    }>;
    reason: z.ZodEnum<{
        "short-text-turn": "short-text-turn";
        "standard-turn": "standard-turn";
        "large-structured-turn": "large-structured-turn";
        "image-capability": "image-capability";
    }>;
    candidateCount: z.ZodNumber;
    fittingCandidateCount: z.ZodOptional<z.ZodNumber>;
    explanation: z.ZodOptional<z.ZodObject<{
        assessment: z.ZodObject<{
            demand: z.ZodEnum<{
                unknown: "unknown";
                simple: "simple";
                routine: "routine";
                complex: "complex";
            }>;
            signals: z.ZodArray<z.ZodEnum<{
                reasoning: "reasoning";
                "context-omitted": "context-omitted";
                "isolated-greeting": "isolated-greeting";
                "bounded-transformation": "bounded-transformation";
                investigation: "investigation";
                continuation: "continuation";
                "insufficient-evidence": "insufficient-evidence";
            }>>;
            source: z.ZodEnum<{
                local: "local";
                semantic: "semantic";
            }>;
            diagnostic: z.ZodOptional<z.ZodEnum<{
                disabled: "disabled";
                unavailable: "unavailable";
                failed: "failed";
                "context-omitted": "context-omitted";
                "invalid-result": "invalid-result";
                timeout: "timeout";
            }>>;
            semantic: z.ZodOptional<z.ZodObject<{
                modelId: z.ZodOptional<z.ZodString>;
                budgetMs: z.ZodNumber;
                elapsedMs: z.ZodNumber;
                stage: z.ZodEnum<{
                    preparing: "preparing";
                    "model-selected": "model-selected";
                    "adapter-started": "adapter-started";
                    "text-received": "text-received";
                    finished: "finished";
                }>;
                adapterStartedMs: z.ZodOptional<z.ZodNumber>;
                firstTextMs: z.ZodOptional<z.ZodNumber>;
                nativeFinish: z.ZodOptional<z.ZodEnum<{
                    stop: "stop";
                    "non-stop": "non-stop";
                }>>;
                outputCharacters: z.ZodNumber;
                validation: z.ZodEnum<{
                    invalid: "invalid";
                    "not-validated": "not-validated";
                    valid: "valid";
                    "context-omitted": "context-omitted";
                }>;
            }, z.core.$strict>>;
        }, z.core.$strict>;
        targetCategory: z.ZodEnum<{
            powerful: "powerful";
            versatile: "versatile";
            lightweight: "lightweight";
        }>;
        selectedCategory: z.ZodEnum<{
            unknown: "unknown";
            powerful: "powerful";
            versatile: "versatile";
            lightweight: "lightweight";
        }>;
        categoryCandidateCount: z.ZodNumber;
        method: z.ZodEnum<{
            continuity: "continuity";
            "equal-distribution": "equal-distribution";
            "weighted-distribution": "weighted-distribution";
            "only-candidate": "only-candidate";
            "no-fit": "no-fit";
        }>;
        fallback: z.ZodBoolean;
        allocation: z.ZodOptional<z.ZodObject<{
            policyVersion: z.ZodLiteral<"high-cost-v1">;
            selectedModelId: z.ZodString;
            candidates: z.ZodArray<z.ZodObject<{
                modelId: z.ZodString;
                highCost: z.ZodBoolean;
                previous: z.ZodBoolean;
                weight: z.ZodNumber;
                expectedShare: z.ZodNumber;
            }, z.core.$strict>>;
        }, z.core.$strict>>;
    }, z.core.$strict>>;
}, z.core.$strict>], "mode">;
export type TurnSelection = {
    readonly mode: 'unknown';
} | {
    readonly mode: 'manual';
} | {
    readonly mode: 'auto';
    readonly preference: AutoModelPreference;
    readonly reason: 'short-text-turn' | 'standard-turn' | 'large-structured-turn' | 'image-capability';
    readonly candidateCount: number;
    readonly fittingCandidateCount?: number;
    readonly explanation?: AutoSelectionExplanation;
};
/** Ephemeral decision evidence only; never session content, model usage or credentials. */
export declare class TurnSelectionStore {
    private readonly agents;
    private timestamps;
    record(agent: object, turn: number, selection: TurnSelection): void;
    get(agent: object, turn: number): TurnSelection;
    allocationSummary(agent: object): AutoAllocationSummary;
    remove(agent: object): void;
    clear(): void;
}
//# sourceMappingURL=turn-selection.d.ts.map