endia 0.0.0-stage → 0.0.2

package/dist/groups/images.d.ts

@@ -0,0 +1,130 @@
+import type { Readable } from "node:stream";
+import type { Filters } from "../contract/common.js";
+import type { BuildResult, ImageDetail, ImageSummary, RemovalEntry, TagResult } from "../contract/images.js";
+import type { BuilderPruneResult } from "../contract/space.js";
+import type { OperationHandle } from "./operations.js";
+/** What a build makes and how: the tags, the build arguments and labels, the stage to build, and the builder's resources. */
+export interface BuildOptions {
+    /** The tags the new image carries, such as `lab/dotnet:10`. */
+    readonly tags?: readonly string[];
+    /** The build arguments, by name. */
+    readonly buildArgs?: Readonly<Record<string, string>>;
+    /** The labels added to the image, by key. */
+    readonly labels?: Readonly<Record<string, string>>;
+    /**
+     * The recipe's stage to build, named by its `FROM ... AS`, as `endia build --target` names it; the tags name that stage's result.
+     * The stages it is built on are built too, or found in the cache. When undefined, the build makes the recipe's last stage.
+     *
+     * @example
+     * For the recipe
+     * ```
+     * FROM eastindia/development:latest AS tools
+     * RUN choco install -y git
+     *
+     * FROM tools AS app
+     * COPY publish/ C:/app/
+     * ```
+     * `client.images.build({ folder: "./lab-image" }, { target: "tools", tags: ["lab/tools:1"] })` builds and tags the first stage
+     * alone. A later build without `target` finds that stage in the cache and builds only `app`.
+     */
+    readonly target?: string;
+    /**
+     * Whether to build every stage even when an image with the same build key exists. The build key is a SHA-256 hash of everything that decides
+     * a build's result, such as the parent image, every step and the content of every copied file; a build that finds an image with
+     * its key reuses that image.
+     */
+    readonly noCache?: boolean;
+    /**
+     * The memory of the builder, the temporary machine that runs the recipe, in bytes; at least 2 GiB. When undefined, the service
+     * uses its configuration key `builderMemoryMiB`.
+     */
+    readonly memory?: number;
+    /** The builder's processors, from 0.01 to 64. When undefined, the service uses its configuration key `builderProcessorCount`. */
+    readonly cpus?: number;
+    readonly signal?: AbortSignal;
+}
+/** A build context folder, packed as the `endia` CLI packs it. */
+export interface FolderContext {
+    /** The context folder. */
+    readonly folder: string;
+    /** The recipe, inside the folder or outside it; when undefined, `Endiafile` in the folder when it exists, and `Dockerfile` otherwise. */
+    readonly recipe?: string;
+}
+/** A build context the caller has already packed as a tar archive. */
+export interface ArchiveContext {
+    /** The archive: its bytes, or a function that opens it afresh, so that a retried request sends the same bytes. */
+    readonly archive: Uint8Array | (() => Readable);
+    /** The recipe's path inside the archive; when undefined, the service reads `Endiafile` at its root when it holds one, and `Dockerfile` otherwise. */
+    readonly recipe?: string;
+}
+/**
+ * The image routes: build, list, inspect, tag and remove, and the prune of the build cache that builds leave. A build and a prune
+ * each return an `OperationHandle`, because the service does that work in the background.
+ */
+export declare class ImagesClient {
+    private readonly connection;
+    private readonly operations;
+    /**
+     * Builds an image from a recipe and its context: `endia build`. A context folder is packed into a temporary archive as the CLI
+     * packs it, honouring its ignore file, and the archive is deleted once the service has accepted the build.
+     *
+     * @param context - A context folder with its recipe, or an archive the caller packed.
+     * @param options - The tags, build arguments, labels and resources.
+     * @returns The build's operation; its result is a `BuildResult`. Cancelling the request does not stop a build that has started.
+     */
+    build(context: FolderContext | ArchiveContext, options?: BuildOptions): Promise<OperationHandle<BuildResult>>;
+    /**
+     * Lists images: `endia images`.
+     *
+     * @param options - `filters` such as `{ dangling: ["true"] }`, and a `reference` pattern such as `lab/*`.
+     * @returns The images.
+     */
+    list(options?: {
+        readonly filters?: Filters;
+        readonly reference?: string;
+        readonly signal?: AbortSignal;
+    }): Promise<ImageSummary[]>;
+    /**
+     * Reads one image: `endia image inspect`.
+     *
+     * @param reference - A reference such as `lab/dotnet:10`, a digest, or a unique prefix of an image ID.
+     * @param signal - Cancels the request.
+     * @returns The image.
+     */
+    inspect(reference: string, signal?: AbortSignal): Promise<ImageDetail>;
+    /**
+     * Points a tag at an image: `endia tag`.
+     *
+     * @param source - The image's reference, digest or ID prefix.
+     * @param target - The new reference, such as `lab/dotnet:approved`.
+     * @param signal - Cancels the request.
+     * @returns The tag, the image it now names, and the image it named before.
+     */
+    tag(source: string, target: string, signal?: AbortSignal): Promise<TagResult>;
+    /**
+     * Removes a tag, and the image once no tag names it: `endia rmi`.
+     *
+     * @param reference - The reference, digest or ID prefix.
+     * @param options - `force` removes an image that several tags name.
+     * @returns Each tag removed and each image deleted.
+     */
+    remove(reference: string, options?: {
+        readonly force?: boolean;
+        readonly signal?: AbortSignal;
+    }): Promise<RemovalEntry[]>;
+    /**
+     * Deletes the unused build cache: `endia builder prune`. A build-cache entry is the committed result of a recipe's stage that a
+     * build made below its target. An entry is unused when no image, machine or other entry is built on it and no running build has
+     * made or found it. The prune deletes every unused entry, repeating until none remains, and leaves the entries that running
+     * builds use.
+     *
+     * @param options - `all` is Docker's `--all`. It deletes the same entries, because once a build has finished the build cache holds
+     * nothing that a build still uses.
+     * @returns The prune's operation; its result names the entries deleted and the space freed.
+     */
+    pruneBuildCache(options?: {
+        readonly all?: boolean;
+        readonly signal?: AbortSignal;
+    }): Promise<OperationHandle<BuilderPruneResult>>;
+    private sendBuild;
+}

