@agentorg/computer 0.0.18 → 0.0.20

package/dist/types/generated/schema.d.ts

@@ -11,7 +11,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** What this service is and how it isolates its computers. */
+        /** What this service offers: this computer, the kinds of computer it can make, and the browsers that can go with each, every one ready or not and why. */
         get: operations["getInfo"];
         put?: never;
         post?: never;
@@ -21,6 +21,95 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/connection": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Who is connected to the service: each client that holds a WebSocket open at this same path, with the control token in its Authorization header and its name as `?name=`. It carries nothing either way, and one that stops answering the service's pings is dropped. */
+        get: operations["getConnection"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/setup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** For each part of the service's machine an agent can use, the person's switch, whether it has all it needs, and each thing it needs, read afresh each time. */
+        get: operations["getSetup"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/setup/{capability}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                capability: components["schemas"]["Switch"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        /** Set a part's switch, which lasts across restarts. Turning it on, or on again, also asks for everything the part is missing, as asking for it with no need named does. Where that couldn't be started, it answers 409, saying why, and the switch stays on. */
+        put: operations["setSetup"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/setup/{capability}/ask": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                capability: components["schemas"]["Switch"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Ask the person, on the service's machine, macOS only, for one thing a part needs, or, with none named, for everything it is missing. screen-recording or accessibility, while it is missing: Cua Driver's own grant, its app started first, which makes the system's requests in its own order, Accessibility first. For a driver an app hosts, the app asks, for that grant alone. Then that grant's own pane in System Settings opens. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, the screen's grant while either is missing, and the first browser installed, Chrome before Edge, while none is on. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing. */
+        post: operations["askSetup"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/acting": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Who is acting now on the computers attached to this machine, all of them at once: each one, on what, and when they last acted there, the most recent first, as each computer's presence surface has it. A computer in a container isn't included: its own presence surface has it. */
+        get: operations["getActing"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/computers": {
         parameters: {
             query?: never;
@@ -31,7 +120,10 @@ export interface paths {
         /** List the computers. */
         get: operations["listComputers"];
         put?: never;
-        /** Create a computer. It answers once the computer is running. */
+        /**
+         * Create a computer. It answers once the computer is running.
+         * @description Meanwhile, once any `copyFrom` copy is done, it is listed by `listComputers` as `starting`, with the name and metadata given here, its `reason`, and its image's `progress` where that is counted: that is how a caller shows a computer being made before `create` has answered.
+         */
         post: operations["createComputer"];
         delete?: never;
         options?: never;
@@ -39,6 +131,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/computers/attach": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Attach this computer, the machine the service runs on, whole: its files and commands reach all of it, as whoever started the service. Each call attaches it as a computer of its own, with its own id and token. Killing one detaches it and removes nothing of the machine's. Refused with 409 by a service that other machines can reach, which doesn't offer it. */
+        post: operations["attachComputer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/computers/{computerID}": {
         parameters: {
             query?: never;
@@ -187,10 +296,24 @@ export interface components {
          */
         Access: "none" | "read" | "files" | "terminal";
         /**
-         * @description failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its logs say why. Stop it and start it again.
+         * @description starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again.
          * @enum {string}
          */
-        ComputerState: "running" | "stopped" | "failed";
+        ComputerState: "starting" | "running" | "stopped" | "failed";
+        /** @description How far a step that counts its bytes has come: today only fetching a computer's image, where Docker is on a socket on the service's machine. */
+        Progress: {
+            /** @description The step, in words with no numbers: "Downloading its image". */
+            title: string;
+            /** @description Bytes come so far. */
+            done: number;
+            /** @description Bytes to come, as far as is known: Docker gives each layer's size as the layer begins, so it can grow. Null while nothing is known. */
+            total: number | null;
+            /**
+             * Format: date-time
+             * @description When it last moved: bytes came, or, for an image, a layer was unpacked. When the step began, until then.
+             */
+            moved: string;
+        };
         /** @description Seconds from now until the computer stops. */
         Timeout: number;
         /** @description Your own labels, kept and returned as given. */
@@ -207,13 +330,33 @@ export interface components {
             browser: boolean;
             /** @description The full path of a folder that exists, on the service's machine. With none, the service makes a folder, which goes when the computer is killed. A folder named here never does. */
             workspace?: string;
-            /** @description How it is isolated, which it keeps for as long as it exists. Left out, it is the service's own, the `isolation` that `getInfo` answers. */
+            /** @description The full path of a folder on the service's machine. The workspace the service makes starts with a copy of what is in it, taken once when the computer is made; the folder itself is never mounted or changed. Links are copied as they are, and sockets, pipes and devices are left out. Use it instead of workspace; it needs access other than none. */
+            copyFrom?: string;
+            /** @description How it is isolated, which it keeps for as long as it exists: container, the default. One with no isolation is no longer made, and asking for one is refused: attach this computer instead. */
             isolation?: components["schemas"]["Isolation"];
             timeout?: components["schemas"]["Timeout"];
             metadata?: components["schemas"]["Metadata"];
         };
+        AttachComputer: {
+            name?: string;
+            access: components["schemas"]["Access"];
+            /**
+             * @description Its browser. true: a headless one of its own. own: the person's own, Chrome or else Edge, signed in, reached through the browser's own attach, which asks the person to allow the connection; attaching waits up to 2 minutes for that, and is refused with 409 if it isn't allowed, or where `info` says it isn't ready. Its agent works only in tabs it opens: the person's own tabs are left alone. It is never closed: when the computer stops, it is only let go. With access none, the computer must have a browser or the screen.
+             * @default false
+             */
+            browser: boolean | "own";
+            /**
+             * @description Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready.
+             * @default false
+             */
+            screen: boolean;
+            /** @description Its work folder: the full path of a folder that exists. Commands and relative paths start there and its agent is told to work there, but nothing keeps its files inside it. Detaching never removes it. */
+            workspace: string;
+            timeout?: components["schemas"]["Timeout"];
+            metadata?: components["schemas"]["Metadata"];
+        };
         /**
-         * @description none: processes of whoever started the service. container: a container of its own, which needs Docker on the service's machine.
+         * @description none: processes of whoever started the service, which only this computer has now; a computer made with no isolation before can't start again. container: a container of its own, which needs Docker on the service's machine.
          * @enum {string}
          */
         Isolation: "none" | "container";
@@ -223,17 +366,28 @@ export interface components {
             computer: string | null;
             /** @description The browser. */
             browser: string | null;
+            /** @description The screen endpoint, or null when this computer was attached without `screen`. */
+            screen: string | null;
         };
         Computer: {
             computerID: string;
             name: string;
             state: components["schemas"]["ComputerState"];
+            /** @description In a line a person reads: while it is starting, the step it waits on, with no numbers, such as "Its image is being fetched.", "Its container is being started." or "It is being started."; while it is failed, why. Null while it is running or stopped. */
+            reason: string | null;
+            /** @description While it is starting, how far its step has come, where the step counts its bytes; null otherwise. */
+            progress: components["schemas"]["Progress"] | null;
             access: components["schemas"]["Access"];
             /** @description The isolation it was made in. It is never run in another. */
             isolation: components["schemas"]["Isolation"];
-            /** @description The version of the program it ran at its last start. With no isolation it is the service's `version` (see `getInfo`). In a container it is the version inside its image, and null for a container made before 0.0.17, which doesn't say, until it is made again. It is kept from its last start, so a stopped computer's can be older than the service's until it starts. Compare it with the service's to show that a computer runs an older program. */
+            /** @description Whether it is this computer, attached rather than made: the service's machine, whole, acting as whoever started the service, with no isolation. False with isolation none marks a computer made with no isolation by an earlier version, which can't start again; its workspace is kept. */
+            attached: boolean;
+            /** @description The version of the program it ran at its last start. For this computer it is the service's `version` (see `getInfo`). In a container it is the version inside its image, and null for a container made before 0.0.17, which doesn't say, until it is made again. It is kept from its last start, so a stopped computer's can be older than the service's until it starts. Compare it with the service's to show that a computer runs an older program. */
             version: string | null;
-            browser: boolean;
+            /** @description Its browser, as it was given, or false where it has none. */
+            browser: boolean | "own";
+            /** @description Whether its agent has the screen: only this computer can have one. */
+            screen: boolean;
             workspace: string | null;
             /**
              * Format: date-time
@@ -259,13 +413,14 @@ export interface components {
             tools: {
                 computer: string[];
                 browser: string[];
+                screen: string[];
             };
         };
         /**
-         * @description terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches or asks.
+         * @description terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches or asks. presence: who is acting on it now, in presence@1, to watch only: a PresenceEvent when the socket opens, and another each time someone starts or stops acting on something. screen: the machine's screen, for this computer attached with it, in screen@1: binary messages are PNG frames of the whole screen, at most 1,280 pixels on their longest side, text messages are ScreenEvent one way and ScreenInput the other. The screen is taken twice a second while a socket is open, and a frame is sent only when the picture changed, so a socket is sent the last one when it opens and nothing more while the screen is still. A socket with more than 4 MiB still to be sent to it is sent nothing until it catches up.
          * @enum {string}
          */
-        Surface: "terminal" | "files" | "browser" | "load";
+        Surface: "terminal" | "files" | "browser" | "load" | "presence" | "screen";
         /**
          * @description In watch you see and don't act: what you send is dropped, except that a files socket may still ask to list, to read and for what changed.
          * @enum {string}
@@ -385,6 +540,39 @@ export interface components {
             /** @description A URL, or back, forward or reload. */
             to: string;
         };
+        /** @description What the service sends on a screen@1 socket, as JSON text. */
+        ScreenEvent: {
+            /** @constant */
+            type: "size";
+            width: number;
+            height: number;
+        } | {
+            /** @constant */
+            type: "refused";
+            message: string;
+        };
+        /** @description What an operate socket sends on screen@1, as JSON text, no message over 65,536 bytes: a larger one closes the socket. Each is done in order, through Cua Driver, as the person. A point is in pixels of the frames, as the last size says, scaled to the screen; keys and text go to the window in front. What isn't done is answered with refused, and why: what Cua Driver refuses, what is none of these, and what is sent while 32 are still waiting. Binary messages, and whatever a watch socket sends, are dropped. */
+        ScreenInput: {
+            /** @constant */
+            type: "mouse";
+            /** @enum {string} */
+            action: "click" | "double_click" | "right_click" | "drag" | "scroll";
+            x: number;
+            y: number;
+            to_x?: number;
+            to_y?: number;
+            /** @enum {string} */
+            direction?: "up" | "down" | "left" | "right";
+            amount?: number;
+        } | {
+            /** @constant */
+            type: "key";
+            keys: string[];
+        } | {
+            /** @constant */
+            type: "text";
+            text: string;
+        };
         /** @description What the service sends on a terminal@1 socket, as JSON text, no message over 65,536 bytes. A terminal is a command the agent started or a shell a person opened; its id is the session id the agent's tools use. A new socket is first sent, for each terminal already there, the oldest first, its start, the end of what it wrote (its last 65,536 characters), and its exit if it has ended; then each event as it happens, with nothing to mark where the first ends. The last 64 that ended are among those already there, and one that leaves that list is not told. A character here is a UTF-16 unit. A socket with more than 4 MiB still to be sent to it is closed, with no close frame (1006): one that has stopped reading, or one that is reading while a terminal writes tens of megabytes at once. It isn't an error. Opened again, it is sent every terminal afresh, with the last 65,536 characters each wrote, in place of whatever it held. */
         TerminalEvent: {
             /** @constant */
@@ -452,7 +640,7 @@ export interface components {
             /** @constant */
             type: "reading";
             /**
-             * @description Whose numbers these are. computer: this computer's own, which a container's are. machine: the whole machine's, which a computer with no isolation shares with whatever else runs there, so every computer of that service reads the same; and a container's where it can't read its own.
+             * @description Whose numbers these are. computer: the computer's own, as a container's are. machine: the whole machine's, as this computer's are, which it shares with whatever else runs there; and a container's where it can't read its own.
              * @enum {string}
              */
             scope: "computer" | "machine";
@@ -467,6 +655,75 @@ export interface components {
             /** @description Bytes on that volume. */
             diskTotal: number;
         };
+        /**
+         * @description A part of the service's machine an agent can use: its terminal, its files, its screen, and the person's own browser.
+         * @enum {string}
+         */
+        Switch: "terminal" | "files" | "screen" | "browser";
+        /**
+         * @description install: Cua Driver, which the screen works through. screen-recording and accessibility: Cua Driver's two grants. chrome and edge: each browser, with remote debugging on or off; named: the one browser a service was given the folder of.
+         * @enum {string}
+         */
+        NeedName: "install" | "screen-recording" | "accessibility" | "chrome" | "edge" | "named";
+        Need: {
+            need: components["schemas"]["NeedName"];
+            /** @description A browser's name: Chrome, Edge, or the browser. */
+            name?: string;
+            /** @description For a grant, whose it is, as System Settings lists it: the outermost app Cua Driver is inside, CuaDriver for its own app, or an app that carries the driver. None where Cua Driver is in no app. */
+            holder?: string;
+            /**
+             * @description missing: not installed. unknown: it can't be read now. A browser is on while it is open with its remote debugging switched on.
+             * @enum {string}
+             */
+            state: "missing" | "granted" | "not-granted" | "unknown" | "on" | "off";
+        };
+        Setup: {
+            /** @description terminal, files, screen and browser, in that order. */
+            capabilities: {
+                capability: components["schemas"]["Switch"];
+                /** @description The person's switch. Off, agents' new calls to the part refuse, saying the person turned it off, and `info` says so; what an agent already started runs on. The terminal and the screen each reach the whole machine: commands read any file, and the screen acts in any app. The browser's switch is for the person's own; any browser's code-running tool answers to the terminal's switch, and a browser call that names files, by `paths` or `filename`, to the files'. A service started with `--lend` starts with every one off; any other, with every one on. */
+                on: boolean;
+                /** @description Whether the part has all it needs, apart from its switch: the screen, each item granted; the browser, one browser on. The terminal and files always do. */
+                ready: boolean;
+                /** @description Each thing the part needs, always, with its state. The terminal and files need nothing. The screen needs Cua Driver, which while it isn't installed is the one item, and on macOS its two grants. The browser lists Chrome then Edge, each on, off or missing, or the one browser named; with both on, the agent's is Chrome. */
+                needs: components["schemas"]["Need"][];
+            }[];
+        };
+        Connection: {
+            /** @description Whether any client holds a connection now. */
+            connected: boolean;
+            /** @description Each client holding one, the earliest first. */
+            clients: {
+                /** @description The name it gave, its first 100 characters, or empty: such as AgentOrg 0.0.15. */
+                name: string;
+                /** Format: date-time */
+                since: string;
+                /** @description Whether it connects from this machine, by the address it connects from. False behind --tls-proxy, where every client comes from the proxy. */
+                local: boolean;
+            }[];
+        };
+        /** @description Someone who acted on a computer in the last 10 seconds. The person acts in a live view at operate: opening a shell, typing into or stopping a terminal, writing a file, any input to the browser but moving the pointer, or any input to the screen that Cua Driver did. Watching is not acting, and the person's own use of the screen, outside a live view, can't be seen. The agent acts by calling its endpoints: starting a command or typing into one (waiting on its output is not acting), any file tool, reads among them, any browser tool that is answered, and any screen tool. Computers attached to the same machine share its files and its screen: each is shown the person and the other computers' agents acting on them, by name. */
+        Acting: {
+            /** @enum {string} */
+            who: "person" | "agent";
+            /** @description The agent's name */
+            name?: string;
+            /** @enum {string} */
+            capability: "terminal" | "files" | "browser" | "screen";
+            /** @description Which terminal, by its id; only for a terminal. */
+            terminal?: string;
+            /**
+             * Format: date-time
+             * @description When it last acted there, as of this message: one who goes on acting is sent again only when someone starts or stops.
+             */
+            at: string;
+        };
+        /** @description What the service sends on a presence@1 socket, as JSON text: the whole list of everyone acting now, the most recent first, empty where nobody is. It is sent when the socket opens and each time someone starts acting on something, or stops: 10 seconds after they last acted there. Nothing is refused by it. What a socket sends is dropped. */
+        PresenceEvent: {
+            /** @constant */
+            type: "presence";
+            acting: components["schemas"]["Acting"][];
+        };
         /** @description What a socket sends on files@1, as JSON text. Each has an id of its own choosing, which the answer repeats; answers come as they are ready, in any order, and ids aren't checked for repeats. A request still unanswered when the socket closes gets no answer. A path is from the workspace, with / between its parts, or absolute inside it, and nothing outside the workspace is reached. A binary message that follows no write closes the socket, and so does any message over 1,048,576 bytes. */
         FilesRequest: {
             /** @constant */
@@ -559,12 +816,42 @@ export interface components {
                 line: string;
             }[];
         };
+        Readiness: {
+            ready: boolean;
+            /** @description Why it isn't ready, in a line a person reads. Only when it isn't. */
+            reason?: string;
+        };
+        /**
+         * @description What a computer offers its agent and the person: what it is, its terminals, its files and its screen. This computer's screen is reached through Cua Driver: it is ready where Cua Driver is installed, at 0.49.7 or later, and granted Screen Recording and Accessibility, and otherwise the reason says what to do. A part the person switched off on that machine isn't ready either.
+         * @enum {string}
+         */
+        Capability: "about" | "terminal" | "files" | "screen";
+        CapabilityState: components["schemas"]["Readiness"] & {
+            capability: components["schemas"]["Capability"];
+        };
+        /**
+         * @description headless: a headless browser with a profile of its own, beside the computer, which a person watches and controls through its live view. own: the person's own browser on the service's machine, Chrome or Edge, signed in, offered for this computer: ready where one is open with its remote debugging switched on, Chrome first, which the person does once on its inspect page; the browser then asks them to allow each connection. Not ready, the reason names the browser and what to do on that machine. Switched off by the person on that machine, it isn't ready either.
+         * @enum {string}
+         */
+        BrowserKind: "headless" | "own";
+        BrowserState: components["schemas"]["Readiness"] & {
+            kind: components["schemas"]["BrowserKind"];
+        };
+        Offer: components["schemas"]["Readiness"] & {
+            /** @description What such a computer has, each ready or not. */
+            capabilities: components["schemas"]["CapabilityState"][];
+            /** @description The browsers that can go with it, each ready or not. */
+            browsers: components["schemas"]["BrowserState"][];
+        };
+        MadeKind: components["schemas"]["Offer"] & {
+            isolation: components["schemas"]["Isolation"];
+        };
         ServiceInfo: {
             version: string;
-            /** @description The isolation of a computer made without saying which, chosen when the service is started. */
-            isolation: components["schemas"]["Isolation"];
-            /** @description The isolations a computer can be made in now, `none` first. `container` is among them while Docker answers on the service's machine. It is what to offer, not a promise: Docker is asked for a second here and for ten when a container is made, so one that is slow can be missing here and still be made. If `isolation` itself is missing, a computer made without saying which is refused with 409. */
-            isolationsAvailable: components["schemas"]["Isolation"][];
+            /** @description This computer, the machine the service runs on, attached whole, as whoever started the service. It can be attached while ready: only where the service listens on loopback, with no proxy in front and no public address. Elsewhere it isn't offered, and one attached before is refused at start. */
+            thisComputer: components["schemas"]["Offer"];
+            /** @description Each kind of computer it makes, ready while it can be made now. A container is ready while Docker answers on the service's machine: asked for a second here and for ten when one is made, so one that is slow can be not ready here and still be made. */
+            made: components["schemas"]["MadeKind"][];
         };
     };
     responses: {
@@ -615,6 +902,145 @@ export interface operations {
             401: components["responses"]["Unauthorized"];
         };
     };
+    getConnection: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Who is connected. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Connection"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getSetup: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Each part. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Setup"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    setSetup: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                capability: components["schemas"]["Switch"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    on: boolean;
+                };
+            };
+        };
+        responses: {
+            /** @description Set, and its steps started. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Setup"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description On, but the steps that ask for what it needs couldn't be started. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    askSetup: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                capability: components["schemas"]["Switch"];
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    need?: components["schemas"]["NeedName"];
+                };
+            };
+        };
+        responses: {
+            /** @description Asked, its steps started. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Setup"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            /** @description The part doesn't need that here, or what it needs can't be asked for, such as a browser that isn't installed, or the steps couldn't be started. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getActing: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Who is acting now. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Acting"][];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
     listComputers: {
         parameters: {
             query?: {
@@ -663,6 +1089,34 @@ export interface operations {
             };
             400: components["responses"]["Error"];
             401: components["responses"]["Unauthorized"];
+            409: components["responses"]["Error"];
+        };
+    };
+    attachComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AttachComputer"];
+            };
+        };
+        responses: {
+            /** @description It, with its access token, shown only now. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreatedComputer"];
+                };
+            };
+            400: components["responses"]["Error"];
+            401: components["responses"]["Unauthorized"];
+            409: components["responses"]["Error"];
         };
     };
     getComputer: {
@@ -709,6 +1163,15 @@ export interface operations {
             };
             401: components["responses"]["Unauthorized"];
             404: components["responses"]["Error"];
+            /** @description It can't be removed here: a container while Docker doesn't answer, or one made before under a service that now only lends this machine. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
         };
     };
     setComputerTimeout: {
@@ -794,6 +1257,7 @@ export interface operations {
             };
             401: components["responses"]["Unauthorized"];
             404: components["responses"]["Error"];
+            409: components["responses"]["Error"];
         };
     };
     getComputerLogs: {