import { Effect, Schema } from "effect";
import type { ParseOptions } from "effect/SchemaAST";
/** @experimental Version string for a durable driver implementation. */
export declare const DriverVersion: Schema.String;
/** @experimental */
export type DriverVersion = typeof DriverVersion.Type;
/** @experimental Current durable driver contract version. */
export declare const currentDriverVersion: "1";
/** @experimental How a host may replay one persisted operation after recovery. */
export declare const ReplayPolicy: Schema.Literals<readonly ["pure", "provider-idempotent", "never"]>;
/** @experimental */
export type ReplayPolicy = typeof ReplayPolicy.Type;
/** @experimental Bounded operation kinds the driver may schedule. */
export declare const DriverOperationKind: Schema.Literals<readonly ["model", "tool", "memory", "compaction", "handoff", "send", "wait", "structured-output"]>;
/** @experimental */
export type DriverOperationKind = typeof DriverOperationKind.Type;
/** @experimental One schedulable nondeterministic operation with deterministic identity. */
export declare const DriverOperation: Schema.Struct<{
    readonly key: Schema.String;
    readonly kind: Schema.Literals<readonly ["model", "tool", "memory", "compaction", "handoff", "send", "wait", "structured-output"]>;
    readonly input: Schema.Unknown;
    readonly inputDigest: Schema.String;
    readonly replayPolicy: Schema.Literals<readonly ["pure", "provider-idempotent", "never"]>;
}>;
/** @experimental */
export type DriverOperation = typeof DriverOperation.Type;
/** @experimental Persisted outcome for one operation attempt. */
export declare const OperationOutcome: Schema.Union<readonly [Schema.Struct<{
    readonly _tag: Schema.tag<"Succeeded">;
    readonly value: Schema.Unknown;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"Failed">;
    readonly error: Schema.Unknown;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"Unknown">;
    readonly operationId: Schema.String;
}>]>;
/** @experimental */
export type OperationOutcome = typeof OperationOutcome.Type;
/** @experimental Wait the driver requests before the next decision. */
export declare const WaitDefinition: Schema.Struct<{
    readonly waitId: Schema.String;
    readonly reason: Schema.String;
    readonly replayToken: Schema.optionalKey<Schema.String>;
}>;
/** @experimental */
export type WaitDefinition = typeof WaitDefinition.Type;
/** @experimental Reconstructable durable checkpoint for one agent run. */
export declare const DriverCheckpoint: Schema.Struct<{
    readonly driverVersion: Schema.String;
    readonly executable: Schema.optionalKey<Schema.Struct<{
        readonly executable: Schema.brand<Schema.String, "@batonfx/core/executable-pin">;
        readonly active: Schema.Union<readonly [Schema.brand<Schema.String, "@batonfx/core/agent-pin">, Schema.brand<Schema.String, "@batonfx/core/program-pin">]>;
    }>>;
    readonly turn: Schema.Finite;
    readonly budget: 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;
    }>;
    readonly state: Schema.Unknown;
}>;
/** @experimental */
export type DriverCheckpoint = typeof DriverCheckpoint.Type;
/** @experimental Terminal structured result carried by a Complete decision. */
export declare const DriverResult: Schema.Struct<{
    readonly text: Schema.String;
    readonly turns: Schema.Finite;
}>;
/** @experimental */
export type DriverResult = typeof DriverResult.Type;
/** @experimental Next step chosen deterministically from one checkpoint. */
export declare const DriverDecision: Schema.Union<readonly [Schema.Struct<{
    readonly _tag: Schema.tag<"Execute">;
    readonly operation: Schema.Struct<{
        readonly key: Schema.String;
        readonly kind: Schema.Literals<readonly ["model", "tool", "memory", "compaction", "handoff", "send", "wait", "structured-output"]>;
        readonly input: Schema.Unknown;
        readonly inputDigest: Schema.String;
        readonly replayPolicy: Schema.Literals<readonly ["pure", "provider-idempotent", "never"]>;
    }>;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"Wait">;
    readonly wait: Schema.Struct<{
        readonly waitId: Schema.String;
        readonly reason: Schema.String;
        readonly replayToken: Schema.optionalKey<Schema.String>;
    }>;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"Continue">;
    readonly checkpoint: Schema.Struct<{
        readonly driverVersion: Schema.String;
        readonly executable: Schema.optionalKey<Schema.Struct<{
            readonly executable: Schema.brand<Schema.String, "@batonfx/core/executable-pin">;
            readonly active: Schema.Union<readonly [Schema.brand<Schema.String, "@batonfx/core/agent-pin">, Schema.brand<Schema.String, "@batonfx/core/program-pin">]>;
        }>>;
        readonly turn: Schema.Finite;
        readonly budget: 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;
        }>;
        readonly state: Schema.Unknown;
    }>;
}>, Schema.Struct<{
    readonly _tag: Schema.tag<"Complete">;
    readonly result: Schema.Struct<{
        readonly text: Schema.String;
        readonly turns: Schema.Finite;
    }>;
}>]>;
/** @experimental */
export type DriverDecision = typeof DriverDecision.Type;
/** @experimental */
export declare const operationKey: (parts: ReadonlyArray<string | number>) => string;
/** @experimental */
export declare const inputDigest: (input: unknown) => string;
/** @experimental */
export declare const makeOperation: (input: {
    readonly key: string;
    readonly kind: DriverOperationKind;
    readonly input: unknown;
    readonly replayPolicy: ReplayPolicy;
}) => DriverOperation;
/** @experimental */
export declare const encodeCheckpoint: {
    (input: DriverCheckpoint, options?: ParseOptions): Effect.Effect<typeof DriverCheckpoint.Encoded, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: DriverCheckpoint) => Effect.Effect<typeof DriverCheckpoint.Encoded, Schema.SchemaError, never>;
};
/** @experimental */
export declare const decodeCheckpoint: {
    (input: typeof DriverCheckpoint.Encoded, options?: ParseOptions): Effect.Effect<DriverCheckpoint, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: typeof DriverCheckpoint.Encoded) => Effect.Effect<DriverCheckpoint, Schema.SchemaError, never>;
};
/** @experimental */
export declare const encodeDecision: {
    (input: DriverDecision, options?: ParseOptions): Effect.Effect<typeof DriverDecision.Encoded, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: DriverDecision) => Effect.Effect<typeof DriverDecision.Encoded, Schema.SchemaError, never>;
};
/** @experimental */
export declare const decodeDecision: {
    (input: typeof DriverDecision.Encoded, options?: ParseOptions): Effect.Effect<DriverDecision, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: typeof DriverDecision.Encoded) => Effect.Effect<DriverDecision, Schema.SchemaError, never>;
};
/** @experimental */
export declare const encodeOutcome: {
    (input: OperationOutcome, options?: ParseOptions): Effect.Effect<typeof OperationOutcome.Encoded, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: OperationOutcome) => Effect.Effect<typeof OperationOutcome.Encoded, Schema.SchemaError, never>;
};
/** @experimental */
export declare const decodeOutcome: {
    (input: typeof OperationOutcome.Encoded, options?: ParseOptions): Effect.Effect<OperationOutcome, Schema.SchemaError, never>;
    (options?: ParseOptions): (input: typeof OperationOutcome.Encoded) => Effect.Effect<OperationOutcome, Schema.SchemaError, never>;
};
/** @experimental */
export declare const isUnknownOutcome: (outcome: OperationOutcome) => outcome is Extract<OperationOutcome, {
    _tag: "Unknown";
}>;
/** @experimental */
export declare const isSucceededOutcome: (outcome: OperationOutcome) => outcome is Extract<OperationOutcome, {
    _tag: "Succeeded";
}>;
/** @experimental */
export declare const isFailedOutcome: (outcome: OperationOutcome) => outcome is Extract<OperationOutcome, {
    _tag: "Failed";
}>;