package/dist/groups/images.js

@@ -0,0 +1,109 @@
+import { packBuildContext } from "../archives/build-context.js";
+import { Routes } from "../routes.js";
+import { jsonBody, tarBody } from "../transport/api-connection.js";
+import { QueryText } from "../transport/query-text.js";
+/**
+ * The image routes: build, list, inspect, tag and remove, and the prune of the build cache that builds leave. A build and a prune
+ * each return an `OperationHandle`, because the service does that work in the background.
+ */
+export class ImagesClient {
+    connection;
+    operations;
+    /** @internal */
+    constructor(connection, operations) {
+        this.connection = connection;
+        this.operations = operations;
+    }
+    /**
+     * Builds an image from a recipe and its context: `endia build`. A context folder is packed into a temporary archive as the CLI
+     * packs it, honouring its ignore file, and the archive is deleted once the service has accepted the build.
+     *
+     * @param context - A context folder with its recipe, or an archive the caller packed.
+     * @param options - The tags, build arguments, labels and resources.
+     * @returns The build's operation; its result is a `BuildResult`. Cancelling the request does not stop a build that has started.
+     */
+    async build(context, options = {}) {
+        if ("archive" in context) {
+            const archive = context.archive;
+            const body = tarBody(archive);
+            return this.sendBuild(body, context.recipe, options);
+        }
+        const packed = await packBuildContext(context.folder, context.recipe);
+        try {
+            return await this.sendBuild(packed.archive.body, packed.recipe, options);
+        }
+        finally {
+            await packed.archive.delete();
+        }
+    }
+    /**
+     * Lists images: `endia images`.
+     *
+     * @param options - `filters` such as `{ dangling: ["true"] }`, and a `reference` pattern such as `lab/*`.
+     * @returns The images.
+     */
+    list(options = {}) {
+        const query = new QueryText().addJson("filters", options.filters).add("reference", options.reference);
+        return this.connection.read(Routes.images + query.toString(), options.signal);
+    }
+    /**
+     * Reads one image: `endia image inspect`.
+     *
+     * @param reference - A reference such as `lab/dotnet:10`, a digest, or a unique prefix of an image ID.
+     * @param signal - Cancels the request.
+     * @returns The image.
+     */
+    inspect(reference, signal) {
+        return this.connection.read(Routes.image(reference), signal);
+    }
+    /**
+     * Points a tag at an image: `endia tag`.
+     *
+     * @param source - The image's reference, digest or ID prefix.
+     * @param target - The new reference, such as `lab/dotnet:approved`.
+     * @param signal - Cancels the request.
+     * @returns The tag, the image it now names, and the image it named before.
+     */
+    tag(source, target, signal) {
+        return this.connection.change({ method: "PUT", path: Routes.tag(target), body: jsonBody({ source }), signal });
+    }
+    /**
+     * Removes a tag, and the image once no tag names it: `endia rmi`.
+     *
+     * @param reference - The reference, digest or ID prefix.
+     * @param options - `force` removes an image that several tags name.
+     * @returns Each tag removed and each image deleted.
+     */
+    remove(reference, options = {}) {
+        const query = new QueryText().addFlag("force", options.force);
+        return this.connection.change({ method: "DELETE", path: Routes.image(reference) + query.toString(), signal: options.signal });
+    }
+    /**
+     * Deletes the unused build cache: `endia builder prune`. A build-cache entry is the committed result of a recipe's stage that a
+     * build made below its target. An entry is unused when no image, machine or other entry is built on it and no running build has
+     * made or found it. The prune deletes every unused entry, repeating until none remains, and leaves the entries that running
+     * builds use.
+     *
+     * @param options - `all` is Docker's `--all`. It deletes the same entries, because once a build has finished the build cache holds
+     * nothing that a build still uses.
+     * @returns The prune's operation; its result names the entries deleted and the space freed.
+     */
+    async pruneBuildCache(options = {}) {
+        const query = new QueryText().addFlag("all", options.all);
+        const accepted = await this.connection.change({ method: "POST", path: Routes.builderPrune + query.toString(), signal: options.signal });
+        return this.operations.handle(accepted);
+    }
+    async sendBuild(body, recipe, options) {
+        const query = new QueryText()
+            .addEach("t", options.tags)
+            .add("dockerfile", recipe)
+            .addJson("buildargs", options.buildArgs)
+            .addJson("labels", options.labels)
+            .add("target", options.target)
+            .add("memory", options.memory)
+            .add("cpus", options.cpus)
+            .addFlag("nocache", options.noCache);
+        const accepted = await this.connection.change({ method: "POST", path: Routes.build + query.toString(), body, signal: options.signal }, false);
+        return this.operations.handle(accepted);
+    }
+}

