import type { EvoPaths } from "../../paths.ts";
import { type EvoCapabilityName, type EvoCapabilityRequestFrame } from "./protocol.ts";
import type { EvoCapabilityComponentIdentity, EvoCapabilityResourceUsage, EvoCapabilityService } from "./service.ts";
type BudgetedCapabilityName = Extract<EvoCapabilityName, "infer" | "spawn-agent">;
type CallCapabilityName = Exclude<EvoCapabilityName, BudgetedCapabilityName>;
export interface EvoCallCapabilityGrant {
    capability: CallCapabilityName;
    maxCalls: number;
}
export interface EvoBudgetedCapabilityGrant {
    capability: BudgetedCapabilityName;
    maxCalls: number;
    models: string[];
    maxInputTokens: number;
    maxOutputTokens: number;
    maxTotalTokens: number;
    maxCostUsd: number;
    maxOutputTokensPerCall: number;
    /** Only meaningful for spawn-agent; omitted for infer. */
    tools?: string[];
}
export type EvoCapabilityGrant = EvoCallCapabilityGrant | EvoBudgetedCapabilityGrant;
export interface EvoCapabilityUsage extends EvoCapabilityResourceUsage {
    capability: EvoCapabilityName;
    calls: number;
}
interface EvoCapabilityReservation extends EvoCapabilityResourceUsage {
    eventId: string;
    authorityId: string;
    artifactDigest: string;
    capability: BudgetedCapabilityName;
}
interface EvoCapabilityOperation {
    eventId: string;
    authorityId: string;
    sessionId: string;
    ownerPid: number;
    startedAt: string;
    component: {
        id: string;
        abi: string;
        artifactDigest: string;
    };
    request: {
        invokeId: number;
        id: string;
        capability: EvoCapabilityName;
    };
}
interface EvoPendingCapabilityAudit {
    auditId: string;
    event: Record<string, unknown>;
}
export interface EvoComponentCapabilityState {
    authorityId: string;
    id: string;
    artifactDigest: string;
    grants: EvoCapabilityGrant[];
    usage: EvoCapabilityUsage[];
}
export interface EvoCapabilityState {
    schemaVersion: 1;
    components: EvoComponentCapabilityState[];
    reservations: EvoCapabilityReservation[];
    operations: EvoCapabilityOperation[];
    pendingAudit: EvoPendingCapabilityAudit[];
}
export type EvoCapabilityBrokerFaultPoint = "after-state-write" | "after-audit-append";
export interface EvoCapabilityBrokerOptions {
    paths: EvoPaths;
    services?: Partial<Record<EvoCapabilityName, EvoCapabilityService>>;
    now?: () => string;
    randomId?: () => string;
    maxAuditResultBytes?: number;
    /** Process-wide by default; injectable only for crash-recovery tests. */
    sessionId?: string;
    /** Current process id by default; injectable only for crash-recovery tests. */
    ownerPid?: number;
    /** Fault injection hook used to verify durable recovery boundaries. */
    faultInjector?: (point: EvoCapabilityBrokerFaultPoint) => void | Promise<void>;
}
export declare class EvoCapabilityDeniedError extends Error {
    readonly code: string;
    constructor(code: string, message: string, options?: ErrorOptions);
}
/**
 * Parse an explicit grant list without touching broker state. Import and
 * proposal code use this to freeze the exact authority a future selection may
 * receive before a component is registered with the broker.
 */
export declare function parseEvoCapabilityGrants(value: unknown, label?: string): EvoCapabilityGrant[];
export declare function deriveEvoCapabilityAuthorityId(artifactDigest: string, grants: readonly EvoCapabilityGrant[]): string;
export declare function parseEvoCapabilityState(value: unknown): EvoCapabilityState;
export declare class EvoCapabilityBroker {
    private readonly paths;
    private readonly services;
    private readonly now;
    private readonly randomId;
    private readonly statePath;
    private readonly auditPath;
    private readonly maxAuditResultBytes;
    private readonly sessionId;
    private readonly ownerPid;
    private readonly faultInjector;
    constructor(options: EvoCapabilityBrokerOptions);
    replaceComponentGrants(component: EvoCapabilityComponentIdentity, grants: readonly EvoCapabilityGrant[]): Promise<string>;
    getState(): Promise<EvoCapabilityState>;
    request(authorityId: string, component: EvoCapabilityComponentIdentity, frame: EvoCapabilityRequestFrame, signal: AbortSignal): Promise<unknown>;
    private readState;
    private writeState;
    private injectFault;
    private queueAudit;
    private repairAuditTail;
    private existingAuditIds;
    private flushPendingAudit;
    private persistStateAndAudit;
    private chargeReservation;
    private operationIsLive;
    private readRecoveredState;
    private boundedAuditResult;
    private auditComponent;
    private deny;
    private authorizeAndReserve;
    private finalize;
}
export {};
//# sourceMappingURL=broker.d.ts.map