endia 0.0.0-stage → 0.0.2

package/dist/groups/bases.d.ts

@@ -0,0 +1,28 @@
+import type { BaseImportRequest, BaseImportResult, BasePrepareRequest } from "../contract/bases.js";
+import type { OperationHandle } from "./operations.js";
+/**
+ * The base routes, which make the images that have no parent: import a Windows disk already on the host, or install Windows from an
+ * installation disc. The service does this work in the background, so each method returns a handle on the operation, which follows
+ * the work and gives its result, the new image's description.
+ */
+export declare class BasesClient {
+    private readonly connection;
+    private readonly operations;
+    /**
+     * Imports a Windows disk on the host as an image: `endia import`.
+     *
+     * @param request - The disk's path on the host, the reference the image will carry, and the configuration changes.
+     * @param signal - Cancels the request.
+     * @returns The import's operation; its result is a `BaseImportResult`.
+     */
+    import(request: BaseImportRequest, signal?: AbortSignal): Promise<OperationHandle<BaseImportResult>>;
+    /**
+     * Installs Windows from an installation disc on the host and imports the result: `endia base prepare`. The request carries a
+     * password, so it is sent once, without an `Idempotency-Key` and without a retry.
+     *
+     * @param request - The disc, the tag, the accounts and their password.
+     * @param signal - Cancels the request.
+     * @returns The preparation's operation; its result is a `BaseImportResult`.
+     */
+    prepare(request: BasePrepareRequest, signal?: AbortSignal): Promise<OperationHandle<BaseImportResult>>;
+}

package/dist/groups/bases.js

@@ -0,0 +1,39 @@
+import { Routes } from "../routes.js";
+import { jsonBody } from "../transport/api-connection.js";
+/**
+ * The base routes, which make the images that have no parent: import a Windows disk already on the host, or install Windows from an
+ * installation disc. The service does this work in the background, so each method returns a handle on the operation, which follows
+ * the work and gives its result, the new image's description.
+ */
+export class BasesClient {
+    connection;
+    operations;
+    /** @internal */
+    constructor(connection, operations) {
+        this.connection = connection;
+        this.operations = operations;
+    }
+    /**
+     * Imports a Windows disk on the host as an image: `endia import`.
+     *
+     * @param request - The disk's path on the host, the reference the image will carry, and the configuration changes.
+     * @param signal - Cancels the request.
+     * @returns The import's operation; its result is a `BaseImportResult`.
+     */
+    async import(request, signal) {
+        const accepted = await this.connection.change({ method: "POST", path: Routes.baseImport, body: jsonBody(request), signal });
+        return this.operations.handle(accepted);
+    }
+    /**
+     * Installs Windows from an installation disc on the host and imports the result: `endia base prepare`. The request carries a
+     * password, so it is sent once, without an `Idempotency-Key` and without a retry.
+     *
+     * @param request - The disc, the tag, the accounts and their password.
+     * @param signal - Cancels the request.
+     * @returns The preparation's operation; its result is a `BaseImportResult`.
+     */
+    async prepare(request, signal) {
+        const accepted = await this.connection.sendOnce({ method: "POST", path: Routes.basePrepare, body: jsonBody(request), signal });
+        return this.operations.handle(accepted);
+    }
+}

package/dist/groups/certificates.d.ts