package/dist/groups/machines.d.ts

@@ -0,0 +1,124 @@
+import type { Filters } from "../contract/common.js";
+import type { MachineDetail, MachineLogLine, MachineRestartResult, MachineSummary, MachinesResult } from "../contract/machines.js";
+import type { MachinePurpose, MachinePurposeResult } from "../contract/purposes.js";
+import { QueryText } from "../transport/query-text.js";
+import type { OperationHandle } from "./operations.js";
+/** Which lines of a machine's main-process output to read, as `endia logs` chooses them. */
+export interface LogOptions {
+    /** Whether to keep reading new lines as the machine writes them, until the caller stops iterating. */
+    readonly follow?: boolean;
+    /** The number of lines from the end to start with, or `all`; every line when undefined. */
+    readonly tail?: number | "all";
+    /** The earliest line, as Docker writes the time: RFC 3339, Unix seconds, or a duration before now such as `10m`. */
+    readonly since?: string;
+    /** The latest line, in the same forms as `since`. */
+    readonly until?: string;
+    /** Ends the request; the iteration then throws the signal's reason. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Adds the query parameters of a log request.
+ *
+ * @param query - The query to add to.
+ * @param options - The lines to read.
+ * @returns The query.
+ */
+export declare function addLogOptions(query: QueryText, options: LogOptions): QueryText;
+/**
+ * The machine routes: list, inspect, start, stop, restart, read the log, and read, set and clear a machine's own purpose. A machine is made and removed with its fleet
+ * (`FleetsClient.up` and `FleetsClient.down`). Starting, stopping and restarting return an `OperationHandle`, because the service
+ * does that work in the background.
+ */
+export declare class MachinesClient {
+    private readonly connection;
+    private readonly operations;
+    /**
+     * Lists machines: `endia ps`.
+     *
+     * @param options - `all` includes machines that are not running; `filters` such as `{ label: ["team=qa"] }`.
+     * @returns The machines.
+     */
+    list(options?: {
+        readonly all?: boolean;
+        readonly filters?: Filters;
+        readonly signal?: AbortSignal;
+    }): Promise<MachineSummary[]>;
+    /**
+     * Reads one machine: `endia inspect`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The machine.
+     */
+    inspect(name: string, signal?: AbortSignal): Promise<MachineDetail>;
+    /**
+     * Reads a machine's own purpose with every change to it, and the purpose in effect for the machine, its own or else its fleet's:
+     * `endia purpose show`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The machine's own purpose and history, and its effective purpose with where it comes from.
+     */
+    purpose(name: string, signal?: AbortSignal): Promise<MachinePurpose>;
+    /**
+     * Replaces a machine's own purpose, which overrides its fleet's for this machine only: `endia purpose set`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param title - What the machine is being used for, in one line of 1 to 200 characters.
+     * @param options - `detail` is Markdown notes of at most 65536 bytes in UTF-8; without it the detail stored before is cleared.
+     * @returns The purpose now stored, which is also the machine's effective purpose.
+     * @throws Error when the title has a line break or the detail is too long. Nothing is sent then.
+     */
+    setPurpose(name: string, title: string, options?: {
+        readonly detail?: string;
+        readonly signal?: AbortSignal;
+    }): Promise<MachinePurposeResult>;
+    /**
+     * Removes a machine's own purpose, which returns the machine to its fleet's: `endia purpose clear`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The machine's own purpose now stored, which is null, and its effective purpose, which is its fleet's or null.
+     */
+    clearPurpose(name: string, signal?: AbortSignal): Promise<MachinePurposeResult>;
+    /**
+     * Starts a stopped machine: `endia start`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The start's operation; its result names the machine.
+     */
+    start(name: string, signal?: AbortSignal): Promise<OperationHandle<MachinesResult>>;
+    /**
+     * Shuts a machine's Windows down: `endia stop`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param options - `timeout` is the time in seconds Windows has to shut down before the virtual machine is turned off.
+     * @returns The stop's operation; its result names the machine.
+     */
+    stop(name: string, options?: {
+        readonly timeout?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<OperationHandle<MachinesResult>>;
+    /**
+     * Restarts a machine's Windows: `endia restart`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param options - `timeout` as for `stop`; `hard` turns the virtual machine off and on instead of restarting Windows.
+     * @returns The restart's operation; its result has the boot IDs before and after.
+     */
+    restart(name: string, options?: {
+        readonly timeout?: number;
+        readonly hard?: boolean;
+        readonly signal?: AbortSignal;
+    }): Promise<OperationHandle<MachineRestartResult>>;
+    /**
+     * Reads a machine's main-process output, one line at a time: `endia logs`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param options - Which lines, and whether to follow new ones.
+     * @returns The lines, as they arrive.
+     */
+    logs(name: string, options?: LogOptions): AsyncGenerator<MachineLogLine, void, undefined>;
+    private sendAction;
+}

package/dist/groups/machines.js

@@ -0,0 +1,127 @@
+import { purposeBody } from "../purposes.js";
+import { Routes } from "../routes.js";
+import { jsonBody } from "../transport/api-connection.js";
+import { QueryText } from "../transport/query-text.js";
+/**
+ * Adds the query parameters of a log request.
+ *
+ * @param query - The query to add to.
+ * @param options - The lines to read.
+ * @returns The query.
+ */
+export function addLogOptions(query, options) {
+    return query.addFlag("follow", options.follow).add("tail", options.tail).add("since", options.since).add("until", options.until);
+}
+/**
+ * The machine routes: list, inspect, start, stop, restart, read the log, and read, set and clear a machine's own purpose. A machine is made and removed with its fleet
+ * (`FleetsClient.up` and `FleetsClient.down`). Starting, stopping and restarting return an `OperationHandle`, because the service
+ * does that work in the background.
+ */
+export class MachinesClient {
+    connection;
+    operations;
+    /** @internal */
+    constructor(connection, operations) {
+        this.connection = connection;
+        this.operations = operations;
+    }
+    /**
+     * Lists machines: `endia ps`.
+     *
+     * @param options - `all` includes machines that are not running; `filters` such as `{ label: ["team=qa"] }`.
+     * @returns The machines.
+     */
+    list(options = {}) {
+        const query = new QueryText().addFlag("all", options.all).addJson("filters", options.filters);
+        return this.connection.read(Routes.machines + query.toString(), options.signal);
+    }
+    /**
+     * Reads one machine: `endia inspect`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The machine.
+     */
+    inspect(name, signal) {
+        return this.connection.read(Routes.machine(name), signal);
+    }
+    /**
+     * Reads a machine's own purpose with every change to it, and the purpose in effect for the machine, its own or else its fleet's:
+     * `endia purpose show`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The machine's own purpose and history, and its effective purpose with where it comes from.
+     */
+    purpose(name, signal) {
+        return this.connection.read(Routes.machinePurpose(name), signal);
+    }
+    /**
+     * Replaces a machine's own purpose, which overrides its fleet's for this machine only: `endia purpose set`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param title - What the machine is being used for, in one line of 1 to 200 characters.
+     * @param options - `detail` is Markdown notes of at most 65536 bytes in UTF-8; without it the detail stored before is cleared.
+     * @returns The purpose now stored, which is also the machine's effective purpose.
+     * @throws Error when the title has a line break or the detail is too long. Nothing is sent then.
+     */
+    async setPurpose(name, title, options = {}) {
+        const body = purposeBody(title, options.detail);
+        return await this.connection.change({ method: "PUT", path: Routes.machinePurpose(name), body: jsonBody(body), signal: options.signal });
+    }
+    /**
+     * Removes a machine's own purpose, which returns the machine to its fleet's: `endia purpose clear`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The machine's own purpose now stored, which is null, and its effective purpose, which is its fleet's or null.
+     */
+    clearPurpose(name, signal) {
+        return this.connection.change({ method: "DELETE", path: Routes.machinePurpose(name), signal });
+    }
+    /**
+     * Starts a stopped machine: `endia start`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param signal - Cancels the request.
+     * @returns The start's operation; its result names the machine.
+     */
+    start(name, signal) {
+        return this.sendAction(Routes.machineStart(name), new QueryText(), signal);
+    }
+    /**
+     * Shuts a machine's Windows down: `endia stop`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param options - `timeout` is the time in seconds Windows has to shut down before the virtual machine is turned off.
+     * @returns The stop's operation; its result names the machine.
+     */
+    stop(name, options = {}) {
+        return this.sendAction(Routes.machineStop(name), new QueryText().add("t", options.timeout), options.signal);
+    }
+    /**
+     * Restarts a machine's Windows: `endia restart`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param options - `timeout` as for `stop`; `hard` turns the virtual machine off and on instead of restarting Windows.
+     * @returns The restart's operation; its result has the boot IDs before and after.
+     */
+    restart(name, options = {}) {
+        const query = new QueryText().add("t", options.timeout).addFlag("hard", options.hard);
+        return this.sendAction(Routes.machineRestart(name), query, options.signal);
+    }
+    /**
+     * Reads a machine's main-process output, one line at a time: `endia logs`.
+     *
+     * @param name - The machine name or a unique prefix of its ID.
+     * @param options - Which lines, and whether to follow new ones.
+     * @returns The lines, as they arrive.
+     */
+    logs(name, options = {}) {
+        return this.connection.readLines(Routes.machineLogs(name) + addLogOptions(new QueryText(), options).toString(), options.signal);
+    }
+    async sendAction(path, query, signal) {
+        const accepted = await this.connection.change({ method: "POST", path: path + query.toString(), signal });
+        return this.operations.handle(accepted);
+    }
+}

package/dist/groups/operations.d.ts

@@ -0,0 +1,127 @@
+import type { Readable } from "node:stream";
+import type { Filters } from "../contract/common.js";
+import type { Operation } from "../contract/operations.js";
+/**
+ * Says whether an operation has finished: succeeded, failed, been cancelled or been interrupted.
+ *
+ * @param operation - The operation as last read.
+ * @returns True when its state never changes again.
+ */
+export declare function isFinished(operation: Operation): boolean;
+/** The options of reading an operation's log. */
+export interface OperationLogOptions {
+    /** Whether the stream stays open until the operation finishes. */
+    readonly follow?: boolean;
+    /** The number of lines from the end of the log to start with; the whole log when undefined. */
+    readonly tail?: number;
+    readonly signal?: AbortSignal;
+}
+/** The options of waiting for an operation to finish. */
+export interface OperationWaitOptions {
+    /** Receives the operation's log text as the service writes it, each piece once. */
+    readonly onLog?: (text: string) => void;
+    readonly signal?: AbortSignal;
+}
+/**
+ * The operation routes: list, inspect, read the log, cancel; and handles that follow one operation to its end. Every route that
+ * starts work returns an `OperationHandle` built here.
+ */
+export declare class OperationsClient {
+    private readonly connection;
+    /**
+     * Lists every kept operation, newest first: `endia operation ls`.
+     *
+     * @param options - `filters` such as `{ state: ["running"], kind: ["build"] }`.
+     * @returns The operations.
+     */
+    list(options?: {
+        readonly filters?: Filters;
+        readonly signal?: AbortSignal;
+    }): Promise<Operation[]>;
+    /**
+     * Reads one operation: `endia operation inspect`.
+     *
+     * @param id - The operation ID or a unique prefix of it.
+     * @param signal - Cancels the request.
+     * @returns The operation.
+     */
+    inspect<TResult = unknown>(id: string, signal?: AbortSignal): Promise<Operation<TResult>>;
+    /**
+     * Opens an operation's log, the lines the command prints as the CLI prints them: `endia operation logs`.
+     *
+     * @param id - The operation ID or a unique prefix of it.
+     * @param options - With `follow`, the stream stays open until the operation finishes.
+     * @returns The log as UTF-8 text.
+     */
+    logs(id: string, options?: OperationLogOptions): Promise<Readable>;
+    /**
+     * Asks the service to cancel an operation: `endia operation cancel`. A build or import cleans up as on failure; a fleet or machine
+     * operation stops before its next machine step; a prune stops before its next deletion.
+     *
+     * @param id - The operation ID or a unique prefix of it.
+     * @param signal - Cancels the request.
+     * @returns The operation in `cancelling`, or unchanged when it had already finished.
+     */
+    cancel(id: string, signal?: AbortSignal): Promise<Operation>;
+    /**
+     * Wraps an operation that was read elsewhere, such as one another program started, in a handle that follows it and waits for its
+     * end.
+     *
+     * @param operation - The operation as last read.
+     * @returns The handle.
+     */
+    handle<TResult>(operation: Operation): OperationHandle<TResult>;
+}
+/**
+ * Work the service has accepted and carries out in the background: a build, an import, a fleet or machine change, or a prune. The
+ * handle follows that work: it reads the operation's state, follows its log, cancels it, and waits for it to finish.
+ *
+ * @typeParam TResult - The result the operation gives when it succeeds, such as `BuildResult`.
+ */
+export declare class OperationHandle<TResult> {
+    private readonly operations;
+    /** The operation as the service answered when it accepted the work. */
+    readonly accepted: Operation;
+    /** The operation ID: 32 lower-case hexadecimal digits. */
+    get id(): string;
+    /**
+     * Reads the operation as it stands now.
+     *
+     * @param signal - Cancels the request.
+     * @returns The operation.
+     */
+    inspect(signal?: AbortSignal): Promise<Operation<TResult>>;
+    /**
+     * Opens the operation's log.
+     *
+     * @param options - With `follow`, the stream stays open until the operation finishes.
+     * @returns The log as UTF-8 text.
+     */
+    logs(options?: OperationLogOptions): Promise<Readable>;
+    /**
+     * Asks the service to cancel the operation. The operation then ends `cancelled`, which `wait` reports.
+     *
+     * @param signal - Cancels the request.
+     * @returns The operation in `cancelling`, or unchanged when it had already finished.
+     */
+    cancel(signal?: AbortSignal): Promise<Operation>;
+    /**
+     * Waits until the operation finishes, whatever its outcome, by following its log to the end as the CLI does.
+     *
+     * When the followed log ends before the operation has finished, as when the connection breaks, the log is opened again after a
+     * pause. The log only grows, so the text `onLog` has already received is skipped and each piece reaches it once.
+     *
+     * @param options - `onLog` receives the log as it is written.
+     * @returns The finished operation, in `succeeded`, `failed`, `cancelled` or `interrupted`.
+     */
+    wait(options?: OperationWaitOptions): Promise<Operation<TResult>>;
+    /**
+     * Waits until the operation finishes and gives its result.
+     *
+     * @param options - `onLog` receives the log as it is written.
+     * @returns The result of the succeeded operation.
+     * @throws EastIndiaApiError when the operation failed, was cancelled or was interrupted; its `code` is the operation's error code,
+     * such as `BUILD_FAILED`, and its `operation` is the finished operation.
+     */
+    result(options?: OperationWaitOptions): Promise<TResult>;
+}