import { z } from 'zod';
import type { ResidentActivityScope, ResidentActivitySource, ResidentAdmission, ResidentSettlement } from './activity.js';
declare const receiptSchema: z.ZodEffects<z.ZodObject<{
    /** The resident step's turn: one receipt per turn, whose session holds its log. */
    sessionId: z.ZodString;
    turnId: z.ZodString;
    /** Own usage includes retry and side-call spend; never add cache buckets again. */
    ownTokens: z.ZodNullable<z.ZodNumber>;
    treeTokens: z.ZodNullable<z.ZodNumber>;
    ownCostUsd: z.ZodNullable<z.ZodNumber>;
    unpricedOwnTokens: z.ZodNullable<z.ZodNumber>;
    usageFinal: z.ZodBoolean;
    cleanup: z.ZodEnum<["confirmed", "unconfirmed", "unknown"]>;
    verification: z.ZodEnum<["recorded", "unconfigured", "unconfirmed"]>;
}, "strip", z.ZodTypeAny, {
    sessionId: string;
    turnId: string;
    verification: "unconfirmed" | "recorded" | "unconfigured";
    ownTokens: number | null;
    treeTokens: number | null;
    ownCostUsd: number | null;
    unpricedOwnTokens: number | null;
    usageFinal: boolean;
    cleanup: "unknown" | "confirmed" | "unconfirmed";
}, {
    sessionId: string;
    turnId: string;
    verification: "unconfirmed" | "recorded" | "unconfigured";
    ownTokens: number | null;
    treeTokens: number | null;
    ownCostUsd: number | null;
    unpricedOwnTokens: number | null;
    usageFinal: boolean;
    cleanup: "unknown" | "confirmed" | "unconfirmed";
}>, {
    sessionId: string;
    turnId: string;
    verification: "unconfirmed" | "recorded" | "unconfigured";
    ownTokens: number | null;
    treeTokens: number | null;
    ownCostUsd: number | null;
    unpricedOwnTokens: number | null;
    usageFinal: boolean;
    cleanup: "unknown" | "confirmed" | "unconfirmed";
}, {
    sessionId: string;
    turnId: string;
    verification: "unconfirmed" | "recorded" | "unconfigured";
    ownTokens: number | null;
    treeTokens: number | null;
    ownCostUsd: number | null;
    unpricedOwnTokens: number | null;
    usageFinal: boolean;
    cleanup: "unknown" | "confirmed" | "unconfirmed";
}>;
/** @experimental Host-authenticated cumulative root receipt. Cost covers this root only. */
export type ResidentConsumptionReceipt = z.infer<typeof receiptSchema>;
/** @experimental A host resolves only authoritative admitted claims and bounds each read. */
export interface ResidentConsumptionResolver {
    /** Worst-case bytes read per resolution; reserved before calling the adapter. */
    readonly maxReadBytes: number;
    resolve(admission: ResidentAdmission, signal?: AbortSignal): Promise<ResidentConsumptionReceipt | null>;
}
/** @experimental Bounds the entire inspection, not just each page. No inference or writes. */
export interface ResidentConsumptionOptions {
    readonly cursor?: number;
    readonly maxRevisions?: number;
    readonly maxHistoryBytes?: number;
    readonly maxReceiptBytes?: number;
}
/** @experimental Missing and deferred receipts never establish zero usage. */
export interface ResidentConsumptionAttempt extends ResidentAdmission {
    readonly settlement: ResidentSettlement | null;
    readonly receipt: ResidentConsumptionReceipt | null;
    readonly receiptStatus: 'available' | 'missing' | 'invalid' | 'deferred' | 'duplicate-turn';
}
/** @experimental An evidence projection, not a bill or an enforced spending cap. */
export interface ResidentConsumptionReport {
    readonly scope: ResidentActivityScope;
    readonly fromRevision: number;
    readonly throughRevision: number;
    readonly nextCursor: number | null;
    readonly historyComplete: boolean;
    readonly unavailableRevisions: readonly number[];
    readonly historyBytes: number;
    readonly receiptBytesReserved: number;
    readonly archivedPursuits: readonly string[];
    readonly attempts: readonly ResidentConsumptionAttempt[];
    readonly recorded: {
        readonly ownTokens: number;
        readonly treeTokens: number;
        readonly ownCostUsd: number;
        readonly unpricedOwnTokens: number;
    };
    readonly unknown: {
        readonly ownUsageAttempts: number;
        readonly treeUsageAttempts: number;
        readonly ownPriceAttempts: number;
    };
    /** Requires complete history and final receipts; says nothing about external billing. */
    readonly usageComplete: boolean;
}
/**
 * @experimental Inspect cumulative root receipts once per admitted claim. Historical
 * archive/reconcile events never erase consumption. Tree tokens are a separate total:
 * adding them to own tokens would count the root twice. Descendant prices are unknown.
 */
export declare function inspectResidentConsumption(source: ResidentActivitySource, resolver: ResidentConsumptionResolver, options?: ResidentConsumptionOptions, signal?: AbortSignal): Promise<ResidentConsumptionReport>;
export {};
//# sourceMappingURL=consumption.d.ts.map