import type { OAuthCredentials } from "../registry/oauth/types.js";
import type { Provider } from "../types.js";
import type { ClientUsageReport, ClientUsageSummary, UsageCredential, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport } from "../usage.js";
import type { SessionAffinity } from "./affinity.js";
import type { CredentialBlocks } from "./blocks.js";
import type { KeyOverrides } from "./cascade.js";
import type { UsageCache } from "./usage-cache.js";
import type { CredentialPool } from "./pool.js";
import type { RankingStrategyResolver } from "../usage/registry.js";
import type { OAuthRefresher } from "./refresh.js";
import type { AuthCredentialStore } from "./store.js";
import type { AuthCredential, OAuthCredential, ObservedUsageInput, UsageApi } from "./types.js";
/** Convert an OAuth usage credential into a refreshable stored shape; used by probes and health. */
export declare function buildRefreshableOauthCredential(credential: UsageCredential): OAuthCredential | null;
/** Merge refreshed OAuth tokens and identity into a usage credential; used by probes and health. */
export declare function mergeRefreshedUsageCredential(credential: UsageCredential, refreshed: OAuthCredentials): UsageCredential;
/** Dependencies for usage fetching and cache coordination; supplied by AuthStorage. */
export interface UsageServiceDeps {
    store: AuthCredentialStore;
    pool: CredentialPool;
    overrides: KeyOverrides;
    refresher: OAuthRefresher;
    cache: UsageCache;
    blocks: CredentialBlocks;
    affinity: SessionAffinity;
    strategies: RankingStrategyResolver;
    usageProviders: (provider: Provider) => UsageProvider | undefined;
    fetch: typeof fetch;
    requestTimeoutMs: number;
    logger: UsageLogger;
}
type UsageReportsOptions = {
    baseUrlResolver?: (provider: Provider) => string | undefined;
    signal?: AbortSignal;
};
/** Usage reports: per-credential cached fetches, aggregate reports, header ingestion, history. */
export declare class UsageService implements UsageApi {
    #private;
    readonly fetch: typeof fetch;
    readonly logger: UsageLogger;
    readonly requestTimeoutMs: number;
    constructor(deps: UsageServiceDeps);
    /** Whether OAuth usage can be fetched via a provider or the store hook. */
    canFetchOAuthUsage(provider: Provider): boolean;
    /**
     * The {@link UsageProvider} registered for `provider`, or undefined when the
     * provider has no usage endpoint at all. Lets callers tell "a credential we
     * could have fetched usage for but didn't" apart from "a provider with no
     * usage concept" (web-search keys, local/keyless servers, inference
     * providers without a usage API) — the latter never warrants a usage row.
     */
    providerFor(provider: Provider): UsageProvider | undefined;
    /**
     * Install a runtime usage provider override (not persisted to disk).
     *
     * Runtime overrides are checked before the configured resolver, including its
     * built-in fallback. Removing the override restores that resolver unchanged.
     */
    setProvider(provider: Provider, usageProvider: UsageProvider, apiKey?: string): void;
    /** Carry runtime usage provider overrides over from the service this one replaces (store swap). */
    adoptRuntimeProviders(previous: UsageService): void;
    /** Remove a runtime usage provider override and restore configured/default resolution. */
    removeProvider(provider: Provider): void;
    /** Preserve the persisted OAuth row's login anchor and subtype metadata on usage-path refresh. */
    persistRefreshedCredential(provider: Provider, previous: UsageCredential, next: UsageCredential, credentialId?: number | undefined): void;
    /**
     * Recorded usage-limit snapshots, oldest first. Empty when the underlying
     * store has no durable history (e.g. a broker-backed remote store).
     */
    history(query?: UsageHistoryQuery): UsageHistoryEntry[];
    /**
     * Forward one completed request's usage to the store's observer hook.
     * Broker-backed stores batch these into per-install reports so the broker
     * can track actual token burn per client; local stores have no hook and
     * the call is a no-op.
     */
    observe(entry: ObservedUsageInput): void;
    /** Broker host: persist one client's observed-usage report (per-install token burn). */
    recordClient(report: ClientUsageReport): boolean;
    /** Broker host: aggregate recorded per-client usage since `sinceMs`. */
    clientSummary(sinceMs: number): ClientUsageSummary;
    /** Merge rate-limit headers into the latest account report. */
    ingestHeaders(provider: Provider, headers: Record<string, string>, options?: {
        sessionId?: string;
        baseUrl?: string;
        responseStatus?: number;
    }): boolean;
    /** Fetch the best available report for one stored credential. */
    report(provider: Provider, credential: AuthCredential, options?: {
        baseUrl?: string;
        timeoutMs?: number;
        signal?: AbortSignal;
    }): Promise<UsageReport | null>;
    /**
     * Return model ids whose live reports map to a quantitative usage scope.
     * Provider strategies supply model/tier mapping when available; otherwise
     * only explicitly matching model ids and account-wide shared limits count.
     * Label-only or ambiguous tier limits are excluded rather than guessed.
     */
    reportingModelIds(provider: Provider, modelIds: readonly string[], reports: readonly UsageReport[]): string[];
    /** Fetch all providers’ current usage reports, sharing concurrent polls. */
    reports(options?: UsageReportsOptions): Promise<UsageReport[] | null>;
    /**
     * Discard cached usage reports before a user-requested refresh. The next
     * read probes upstream serially per provider unless a failure cooldown is
     * active. Failed probes never replay an invalidated last-good snapshot.
     */
    invalidate(provider?: string, signal?: AbortSignal): Promise<void>;
}
export {};