@@ -0,0 +1,32 @@
+import type { ClientCertificateSummary, IssuedClientCertificate } from "../contract/clients.js";
+/**
+ * The client certificate routes: issue, list and revoke the certificates that callers over HTTPS present. The service answers them
+ * only on its named pipe, and refuses a caller over HTTPS with `PERMISSION_DENIED`.
+ */
+export declare class CertificatesClient {
+    private readonly connection;
+    /**
+     * Issues a client certificate: `endia context export`. The answer holds the new certificate's private key, and the service
+     * keeps no copy of it to replay. The request is therefore sent once, without an `Idempotency-Key` and without a retry.
+     *
+     * @param name - The certificate's name, which the service records as the caller of each request made with it.
+     * @param signal - Cancels the request.
+     * @returns The authority, the certificate and its private key, as PEM text.
+     */
+    issue(name: string, signal?: AbortSignal): Promise<IssuedClientCertificate>;
+    /**
+     * Lists the issued client certificates: `endia cert ls`.
+     *
+     * @param signal - Cancels the request.
+     * @returns The certificates, without their keys.
+     */
+    list(signal?: AbortSignal): Promise<ClientCertificateSummary[]>;
+    /**
+     * Revokes a client certificate, after which the service refuses it: `endia cert rm`.
+     *
+     * @param name - The certificate's name.
+     * @param signal - Cancels the request.
+     * @returns The certificate as revoked.
+     */
+    revoke(name: string, signal?: AbortSignal): Promise<ClientCertificateSummary>;
+}

package/dist/groups/certificates.js

@@ -0,0 +1,43 @@
+import { Routes } from "../routes.js";
+import { jsonBody } from "../transport/api-connection.js";
+/**
+ * The client certificate routes: issue, list and revoke the certificates that callers over HTTPS present. The service answers them
+ * only on its named pipe, and refuses a caller over HTTPS with `PERMISSION_DENIED`.
+ */
+export class CertificatesClient {
+    connection;
+    /** @internal */
+    constructor(connection) {
+        this.connection = connection;
+    }
+    /**
+     * Issues a client certificate: `endia context export`. The answer holds the new certificate's private key, and the service
+     * keeps no copy of it to replay. The request is therefore sent once, without an `Idempotency-Key` and without a retry.
+     *
+     * @param name - The certificate's name, which the service records as the caller of each request made with it.
+     * @param signal - Cancels the request.
+     * @returns The authority, the certificate and its private key, as PEM text.
+     */
+    issue(name, signal) {
+        return this.connection.sendOnce({ method: "POST", path: Routes.clients, body: jsonBody({ name }), signal });
+    }
+    /**
+     * Lists the issued client certificates: `endia cert ls`.
+     *
+     * @param signal - Cancels the request.
+     * @returns The certificates, without their keys.
+     */
+    list(signal) {
+        return this.connection.read(Routes.clients, signal);
+    }
+    /**
+     * Revokes a client certificate, after which the service refuses it: `endia cert rm`.
+     *
+     * @param name - The certificate's name.
+     * @param signal - Cancels the request.
+     * @returns The certificate as revoked.
+     */
+    revoke(name, signal) {
+        return this.connection.change({ method: "DELETE", path: Routes.client(name), signal });
+    }
+}

package/dist/groups/desktop.d.ts

