import { Context, Effect, Schema } from "effect";
/** @experimental Stable, bounded, source-owned identity for one effectful operation. */
export declare const ProgramOperationName: Schema.String;
/** @experimental */
export type ProgramOperationName = typeof ProgramOperationName.Type;
/** @experimental Stable, bounded identity for one member of a map or fan-out. */
export declare const ProgramMemberKey: Schema.String;
/** @experimental */
export type ProgramMemberKey = typeof ProgramMemberKey.Type;
/** @experimental */
export declare const LogLevel: Schema.Literals<readonly ["debug", "info", "warn", "error"]>;
/** @experimental */
export type LogLevel = typeof LogLevel.Type;
declare const ProgramCapabilityMissing_base: Schema.Class<ProgramCapabilityMissing, Schema.TaggedStruct<"@batonfx/core/ProgramCapabilityMissing", {
    readonly capability: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramCapabilityMissing extends ProgramCapabilityMissing_base {
}
declare const ProgramCapabilityDenied_base: Schema.Class<ProgramCapabilityDenied, Schema.TaggedStruct<"@batonfx/core/ProgramCapabilityDenied", {
    readonly capability: Schema.String;
    readonly operation: Schema.String;
    readonly reason: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramCapabilityDenied extends ProgramCapabilityDenied_base {
}
declare const ProgramAuthorizationFailure_base: Schema.Class<ProgramAuthorizationFailure, Schema.TaggedStruct<"@batonfx/core/ProgramAuthorizationFailure", {
    readonly capability: Schema.String;
    readonly operation: Schema.String;
    readonly cause: Schema.Unknown;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramAuthorizationFailure extends ProgramAuthorizationFailure_base {
}
declare const ProgramSchemaFailure_base: Schema.Class<ProgramSchemaFailure, Schema.TaggedStruct<"@batonfx/core/ProgramSchemaFailure", {
    readonly boundary: Schema.Literals<readonly ["program-input", "program-output", "tool-input", "tool-output", "step-input", "step-output", "agent-input", "agent-output"]>;
    readonly capability: Schema.optionalKey<Schema.String>;
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramSchemaFailure extends ProgramSchemaFailure_base {
}
declare const ProgramToolFailure_base: Schema.Class<ProgramToolFailure, Schema.TaggedStruct<"@batonfx/core/ProgramToolFailure", {
    readonly tool: Schema.String;
    readonly operation: Schema.String;
    readonly cause: Schema.Unknown;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramToolFailure extends ProgramToolFailure_base {
}
declare const ProgramStepFailure_base: Schema.Class<ProgramStepFailure, Schema.TaggedStruct<"@batonfx/core/ProgramStepFailure", {
    readonly step: Schema.String;
    readonly operation: Schema.String;
    readonly cause: Schema.Unknown;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramStepFailure extends ProgramStepFailure_base {
}
declare const ProgramAgentFailure_base: Schema.Class<ProgramAgentFailure, Schema.TaggedStruct<"@batonfx/core/ProgramAgentFailure", {
    readonly selection: Schema.String;
    readonly operation: Schema.String;
    readonly cause: Schema.Unknown;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramAgentFailure extends ProgramAgentFailure_base {
}
declare const ProgramBudgetExhausted_base: Schema.Class<ProgramBudgetExhausted, Schema.TaggedStruct<"@batonfx/core/ProgramBudgetExhausted", {
    readonly dimension: Schema.Literals<readonly ["agentRuns", "concurrency", "toolCalls", "tokens", "wallClockMillis", "logBytes", "outputBytes"]>;
    readonly limit: Schema.Finite;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramBudgetExhausted extends ProgramBudgetExhausted_base {
}
declare const ProgramReplayDivergence_base: Schema.Class<ProgramReplayDivergence, Schema.TaggedStruct<"@batonfx/core/ProgramReplayDivergence", {
    readonly operation: Schema.String;
    readonly expected: Schema.String;
    readonly actual: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramReplayDivergence extends ProgramReplayDivergence_base {
}
declare const ProgramOperationUnknown_base: Schema.Class<ProgramOperationUnknown, Schema.TaggedStruct<"@batonfx/core/ProgramOperationUnknown", {
    readonly operation: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramOperationUnknown extends ProgramOperationUnknown_base {
}
declare const ProgramInvocationFailure_base: Schema.Class<ProgramInvocationFailure, Schema.TaggedStruct<"@batonfx/core/ProgramInvocationFailure", {
    readonly cause: Schema.Unknown;
}>, import("effect/Cause").YieldableError>;
/** @experimental One decoded invocation failed with an implementation-specific error. */
export declare class ProgramInvocationFailure extends ProgramInvocationFailure_base {
}
declare const ProgramSuspended_base: Schema.Class<ProgramSuspended, Schema.TaggedStruct<"@batonfx/core/ProgramSuspended", {
    readonly operation: Schema.String;
    readonly reason: Schema.Literals<readonly ["approval", "tool-wait", "agent", "step"]>;
    readonly token: Schema.optionalKey<Schema.String>;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramSuspended extends ProgramSuspended_base {
}
declare const ProgramCancelled_base: Schema.Class<ProgramCancelled, Schema.TaggedStruct<"@batonfx/core/ProgramCancelled", {
    readonly reason: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class ProgramCancelled extends ProgramCancelled_base {
}
/** @experimental */
export interface ToolCallInput {
    readonly operation: ProgramOperationName;
    readonly tool: string;
    readonly input: unknown;
}
/** @experimental */
export interface StepCallInput {
    readonly operation: ProgramOperationName;
    readonly step: string;
    readonly input: unknown;
}
/** @experimental */
export interface AgentRunInput {
    readonly operation: ProgramOperationName;
    readonly selection: string;
    readonly input: unknown;
}
/** @experimental Token accounting reported by the host-owned Agent executor. */
export interface AgentTokenUsage {
    readonly input: number;
    readonly output: number;
}
/** @experimental */
export interface AgentRunResult {
    readonly text: string;
    readonly turns: number;
    readonly tokenUsage: AgentTokenUsage;
}
/** @experimental */
export interface AgentMapMember {
    readonly member: ProgramMemberKey;
    readonly input: unknown;
}
/** @experimental */
export interface AgentMapInput {
    readonly operation: ProgramOperationName;
    readonly selection: string;
    readonly members: ReadonlyArray<AgentMapMember>;
}
/** @experimental */
export interface AgentFanOutMember extends AgentMapMember {
    readonly selection: string;
}
/** @experimental */
export interface AgentFanOutInput {
    readonly operation: ProgramOperationName;
    readonly members: ReadonlyArray<AgentFanOutMember>;
}
/** @experimental */
export interface AgentMemberResult {
    readonly member: ProgramMemberKey;
    readonly result: AgentRunResult;
}
/** @experimental */
export interface LogInput {
    readonly operation: ProgramOperationName;
    readonly level: LogLevel;
    readonly message: string;
    readonly data?: Readonly<Record<string, unknown>>;
}
/** @experimental One manifest-scoped tool visible to Program source. */
export interface ToolSummary {
    readonly name: string;
}
/** @experimental Focused encoded type description for one manifest-scoped tool. */
export interface ToolDescription extends ToolSummary {
    readonly inputSchema: Schema.Json;
    readonly outputSchema: Schema.Json;
}
/** @experimental Failures crossing the encoded program capability protocol. */
export declare const CapabilityFailure: Schema.Union<readonly [typeof ProgramCapabilityMissing, typeof ProgramCapabilityDenied, typeof ProgramAuthorizationFailure, typeof ProgramSchemaFailure, typeof ProgramToolFailure, typeof ProgramStepFailure, typeof ProgramAgentFailure, typeof ProgramBudgetExhausted, typeof ProgramReplayDivergence, typeof ProgramOperationUnknown, typeof ProgramSuspended, typeof ProgramCancelled]>;
/** @experimental */
export type CapabilityFailure = typeof CapabilityFailure.Type;
/** @experimental Encoded operations visible to sandboxed source. */
export interface Interface {
    readonly discoverTools: Effect.Effect<ReadonlyArray<ToolSummary>>;
    readonly describeTool: (name: string) => Effect.Effect<ToolDescription, ProgramCapabilityMissing>;
    readonly callTool: (input: ToolCallInput) => Effect.Effect<unknown, CapabilityFailure>;
    readonly callStep: (input: StepCallInput) => Effect.Effect<unknown, CapabilityFailure>;
    readonly runAgent: (input: AgentRunInput) => Effect.Effect<AgentRunResult, CapabilityFailure>;
    readonly mapAgents: (input: AgentMapInput) => Effect.Effect<ReadonlyArray<AgentMemberResult>, CapabilityFailure>;
    readonly fanOutAgents: (input: AgentFanOutInput) => Effect.Effect<ReadonlyArray<AgentMemberResult>, CapabilityFailure>;
    readonly log: (input: LogInput) => Effect.Effect<void, CapabilityFailure>;
}
declare const ProgramCapabilities_base: Context.ServiceClass<ProgramCapabilities, "@batonfx/core/program/program-capabilities/ProgramCapabilities", Interface>;
/** @experimental Host-owned encoded operations exposed only inside a sandbox execution. */
export declare class ProgramCapabilities extends ProgramCapabilities_base {
}
export {};