endia 0.0.0-stage → 0.0.2

package/dist/contract/desktop.d.ts

@@ -0,0 +1,269 @@
+import type { Timestamp, WindowBounds } from "./common.js";
+import type { ProcessWindow } from "./processes.js";
+/** The body of `POST /v1/machines/{name}/desktop/click`: the element the pointer clicks at its centre. It exists for elements that answer only the mouse, which `invoke` cannot press, without the caller working out a point from the element's bounds. */
+export interface ClickRequest {
+    /** The ID of the process that owns the element's window. */
+    readonly processId: number;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** The element selector; its first segment names one of the process's top-level windows. */
+    readonly element: string;
+    /** The button: `left`, `right` or `middle`. */
+    readonly button?: string;
+    /** Whether to click twice, as a double-click. */
+    readonly doubleClick?: boolean;
+}
+/** The body of `POST /v1/machines/{name}/desktop/inspect`: the process whose UI tree to read, and optionally one of its windows. */
+export interface DesktopInspectRequest {
+    /** The process ID. */
+    readonly processId: number;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** One window's handle as hexadecimal text, or null for every visible top-level window of the process. */
+    readonly window?: string | null;
+}
+/** The body of `POST /v1/machines/{name}/desktop/launch`, which `endia desktop launch` sends: the program to start in the desktop user's session. */
+export interface DesktopLaunchRequest {
+    /** The program: a full path, or a file name Windows looks for on the desktop user's `PATH`. */
+    readonly program: string;
+    /** The arguments, each passed to the program as one argument. */
+    readonly args?: readonly string[];
+    /** The working folder, or null for the folder the guest service chooses. */
+    readonly workingDir?: string | null;
+    /** Extra environment variables, each `NAME=value`, added to the desktop user's own. */
+    readonly env?: readonly string[];
+    /** Whether to start the program with the desktop user's linked administrator token. */
+    readonly elevated?: boolean;
+}
+/** The body of `POST /v1/machines/{name}/desktop/wait`: the element to wait for, and whether to wait for it to appear or to go. Without this route a caller would poll `desktop inspect` in a loop of its own. */
+export interface DesktopWaitRequest {
+    /** The ID of the process that owns the element's window. */
+    readonly processId: number;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** The element selector; its first segment names one of the process's top-level windows, and a selector of that one segment waits for the window itself. */
+    readonly element: string;
+    /** Whether to wait until the selector names no element, instead of until it names exactly one. */
+    readonly gone?: boolean;
+    /** The longest wait in seconds, or null for `desktopActionTimeoutSeconds`. */
+    readonly timeoutSeconds?: number | null;
+}
+/** The body of `POST /v1/machines/{name}/desktop/invoke`: the element whose Invoke pattern to use, such as a button to press. */
+export interface InvokeRequest {
+    /** The ID of the process that owns the element's window. */
+    readonly processId: number;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** The element selector, for example `Window[Trainee]/Button[Send diagnostics]`; its first segment names one of the process's top-level windows. */
+    readonly element: string;
+}
+/** The body of `POST /v1/machines/{name}/desktop/keys`: keys to press, or text to type, in the process's main window. Exactly one of `Keys` and `Text` is given. */
+export interface KeysRequest {
+    /** The ID of the process whose main window receives the input. */
+    readonly processId: number;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** Chords separated by spaces, such as `ctrl+s` or `alt+f4 enter`; or null when `Text` is given. */
+    readonly keys?: string | null;
+    /** Text typed literally as Unicode characters; or null when `Keys` is given. */
+    readonly text?: string | null;
+}
+/** The body of `POST /v1/machines/{name}/desktop/pointer`: what the pointer does, and where: in a process's main window, or on the screen when no process is named. */
+export interface PointerRequest {
+    /** The ID of the process whose main window the pointer acts in, or null to act at a point on the screen. */
+    readonly processId?: number | null;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** The action: `move`, `click`, `double-click` or `scroll`. */
+    readonly action: string;
+    /** The distance in physical pixels from the left edge of the window's client area, or of the screen when no process is named. */
+    readonly x: number;
+    /** The distance in physical pixels from the top edge of the window's client area, or of the screen when no process is named. */
+    readonly y: number;
+    /** The button a click uses: `left`, `right` or `middle`. */
+    readonly button?: string;
+    /** The wheel notches a scroll turns; positive scrolls up, negative down. */
+    readonly delta?: number;
+}
+/** The body of `POST /v1/machines/{name}/desktop/screenshot`: the whole desktop, or the largest visible window of one process. */
+export interface ScreenshotRequest {
+    /** The process whose largest visible top-level window to capture, or null for the whole desktop. */
+    readonly processId?: number | null;
+}
+/** The body of `POST /v1/machines/{name}/desktop/set-value`: the element whose Value pattern to set, the value, and whether the value is a secret. */
+export interface SetValueRequest {
+    /** The ID of the process that owns the element's window. */
+    readonly processId: number;
+    /** The time the process must have started, or null to take whichever process has the ID. */
+    readonly started?: Timestamp | null;
+    /** The element selector; its first segment names one of the process's top-level windows. */
+    readonly element: string;
+    /** The value to set. */
+    readonly value: string;
+    /** Whether the value is a secret, such as a password: it may then go into a password field, it is never logged, recorded or printed, and it is not read back. */
+    readonly secret?: boolean;
+}
+/** The body of `POST /v1/machines/{name}/desktop/tray/click`: which notification-area icon the pointer clicks, and how. */
+export interface TrayClickRequest {
+    /** The start of the icon's name, compared with case; exactly one icon's name must start with it. */
+    readonly icon: string;
+    /** The button: `left`, `right` or `middle`. */
+    readonly button?: string;
+    /** Whether to click twice, as a double-click. */
+    readonly doubleClick?: boolean;
+}
+/** The body of `POST /v1/machines/{name}/desktop/uac`, which `endia desktop uac` sends: which program's elevation prompt to wait for, and how to answer it. The password is used for this one action: the service writes it to no log, record or stored reply, which is why this route ignores an `Idempotency-Key`. */
+export interface UacRequest {
+    /** The file name of the program the prompt must name, for example `diagnostics.exe`, compared without regard to case. */
+    readonly expectedProgram: string;
+    /** How to answer: `credentials`, `consent` or `cancel`. */
+    readonly action: string;
+    /** The account to choose for `credentials`; otherwise null. */
+    readonly user?: string | null;
+    /** The account's password for `credentials`; otherwise null. */
+    readonly password?: string | null;
+    /** The seconds to wait for the prompt, or null for `desktopActionTimeoutSeconds`. */
+    readonly timeoutSeconds?: number | null;
+}
+/** The answer to `endia desktop inspect`: the UI tree of each window read, as UI Automation's control view shows it. */
+export interface DesktopInspectResult {
+    /** The windows, the frontmost first. */
+    readonly windows: readonly InspectedWindow[];
+}
+/** The answer to `endia desktop launch`, given once the process exists and without waiting for a window: the real process ID and the facts that name the process safely afterwards. */
+export interface DesktopLaunchResult {
+    /** The process ID. */
+    readonly processId: number;
+    /** When the process started; `--started` takes this value. */
+    readonly started: Timestamp;
+    /** The desktop user's Windows session. */
+    readonly sessionId: number;
+    /** The account the process runs as. */
+    readonly user: string;
+    /** The integrity level of the process's token: `low`, `medium`, `high` or `system`. */
+    readonly integrityLevel: string;
+    /** The windows the process had shown when it was found to exist; usually none yet. */
+    readonly windows: readonly ProcessWindow[];
+}
+/** The answer of `POST /v1/machines/{name}/desktop/wait`: the element the wait found, and the window that holds it, so that the caller can act on the element without reading the tree again. Both are null when the wait was for the element to go. */
+export interface DesktopWaitResult {
+    /** The handle, in hexadecimal, of the window that holds the element, or null when the element has gone. */
+    readonly window: string | null;
+    /** The element found, without its children, or null when the element has gone. */
+    readonly element: UiElement | null;
+}
+/** The answer to `endia desktop invoke`. */
+export interface InvokeResult {
+    /** Whether the element was invoked; always true, because a failure is a refusal. */
+    readonly invoked: boolean;
+}
+/** The answer to `endia desktop keys`. */
+export interface KeysResult {
+    /** The number of input events sent: a press and a release for each key. */
+    readonly sent: number;
+}
+/** The answer to `endia desktop pointer`: where on the screen the pointer acted, and the window it acted on. */
+export interface PointerResult {
+    /** The distance in physical pixels from the left edge of the screen. */
+    readonly screenX: number;
+    /** The distance in physical pixels from the top edge of the screen. */
+    readonly screenY: number;
+    /** The handle of the top-level window under the point, as hexadecimal text; null when the guest did not report it. */
+    readonly window: string | null;
+    /** The ID of the process that owns that window; null when the guest did not report it. */
+    readonly processId: number | null;
+}
+/** The answer to `endia desktop set-value`. */
+export interface SetValueResult {
+    /** The element's value read back after it was set, or null when the element no longer gives one. */
+    readonly value: string | null;
+}
+/** The answer of `POST /v1/machines/{name}/desktop/tray/click`: the full name of the icon clicked, which may carry more than the start the caller gave, and the screen point the pointer clicked. */
+export interface TrayClickResult {
+    /** The full name of the icon clicked. */
+    readonly name: string;
+    /** The horizontal screen position clicked, in physical pixels. */
+    readonly screenX: number;
+    /** The vertical screen position clicked, in physical pixels. */
+    readonly screenY: number;
+}
+/** The answer to `endia desktop uac`: what became of the prompt, what it showed, and the desktop before and after the answer. Whether the program then ran elevated is not reported; the caller checks that through its workload. */
+export interface UacResult {
+    /** The outcome: `accepted` when the prompt closed after Yes, `credentialsRefused` when it still shows after Yes and is left open, or `cancelled` after No. */
+    readonly outcome: string;
+    /** What the prompt showed. */
+    readonly prompt: UacPromptDetail;
+    /** A PNG of the desktop before the answer, base64 encoded. */
+    readonly screenshotBefore: string;
+    /** A PNG of the desktop, base64 encoded. It is taken after the answer, once the wait that the host's configuration sets in `uacSettleSeconds` has passed. */
+    readonly screenshotAfter: string;
+}
+/** One element of a window's UI tree, with what an element selector matches on (its control type, name and automation ID) and what an action needs to know (whether it is enabled, its value and the patterns it supports). */
+export interface UiElement {
+    /** UI Automation's control type without `ControlType.`, for example `Button`. */
+    readonly controlType: string;
+    /** The element's name, or null when it has none. */
+    readonly name: string | null;
+    /** The element's automation ID, or null when it has none. */
+    readonly automationId: string | null;
+    /** The element's window class name, or null when it has none. */
+    readonly className: string | null;
+    /** The element's value, or null when it has no value or is a password field, whose value is never read. */
+    readonly value: string | null;
+    /** Whether the element accepts input. */
+    readonly enabled: boolean;
+    /** Whether the element is on screen. */
+    readonly visible: boolean;
+    /** Whether the element is a password field. */
+    readonly isPassword: boolean;
+    /** Where the element is, in physical pixels from the top-left corner of its window, or null when it has no size. */
+    readonly bounds: WindowBounds | null;
+    /** Where the element is, in physical pixels from the top-left corner of the screen, or null when it has no size. A point inside it is where `desktop pointer --screen` acts on the element, if no other window covers it. */
+    readonly screenBounds: WindowBounds | null;
+    /** The UI Automation patterns the element supports, for example `Invoke` or `Value`. */
+    readonly patterns: readonly string[];
+    /** The child elements, in document order. */
+    readonly children: readonly UiElement[];
+}
+/** One window and its UI tree. */
+export interface InspectedWindow {
+    /** The window handle as hexadecimal text. */
+    readonly handle: string;
+    /** The title bar text; empty when the window has none. */
+    readonly title: string;
+    /** The window's own element, with its descendants. */
+    readonly root: UiElement;
+}
+/** One visible top-level window on a machine's desktop, as `endia desktop windows` lists it, with the process that owns it. */
+export interface DesktopWindow {
+    /** The ID of the process that owns the window, which the other desktop commands take. */
+    readonly processId: number;
+    /** The name of that process's program, without its extension; empty when the desktop helper may not read it. */
+    readonly processName: string;
+    /** The window handle as hexadecimal text, for example `0x2a0b4c`, which `desktop inspect --window` takes. */
+    readonly handle: string;
+    /** The title bar text; empty when the window has none. */
+    readonly title: string;
+    /** The window class name. */
+    readonly className: string;
+    /** Where the window is, in physical pixels from the top-left corner of the screen. */
+    readonly bounds: WindowBounds;
+}
+/** One icon of the notification area, as `GET /v1/machines/{name}/desktop/tray` lists it. The icon belongs to Windows' taskbar, not to the program that put it there, so the window and element commands, which name a process, cannot reach it. */
+export interface TrayIcon {
+    /** The name Windows shows for the icon, usually the program's tooltip. */
+    readonly name: string;
+    /** Whether Windows has moved the icon behind the "Show hidden icons" button. */
+    readonly hidden: boolean;
+    /** Where the icon is on the screen, in physical pixels from the top-left corner of the primary screen, or null for a hidden icon. */
+    readonly screenBounds: WindowBounds | null;
+}
+/** What an elevation prompt showed. */
+export interface UacPromptDetail {
+    /** The program the prompt asked to elevate. */
+    readonly program: string;
+    /** The publisher the prompt showed, or null when it showed none. */
+    readonly publisher: string | null;
+    /** The accounts the prompt offered; empty on a consent prompt. */
+    readonly accounts: readonly string[];
+}

