/**
 * Token usage / cost tracker. Mirrors `python/src/adk_fluent/_usage/`.
 *
 * The module ships three layers:
 *   - `ModelRate` / `CostTable` — frozen per-model pricing
 *   - `TurnUsage` / `AgentUsage` — mutable accumulators scoped to a
 *     single turn or to the whole session per-agent
 *   - `UsageTracker` — the original flat tracker (still used by H.usage())
 */
/** Flat per-million token rate for one model. */
export interface ModelRate {
    readonly inputPerMillion: number;
    readonly outputPerMillion: number;
}
/** Frozen table of per-model rates plus a default fallback. */
export declare class CostTable {
    readonly rates: ReadonlyMap<string, ModelRate>;
    readonly defaultRate: ModelRate;
    constructor(rates?: Iterable<[string, ModelRate]>, defaultRate?: ModelRate);
    /** Look up a rate by model name, falling back to `defaultRate`. */
    rateFor(model: string): ModelRate;
    /** Cost (USD) of `input`/`output` tokens for `model`. */
    cost(model: string, inputTokens: number, outputTokens: number): number;
    /** Shortcut: uniform rate for every model. */
    static flat(inputPerMillion: number, outputPerMillion: number): CostTable;
}
/** Per-turn accumulator. */
export declare class TurnUsage {
    inputTokens: number;
    outputTokens: number;
    costUsd: number;
    modelCalls: number;
    add(input: number, output: number, cost: number): void;
    get totalTokens(): number;
}
/** Per-agent accumulator. Holds one `TurnUsage` per turn index. */
export declare class AgentUsage {
    readonly agent: string;
    readonly turns: TurnUsage[];
    constructor(agent: string);
    turn(index: number): TurnUsage;
    get inputTokens(): number;
    get outputTokens(): number;
    get totalTokens(): number;
    get costUsd(): number;
}
export interface UsageTrackerOptions {
    costPerMillionInput?: number;
    costPerMillionOutput?: number;
    costTable?: CostTable;
}
export interface UsageRecord {
    model: string;
    inputTokens: number;
    outputTokens: number;
    totalTokens: number;
    costUsd: number;
    timestamp: number;
}
export declare class UsageTracker {
    readonly costPerMillionInput: number;
    readonly costPerMillionOutput: number;
    readonly costTable?: CostTable;
    readonly records: UsageRecord[];
    readonly agents: Map<string, AgentUsage>;
    constructor(opts?: UsageTrackerOptions);
    /** Get or create a per-agent accumulator. */
    forAgent(name: string): AgentUsage;
    /** Record token usage for one model call. */
    record(model: string, inputTokens: number, outputTokens: number): UsageRecord;
    get totalInputTokens(): number;
    get totalOutputTokens(): number;
    get totalTokens(): number;
    get totalCostUsd(): number;
    /** Human-readable summary line. */
    summary(): string;
    /** Build an after-model callback compatible with `Agent.afterModel(...)`. */
    callback(): (event: {
        model?: string;
        inputTokens?: number;
        outputTokens?: number;
    }) => void;
}
//# sourceMappingURL=usage.d.ts.map