import type { ProviderConcurrencyConfig, ProviderRpmConfig, ProviderRuntimeProfile } from '../../../providers/core/api/provider-types.js';
export type ResolvedProviderTrafficPolicy = {
    concurrency: Required<ProviderConcurrencyConfig>;
    rpm: Required<ProviderRpmConfig> & {
        windowMs: number;
    };
};
export type ProviderTrafficPermit = {
    runtimeKey: string;
    providerKey?: string;
    requestId: string;
    leaseId: string;
    stateKey: string;
};
export declare class ProviderTrafficSaturatedError extends Error {
    readonly statusCode = 429;
    readonly code = "PROVIDER_TRAFFIC_SATURATED";
    readonly retryable = true;
    readonly details: Record<string, unknown>;
    constructor(message: string, details: Record<string, unknown>);
}
export type ProviderTrafficAcquireResult = {
    permit: ProviderTrafficPermit;
    policy: ResolvedProviderTrafficPolicy;
    waitedMs: number;
    activeInFlight: number;
    rpmInWindow: number;
};
export type ProviderTrafficOutcomeEvent = {
    runtimeKey: string;
    providerKey?: string;
    requestId?: string;
    success: boolean;
    statusCode?: number;
    errorCode?: string;
    upstreamCode?: string;
    reason?: string;
    activeInFlight?: number;
    observedAtMs?: number;
    configuredMaxInFlight?: number;
};
export interface ProviderTrafficGovernorLike {
    acquire(options: {
        runtimeKey: string;
        providerKey?: string;
        requestId: string;
        runtime: ProviderRuntimeProfile;
        softWaitTimeoutMs?: number;
    }): Promise<ProviderTrafficAcquireResult>;
    release(permit: ProviderTrafficPermit): Promise<{
        released: boolean;
        activeInFlight: number;
    }>;
    observeOutcome?(event: ProviderTrafficOutcomeEvent): Promise<void>;
}
export type ProviderTrafficResetResult = {
    stateFilesScanned: number;
    stateFilesUpdated: number;
    leasesRemoved: number;
    rpmEventsRemoved: number;
};
export declare function resolveProviderTrafficPolicy(runtime: ProviderRuntimeProfile, _providerKey?: string): ResolvedProviderTrafficPolicy;
export declare class ProviderTrafficGovernor implements ProviderTrafficGovernorLike {
    private readonly rootDir;
    private readonly lockDir;
    private readonly stateDir;
    private readonly adaptiveEnabled;
    private readonly adaptiveConfigPath;
    private readonly adaptiveHardMax;
    private readonly adaptiveHardMultiplier;
    private readonly adaptiveStateByRuntime;
    private readonly waiterStateByRuntime;
    private ensureDirsPromise;
    private adaptiveLoadPromise;
    private adaptiveWritePromise;
    private adaptiveWriteTimer;
    constructor(rootDir?: string);
    private resolveAdaptiveHardMax;
    private resolveMaxAcquireWaiters;
    private acquireWaiterSlot;
    private releaseWaiterSlot;
    private ensureAdaptiveLoaded;
    private toAdaptivePersistedConfig;
    private scheduleAdaptivePersist;
    private persistAdaptiveConfig;
    private getOrCreateAdaptiveState;
    private getOrCreateMinuteBucket;
    private getWindowBuckets;
    private resolveAdaptiveEffectiveCap;
    private maybeEvaluateAdaptiveState;
    private ensureDirs;
    private getLockFile;
    private getStateFile;
    resetCurrentProcessState(): Promise<ProviderTrafficResetResult>;
    private acquireFileLock;
    private pruneState;
    acquire(options: {
        runtimeKey: string;
        providerKey?: string;
        requestId: string;
        runtime: ProviderRuntimeProfile;
        softWaitTimeoutMs?: number;
    }): Promise<ProviderTrafficAcquireResult>;
    release(permit: ProviderTrafficPermit): Promise<{
        released: boolean;
        activeInFlight: number;
    }>;
    observeOutcome(event: ProviderTrafficOutcomeEvent): Promise<void>;
}
export declare function getSharedProviderTrafficGovernor(): ProviderTrafficGovernor;
export declare function createNoopProviderTrafficGovernor(): ProviderTrafficGovernorLike;