import { z } from "zod";
export declare const BudgetConfigSchema: z.ZodObject<{
    llmTokens: z.ZodDefault<z.ZodObject<{
        dailyBudget: z.ZodDefault<z.ZodNumber>;
        perActionBudget: z.ZodDefault<z.ZodNumber>;
        perMonitorBudget: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        dailyBudget: number;
        perActionBudget: number;
        perMonitorBudget: number;
    }, {
        dailyBudget?: number | undefined;
        perActionBudget?: number | undefined;
        perMonitorBudget?: number | undefined;
    }>>;
    externalRequests: z.ZodDefault<z.ZodObject<{
        npmPerHour: z.ZodDefault<z.ZodNumber>;
        githubPerHour: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        npmPerHour: number;
        githubPerHour: number;
    }, {
        npmPerHour?: number | undefined;
        githubPerHour?: number | undefined;
    }>>;
}, "strict", z.ZodTypeAny, {
    llmTokens: {
        dailyBudget: number;
        perActionBudget: number;
        perMonitorBudget: number;
    };
    externalRequests: {
        npmPerHour: number;
        githubPerHour: number;
    };
}, {
    llmTokens?: {
        dailyBudget?: number | undefined;
        perActionBudget?: number | undefined;
        perMonitorBudget?: number | undefined;
    } | undefined;
    externalRequests?: {
        npmPerHour?: number | undefined;
        githubPerHour?: number | undefined;
    } | undefined;
}>;
export type BudgetConfig = z.infer<typeof BudgetConfigSchema>;
export declare const CadenceConfigSchema: z.ZodObject<{
    globalMinIntervalSeconds: z.ZodDefault<z.ZodNumber>;
    perMonitorJitterPercent: z.ZodDefault<z.ZodNumber>;
    maxMonitorRunsPerHour: z.ZodDefault<z.ZodNumber>;
    maxActionsPerHour: z.ZodDefault<z.ZodNumber>;
    maxApprovalsPerHour: z.ZodDefault<z.ZodNumber>;
    panicStop: z.ZodDefault<z.ZodBoolean>;
}, "strict", z.ZodTypeAny, {
    globalMinIntervalSeconds: number;
    perMonitorJitterPercent: number;
    maxMonitorRunsPerHour: number;
    maxActionsPerHour: number;
    maxApprovalsPerHour: number;
    panicStop: boolean;
}, {
    globalMinIntervalSeconds?: number | undefined;
    perMonitorJitterPercent?: number | undefined;
    maxMonitorRunsPerHour?: number | undefined;
    maxActionsPerHour?: number | undefined;
    maxApprovalsPerHour?: number | undefined;
    panicStop?: boolean | undefined;
}>;
export type CadenceConfig = z.infer<typeof CadenceConfigSchema>;
export declare const DEFAULT_BUDGET: BudgetConfig;
export declare const DEFAULT_CADENCE: CadenceConfig;
export declare function loadBudget(workspaceRoot: string): Promise<BudgetConfig>;
export declare function loadCadence(workspaceRoot: string): Promise<CadenceConfig>;
export interface BudgetDecision {
    readonly decision: "allow" | "block";
    readonly reason: string;
    readonly used: number;
    readonly limit: number;
}
export declare class BudgetGuard {
    private readonly budget;
    private readonly cadence;
    constructor(budget: BudgetConfig, cadence: CadenceConfig);
    decideTokens(requested: number, usedToday: number): BudgetDecision;
    decideAction(usedThisHour: number): BudgetDecision;
    decideMonitorRun(usedThisHour: number): BudgetDecision;
    decideExternalRequest(kind: "npm" | "github", usedThisHour: number): BudgetDecision;
    isPanicStopped(): boolean;
}
export interface BudgetSnapshot {
    readonly budget: BudgetConfig;
    readonly cadence: CadenceConfig;
    readonly source: {
        readonly budget: string;
        readonly cadence: string;
    };
}
export declare function loadBudgetSnapshot(workspaceRoot: string): Promise<BudgetSnapshot>;
//# sourceMappingURL=budget-ledger.d.ts.map