@@ -0,0 +1,143 @@
+import type { Timestamp } from "../contract/common.js";
+import type { ClickRequest, DesktopInspectRequest, DesktopInspectResult, DesktopLaunchRequest, DesktopLaunchResult, DesktopWaitRequest, DesktopWaitResult, DesktopWindow, InvokeRequest, InvokeResult, KeysRequest, KeysResult, PointerRequest, PointerResult, SetValueRequest, SetValueResult, TrayClickRequest, TrayClickResult, TrayIcon, UacRequest, UacResult } from "../contract/desktop.js";
+/** A picture of the desktop user's screen, or of one process's windows. */
+export interface DesktopScreenshot {
+    /** The picture as PNG bytes. */
+    readonly png: Buffer;
+    readonly width: number;
+    readonly height: number;
+    /** The Windows session the picture was taken in. */
+    readonly sessionId: number;
+    readonly taken: Timestamp;
+}
+/**
+ * The desktop routes of a running machine, which drive the signed-in desktop user's session through UI Automation, the Windows
+ * interface that reads and operates the controls of other programs' windows. A program is launched with `launch`; its controls are
+ * then found by a selector whose first segment names one of the program's top-level windows, and operated with `invoke`, `click`,
+ * `setValue` and `keys`.
+ */
+export declare class DesktopClient {
+    private readonly connection;
+    /**
+     * Starts a program in the desktop user's session: `endia desktop launch`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program, its arguments, and whether to start it elevated.
+     * @param signal - Cancels the request.
+     * @returns The process and its windows; its `processId` and `started` name the process in the other desktop requests.
+     */
+    launch(machine: string, request: DesktopLaunchRequest, signal?: AbortSignal): Promise<DesktopLaunchResult>;
+    /**
+     * Takes a picture of the screen: `endia desktop screenshot`. It changes nothing, so it carries no `Idempotency-Key`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param options - `processId` limits the picture to that process's windows.
+     * @returns The picture.
+     */
+    screenshot(machine: string, options?: {
+        readonly processId?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<DesktopScreenshot>;
+    /**
+     * Reads the tree of controls in a process's windows: `endia desktop inspect`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, and optionally one of its windows.
+     * @param signal - Cancels the request.
+     * @returns Each window with its tree of elements.
+     */
+    inspect(machine: string, request: DesktopInspectRequest, signal?: AbortSignal): Promise<DesktopInspectResult>;
+    /**
+     * Waits until a selector names exactly one element, or with `gone` until it names none: `endia desktop wait`. The service
+     * answers only when the wait ends, so the client's own time limit does not apply; `timeoutSeconds` limits the wait.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, the selector and the longest wait.
+     * @param signal - Cancels the request.
+     * @returns The element and its window; both null after a wait for `gone`.
+     */
+    wait(machine: string, request: DesktopWaitRequest, signal?: AbortSignal): Promise<DesktopWaitResult>;
+    /**
+     * Uses an element's Invoke pattern, as pressing a button does: `endia desktop invoke`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process and the selector.
+     * @param signal - Cancels the request.
+     * @returns Whether the element was invoked.
+     */
+    invoke(machine: string, request: InvokeRequest, signal?: AbortSignal): Promise<InvokeResult>;
+    /**
+     * Clicks the pointer at an element's centre: `endia desktop click`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, the selector and the button.
+     * @param signal - Cancels the request.
+     * @returns The point clicked on the screen.
+     */
+    click(machine: string, request: ClickRequest, signal?: AbortSignal): Promise<PointerResult>;
+    /**
+     * Sets an element's value, such as a text box's text: `endia desktop set-value`. A secret value, such as a password, is sent
+     * once, without an `Idempotency-Key` and without a retry, so that the service never stores it.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, the selector, the value, and whether it is secret.
+     * @param signal - Cancels the request.
+     * @returns The value read back, or null for a secret value.
+     */
+    setValue(machine: string, request: SetValueRequest, signal?: AbortSignal): Promise<SetValueResult>;
+    /**
+     * Types keys or text into a process's main window: `endia desktop keys`. The service brings the window to the foreground and
+     * checks that it is there before sending anything; otherwise it refuses the request with `FOCUS_REFUSED`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, and `keys` as space-separated chords such as `ctrl+s`, or `text` to type as it is.
+     * @param signal - Cancels the request.
+     * @returns The number of input events sent.
+     */
+    keys(machine: string, request: KeysRequest, signal?: AbortSignal): Promise<KeysResult>;
+    /**
+     * Moves, clicks or scrolls the pointer at a point: `endia desktop pointer`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The action, the point, and optionally the process whose window the point is relative to.
+     * @param signal - Cancels the request.
+     * @returns The point on the screen, and the window under it.
+     */
+    pointer(machine: string, request: PointerRequest, signal?: AbortSignal): Promise<PointerResult>;
+    /**
+     * Lists the visible top-level windows of the desktop user's session: `endia desktop windows`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The windows.
+     */
+    windows(machine: string, signal?: AbortSignal): Promise<DesktopWindow[]>;
+    /**
+     * Lists the icons of the notification area: `endia desktop tray ls`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The icons.
+     */
+    tray(machine: string, signal?: AbortSignal): Promise<TrayIcon[]>;
+    /**
+     * Clicks an icon of the notification area: `endia desktop tray click`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The icon's name and the button.
+     * @param signal - Cancels the request.
+     * @returns The icon and the point clicked.
+     */
+    trayClick(machine: string, request: TrayClickRequest, signal?: AbortSignal): Promise<TrayClickResult>;
+    /**
+     * Answers an elevation prompt for an expected program: `endia desktop uac`. The request may carry a password, so it is sent
+     * once, without an `Idempotency-Key`, without a retry and without the client's time limit.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program the prompt must name, and how to answer it.
+     * @param signal - Cancels the request.
+     * @returns The outcome, the prompt as read, and pictures of the screen before and after.
+     */
+    answerPrompt(machine: string, request: UacRequest, signal?: AbortSignal): Promise<UacResult>;
+    private send;
+}

package/dist/groups/desktop.js

@@ -0,0 +1,182 @@
+import { Headers, Routes } from "../routes.js";
+import { jsonBody } from "../transport/api-connection.js";
+/**
+ * The desktop routes of a running machine, which drive the signed-in desktop user's session through UI Automation, the Windows
+ * interface that reads and operates the controls of other programs' windows. A program is launched with `launch`; its controls are
+ * then found by a selector whose first segment names one of the program's top-level windows, and operated with `invoke`, `click`,
+ * `setValue` and `keys`.
+ */
+export class DesktopClient {
+    connection;
+    /** @internal */
+    constructor(connection) {
+        this.connection = connection;
+    }
+    /**
+     * Starts a program in the desktop user's session: `endia desktop launch`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program, its arguments, and whether to start it elevated.
+     * @param signal - Cancels the request.
+     * @returns The process and its windows; its `processId` and `started` name the process in the other desktop requests.
+     */
+    launch(machine, request, signal) {
+        return this.send(machine, "launch", request, signal);
+    }
+    /**
+     * Takes a picture of the screen: `endia desktop screenshot`. It changes nothing, so it carries no `Idempotency-Key`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param options - `processId` limits the picture to that process's windows.
+     * @returns The picture.
+     */
+    async screenshot(machine, options = {}) {
+        const answer = await this.connection.sendWithoutKey({
+            method: "POST",
+            path: Routes.desktop(machine, "screenshot"),
+            body: jsonBody({ processId: options.processId }),
+            signal: options.signal,
+        });
+        return {
+            png: answer.body,
+            width: Number(header(answer, Headers.screenshotWidth)),
+            height: Number(header(answer, Headers.screenshotHeight)),
+            sessionId: Number(header(answer, Headers.screenshotSession)),
+            taken: header(answer, Headers.screenshotTaken),
+        };
+    }
+    /**
+     * Reads the tree of controls in a process's windows: `endia desktop inspect`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, and optionally one of its windows.
+     * @param signal - Cancels the request.
+     * @returns Each window with its tree of elements.
+     */
+    inspect(machine, request, signal) {
+        return this.send(machine, "inspect", request, signal);
+    }
+    /**
+     * Waits until a selector names exactly one element, or with `gone` until it names none: `endia desktop wait`. The service
+     * answers only when the wait ends, so the client's own time limit does not apply; `timeoutSeconds` limits the wait.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, the selector and the longest wait.
+     * @param signal - Cancels the request.
+     * @returns The element and its window; both null after a wait for `gone`.
+     */
+    wait(machine, request, signal) {
+        return this.connection.change({ method: "POST", path: Routes.desktop(machine, "wait"), body: jsonBody(request), signal }, false);
+    }
+    /**
+     * Uses an element's Invoke pattern, as pressing a button does: `endia desktop invoke`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process and the selector.
+     * @param signal - Cancels the request.
+     * @returns Whether the element was invoked.
+     */
+    invoke(machine, request, signal) {
+        return this.send(machine, "invoke", request, signal);
+    }
+    /**
+     * Clicks the pointer at an element's centre: `endia desktop click`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, the selector and the button.
+     * @param signal - Cancels the request.
+     * @returns The point clicked on the screen.
+     */
+    click(machine, request, signal) {
+        return this.send(machine, "click", request, signal);
+    }
+    /**
+     * Sets an element's value, such as a text box's text: `endia desktop set-value`. A secret value, such as a password, is sent
+     * once, without an `Idempotency-Key` and without a retry, so that the service never stores it.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, the selector, the value, and whether it is secret.
+     * @param signal - Cancels the request.
+     * @returns The value read back, or null for a secret value.
+     */
+    setValue(machine, request, signal) {
+        const exchange = { method: "POST", path: Routes.desktop(machine, "set-value"), body: jsonBody(request), signal };
+        return request.secret === true ? this.connection.sendOnce(exchange) : this.connection.change(exchange);
+    }
+    /**
+     * Types keys or text into a process's main window: `endia desktop keys`. The service brings the window to the foreground and
+     * checks that it is there before sending anything; otherwise it refuses the request with `FOCUS_REFUSED`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The process, and `keys` as space-separated chords such as `ctrl+s`, or `text` to type as it is.
+     * @param signal - Cancels the request.
+     * @returns The number of input events sent.
+     */
+    keys(machine, request, signal) {
+        return this.send(machine, "keys", request, signal);
+    }
+    /**
+     * Moves, clicks or scrolls the pointer at a point: `endia desktop pointer`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The action, the point, and optionally the process whose window the point is relative to.
+     * @param signal - Cancels the request.
+     * @returns The point on the screen, and the window under it.
+     */
+    pointer(machine, request, signal) {
+        return this.send(machine, "pointer", request, signal);
+    }
+    /**
+     * Lists the visible top-level windows of the desktop user's session: `endia desktop windows`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The windows.
+     */
+    windows(machine, signal) {
+        return this.connection.read(Routes.desktop(machine, "windows"), signal);
+    }
+    /**
+     * Lists the icons of the notification area: `endia desktop tray ls`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The icons.
+     */
+    tray(machine, signal) {
+        return this.connection.read(Routes.desktop(machine, "tray"), signal);
+    }
+    /**
+     * Clicks an icon of the notification area: `endia desktop tray click`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The icon's name and the button.
+     * @param signal - Cancels the request.
+     * @returns The icon and the point clicked.
+     */
+    trayClick(machine, request, signal) {
+        return this.send(machine, "tray/click", request, signal);
+    }
+    /**
+     * Answers an elevation prompt for an expected program: `endia desktop uac`. The request may carry a password, so it is sent
+     * once, without an `Idempotency-Key`, without a retry and without the client's time limit.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program the prompt must name, and how to answer it.
+     * @param signal - Cancels the request.
+     * @returns The outcome, the prompt as read, and pictures of the screen before and after.
+     */
+    answerPrompt(machine, request, signal) {
+        return this.connection.sendOnce({ method: "POST", path: Routes.desktop(machine, "uac"), body: jsonBody(request), signal });
+    }
+    send(machine, action, request, signal) {
+        return this.connection.change({ method: "POST", path: Routes.desktop(machine, action), body: jsonBody(request), signal });
+    }
+}
+function header(answer, name) {
+    const value = answer.headers[name.toLowerCase()];
+    if (typeof value !== "string") {
+        throw new Error(`The service's screenshot came without the header ${name}.`);
+    }
+    return value;
+}

package/dist/groups/execs.d.ts

@@ -0,0 +1,110 @@
+import type { ExecCreated, ExecCreateRequest, ExecDetail, ExecStarted } from "../contract/execs.js";
+import { ExecSession } from "../exec/exec-session.js";
+/** What `ExecsClient.run` sends to the program and how it decodes what the program writes. */
+export interface RunOptions {
+    /** Text or bytes sent to the program's standard input, which is then closed. The standard input is attached only when this is given. */
+    readonly input?: string | Uint8Array;
+    /** Cancels the requests; the program keeps running. */
+    readonly signal?: AbortSignal;
+}
+/** A program that has run to its end, with everything it wrote. */
+export interface ExecResult {
+    /** The program's exit code in full, such as 3010; null when Windows restarted before the program ended. 127 means the program was not found, and 126 that it was found but could not start. */
+    readonly exitCode: number | null;
+    /** Why the program could not start, or null. */
+    readonly startError: string | null;
+    /** Everything the program wrote to standard output, decoded as UTF-8; with a console, all of its output. */
+    readonly stdout: string;
+    /** Everything the program wrote to standard error, decoded as UTF-8; empty with a console. */
+    readonly stderr: string;
+    /** The exec as the service recorded it at the end. */
+    readonly exec: ExecDetail;
+}
+/** A program started without the caller attached, as `endia exec -d` starts it. */
+export interface DetachedExec extends ExecStarted {
+    /** The exec ID, which `inspect` takes. */
+    readonly id: string;
+}
+/**
+ * The exec routes, which run a program in a running machine as `docker exec` does: create the exec, then start it attached over a
+ * WebSocket or detached. `run`, `spawn` and `start` do both steps; `create`, `attach`, `startDetached`, `inspect` and `resize` are the
+ * single routes.
+ */
+export declare class ExecsClient {
+    private readonly connection;
+    /**
+     * Runs a program to its end and collects its output: `endia exec`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program and its arguments in `cmd`, and how to run it.
+     * @param options - `input` is sent to the program's standard input.
+     * @returns The exit code in full and the output.
+     */
+    run(machine: string, request: ExecCreateRequest, options?: RunOptions): Promise<ExecResult>;
+    /**
+     * Starts a program with the caller attached to its streams: `endia exec` without collecting.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program and its arguments in `cmd`, and how to run it. With `attachStdin`, the session's `stdin` is open.
+     * @param signal - Cancels the requests; the program keeps running once it has started.
+     * @returns The running program's streams; read both output streams.
+     */
+    spawn(machine: string, request: ExecCreateRequest, signal?: AbortSignal): Promise<ExecSession>;
+    /**
+     * Starts a program and returns at once: `endia exec -d`. The program's output is kept in the machine for
+     * `ProcessesClient.logs`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program and its arguments in `cmd`, and how to run it.
+     * @param signal - Cancels the requests.
+     * @returns The exec ID and the process the program runs in, which the process routes take.
+     */
+    start(machine: string, request: ExecCreateRequest, signal?: AbortSignal): Promise<DetachedExec>;
+    /**
+     * Creates an exec without starting it: `POST /v1/machines/{name}/exec`.
+     *
+     * @param machine - The machine name or a unique prefix of its ID.
+     * @param request - The program and its arguments in `cmd`, and how to run it.
+     * @param signal - Cancels the request.
+     * @returns The new exec's ID.
+     */
+    create(machine: string, request: ExecCreateRequest, signal?: AbortSignal): Promise<ExecCreated>;
+    /**
+     * Starts a created exec with the caller attached, over a WebSocket: `GET /v1/execs/{id}/start`.
+     *
+     * @param id - The exec ID.
+     * @param shape - Whether the exec was created with `tty` and with `attachStdin`, which decides how its messages are read and written.
+     * @param signal - Cancels the opening.
+     * @returns The running program's streams.
+     */
+    attach(id: string, shape: {
+        readonly tty: boolean;
+        readonly attachStdin: boolean;
+    }, signal?: AbortSignal): Promise<ExecSession>;
+    /**
+     * Starts a created exec without the caller attached: `POST /v1/execs/{id}/start` with `{ "detach": true }`.
+     *
+     * @param id - The exec ID.
+     * @param signal - Cancels the request.
+     * @returns The process the program runs in.
+     */
+    startDetached(id: string, signal?: AbortSignal): Promise<ExecStarted>;
+    /**
+     * Reads an exec: what was asked for, its process, and its exit code once it has ended.
+     *
+     * @param id - The exec ID.
+     * @param signal - Cancels the request.
+     * @returns The exec.
+     */
+    inspect(id: string, signal?: AbortSignal): Promise<ExecDetail>;
+    /**
+     * Changes the size of an exec's console.
+     *
+     * @param id - The exec ID.
+     * @param rows - The number of rows.
+     * @param columns - The number of columns.
+     * @param signal - Cancels the request.
+     * @returns When the service has resized the console.
+     */
+    resize(id: string, rows: number, columns: number, signal?: AbortSignal): Promise<void>;
+}