import { Context, Effect, Layer, Schema, Scope } from "effect";
import { type ProgramCapabilities } from "./program-capabilities.js";
/** @experimental */
export interface Request {
    readonly language: "javascript";
    readonly source: string;
    readonly sourceDigest: string;
    readonly input: unknown;
    readonly signal: AbortSignal;
    readonly limits: {
        readonly wallTimeMillis: number;
        readonly outputBytes: number;
    };
}
declare const SandboxUnavailable_base: Schema.Class<SandboxUnavailable, Schema.TaggedStruct<"@batonfx/core/SandboxUnavailable", {
    readonly language: Schema.Literal<"javascript">;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class SandboxUnavailable extends SandboxUnavailable_base {
}
declare const SandboxExecutionFailure_base: Schema.Class<SandboxExecutionFailure, Schema.TaggedStruct<"@batonfx/core/SandboxExecutionFailure", {
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class SandboxExecutionFailure extends SandboxExecutionFailure_base {
}
declare const SandboxProtocolViolation_base: Schema.Class<SandboxProtocolViolation, Schema.TaggedStruct<"@batonfx/core/SandboxProtocolViolation", {
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** @experimental */
export declare class SandboxProtocolViolation extends SandboxProtocolViolation_base {
}
/** @experimental Typed failures that may cross the sandbox capability protocol. */
export declare const ExecutionFailure: Schema.Union<readonly [typeof SandboxUnavailable, typeof SandboxExecutionFailure, typeof SandboxProtocolViolation, Schema.Union<readonly [typeof import("./program-capabilities.js").ProgramCapabilityMissing, typeof import("./program-capabilities.js").ProgramCapabilityDenied, typeof import("./program-capabilities.js").ProgramAuthorizationFailure, typeof import("./program-capabilities.js").ProgramSchemaFailure, typeof import("./program-capabilities.js").ProgramToolFailure, typeof import("./program-capabilities.js").ProgramStepFailure, typeof import("./program-capabilities.js").ProgramAgentFailure, typeof import("./program-capabilities.js").ProgramBudgetExhausted, typeof import("./program-capabilities.js").ProgramReplayDivergence, typeof import("./program-capabilities.js").ProgramOperationUnknown, typeof import("./program-capabilities.js").ProgramSuspended, typeof import("./program-capabilities.js").ProgramCancelled]>]>;
/** @experimental */
export type ExecutionFailure = typeof ExecutionFailure.Type;
/**
 * @experimental Immutable JSON identity of one executor implementation and its enforced limits. Hosts pin,
 * persist, and compare this value so an admitted Program can only run under the exact executor that admitted it.
 */
export declare const Identity: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
/** @experimental */
export type Identity = typeof Identity.Type;
/** @experimental */
export interface Interface {
    readonly identity: Identity;
    readonly execute: (request: Request) => Effect.Effect<unknown, ExecutionFailure, ProgramCapabilities | Scope.Scope>;
}
declare const SandboxExecutor_base: Context.ServiceClass<SandboxExecutor, "@batonfx/core/program/sandbox-executor/SandboxExecutor", Interface>;
/** @experimental Host-supplied isolated source executor. Baton does not provide a production implementation. */
export declare class SandboxExecutor extends SandboxExecutor_base {
}
/** @experimental Identity carried by trusted fixture executors. No production host may claim it. */
export declare const testIdentity: Identity;
/** @experimental Trusted fixture executor for tests only. */
export declare const makeTest: {
    (identity?: Identity): (execute: Interface["execute"]) => Interface;
    (execute: Interface["execute"], identity?: Identity): Interface;
};
/** @experimental Trusted fixture Layer for tests only. It provides no source isolation. */
export declare const layerTest: {
    (identity?: Identity): (execute: Interface["execute"]) => Layer.Layer<SandboxExecutor>;
    (execute: Interface["execute"], identity?: Identity): Layer.Layer<SandboxExecutor>;
};
export {};