import { Effect, Schema } from "effect";
import type { ParseOptions } from "effect/SchemaAST";
export declare const BudgetLimits: Schema.Struct<{
    readonly modelCalls: Schema.optionalKey<Schema.Int>;
    readonly toolCalls: Schema.optionalKey<Schema.Int>;
    readonly totalTokens: Schema.optionalKey<Schema.Int>;
    readonly childRuns: Schema.optionalKey<Schema.Int>;
    readonly handoffs: Schema.optionalKey<Schema.Int>;
    readonly depth: Schema.optionalKey<Schema.Int>;
    readonly deadline: Schema.optionalKey<Schema.String>;
}>;
/** @experimental */
export type BudgetLimits = typeof BudgetLimits.Type;
/** @experimental Portable run budget with allocation, remaining capacity, and tree depth. */
export declare const RunBudget: Schema.Struct<{
    readonly allocation: Schema.Struct<{
        readonly modelCalls: Schema.optionalKey<Schema.Int>;
        readonly toolCalls: Schema.optionalKey<Schema.Int>;
        readonly totalTokens: Schema.optionalKey<Schema.Int>;
        readonly childRuns: Schema.optionalKey<Schema.Int>;
        readonly handoffs: Schema.optionalKey<Schema.Int>;
        readonly depth: Schema.optionalKey<Schema.Int>;
        readonly deadline: Schema.optionalKey<Schema.String>;
    }>;
    readonly remaining: Schema.Struct<{
        readonly modelCalls: Schema.optionalKey<Schema.Int>;
        readonly toolCalls: Schema.optionalKey<Schema.Int>;
        readonly totalTokens: Schema.optionalKey<Schema.Int>;
        readonly childRuns: Schema.optionalKey<Schema.Int>;
        readonly handoffs: Schema.optionalKey<Schema.Int>;
        readonly depth: Schema.optionalKey<Schema.Int>;
        readonly deadline: Schema.optionalKey<Schema.String>;
    }>;
    readonly depth: Schema.Int;
}>;
/** @experimental */
export type RunBudget = typeof RunBudget.Type;
declare const RunBudgetExhausted_base: Schema.Class<RunBudgetExhausted, Schema.TaggedStruct<"@batonfx/core/RunBudgetExhausted", {
    readonly dimension: Schema.Literals<readonly ["modelCalls", "toolCalls", "totalTokens", "childRuns", "handoffs", "depth", "deadline"]>;
    readonly requested: Schema.Finite;
    readonly remaining: Schema.optionalKey<Schema.Finite>;
    readonly message: Schema.optionalKey<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class RunBudgetExhausted extends RunBudgetExhausted_base {
}
declare const RunBudgetGrantWidened_base: Schema.Class<RunBudgetGrantWidened, Schema.TaggedStruct<"@batonfx/core/RunBudgetGrantWidened", {
    readonly dimension: Schema.Literals<readonly ["modelCalls", "toolCalls", "totalTokens", "childRuns", "handoffs", "depth"]>;
    readonly grant: Schema.Finite;
    readonly remaining: Schema.Finite;
    readonly message: Schema.optionalKey<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class RunBudgetGrantWidened extends RunBudgetGrantWidened_base {
}
/** @experimental */
export declare const make: {
    (depth?: number): (allocation: BudgetLimits) => RunBudget;
    (allocation: BudgetLimits, depth?: number): RunBudget;
};
/**
 * @experimental The allocation that charges nothing. Every dimension is undefined, so `charge`
 * short-circuits on an undefined remaining and no usage can exhaust it. Naming it keeps an
 * unbounded run from reading like a forgotten argument.
 */
export declare const unbounded: BudgetLimits;
/** @experimental */
export declare const allocate: {
    (depth?: number): (allocation: BudgetLimits) => RunBudget;
    (allocation: BudgetLimits, depth?: number): RunBudget;
};
/** @experimental */
export declare const charge: {
    (usage: BudgetLimits): (budget: RunBudget) => Effect.Effect<RunBudget, RunBudgetExhausted>;
    (budget: RunBudget, usage: BudgetLimits): Effect.Effect<RunBudget, RunBudgetExhausted>;
};
/** @experimental */
export declare const reserveChild: {
    (grant: BudgetLimits): (parent: RunBudget) => Effect.Effect<{
        readonly parent: RunBudget;
        readonly child: RunBudget;
    }, RunBudgetExhausted | RunBudgetGrantWidened>;
    (parent: RunBudget, grant: BudgetLimits): Effect.Effect<{
        readonly parent: RunBudget;
        readonly child: RunBudget;
    }, RunBudgetExhausted | RunBudgetGrantWidened>;
};
/** @experimental */
export declare const narrowChild: {
    (child: RunBudget, narrower: BudgetLimits): (parent: RunBudget) => Effect.Effect<{
        readonly parent: RunBudget;
        readonly child: RunBudget;
    }, RunBudgetGrantWidened>;
    (parent: RunBudget, child: RunBudget, narrower: BudgetLimits): Effect.Effect<{
        readonly parent: RunBudget;
        readonly child: RunBudget;
    }, RunBudgetGrantWidened>;
};
/** @experimental */
export declare const refundUnused: {
    (child: RunBudget): (parent: RunBudget) => RunBudget;
    (parent: RunBudget, child: RunBudget): RunBudget;
};
/** @experimental */
export declare const isDeadlineExpired: {
    (nowIso: string): (budget: RunBudget) => boolean;
    (budget: RunBudget, nowIso: string): boolean;
};
/** @experimental */
export declare const assertNotExpired: {
    (nowIso: string): (budget: RunBudget) => Effect.Effect<void, RunBudgetExhausted>;
    (budget: RunBudget, nowIso: string): Effect.Effect<void, RunBudgetExhausted>;
};
/** @experimental */
export declare const resolve: {
    (runOverride?: BudgetLimits): (agentDefault?: BudgetLimits) => RunBudget;
    (agentDefault?: BudgetLimits, runOverride?: BudgetLimits): RunBudget;
};
/** @experimental Narrow a base budget with optional per-run overrides; omitted dimensions stay unchanged. */
export declare const narrowLimits: {
    (override?: BudgetLimits): (base?: BudgetLimits) => BudgetLimits;
    (base?: BudgetLimits, override?: BudgetLimits): BudgetLimits;
};
/** @experimental */
export declare const encode: {
    (input: RunBudget, options?: ParseOptions): Effect.Effect<typeof RunBudget.Encoded, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: RunBudget) => Effect.Effect<typeof RunBudget.Encoded, Schema.SchemaError, never>;
};
/** @experimental */
export declare const decode: {
    (input: typeof RunBudget.Encoded, options?: ParseOptions): Effect.Effect<RunBudget, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: typeof RunBudget.Encoded) => Effect.Effect<RunBudget, Schema.SchemaError, never>;
};
export {};