package/dist/contract/desktop.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/execs.d.ts

@@ -0,0 +1,61 @@
+import type { Timestamp } from "./common.js";
+/** The body of `POST /v1/machines/{name}/exec`, which `endia exec` sends to create an exec: the program and its arguments, the account, the working folder, the extra variables, and whether the program gets a console and standard input. The exec is started by a second request. */
+export interface ExecCreateRequest {
+    /** The program followed by its arguments; at least the program. */
+    readonly cmd: readonly string[];
+    /** The local account to run as, or null to run as the service's default user, or the image's user when the service sets none. */
+    readonly user?: string | null;
+    /** The folder to start in, or null to start in the service's default folder, or the image's folder when the service sets none. */
+    readonly workingDir?: string | null;
+    /** The extra variables, each written `NAME=value`, laid over the machine's main-process environment. */
+    readonly env?: readonly string[];
+    /** Whether the program gets a Windows pseudo console. */
+    readonly tty?: boolean;
+    /** Whether the program's standard input stays open for what the caller sends. */
+    readonly attachStdin?: boolean;
+    /** The console's size as rows and then columns, or null for the pseudo console's default. */
+    readonly consoleSize?: readonly number[] | null;
+}
+/** The answer to `POST /v1/machines/{name}/exec`: the new exec's ID, which the start, inspect and resize routes take. */
+export interface ExecCreated {
+    /** The exec ID: 32 lower-case hexadecimal digits. */
+    readonly id: string;
+}
+/** The answer to a detached start: the process the program runs in, which the process commands take. */
+export interface ExecStarted {
+    /** The Windows process ID inside the machine. */
+    readonly processId: number;
+    /** When the process started, which tells it apart from a later process given the same ID. */
+    readonly started: Timestamp;
+}
+/** One exec as `GET /v1/execs/{id}` shows it: what was asked for, the process it runs in, whether it still runs and, once it has ended, its exit code. `endia exec` reads the exit code here once the program's output has ended. */
+export interface ExecDetail {
+    /** The exec ID: 32 lower-case hexadecimal digits. */
+    readonly id: string;
+    /** The name of the machine the exec runs in. */
+    readonly machine: string;
+    /** The boot of Windows in which the exec was created or, once the exec has started, in which it started. */
+    readonly bootId: string | null;
+    /** The program followed by its arguments. */
+    readonly cmd: readonly string[];
+    /** The account asked for, or null for the default. */
+    readonly user: string | null;
+    /** The working folder asked for, or null for the default. */
+    readonly workingDir: string | null;
+    /** Whether the program has a pseudo console. */
+    readonly tty: boolean;
+    /** Whether the exec was started detached. */
+    readonly detached: boolean;
+    /** The Windows process ID inside the machine, or null before the program has started or when it could not. */
+    readonly processId: number | null;
+    /** When the program started, or null before it has. */
+    readonly started: Timestamp | null;
+    /** Whether the program runs now. */
+    readonly running: boolean;
+    /** The program's exit code once it has ended: 127 when the program was not found and 126 when it was found but could not start, as Docker gives them. Null while it runs, and when Windows restarted before it ended. */
+    readonly exitCode: number | null;
+    /** When the program ended, or null. */
+    readonly exited: Timestamp | null;
+    /** Why the program could not start, or null. */
+    readonly startError: string | null;
+}

