import type { SandboxLogEntry, SandboxStats } from './client.js';
import { type BridgeResult, type LocalRuntime } from './runtime.js';
export declare const DEFAULT_IMAGE = "alpine:3.20";
export declare const MAX_ARTIFACT_BYTES: number;
export declare const MAX_EXECUTION_EVENT_BATCH_ITEMS = 4096;
export declare const DEFAULT_EVENT_STREAM_BATCH_ITEMS = 256;
export declare const DEFAULT_EVENT_STREAM_WAIT_TIMEOUT_MS = 1000;
export type Isolation = 'microvm' | 'sandbox';
export type SandboxNetwork = {
    readonly mode: 'tsi';
} | {
    readonly mode: 'none';
} | {
    readonly mode: 'bridge';
    readonly name: string;
};
export type VolumeMount = {
    readonly kind: 'bind';
    readonly source: string;
    readonly target: string;
    readonly readOnly?: boolean;
} | {
    readonly kind: 'named';
    readonly name: string;
    readonly target: string;
    readonly readOnly?: boolean;
};
export interface TmpfsMount {
    target: string;
    sizeBytes?: number;
    readOnly?: boolean;
}
export interface PortMapping {
    hostPort: number;
    guestPort: number;
}
export interface Script {
    source: string | Uint8Array;
    interpreter?: readonly string[];
}
export interface SandboxCreateOptions {
    command?: readonly string[];
    entrypoint?: readonly string[];
    timeoutMs?: number;
    envs?: Readonly<Record<string, string>>;
    metadata?: Readonly<Record<string, string>>;
    name?: string;
    cpus?: number;
    memoryMb?: number;
    isolation?: Isolation;
    filesystemSnapshotId?: string;
    workspace?: string;
    workdir?: string;
    user?: string;
    hostname?: string;
    mounts?: readonly VolumeMount[];
    tmpfs?: readonly TmpfsMount[];
    network?: SandboxNetwork;
    ports?: readonly PortMapping[];
    dns?: readonly string[];
    hostAliases?: Readonly<Record<string, string>>;
    readOnly?: boolean;
    persistent?: boolean;
    autoRemove?: boolean;
    runtime?: LocalRuntime;
}
export interface SandboxConnectOptions {
    runtime?: LocalRuntime;
}
export interface CommandRunOptions {
    timeoutMs?: number;
    envs?: Readonly<Record<string, string>>;
    cwd?: string;
    user?: string;
    stdin?: string | Uint8Array;
    /**
     * Stable one-shot exec identity for replay-safe retries after retryable
     * Unavailable. When omitted, the Rust Sandbox facade mints a fresh id.
     * Reuse the same id on retry; do not append `.retry-N`.
     */
    requestId?: string;
}
export interface CommandResult {
    stdout: string;
    stderr: string;
    exitCode: number;
    truncated: boolean;
    /** Process-journal identity used for this one-shot exec. */
    requestId: string;
}
export interface WriteInfo {
    path: string;
    size: number;
    /** Durable upload identity used for this write (SDK-minted or caller-supplied). */
    requestId: string;
}
/** Result of a successful mutating filesystem op (makeDir / rename / remove). */
export interface MutateInfo {
    /** Durable mutate identity used for this op (SDK-minted `fs-*` or caller-supplied). */
    requestId: string;
}
export interface Artifact {
    path: string;
    data: Uint8Array;
    size: number;
    sha256: string;
    hostPath?: string;
}
export interface ArtifactExportOptions {
    maxBytes?: number;
    destination?: string;
    user?: string;
}
export interface FilesystemSnapshotInfo {
    snapshotId: string;
    sizeBytes: number;
    state: string;
    generation: number;
}
export interface EntryInfo {
    name: string;
    type: 'file' | 'directory' | 'unspecified';
    path: string;
    size: number;
    mode: number;
    permissions: string;
    owner: string;
    group: string;
    modifiedSeconds: number;
    modifiedNanos: number;
    symlinkTarget?: string;
}
export interface FilesystemReadOptions {
    format?: 'text' | 'bytes';
    user?: string;
}
export interface ExecutionProcessInfo {
    processId: string;
    pid?: number;
    terminal: boolean;
}
export interface ExecutionProcessInventory {
    executionId: string;
    generation: number;
    processes: ExecutionProcessInfo[];
}
export interface ExecutionCpuStats {
    usageNs: number;
    userNs: number;
    systemNs: number;
    throttledNs: number;
}
export interface ExecutionMemoryStats {
    usageBytes: number;
    limitBytes?: number;
    peakBytes?: number;
}
export interface ExecutionStats {
    executionId: string;
    generation: number;
    /** Exact Unix epoch nanoseconds. */
    timestampUnixNs: bigint;
    cpu: ExecutionCpuStats;
    memory: ExecutionMemoryStats;
    processCount: number;
    metrics: Readonly<Record<string, number>>;
}
export type ExecutionEventKind = 'container-creating' | 'container-created' | 'container-started' | 'container-stopped' | 'container-deleted' | 'container-paused' | 'container-resumed' | 'resources-updated' | 'process-created' | 'process-started' | 'process-exited' | 'output-dropped' | 'runtime-warning';
export interface ExecutionRuntimeEvent {
    sequence: number;
    /** Exact Unix epoch nanoseconds. */
    timestampUnixNs: bigint;
    processId?: string;
    kind: ExecutionEventKind;
    attributes: Readonly<Record<string, string>>;
}
export interface ExecutionEventBatch {
    executionId: string;
    generation: number;
    events: ExecutionRuntimeEvent[];
    nextSequence: number;
}
export interface ExecutionEventsOptions {
    afterSequence?: number;
    limit?: number;
    waitTimeoutMs?: number;
}
export interface ExecutionEventStreamOptions {
    afterSequence?: number;
    batchSize?: number;
    waitTimeoutMs?: number;
    signal?: AbortSignal;
}
export interface ExecutionResourceUpdate {
    memoryReservation?: number;
    memorySwap?: number;
    pidsLimit?: number;
    cpuShares?: number;
    cpuQuota?: number;
    cpuPeriod?: number;
    cpusetCpus?: string;
}
export interface UpdateResourcesOptions {
    operationId?: string;
}
export declare class Sandbox {
    readonly sandboxId: string;
    readonly id: string;
    generation: number;
    state: string;
    readonly isolation: Isolation;
    readonly commands: Commands;
    readonly files: Filesystem;
    private readonly runtime;
    protected constructor(sandboxId: string, generation: number, state: string, isolation: Isolation, runtime: LocalRuntime);
    static create(template?: string, options?: SandboxCreateOptions): Promise<Sandbox>;
    static connect(sandboxId: string, options?: SandboxConnectOptions): Promise<Sandbox>;
    private static fromResult;
    kill(): Promise<void>;
    stop(): Promise<void>;
    restart(options?: {
        operationId?: string;
        stopTimeoutSeconds?: number;
    }): Promise<void>;
    remove(): Promise<void>;
    pause(options?: {
        keepMemory?: boolean;
    }): Promise<void>;
    resume(): Promise<void>;
    isRunning(): Promise<boolean>;
    logs(options?: {
        tail?: number;
    }): Promise<SandboxLogEntry[]>;
    stats(): Promise<SandboxStats | undefined>;
    processes(): Promise<ExecutionProcessInventory>;
    runtimeStats(): Promise<ExecutionStats>;
    events(options?: ExecutionEventsOptions): Promise<ExecutionEventBatch>;
    streamEvents(options?: ExecutionEventStreamOptions): AsyncIterable<ExecutionRuntimeEvent>;
    updateResources(update: ExecutionResourceUpdate, options?: UpdateResourcesOptions): Promise<void>;
    createFilesystemSnapshot(snapshotId: string): Promise<FilesystemSnapshotInfo>;
    script(source: string | Uint8Array | Script): ScriptBuilder;
    static filesystemSnapshotSize(snapshotId: string, options?: SandboxConnectOptions): Promise<number | undefined>;
    static deleteFilesystemSnapshot(snapshotId: string, options?: SandboxConnectOptions): Promise<boolean>;
    bridgeRequest(request: Readonly<Record<string, unknown>>): Promise<BridgeResult>;
    private lifecycleRequest;
    private updateLifecycle;
    private requireRunning;
    private requireObservable;
    private requireStreamGeneration;
    private validateExecutionIdentity;
}
export declare class Commands {
    private readonly sandbox;
    constructor(sandbox: Sandbox);
    run(command: string | readonly string[], options?: CommandRunOptions): Promise<CommandResult>;
    script(source: string | Uint8Array | Script): ScriptBuilder;
    runScript(source: string | Uint8Array | Script, options?: CommandRunOptions): Promise<CommandResult>;
}
/** Fluent script builder that sends source through stdin to an interpreter. */
export declare class ScriptBuilder {
    private readonly commands;
    private readonly source;
    private interpreterArgv;
    private options;
    constructor(commands: Commands, script: string | Uint8Array | Script);
    interpreter(executable: string, ...args: string[]): ScriptBuilder;
    timeout(timeoutMs: number): ScriptBuilder;
    env(key: string, value: string): ScriptBuilder;
    cwd(path: string): ScriptBuilder;
    user(user: string): ScriptBuilder;
    requestId(requestId: string): ScriptBuilder;
    run(): Promise<CommandResult>;
}
export declare class Filesystem {
    private readonly sandbox;
    constructor(sandbox: Sandbox);
    write(path: string, data: string | Uint8Array, options?: {
        user?: string;
        requestId?: string;
    }): Promise<WriteInfo>;
    read(path: string, options?: FilesystemReadOptions): Promise<string>;
    read(path: string, options: FilesystemReadOptions & {
        format: 'bytes';
    }): Promise<Uint8Array>;
    export(path: string, options?: ArtifactExportOptions): Promise<Artifact>;
    stat(path: string, options?: {
        user?: string;
    }): Promise<EntryInfo>;
    exists(path: string, options?: {
        user?: string;
    }): Promise<boolean>;
    list(path: string, options?: {
        depth?: number;
        user?: string;
    }): Promise<EntryInfo[]>;
    makeDir(path: string, options?: {
        user?: string;
        requestId?: string;
    }): Promise<MutateInfo>;
    rename(oldPath: string, newPath: string, options?: {
        user?: string;
        requestId?: string;
    }): Promise<MutateInfo>;
    remove(path: string, options?: {
        user?: string;
        requestId?: string;
    }): Promise<MutateInfo>;
    private readBytes;
    private request;
}
//# sourceMappingURL=sandbox.d.ts.map