import { type TransportBreaker } from "./breaker.js";
import type { TransportErrorCode } from "./errors.js";
export type TransportProvider = "codex" | "openai";
export type ConnectIntent = "demand" | "prewarm";
export type ConnectPermit = {
    scopeKey: string;
    probeToken?: number;
    intent: ConnectIntent;
    startedAt: number;
};
export type AdmissionResult = {
    ok: true;
    reason?: string;
    permit?: ConnectPermit;
} | {
    ok: false;
    reason: TransportErrorCode;
};
export type TransportCoordinatorOptions = {
    processMaxSockets?: number;
    maxSocketsPerProvider?: number;
    maxSocketsPerAccount?: number;
    maxConnecting?: number;
    prewarmMaxConnecting?: number;
    prewarmDemandReserve?: number;
    connectRateProcessPerMin?: number;
    connectRateProviderPerMin?: number;
    connectRateOriginPerMin?: number;
    connectRateAccountPerMin?: number;
    maxAccountingEntries?: number;
    queueMaxBytesPerStream?: number;
    queueMaxBytesTotal?: number;
    maxSessions?: number;
    eventLoopLagMs?: number;
    rssMb?: number;
    breaker?: TransportBreaker;
    now?: () => number;
    getRssMb?: () => number;
    getEventLoopLagMs?: () => number;
};
type Histogram = {
    bounds: number[];
    counts: number[];
};
export declare function canonicalWebSocketOrigin(raw: string): string;
export declare class TransportCoordinator {
    readonly processMaxSockets: number;
    readonly maxSocketsPerProvider: number;
    readonly maxSocketsPerAccount: number;
    readonly maxConnecting: number;
    readonly prewarmMaxConnecting: number;
    readonly prewarmDemandReserve: number;
    readonly maxAccountingEntries: number;
    readonly queueMaxBytesPerStream: number;
    readonly queueMaxBytesTotal: number;
    readonly maxSessions: number;
    readonly eventLoopLagMs: number;
    readonly rssMb: number;
    readonly breaker: TransportBreaker;
    readonly now: () => number;
    readonly getRssMb: () => number;
    readonly getEventLoopLagMs: () => number;
    private readonly rateLimits;
    private physicalSockets;
    private connecting;
    private prewarming;
    private sessions;
    private queuedInboundBytes;
    private queuedInboundMessages;
    private queueOverflows;
    private readonly providerQueues;
    private readonly providerSockets;
    private readonly accountSockets;
    private readonly rateWindows;
    private readonly streamQueues;
    private readonly finishedPermits;
    private lagMonitor;
    private lagTimer;
    private lastLagMs;
    private disposed;
    private readonly counters;
    private readonly histograms;
    constructor(opts?: TransportCoordinatorOptions);
    dispose(): void;
    private memoryBlocked;
    private isFixedRateKey;
    reserveSocket(input: {
        accountFp: string;
        provider: TransportProvider;
        intent: ConnectIntent;
    }): {
        ok: true;
        reason: "admitted";
    } | {
        ok: false;
        reason: TransportErrorCode;
    };
    releaseSocket(input: {
        accountFp: string;
        provider: TransportProvider;
    }): void;
    private pruneWindow;
    private rateBlock;
    private activeRateKeys;
    /** Make room for required rate keys without evicting process/provider windows. */
    private ensureRateCapacity;
    private recordRates;
    private boundRateWindows;
    startConnect(input: {
        intent: ConnectIntent;
        provider: TransportProvider;
        origin: string;
        accountFp: string;
        scopeKey: string;
    }): {
        ok: true;
        permit: ConnectPermit;
    } | {
        ok: false;
        reason: TransportErrorCode;
    };
    finishConnect(permit: ConnectPermit, result: {
        success: boolean;
        breakerEligible?: boolean;
        timeout?: boolean;
    }): void;
    adjustQueue(input: {
        provider: TransportProvider;
        streamKey: string;
        bytes: number;
        messages: number;
    }): boolean;
    releaseAccounting(streamKey: string): void;
    resetAccounting(): void;
    adjustSessions(delta: number): void;
    noteLeaseAttempt(): void;
    noteLeaseAdmission(): void;
    noteAdmissionMiss(reason: string): void;
    noteFallback(reason: string): void;
    noteAuthStale(): void;
    noteCooldown(): void;
    notePrewarmAttempt(): void;
    notePrewarmDeferred(): void;
    noteMaxAgeRetire(): void;
    noteSocketClosed(lifetimeMs: number, turns: number): void;
    sweep(): void;
    snapshot(): {
        physicalSockets: number;
        connecting: number;
        prewarming: number;
        sessions: number;
        accountEntries: number;
        rateEntries: number;
        queuedInboundBytes: number;
        queuedInboundMessages: number;
        queueOverflows: number;
        providerQueues: {
            codex: {
                bytes: number;
                messages: number;
            };
            openai: {
                bytes: number;
                messages: number;
            };
        };
        counters: {
            admissionMissesByReason: {
                provider_breaker: number;
                session_busy: number;
                session_cooldown: number;
                provider_cap: number;
                process_cap: number;
                account_cap: number;
                connect_cap: number;
                handshake_rate: number;
                memory_guard: number;
                connect_failure: number;
                handshake_timeout: number;
                stale_auth: number;
                other: number;
            };
            httpByReason: {
                provider_breaker: number;
                session_busy: number;
                session_cooldown: number;
                provider_cap: number;
                process_cap: number;
                account_cap: number;
                connect_cap: number;
                handshake_rate: number;
                memory_guard: number;
                connect_failure: number;
                handshake_timeout: number;
                stale_auth: number;
                provider_connection_limit: number;
                previous_response_not_found: number;
                other: number;
            };
            leaseAttempts: number;
            leaseAdmissions: number;
            connectAttempts: number;
            connectSuccesses: number;
            connectFailures: number;
            connectTimeouts: number;
            prewarmAttempts: number;
            prewarmDeferred: number;
            prewarmFailures: number;
            authStaleRejects: number;
            sessionCooldowns: number;
            fallbacks: number;
            maxAgeRetires: number;
        };
        distributions: {
            handshakeLatencyMs: Histogram;
            socketLifetimeMs: Histogram;
            turnsPerConnection: Histogram;
            inboundQueueHighWaterBytes: Histogram;
            inboundQueueHighWaterMessages: Histogram;
        };
        breaker: import("./breaker.js").TransportBreakerSnapshot;
    };
}
export declare function defaultTransportCoordinatorOptions(): TransportCoordinatorOptions;
export declare function getTransportCoordinator(): TransportCoordinator;
export declare function configureTransportCoordinator(options: TransportCoordinatorOptions): TransportCoordinator;
export declare function resetTransportCoordinatorForTesting(): void;
export {};
//# sourceMappingURL=coordinator.d.ts.map