package/dist/contract/execs.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/fleets.d.ts

@@ -0,0 +1,136 @@
+import type { Timestamp } from "./common.js";
+import type { MachineSummary } from "./machines.js";
+import type { PurposeDetail, PurposeSummary } from "./purposes.js";
+/** One planned action in a dry run: what would be done, to what, and why. */
+export interface DryRunAction {
+    /** What would be done: `createNetwork`, `createVolume`, `build`, `create`, `recreate`, `start`, `remove` or `keep`. */
+    readonly action: string;
+    /** What it would be done to: a network or volume name, a service name for a build, or a machine name. */
+    readonly target: string;
+    /** Why, in words for the caller, such as `no machine has index 3`. */
+    readonly reason: string;
+}
+/** One fleet as `endia compose ps` reads it: the fleet's record, with each of its machines as `endia ps` lists one. */
+export interface FleetDetail {
+    /** The fleet name, which is the Compose project name. */
+    readonly name: string;
+    /** The paths of the Compose files as the CLI sent them with the last `compose up`. */
+    readonly configFiles: readonly string[];
+    /** The folder against which the CLI resolved relative paths. */
+    readonly projectDirectory: string;
+    /** The resolved Compose model of the last `compose up`, as `compose config --format json` prints it. */
+    readonly model: unknown;
+    /** The fleet's private networks. */
+    readonly networks: readonly FleetNetworkDetail[];
+    /** The names of the named volumes the fleet declares. */
+    readonly volumes: readonly string[];
+    /** The fleet's machines, sorted by service and then by index. */
+    readonly machines: readonly MachineSummary[];
+    /** When the fleet was first brought up. */
+    readonly created: Timestamp;
+    /** When the fleet's record was last changed. */
+    readonly updated: Timestamp;
+    /** What the fleet is being used for, in full, or null when it has no purpose. Each machine without a purpose of its own has it. */
+    readonly purpose: PurposeDetail | null;
+}
+/** What `compose down` removed, as its operation's result, with the warnings for the caller. */
+export interface FleetDownResult {
+    /** The fleet name. */
+    readonly fleet: string;
+    /** The machines removed, in the order they were removed: dependants before the services they depend on. */
+    readonly machines: readonly string[];
+    /** The networks whose switches were removed. */
+    readonly networks: readonly string[];
+    /** The named volumes whose disks were deleted. */
+    readonly volumes: readonly string[];
+    /** The warnings, in Docker Compose's words where Docker Compose has them. */
+    readonly warnings: readonly string[];
+}
+/** The answer to `compose up --dry-run`: what `compose up` would do, in order, and whether the host has the memory the machines it would start need. Nothing is changed to give it. */
+export interface FleetDryRun {
+    /** The planned actions, in the order `compose up` would perform them. */
+    readonly actions: readonly DryRunAction[];
+    /** The memory, in bytes, of the machines the plan would start: those it creates, recreates or starts. */
+    readonly memoryRequiredBytes: number;
+    /** The host's free memory, in bytes, less `hostReserveMiB`. */
+    readonly memoryAvailableBytes: number;
+}
+/** The result of `compose stop`, `compose start` and `compose restart`: the machines acted on, in the order they were acted on, and the warnings for the caller. */
+export interface FleetMachinesResult {
+    /** The fleet name. */
+    readonly fleet: string;
+    /** The machines stopped, started or restarted, in order. */
+    readonly machines: readonly string[];
+    /** The warnings, in Docker Compose's words where Docker Compose has them. */
+    readonly warnings: readonly string[];
+}
+/** One private network of a fleet: the Hyper-V switch that carries it, its address range and each machine's address on it. */
+export interface FleetNetworkDetail {
+    /** The network's key in the Compose model, for example `backend`. */
+    readonly key: string;
+    /** The network's name: its `name` in the Compose model, or else `<fleet>_<key>`. */
+    readonly name: string;
+    /** The name of the private Hyper-V switch. */
+    readonly switchName: string;
+    /** Hyper-V's identifier of the switch. */
+    readonly switchId: string;
+    /** The address range in CIDR form, for example `10.231.0.0/24`. */
+    readonly subnet: string;
+    /** Whether the network is internal: its machines have no card on the host's internet switch. */
+    readonly internal: boolean;
+    /** The IPv4 address of each machine on the network, by machine name. */
+    readonly addresses: Readonly<Record<string, string>>;
+}
+/** One fleet as `endia compose ls` lists it: its name, how many of its machines are in each state, and the Compose files its last `compose up` came from. */
+export interface FleetSummary {
+    /** The fleet name, which is the Compose project name. */
+    readonly name: string;
+    /** The number of machines in each state, as Docker Compose words it: each state with its count in brackets, the states sorted by name and joined by a comma and a space, such as `exited(1), running(3)`; empty for a fleet without machines. A listing that does not ask for every fleet counts only running and restarting machines. */
+    readonly status: string;
+    /** The paths of the Compose files as the CLI sent them with the last `compose up`. */
+    readonly configFiles: readonly string[];
+    /** What the fleet is being used for, or null when it has no purpose. */
+    readonly purpose: PurposeSummary | null;
+}
+/** What `compose up` did, as its operation's result: each machine, network and volume of the fleet with what was done to it, and the warnings for the caller. */
+export interface FleetUpResult {
+    /** The fleet name. */
+    readonly fleet: string;
+    /** Each machine the plan acted on or kept, in the order of the plan. */
+    readonly machines: readonly MachineOutcome[];
+    /** Each network the selected services join, in the order the project declares them. */
+    readonly networks: readonly NetworkOutcome[];
+    /** Each named volume the selected services mount, in the order the project declares them. */
+    readonly volumes: readonly VolumeOutcome[];
+    /** The warnings, in Docker Compose's words where Docker Compose has them, such as the list of orphan machines. */
+    readonly warnings: readonly string[];
+}
+/** One machine in the result of `compose up`: what was done to it, and its state and health once the operation finished. */
+export interface MachineOutcome {
+    /** The machine name, such as `classroom-trainee-2`. */
+    readonly name: string;
+    /** The machine's service. */
+    readonly service: string;
+    /** What was done: `created`, `recreated`, `started`, `removed` or `unchanged`. */
+    readonly action: string;
+    /** The machine's state as its record holds it, such as `running`; `removed` for a machine that no longer exists. */
+    readonly state: string;
+    /** The machine's health: `none`, `starting`, `healthy` or `unhealthy`. */
+    readonly health: string;
+}
+/** One network in the result of `compose up`: its name, its subnet and whether this run created it. */
+export interface NetworkOutcome {
+    /** The network's name, such as `classroom_classroom`. */
+    readonly name: string;
+    /** The subnet in CIDR form, such as `10.231.10.0/24`. */
+    readonly subnet: string;
+    /** `created` or `unchanged`. */
+    readonly action: string;
+}
+/** One named volume in the result of `compose up`: its name and whether this run created its disk. */
+export interface VolumeOutcome {
+    /** The volume's name, such as `classroom_server-data`. */
+    readonly name: string;
+    /** `created` or `unchanged`. */
+    readonly action: string;
+}

