import { Cause, Context, Effect, Layer, Schema, Stream } from "effect";
import type { Prompt } from "effect/unstable/ai";
import { type DriverCheckpoint, type DriverOperation, type OperationOutcome, type ReplayPolicy, type DriverOperationKind } from "./driver-contract.js";
import { DriverError, DriverStateInvalid, type DurableAgentDriver } from "./durable-driver.js";
import { type BudgetLimits, type RunBudget, RunBudgetExhausted, type RunBudgetGrantWidened } from "./run-budget.js";
import type { Agent, RunOptions } from "../agent/agent.js";
import type { HandoffControlState } from "../agent/handoff-state.js";
/** @experimental Operation scheduled at one agent-loop effect boundary. */
export interface OperationSpec {
    readonly kind: DriverOperationKind;
    readonly key: string;
    readonly input: unknown;
    readonly replayPolicy: ReplayPolicy;
    readonly turn?: number;
}
/** @experimental Recorded operation for tests and future runtime journaling. */
export interface RecordedOperation {
    readonly operation: DriverOperation;
    readonly outcome: OperationOutcome;
    readonly checkpoint: DriverCheckpoint;
}
/** @experimental Host hook surface for durable operation journaling without runtime imports. */
export interface DriverJournal {
    readonly onScheduled: (operation: DriverOperation, checkpoint: DriverCheckpoint) => Effect.Effect<OperationOutcome | void>;
    readonly onCompleted: (operation: DriverOperation, outcome: OperationOutcome, checkpoint: DriverCheckpoint) => Effect.Effect<void>;
    readonly onCheckpoint: (checkpoint: DriverCheckpoint) => Effect.Effect<void>;
}
declare const DriverJournalService_base: Context.ServiceClass<DriverJournalService, "@batonfx/core/durable/driver-interpreter/DriverJournalService", DriverJournal>;
/** @experimental Optional host journal service merged into Agent.stream driver layers. */
export declare class DriverJournalService extends DriverJournalService_base {
}
/** @experimental Caller-owned successful stream result and replay codec. */
export interface StreamSuccessCodec<A, Success, ReplayError = never, ReplayServices = never> {
    readonly observe: (value: A) => void;
    /** Whether the source reached its authored semantic terminal value rather than a downstream consumer stopping early. */
    readonly isComplete?: () => boolean;
    readonly complete: () => Success;
    readonly replay: (success: Success) => Stream.Stream<A, ReplayError, ReplayServices>;
}
type OperationError<E> = E | DriverError | DriverStateInvalid | DriverUnknownReplay | RunBudgetExhausted;
/** @experimental Inline interpreter executing driver operations through Effect services. */
export interface Interface {
    readonly checkpoint: Effect.Effect<DriverCheckpoint>;
    readonly run: <A, E, R>(spec: OperationSpec, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, OperationError<E>, R>;
    readonly runStream: {
        <A, E, R>(spec: OperationSpec, stream: Stream.Stream<A, E, R>): Stream.Stream<A, OperationError<E>, R>;
        <A, E, R, Success, ReplayError, ReplayServices>(spec: OperationSpec, stream: Stream.Stream<A, E, R>, options: {
            readonly successCodec: StreamSuccessCodec<A, Success, ReplayError, ReplayServices>;
        }): Stream.Stream<A, OperationError<E> | ReplayError, R | ReplayServices>;
    };
    readonly recordSuspension: (input: {
        readonly waitId: string;
        readonly reason: string;
        readonly token: string;
    }) => Effect.Effect<void, DriverError | DriverStateInvalid | DriverUnknownReplay | RunBudgetExhausted>;
    readonly bindResume: (token: string) => Effect.Effect<void, DriverError | DriverStateInvalid | DriverUnknownReplay | RunBudgetExhausted>;
    readonly recorded: Effect.Effect<ReadonlyArray<RecordedOperation>>;
    readonly abortPending: (error: unknown) => Effect.Effect<void, DriverError | DriverStateInvalid | DriverUnknownReplay>;
    readonly chargeUsage: (usage: BudgetLimits) => Effect.Effect<void, RunBudgetExhausted>;
    readonly setBudget: (budget: RunBudget) => Effect.Effect<void>;
    readonly reserveChild: (grant: BudgetLimits) => Effect.Effect<RunBudget, RunBudgetExhausted | RunBudgetGrantWidened>;
    readonly refundChild: (child: RunBudget) => Effect.Effect<void>;
    readonly setHandoffState: (state: HandoffControlState) => Effect.Effect<void, DriverStateInvalid>;
}
declare const DriverUnknownReplay_base: Schema.Class<DriverUnknownReplay, Schema.TaggedStruct<"@batonfx/core/DriverUnknownReplay", {
    readonly operationKey: Schema.String;
    readonly operationId: Schema.String;
}>, Cause.YieldableError>;
/** @experimental */
export declare class DriverUnknownReplay extends DriverUnknownReplay_base {
}
declare const DriverInterpreter_base: Context.ServiceClass<DriverInterpreter, "@batonfx/core/durable/driver-interpreter/DriverInterpreter", Interface>;
/** @experimental */
export declare class DriverInterpreter extends DriverInterpreter_base {
}
/** @experimental */
export declare const guardUnknownNeverReplay: {
    (outcome: OperationOutcome): (operation: DriverOperation) => Effect.Effect<void, DriverUnknownReplay>;
    (operation: DriverOperation, outcome: OperationOutcome): Effect.Effect<void, DriverUnknownReplay>;
};
/** @experimental */
export declare const makeInline: (input: {
    readonly driver: DurableAgentDriver;
    readonly journal?: DriverJournal;
    readonly initial: DriverCheckpoint;
}) => Effect.Effect<Interface>;
/** @experimental */
export declare const layerInline: (input: {
    readonly driver: DurableAgentDriver;
    readonly journal?: DriverJournal;
    readonly initial: DriverCheckpoint;
}) => Layer.Layer<DriverInterpreter>;
/** @experimental */
export declare const layerForRun: {
    <Tools extends Record<string, import("effect/unstable/ai").Tool.Any>, R>(options: RunOptions, prompt: Prompt.Prompt, budget?: RunBudget): (agent: Agent<Tools, R>) => Layer.Layer<DriverInterpreter, DriverError | DriverStateInvalid>;
    <Tools extends Record<string, import("effect/unstable/ai").Tool.Any>, R>(agent: Agent<Tools, R>, options: RunOptions, prompt: Prompt.Prompt, budget?: RunBudget): Layer.Layer<DriverInterpreter, DriverError | DriverStateInvalid>;
};
/** @experimental */
export declare const layerTest: (input: {
    readonly driver: DurableAgentDriver;
    readonly initial: DriverCheckpoint;
    readonly journal?: DriverJournal;
}) => Layer.Layer<DriverInterpreter>;
/** @experimental */
export declare const operationKey: (logicalOperationId: string, ...parts: ReadonlyArray<string | number>) => string;
export {};