import { promises as fs } from "node:fs";
type OpenFileHandle = {
    appendFile(data: string, options?: BufferEncoding): Promise<void>;
    close(): Promise<void>;
};
type RoutingStateIO = {
    mkdir: typeof fs.mkdir;
    appendFile: typeof fs.appendFile;
    readFile: typeof fs.readFile;
    readdir: typeof fs.readdir;
    rename: typeof fs.rename;
    writeFile: typeof fs.writeFile;
    unlink: typeof fs.unlink;
    open: (path: string, flags: string) => Promise<OpenFileHandle>;
};
type AppendRoutingEventInput = {
    directory: string;
    event: RoutingEvent;
    maxRetries?: number;
    retryDelayMs?: number;
    io?: RoutingStateIO;
};
export type RotateActiveLogInput = {
    directory: string;
    now?: number;
    pid?: number;
    maxRetries?: number;
    retryDelayMs?: number;
    io?: RoutingStateIO;
    beforeCreateActiveLog?: () => Promise<void>;
};
export type RotateActiveLogResult = {
    rotated: boolean;
    skipped: boolean;
    segmentName?: string;
};
type CompactRoutingStateInput = {
    directory: string;
    now: number;
    io?: RoutingStateIO;
};
export type RoutingAccountState = {
    touchBuckets?: Record<string, number>;
    lastRateLimitedAt?: number;
};
export type RoutingSnapshot = {
    accounts: Record<string, RoutingAccountState>;
    appliedSegments?: string[];
};
export type SessionTouchEvent = {
    type: "session-touch";
    accountName: string;
    sessionID: string;
    at: number;
};
export type RateLimitFlaggedEvent = {
    type: "rate-limit-flagged";
    accountName: string;
    at: number;
    retryAfterMs?: number;
};
export type RouteDecisionEvent = {
    type: "route-decision";
    at: number;
    modelID?: string;
    chosenAccount: string;
    chosenAccountAuthFingerprint?: string;
    debugLinkId?: string;
    networkRequestUsedInitHeaders?: boolean;
    sessionID?: string;
    sessionIDPresent: boolean;
    groupSource: "model" | "active";
    candidateNames: string[];
    loads: Record<string, number>;
    reason: "regular" | "subagent" | "compaction" | "user-reselect" | "unbound-fallback" | "rate-limit-switch";
    switched: boolean;
    switchFrom?: string;
    switchBlockedBy?: "no-cooled-down-candidate" | "replacement-load-higher" | "routing-state-read-failed" | "no-replacement-candidate";
    touchWriteOutcome: "written" | "throttled" | "skipped-missing-session" | "failed";
    touchWriteError?: string;
    rateLimitMatched: boolean;
    retryAfterMs?: number;
    finalRequestHeaders?: Record<string, string>;
    networkRequestHeaders?: Record<string, string>;
};
export type RoutingEvent = SessionTouchEvent | RateLimitFlaggedEvent;
export declare function appendRouteDecisionEvent(input: {
    directory: string;
    event: RouteDecisionEvent;
}): Promise<void>;
export type AppendSessionTouchEventInput = {
    directory: string;
    accountName: string;
    sessionID: string;
    at: number;
    lastTouchWrites: Map<string, number>;
    appendEvent?: (input: {
        directory: string;
        event: RoutingEvent;
    }) => Promise<void>;
};
export declare function routingStatePath(): string;
export declare function appendRoutingEvent(input: AppendRoutingEventInput): Promise<void>;
export declare function appendSessionTouchEvent(input: AppendSessionTouchEventInput): Promise<boolean>;
export declare function buildCandidateAccountLoads(input: {
    snapshot: RoutingSnapshot;
    candidateAccountNames: string[];
    now: number;
}): Map<string, number>;
export declare function getAccountLastRateLimitedAt(snapshot: RoutingSnapshot, accountName: string): number | undefined;
export declare function isAccountRateLimitCooledDown(input: {
    snapshot: RoutingSnapshot;
    accountName: string;
    now: number;
    cooldownMs: number;
}): boolean;
export declare function foldRoutingEvents(base: RoutingSnapshot, events: RoutingEvent[]): RoutingSnapshot;
export declare function compactRoutingSnapshot(snapshot: RoutingSnapshot, now: number): RoutingSnapshot;
export declare function readRoutingState(directory: string): Promise<RoutingSnapshot>;
export declare function rotateActiveLog(input: RotateActiveLogInput): Promise<RotateActiveLogResult>;
export declare function compactRoutingState(input: CompactRoutingStateInput): Promise<RoutingSnapshot>;
export {};