package/dist/contract/fleets.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/images.d.ts

@@ -0,0 +1,130 @@
+import type { Timestamp } from "./common.js";
+/** One image in the list that `endia images` prints. Members that Docker's API also gives an image in its list, such as `id`, `repoTags` and `parentId`, carry Docker's names, so that a `--format` template written for Docker reads the same fields. */
+export interface ImageSummary {
+    /** The image's digest, `sha256:` and 64 hexadecimal digits, which is its ID. */
+    readonly id: string;
+    /** Every tag that names the image, in full `name:tag` form, sorted; empty for an image without tags. */
+    readonly repoTags: readonly string[];
+    /** The digest of the image this one is built on; null for an imported image, which has no parent. */
+    readonly parentId: string | null;
+    /** When the image was recorded. */
+    readonly created: Timestamp;
+    /** The size in bytes of the image's own disk file, not counting the disks of the images it is built on. */
+    readonly size: number;
+    /** The image's labels, by name. */
+    readonly labels: Readonly<Record<string, string>>;
+    /** The start, at midnight UTC, of the day on which the image's evaluation edition of Windows expires; null when the image is not an evaluation edition. */
+    readonly evaluationExpires: Timestamp | null;
+    /** Whether the expiry date is fewer than `evaluationWarningDays` days away or has passed, so that the image needs a warning. */
+    readonly expiryWarning: boolean;
+    /** The number of machines made from the image. */
+    readonly machines: number;
+    /** The number of images built on the image. */
+    readonly children: number;
+}
+/** Everything that `endia image inspect` shows about one image: its tags, the chain of parents it is built on, its configuration and labels, its disk, the recipe and arguments that built it, and the machines and images that depend on it. Members that Docker's image inspect also gives, such as `id`, `repoTags`, `os` and `config`, carry Docker's names, so that a `--format` template written for Docker, such as `{{.Id}}`, reads the same fields. */
+export interface ImageDetail {
+    /** The image's digest, `sha256:` and 64 hexadecimal digits, which is its ID. */
+    readonly id: string;
+    /** Every tag that names the image, in full `name:tag` form, sorted; empty for an image without tags. */
+    readonly repoTags: readonly string[];
+    /** The digest of the image this one is built on; null for an imported image, which has no parent. */
+    readonly parentId: string | null;
+    /** When the image was recorded. */
+    readonly created: Timestamp;
+    /** The operating system that machines made from the image run: always `windows`. */
+    readonly os: string;
+    /** The processor architecture, as Docker names it: always `amd64`. */
+    readonly architecture: string;
+    /** The size in bytes of the image's own disk file, not counting the disks of the images it is built on. */
+    readonly size: number;
+    /** The configuration that machines made from the image, and images built on it, inherit; null when the image's record holds no configuration, which is the case only for a record written before image records kept it. */
+    readonly config: ImageConfigDetail | null;
+    /** The image's labels, by name. */
+    readonly labels: Readonly<Record<string, string>>;
+    /** The digests of the images this one is built on: its parent first, then the parent's parent, up to the imported image. Empty for an imported image. */
+    readonly chain: readonly string[];
+    /** The image's disk file: where it is, and how it came to be in the image folder. */
+    readonly disk: ImageDiskDetail;
+    /** The build key, a SHA-256 hash of everything that decided the build's result; null for an imported image. */
+    readonly buildKey: string | null;
+    /** The recipe and build arguments that built the image; null for an imported image. */
+    readonly build: ImageBuildDetail | null;
+    /** The names of the machines made from the image, sorted. */
+    readonly machines: readonly string[];
+    /** The digests of the images whose parent is this image. */
+    readonly children: readonly string[];
+}
+/** The configuration of an image as `endia image inspect` shows it: what a machine made from the image, and an image built on it, inherit from its recipe and its parents' recipes. */
+export interface ImageConfigDetail {
+    /** The environment variables, each written `NAME=value`, ordered by name. */
+    readonly env: readonly string[];
+    /** The default arguments, or null when none are set since the last entry point. */
+    readonly cmd: readonly string[] | null;
+    /** The entry point, or null when none is set. */
+    readonly entrypoint: readonly string[] | null;
+    /** The working directory with `/` separators, such as `C:/app`, or empty when none is set. */
+    readonly workingDir: string;
+    /** The account programs run as, or empty when none is set. */
+    readonly user: string;
+    /** The exposed ports, each written `number/protocol` such as `8080/tcp`. */
+    readonly exposedPorts: readonly string[];
+    /** The shell that runs shell-form commands, the executable first, or empty when none is set. */
+    readonly shell: readonly string[];
+}
+/** An image's disk file as `endia image inspect` shows it: its path, and how it came to be in the image folder. */
+export interface ImageDiskDetail {
+    /** The full path of the disk file in the image folder. */
+    readonly path: string;
+    /** How the disk file came to be in the image folder: `built` when a build made it, or, for an imported image, `copied`, `moved` or `inPlace`, the last when the file was already in the image folder and was used where it was. Null for an imported image whose record was written before image records kept how the disk came in. */
+    readonly broughtIn: string | null;
+}
+/** What built an image, as `endia image inspect` shows it: the recipe's text and the build arguments it was built with. */
+export interface ImageBuildDetail {
+    /** The text of the recipe. */
+    readonly recipe: string;
+    /** The build arguments, by name. */
+    readonly buildArgs: Readonly<Record<string, string>>;
+}
+/** The answer to `endia tag`: the tag that was set, the image it names now and the image it named before. */
+export interface TagResult {
+    /** The tag that was set, the `TARGET_IMAGE[:TAG]` argument of `endia tag`. */
+    readonly target: string;
+    /** The digest of the image that the tag now names. */
+    readonly digest: string;
+    /** The digest of the image that the tag named before; null when the tag is new. */
+    readonly previousDigest: string | null;
+}
+/** One event of `endia rmi`, as `docker rmi` answers: a tag that was removed, written `{ "untagged": tag }`, or an image that was deleted, written `{ "deleted": digest }`. The answer lists the events in the order they happened, so the removal of an image's last tag comes before the deletion it led to. */
+export interface RemovalEntry {
+    /** The tag that was removed, in the form `name:tag`, or null when the event is a deletion. */
+    readonly untagged?: string | null;
+    /** The digest of the image that was deleted, or null when the event is a removed tag. */
+    readonly deleted?: string | null;
+}
+/** The result of a finished build: the image it made or reused for its target stage, the tags that now name that image, whether anything was built, and what each stage on the way to the target gave. */
+export interface BuildResult {
+    /** The digest of the image, in the form `sha256:` followed by 64 hexadecimal digits. */
+    readonly digest: string;
+    /** The tags that were requested, each of which now names the image; empty when the build asked for none. */
+    readonly tags: readonly string[];
+    /** The target stage's build key: a SHA-256 hash of everything that decides its result. A later build with the same key reuses this image. */
+    readonly buildKey: string;
+    /** Whether every stage was found in the cache, so that nothing was built. */
+    readonly cacheHit: boolean;
+    /** How long the build took, in seconds, from the start of the operation's work to the last tag moved. */
+    readonly seconds: number;
+    /** Each stage the build made or found, from the lowest, built on an image, to the target. A recipe of one stage gives one. A service older than multi-stage builds leaves it out. */
+    readonly stages?: readonly BuildStageResult[];
+}
+/** What one stage of a build gave: the image, for the target stage, or a build-cache entry, for a stage below it. A stage is the part of a recipe from one `FROM` to the next; a build-cache entry is a stage's committed result that is not an image, which a later build whose stage has the same build key reuses. */
+export interface BuildStageResult {
+    /** The name that the stage's `FROM ... AS` gives it, in lower case, or null for a stage without one. */
+    readonly name: string | null;
+    /** The digest of the stage's result, in the form `sha256:` followed by 64 hexadecimal digits. */
+    readonly digest: string;
+    /** The stage's build key: a SHA-256 hash of everything that decides the stage's result. */
+    readonly buildKey: string;
+    /** Whether an image or build-cache entry with the stage's build key already existed, so that the stage was not built. */
+    readonly cacheHit: boolean;
+}

package/dist/contract/images.js

@@ -0,0 +1 @@
+export {};