import type { SandboxControlCommand, SandboxControlEvent, SandboxControlFsCommand } from "./control-codec.ts";
type SandboxControlFsRequest = SandboxControlFsCommand extends infer T ? T extends SandboxControlFsCommand ? Omit<T, "id"> : never : never;
export interface SandboxControl extends Transport<SandboxControlEvent, SandboxControlCommand> {
    requestFileSystem(command: SandboxControlFsRequest): Promise<Extract<SandboxControlEvent, {
        type: "guest.fs.response";
    }>>;
    exec(input: {
        readonly id?: string;
        readonly argv: readonly string[];
        readonly env?: Record<string, string>;
        readonly cwd: string;
        readonly timeoutMs?: number;
        readonly signal?: AbortSignal;
    }): Promise<Extract<SandboxControlEvent, {
        type: "guest.exec.complete";
    }>>;
    spawn(input: {
        readonly id?: string;
        readonly argv: readonly string[];
        readonly env?: Record<string, string>;
        readonly cwd: string;
        readonly pipes: readonly number[];
    }): ControlBackedSandboxProcess;
    pty(input: {
        readonly id?: string;
        readonly argv: readonly string[];
        readonly env?: Record<string, string>;
        readonly cwd: string;
        readonly size: {
            readonly rows: number;
            readonly cols: number;
        };
    }): ControlBackedSandboxPty;
    openConnection(input: {
        readonly hostname: string;
        readonly port: number;
        readonly secure: boolean;
        readonly timeoutMs: number;
        readonly serverName?: string;
    }): ControlBackedGuestConnection;
}
export interface Transport<TIncoming = unknown, TOutgoing = unknown> {
    readonly incoming: AsyncIterable<TIncoming>;
    send(message: TOutgoing): Promise<void>;
    close(): Promise<void>;
}
export interface HostControlChannel {
    readonly packets: AsyncIterable<Uint8Array>;
    writeControlPacket(packet: Uint8Array): void;
}
type SandboxProcessSignal = "SIGHUP" | "SIGINT" | "SIGQUIT" | "SIGTERM" | "SIGKILL";
export declare class HostControlTransport implements SandboxControl {
    #private;
    readonly incoming: AsyncIterable<SandboxControlEvent>;
    constructor(options?: {
        readonly connected?: boolean;
        readonly channel?: HostControlChannel;
    });
    send(message: SandboxControlCommand): Promise<void>;
    requestFileSystem(command: SandboxControlFsRequest): Promise<Extract<SandboxControlEvent, {
        type: "guest.fs.response";
    }>>;
    exec(input: {
        readonly id?: string;
        readonly argv: readonly string[];
        readonly env?: Record<string, string>;
        readonly cwd: string;
        readonly timeoutMs?: number;
        readonly signal?: AbortSignal;
    }): Promise<Extract<SandboxControlEvent, {
        type: "guest.exec.complete";
    }>>;
    spawn(input: {
        readonly id?: string;
        readonly argv: readonly string[];
        readonly env?: Record<string, string>;
        readonly cwd: string;
        readonly pipes: readonly number[];
    }): ControlBackedSandboxProcess;
    pty(input: {
        readonly id?: string;
        readonly argv: readonly string[];
        readonly env?: Record<string, string>;
        readonly cwd: string;
        readonly size: {
            readonly rows: number;
            readonly cols: number;
        };
    }): ControlBackedSandboxPty;
    openConnection(input: {
        readonly hostname: string;
        readonly port: number;
        readonly secure: boolean;
        readonly timeoutMs: number;
        readonly serverName?: string;
    }): ControlBackedGuestConnection;
    close(): Promise<void>;
    emit(event: SandboxControlEvent): void;
}
export declare class ControlBackedGuestConnection {
    #private;
    readonly opened: Promise<void>;
    constructor(id: string, control: SandboxControl, onClose: () => void);
    onError(handler: (error: Error) => void): void;
    write(data: Uint8Array): Promise<void>;
    read(maxBytes: number): Promise<Uint8Array | null>;
    close(): void;
    emit(event: Extract<SandboxControlEvent, {
        type: "guest.connection.opened" | "guest.connection.write.complete" | "guest.connection.data" | "guest.connection.end" | "guest.connection.error";
    }>): void;
    fail(error: unknown): void;
}
export declare class ControlBackedSandboxProcess {
    #private;
    readonly stdin: WritableStream<Uint8Array>;
    readonly stdout: ReadableStream<Uint8Array>;
    readonly stderr: ReadableStream<Uint8Array>;
    readonly pipes: ReadonlyMap<number, ControlBackedSandboxProcessPipe>;
    readonly ready: Promise<void>;
    readonly exit: Promise<{
        readonly exitCode: number | null;
        readonly signal: SandboxProcessSignal | null;
    }>;
    constructor(id: string, control: SandboxControl, pipes: readonly number[]);
    emit(event: Extract<SandboxControlEvent, {
        type: "guest.spawn.stdout" | "guest.spawn.stderr" | "guest.spawn.pipe.output" | "guest.spawn.pipe.output.closed" | "guest.spawn.exit" | "guest.spawn.streams.closed";
    }>): void;
    resolveReady(): void;
    rejectReady(error: unknown): void;
    kill(signal?: SandboxProcessSignal): void;
    fail(error: unknown): void;
}
export declare class ControlBackedSandboxProcessPipe {
    #private;
    readonly input: WritableStream<Uint8Array>;
    readonly output: ReadableStream<Uint8Array>;
    constructor(control: SandboxControl, id: string, fd: number);
    enqueue(chunk: Uint8Array): void;
    closeFromGuest(error: unknown): void;
    closeOutputFromGuest(): void;
    fail(error: unknown): void;
}
export declare class ControlBackedSandboxPty {
    #private;
    readonly input: WritableStream<Uint8Array>;
    readonly output: ReadableStream<Uint8Array>;
    readonly ready: Promise<void>;
    readonly exit: Promise<{
        readonly exitCode: number | null;
        readonly signal: SandboxProcessSignal | null;
    }>;
    constructor(id: string, control: SandboxControl);
    emit(event: Extract<SandboxControlEvent, {
        type: "guest.spawn.stdout" | "guest.spawn.stderr" | "guest.spawn.exit" | "guest.spawn.streams.closed";
    }>): void;
    resolveReady(): void;
    rejectReady(error: unknown): void;
    resize(size: {
        readonly rows: number;
        readonly cols: number;
    }): void;
    kill(signal?: SandboxProcessSignal): void;
    fail(error: unknown): void;
}
export {};
//# sourceMappingURL=control.d.ts.map