@ankorcs/protocol 0.0.0-stage → 0.6.1

package/dist/agent-socket.d.ts

@@ -0,0 +1,3927 @@
+/**
+ * Outbound agent WebSocket authenticated by bearer token.
+ *
+ * Requests carry `id`. A reply echoes it in `reply_to` and names the request's `type` in `request`.
+ * Unsolicited frames omit correlation fields.
+ */
+import { z } from 'zod';
+/** The `code` of a failed {@link AgentReply | reply}. `detail` carries the human-readable rest. */
+export declare const AGENT_ERRORS: {
+    /** No slot is idle, unreserved and on a token Steam has not refused. */
+    readonly noFreeSlot: "no_free_slot";
+    /**
+     * A newer public CS2 build is out and the node has not updated to it yet, so its `cs2.build_id`
+     * is behind `cs2.latest_build_id`. The node takes launches again once it has updated. A node
+     * whose `auto_update` is `false` never refuses with this.
+     */
+    readonly cs2Outdated: "cs2_outdated";
+    /**
+     * CS2 is not installed on the node, so its `cs2.build_id` is `null`. The node takes launches once
+     * an {@link ControllerUpdateCs2 | update_cs2} has installed it.
+     */
+    readonly cs2NotInstalled: "cs2_not_installed";
+    /** The node reports `unavailable` for a reason other than `maintenance`. */
+    readonly nodeUnavailable: "node_unavailable";
+    /**
+     * An operation that needs every slot idle found one held: {@link ControllerUpdateCs2 | update_cs2}, or a
+     * {@link ControllerSetConfig | set_config} that changes any key under `controller`.
+     */
+    readonly slotsHeld: "slots_held";
+    /**
+     * A slot holds a server that is `starting`, `running` or `stopping`, and
+     * {@link ControllerSetConfig | set_config} would remove or re-port the slot or give its server's token
+     * to another slot, or {@link ControllerReserveSlot | reserve_slot} asked for it. `detail` names the
+     * slots.
+     */
+    readonly slotHeld: "slot_held";
+    /** The node has no slot with that id. */
+    readonly unknownSlot: "unknown_slot";
+    /**
+     * {@link ControllerSetConfig | set_config} kept the token of a slot the node does not have yet. A new
+     * slot needs a new token.
+     */
+    readonly slotTokenRequired: "slot_token_required";
+    /**
+     * {@link ControllerSetConfig | set_config} kept the value of a demo upload header the node does not
+     * send. A new header needs its value.
+     */
+    readonly demoHeaderValueRequired: "demo_header_value_required";
+    /** No server with that allocation id. */
+    readonly unknownAllocation: "unknown_allocation";
+    /**
+     * A maintenance operation runs on the node. That operation is unaffected, and `unavailable` shows
+     * it as `maintenance`.
+     */
+    readonly maintenanceRunning: "maintenance_running";
+    /**
+     * The image is not on the node and the request asked for no pull. Asking again with `pull`
+     * fetches it.
+     */
+    readonly imageMissing: "image_missing";
+    /**
+     * The image is not an official one, and the node's `official_images_only` is on. The node's
+     * operator decides which images it runs.
+     */
+    readonly imageNotAllowed: "image_not_allowed";
+    /** The demo is uploading. It can be deleted once the upload ends. */
+    readonly demoUploading: "demo_uploading";
+    /** The slot has no demo of that name, such as one an upload or a delete has already removed. */
+    readonly unknownDemo: "unknown_demo";
+    /** The demo is still being recorded. It can be deleted once its server ends the recording. */
+    readonly demoRecording: "demo_recording";
+    /** The server's plugin is not connected to the agent, or left before it answered. */
+    readonly pluginOffline: "plugin_offline";
+    /**
+     * The plugin did not answer {@link ControllerGetServerStatus | get_server_status},
+     * {@link ControllerConsoleCommand | console_command}, {@link ControllerStartMatch | start_match} or
+     * {@link ControllerRestoreRound | restore_round} within {@link SERVER_STATUS_TIMEOUT_MS}.
+     */
+    readonly pluginStatusTimeout: "plugin_status_timeout";
+    /** The server runs without a match. */
+    readonly noMatch: "no_match";
+    /** The match is past its warmup. */
+    readonly notInWarmup: "not_in_warmup";
+    /** A team has no player connected. */
+    readonly teamEmpty: "team_empty";
+    /** The match is not live, such as in warmup, during the knife round or after it ended. */
+    readonly notLive: "not_live";
+    /**
+     * The match is in its halftime break, while the sides are about to swap. Ask again once the next
+     * round has started.
+     */
+    readonly atHalftime: "at_halftime";
+    /**
+     * The node has no backup of the round that {@link ControllerRestoreRound | restore_round} named for that
+     * server.
+     */
+    readonly noBackup: "no_backup";
+    /** The request did not match its schema. */
+    readonly invalidRequest: "invalid_request";
+    /**
+     * {@link ControllerStartServer | start_server} named an allocation this node is already launching or
+     * running. Its server exists or is on its way, as after a {@link ControllerStartServer | start_server}
+     * sent again when its reply was slow.
+     */
+    readonly allocationInUse: "allocation_in_use";
+    /**
+     * {@link ControllerStartServer | start_server} named an allocation that this node launched before, among
+     * the last {@link REMEMBERED_ALLOCATIONS}. The node files a server's events and demos under its
+     * allocation, so every launch needs a new one.
+     */
+    readonly allocationReused: "allocation_reused";
+    /** The agent does not know the request's `type`, or the plugin the command's. */
+    readonly unsupportedRequest: "unsupported_request";
+    /**
+     * The agent is stopping and started no work for the request, as after its
+     * {@link AgentShutdown | shutdown}. Send the request again once the node reconnects.
+     */
+    readonly shuttingDown: "shutting_down";
+    /** Any failure that no other code names, such as a Docker failure. */
+    readonly failed: "failed";
+};
+/** The `code` of a failed reply, one of the values of {@link AGENT_ERRORS}. */
+export declare const AgentErrorCode: z.ZodEnum<{
+    /** No slot is idle, unreserved and on a token Steam has not refused. */
+    readonly noFreeSlot: "no_free_slot";
+    /**
+     * A newer public CS2 build is out and the node has not updated to it yet, so its `cs2.build_id`
+     * is behind `cs2.latest_build_id`. The node takes launches again once it has updated. A node
+     * whose `auto_update` is `false` never refuses with this.
+     */
+    readonly cs2Outdated: "cs2_outdated";
+    /**
+     * CS2 is not installed on the node, so its `cs2.build_id` is `null`. The node takes launches once
+     * an {@link ControllerUpdateCs2 | update_cs2} has installed it.
+     */
+    readonly cs2NotInstalled: "cs2_not_installed";
+    /** The node reports `unavailable` for a reason other than `maintenance`. */
+    readonly nodeUnavailable: "node_unavailable";
+    /**
+     * An operation that needs every slot idle found one held: {@link ControllerUpdateCs2 | update_cs2}, or a
+     * {@link ControllerSetConfig | set_config} that changes any key under `controller`.
+     */
+    readonly slotsHeld: "slots_held";
+    /**
+     * A slot holds a server that is `starting`, `running` or `stopping`, and
+     * {@link ControllerSetConfig | set_config} would remove or re-port the slot or give its server's token
+     * to another slot, or {@link ControllerReserveSlot | reserve_slot} asked for it. `detail` names the
+     * slots.
+     */
+    readonly slotHeld: "slot_held";
+    /** The node has no slot with that id. */
+    readonly unknownSlot: "unknown_slot";
+    /**
+     * {@link ControllerSetConfig | set_config} kept the token of a slot the node does not have yet. A new
+     * slot needs a new token.
+     */
+    readonly slotTokenRequired: "slot_token_required";
+    /**
+     * {@link ControllerSetConfig | set_config} kept the value of a demo upload header the node does not
+     * send. A new header needs its value.
+     */
+    readonly demoHeaderValueRequired: "demo_header_value_required";
+    /** No server with that allocation id. */
+    readonly unknownAllocation: "unknown_allocation";
+    /**
+     * A maintenance operation runs on the node. That operation is unaffected, and `unavailable` shows
+     * it as `maintenance`.
+     */
+    readonly maintenanceRunning: "maintenance_running";
+    /**
+     * The image is not on the node and the request asked for no pull. Asking again with `pull`
+     * fetches it.
+     */
+    readonly imageMissing: "image_missing";
+    /**
+     * The image is not an official one, and the node's `official_images_only` is on. The node's
+     * operator decides which images it runs.
+     */
+    readonly imageNotAllowed: "image_not_allowed";
+    /** The demo is uploading. It can be deleted once the upload ends. */
+    readonly demoUploading: "demo_uploading";
+    /** The slot has no demo of that name, such as one an upload or a delete has already removed. */
+    readonly unknownDemo: "unknown_demo";
+    /** The demo is still being recorded. It can be deleted once its server ends the recording. */
+    readonly demoRecording: "demo_recording";
+    /** The server's plugin is not connected to the agent, or left before it answered. */
+    readonly pluginOffline: "plugin_offline";
+    /**
+     * The plugin did not answer {@link ControllerGetServerStatus | get_server_status},
+     * {@link ControllerConsoleCommand | console_command}, {@link ControllerStartMatch | start_match} or
+     * {@link ControllerRestoreRound | restore_round} within {@link SERVER_STATUS_TIMEOUT_MS}.
+     */
+    readonly pluginStatusTimeout: "plugin_status_timeout";
+    /** The server runs without a match. */
+    readonly noMatch: "no_match";
+    /** The match is past its warmup. */
+    readonly notInWarmup: "not_in_warmup";
+    /** A team has no player connected. */
+    readonly teamEmpty: "team_empty";
+    /** The match is not live, such as in warmup, during the knife round or after it ended. */
+    readonly notLive: "not_live";
+    /**
+     * The match is in its halftime break, while the sides are about to swap. Ask again once the next
+     * round has started.
+     */
+    readonly atHalftime: "at_halftime";
+    /**
+     * The node has no backup of the round that {@link ControllerRestoreRound | restore_round} named for that
+     * server.
+     */
+    readonly noBackup: "no_backup";
+    /** The request did not match its schema. */
+    readonly invalidRequest: "invalid_request";
+    /**
+     * {@link ControllerStartServer | start_server} named an allocation this node is already launching or
+     * running. Its server exists or is on its way, as after a {@link ControllerStartServer | start_server}
+     * sent again when its reply was slow.
+     */
+    readonly allocationInUse: "allocation_in_use";
+    /**
+     * {@link ControllerStartServer | start_server} named an allocation that this node launched before, among
+     * the last {@link REMEMBERED_ALLOCATIONS}. The node files a server's events and demos under its
+     * allocation, so every launch needs a new one.
+     */
+    readonly allocationReused: "allocation_reused";
+    /** The agent does not know the request's `type`, or the plugin the command's. */
+    readonly unsupportedRequest: "unsupported_request";
+    /**
+     * The agent is stopping and started no work for the request, as after its
+     * {@link AgentShutdown | shutdown}. Send the request again once the node reconnects.
+     */
+    readonly shuttingDown: "shutting_down";
+    /** Any failure that no other code names, such as a Docker failure. */
+    readonly failed: "failed";
+}>;
+export type AgentErrorCode = z.infer<typeof AgentErrorCode>;
+/** Longest `detail` a refused request carries. The agent cuts the message to it. */
+export declare const AGENT_ERROR_DETAIL_MAX_CHARS = 512;
+/** Why a request failed. Branch on `code`. `detail` is for people. */
+export declare const AgentError: z.ZodObject<{
+    code: z.ZodEnum<{
+        /** No slot is idle, unreserved and on a token Steam has not refused. */
+        readonly noFreeSlot: "no_free_slot";
+        /**
+         * A newer public CS2 build is out and the node has not updated to it yet, so its `cs2.build_id`
+         * is behind `cs2.latest_build_id`. The node takes launches again once it has updated. A node
+         * whose `auto_update` is `false` never refuses with this.
+         */
+        readonly cs2Outdated: "cs2_outdated";
+        /**
+         * CS2 is not installed on the node, so its `cs2.build_id` is `null`. The node takes launches once
+         * an {@link ControllerUpdateCs2 | update_cs2} has installed it.
+         */
+        readonly cs2NotInstalled: "cs2_not_installed";
+        /** The node reports `unavailable` for a reason other than `maintenance`. */
+        readonly nodeUnavailable: "node_unavailable";
+        /**
+         * An operation that needs every slot idle found one held: {@link ControllerUpdateCs2 | update_cs2}, or a
+         * {@link ControllerSetConfig | set_config} that changes any key under `controller`.
+         */
+        readonly slotsHeld: "slots_held";
+        /**
+         * A slot holds a server that is `starting`, `running` or `stopping`, and
+         * {@link ControllerSetConfig | set_config} would remove or re-port the slot or give its server's token
+         * to another slot, or {@link ControllerReserveSlot | reserve_slot} asked for it. `detail` names the
+         * slots.
+         */
+        readonly slotHeld: "slot_held";
+        /** The node has no slot with that id. */
+        readonly unknownSlot: "unknown_slot";
+        /**
+         * {@link ControllerSetConfig | set_config} kept the token of a slot the node does not have yet. A new
+         * slot needs a new token.
+         */
+        readonly slotTokenRequired: "slot_token_required";
+        /**
+         * {@link ControllerSetConfig | set_config} kept the value of a demo upload header the node does not
+         * send. A new header needs its value.
+         */
+        readonly demoHeaderValueRequired: "demo_header_value_required";
+        /** No server with that allocation id. */
+        readonly unknownAllocation: "unknown_allocation";
+        /**
+         * A maintenance operation runs on the node. That operation is unaffected, and `unavailable` shows
+         * it as `maintenance`.
+         */
+        readonly maintenanceRunning: "maintenance_running";
+        /**
+         * The image is not on the node and the request asked for no pull. Asking again with `pull`
+         * fetches it.
+         */
+        readonly imageMissing: "image_missing";
+        /**
+         * The image is not an official one, and the node's `official_images_only` is on. The node's
+         * operator decides which images it runs.
+         */
+        readonly imageNotAllowed: "image_not_allowed";
+        /** The demo is uploading. It can be deleted once the upload ends. */
+        readonly demoUploading: "demo_uploading";
+        /** The slot has no demo of that name, such as one an upload or a delete has already removed. */
+        readonly unknownDemo: "unknown_demo";
+        /** The demo is still being recorded. It can be deleted once its server ends the recording. */
+        readonly demoRecording: "demo_recording";
+        /** The server's plugin is not connected to the agent, or left before it answered. */
+        readonly pluginOffline: "plugin_offline";
+        /**
+         * The plugin did not answer {@link ControllerGetServerStatus | get_server_status},
+         * {@link ControllerConsoleCommand | console_command}, {@link ControllerStartMatch | start_match} or
+         * {@link ControllerRestoreRound | restore_round} within {@link SERVER_STATUS_TIMEOUT_MS}.
+         */
+        readonly pluginStatusTimeout: "plugin_status_timeout";
+        /** The server runs without a match. */
+        readonly noMatch: "no_match";
+        /** The match is past its warmup. */
+        readonly notInWarmup: "not_in_warmup";
+        /** A team has no player connected. */
+        readonly teamEmpty: "team_empty";
+        /** The match is not live, such as in warmup, during the knife round or after it ended. */
+        readonly notLive: "not_live";
+        /**
+         * The match is in its halftime break, while the sides are about to swap. Ask again once the next
+         * round has started.
+         */
+        readonly atHalftime: "at_halftime";
+        /**
+         * The node has no backup of the round that {@link ControllerRestoreRound | restore_round} named for that
+         * server.
+         */
+        readonly noBackup: "no_backup";
+        /** The request did not match its schema. */
+        readonly invalidRequest: "invalid_request";
+        /**
+         * {@link ControllerStartServer | start_server} named an allocation this node is already launching or
+         * running. Its server exists or is on its way, as after a {@link ControllerStartServer | start_server}
+         * sent again when its reply was slow.
+         */
+        readonly allocationInUse: "allocation_in_use";
+        /**
+         * {@link ControllerStartServer | start_server} named an allocation that this node launched before, among
+         * the last {@link REMEMBERED_ALLOCATIONS}. The node files a server's events and demos under its
+         * allocation, so every launch needs a new one.
+         */
+        readonly allocationReused: "allocation_reused";
+        /** The agent does not know the request's `type`, or the plugin the command's. */
+        readonly unsupportedRequest: "unsupported_request";
+        /**
+         * The agent is stopping and started no work for the request, as after its
+         * {@link AgentShutdown | shutdown}. Send the request again once the node reconnects.
+         */
+        readonly shuttingDown: "shutting_down";
+        /** Any failure that no other code names, such as a Docker failure. */
+        readonly failed: "failed";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export type AgentError = z.infer<typeof AgentError>;
+/**
+ * The {@link ControllerStartServer | start_server} refusals the agent sends before reserving a slot.
+ * Nothing started, so another node may take the launch.
+ */
+export declare const StartRefusal: z.ZodEnum<{
+    no_free_slot: "no_free_slot";
+    cs2_outdated: "cs2_outdated";
+    cs2_not_installed: "cs2_not_installed";
+    node_unavailable: "node_unavailable";
+    maintenance_running: "maintenance_running";
+    shutting_down: "shutting_down";
+}>;
+export type StartRefusal = z.infer<typeof StartRefusal>;
+/**
+ * What a slot is doing.
+ *
+ * - `idle`: the slot has no server.
+ * - `starting`: the slot holds a server that its plugin has not yet reported ready for players with
+ *   a `server_status` with `ready`. A server that a restarted agent took over starts here too.
+ * - `running`: the plugin has reported the server ready.
+ * - `stopping`: the server is being stopped.
+ */
+export declare const SlotState: z.ZodEnum<{
+    idle: "idle";
+    starting: "starting";
+    running: "running";
+    stopping: "stopping";
+}>;
+export type SlotState = z.infer<typeof SlotState>;
+/**
+ * Why the agent stopped a server on its own.
+ *
+ * - `idle_empty`: the server stayed empty for its launch's `idle_shutdown_seconds`.
+ * - `config_rejected`: the plugin refused its match config, as `config_error` says.
+ * - `start_timeout`: the server was still `starting` {@link START_TIMEOUT_SECONDS} after its
+ *   launch, or after a restarted agent took it over.
+ * - `quit_timeout`: the server was still running {@link QUIT_TIMEOUT_SECONDS} after its plugin sent
+ *   `quitting`.
+ * - `slot_removed`: a restarted agent found the server running on a slot that `agent.yml` no longer
+ *   has.
+ */
+export declare const AgentStopReason: z.ZodEnum<{
+    idle_empty: "idle_empty";
+    config_rejected: "config_rejected";
+    start_timeout: "start_timeout";
+    quit_timeout: "quit_timeout";
+    slot_removed: "slot_removed";
+}>;
+export type AgentStopReason = z.infer<typeof AgentStopReason>;
+/**
+ * Why a server ended: one of the {@link AgentStopReason} values when the agent stopped it on its
+ * own, or one of these.
+ *
+ * - `requested`: a {@link ControllerStopServer | stop_server} from the controller stopped it.
+ * - `clean_exit`: it ended on its own with exit code `0`, as after its match or a console `quit`.
+ * - `crashed`: it ended on its own with another exit code.
+ * - `launch_failed`: its container never started.
+ * - `lost`: it ended and the agent did not see how, such as a container removed by hand.
+ */
+export declare const ServerExitReason: z.ZodEnum<{
+    idle_empty: "idle_empty";
+    config_rejected: "config_rejected";
+    start_timeout: "start_timeout";
+    quit_timeout: "quit_timeout";
+    slot_removed: "slot_removed";
+    requested: "requested";
+    clean_exit: "clean_exit";
+    crashed: "crashed";
+    launch_failed: "launch_failed";
+    lost: "lost";
+}>;
+export type ServerExitReason = z.infer<typeof ServerExitReason>;
+/**
+ * A slot as {@link ControllerSetConfig | set_config} asks for it.
+ *
+ * `gslt` is a new token, which may replace the token of a slot that runs a server. That server
+ * keeps the token it started with, and no other slot may use that token until the server ends
+ * (`slot_held`). Without `gslt` the slot keeps its current token, so a slot the node does not have
+ * yet needs one (`slot_token_required`), and a slot from a {@link AgentHello | hello} can be sent
+ * back unchanged.
+ */
+export declare const SlotEdit: z.ZodObject<{
+    id: z.ZodString;
+    port: z.ZodNumber;
+    tv_port: z.ZodNumber;
+    gslt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SlotEdit = z.infer<typeof SlotEdit>;
+/** The id Docker gives an image: `sha256:` and 64 hex digits. */
+export declare const ImageId: z.ZodString;
+/** A Steam build id, in decimal. */
+export declare const BuildId: z.ZodString;
+/**
+ * One slot as the agent sees it.
+ *
+ * Rejected when an `idle` slot names an `allocation_id`, a `match_id` or a `server_steam_id`, or
+ * when a slot in any other state has no `allocation_id`. It is also rejected when a slot that is
+ * not `idle` is `reserved`.
+ */
+export declare const SlotStatus: z.ZodObject<{
+    slot_id: z.ZodString;
+    state: z.ZodEnum<{
+        idle: "idle";
+        starting: "starting";
+        running: "running";
+        stopping: "stopping";
+    }>;
+    allocation_id: z.ZodNullable<z.ZodUUID>;
+    match_id: z.ZodNullable<z.ZodUUID>;
+    plugin_online: z.ZodBoolean;
+    gslt_state: z.ZodEnum<{
+        ok: "ok";
+        invalid: "invalid";
+        unchecked: "unchecked";
+    }>;
+    reserved: z.ZodBoolean;
+    server_steam_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SlotStatus = z.infer<typeof SlotStatus>;
+/**
+ * The part of `agent.yml` that the controller may edit, as {@link AgentHello | hello} reports it
+ * applied.
+ */
+export declare const NodeSettings: z.ZodObject<{
+    slots: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        port: z.ZodNumber;
+        tv_port: z.ZodNumber;
+        gslt_hint: z.ZodString;
+    }, z.core.$strip>>;
+    pinned_ip: z.ZodNullable<z.ZodString>;
+    controller: z.ZodObject<{
+        host: z.ZodString;
+        tls: z.ZodBoolean;
+        socket_path: z.ZodString;
+        events_path: z.ZodString;
+    }, z.core.$strip>;
+    auto_update: z.ZodBoolean;
+    demo_upload: z.ZodNullable<z.ZodObject<{
+        url: z.ZodURL;
+        limit_mbit: z.ZodNullable<z.ZodNumber>;
+        header: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            value_sha256: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    memory_mb: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type NodeSettings = z.infer<typeof NodeSettings>;
+/**
+ * {@link NodeSettings} as {@link ControllerSetConfig | set_config} asks for them. A missing field keeps
+ * the node's value. Null is a value, as {@link NodeSettings} describes. `slots`, when present, is
+ * the whole layout.
+ */
+export declare const NodeSettingsEdit: z.ZodObject<{
+    pinned_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    controller: z.ZodOptional<z.ZodObject<{
+        host: z.ZodString;
+        tls: z.ZodBoolean;
+        socket_path: z.ZodString;
+        events_path: z.ZodString;
+    }, z.core.$strip>>;
+    auto_update: z.ZodOptional<z.ZodBoolean>;
+    memory_mb: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        port: z.ZodNumber;
+        tv_port: z.ZodNumber;
+        gslt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    demo_upload: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        url: z.ZodURL;
+        limit_mbit: z.ZodNullable<z.ZodNumber>;
+        header: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type NodeSettingsEdit = z.infer<typeof NodeSettingsEdit>;
+/** Longer os-release names are cut to this many characters. */
+export declare const OS_NAME_MAX_CHARS = 256;
+/** Longest demo file name a node reports, `.dem` included. */
+export declare const DEMO_FILE_NAME_MAX_CHARS = 160;
+/**
+ * A demo's file name, as it sits in its launch's directory, `demos/<allocation_id>/` in its slot.
+ */
+export declare const DemoFileName: z.ZodString;
+/** Longest `upload_error` a demo carries. The agent cuts the failure's message to it. */
+export declare const DEMO_UPLOAD_ERROR_MAX_CHARS = 512;
+/** A demo kept on the node. */
+export declare const DemoFile: z.ZodObject<{
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    size_bytes: z.ZodNumber;
+    modified_at: z.ZodNumber;
+    recording: z.ZodBoolean;
+    uploading: z.ZodBoolean;
+    upload_error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DemoFile = z.infer<typeof DemoFile>;
+/** Longer reasons a node cannot run servers are cut to this many characters. */
+export declare const NODE_UNAVAILABLE_DETAIL_MAX_CHARS = 512;
+/** Free space a node needs on its data disk to take launches, in bytes. */
+export declare const DISK_SPACE_MIN_BYTES: number;
+/** Why a node cannot run servers. */
+export declare const NODE_UNAVAILABLE: {
+    /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+    readonly maintenance: "maintenance";
+    /**
+     * The agent cannot use the local store that keeps gameplay events until the controller takes
+     * them. `detail` says why.
+     * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+     *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+     * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+     *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+     *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+     */
+    readonly eventStorage: "event_storage";
+    /**
+     * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+     * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+     * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+     * sooner is taken if the disk has room by then.
+     */
+    readonly diskSpace: "disk_space";
+};
+/** Why a node cannot run servers, one of the values of {@link NODE_UNAVAILABLE}. */
+export declare const NodeUnavailableCode: z.ZodEnum<{
+    /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+    readonly maintenance: "maintenance";
+    /**
+     * The agent cannot use the local store that keeps gameplay events until the controller takes
+     * them. `detail` says why.
+     * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+     *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+     * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+     *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+     *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+     */
+    readonly eventStorage: "event_storage";
+    /**
+     * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+     * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+     * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+     * sooner is taken if the disk has room by then.
+     */
+    readonly diskSpace: "disk_space";
+}>;
+export type NodeUnavailableCode = z.infer<typeof NodeUnavailableCode>;
+/**
+ * The maintenance operation that runs on the node.
+ *
+ * - `cs2_update`: a CS2 install or update, also one an earlier agent started.
+ * - `agent_update`: an {@link ControllerUpdateAgent | update_agent}, until its replacement has proved it
+ *   stays up.
+ * - `cs2_image_update`: an {@link ControllerUpdateCs2Image | update_cs2_image}.
+ * - `image_cleanup`: the agent's removal of replaced images when it starts.
+ */
+export declare const MaintenanceOperation: z.ZodEnum<{
+    cs2_update: "cs2_update";
+    agent_update: "agent_update";
+    cs2_image_update: "cs2_image_update";
+    image_cleanup: "image_cleanup";
+}>;
+export type MaintenanceOperation = z.infer<typeof MaintenanceOperation>;
+/**
+ * Why the node cannot run servers now, with `maintenance` first while it lasts. Meanwhile
+ * {@link ControllerStartServer | start_server} is refused with `maintenance_running` for `maintenance` and
+ * `node_unavailable` otherwise. Everything else works.
+ *
+ * Rejected when `operation` is null while `code` is `maintenance`, or set while `code` is another
+ * value.
+ */
+export declare const NodeUnavailable: z.ZodObject<{
+    code: z.ZodEnum<{
+        /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+        readonly maintenance: "maintenance";
+        /**
+         * The agent cannot use the local store that keeps gameplay events until the controller takes
+         * them. `detail` says why.
+         * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+         *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+         * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+         *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+         *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+         */
+        readonly eventStorage: "event_storage";
+        /**
+         * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+         * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+         * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+         * sooner is taken if the disk has room by then.
+         */
+        readonly diskSpace: "disk_space";
+    }>;
+    operation: z.ZodNullable<z.ZodEnum<{
+        cs2_update: "cs2_update";
+        agent_update: "agent_update";
+        cs2_image_update: "cs2_image_update";
+        image_cleanup: "image_cleanup";
+    }>>;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export type NodeUnavailable = z.infer<typeof NodeUnavailable>;
+/** The running agent. */
+export declare const AgentInfo: z.ZodObject<{
+    version: z.ZodString;
+    image: z.ZodString;
+    image_id: z.ZodString;
+}, z.core.$strip>;
+export type AgentInfo = z.infer<typeof AgentInfo>;
+/** Longest `detail` an agent update carries. The agent cuts the swap's message to it. */
+export declare const AGENT_UPDATE_DETAIL_MAX_CHARS = 512;
+/**
+ * Where an {@link ControllerUpdateAgent | update_agent} or {@link ControllerUpdateCs2Image | update_cs2_image}
+ * is.
+ *
+ * - `pulling`: the image is being pulled.
+ * - `switching`: the image is on the node and is put into use. A switch of the agent replaces its
+ *   container, so the node goes offline and comes back. A switch of the cs2 image extracts its
+ *   plugin files for future launches.
+ */
+export declare const ImageUpdateStep: z.ZodEnum<{
+    pulling: "pulling";
+    switching: "switching";
+}>;
+export type ImageUpdateStep = z.infer<typeof ImageUpdateStep>;
+/**
+ * How an {@link ControllerUpdateAgent | update_agent} ended.
+ *
+ * - `completed`: the replacement agent stayed up and the old container is removed.
+ * - `unchanged`: the node already ran that image, so nothing was swapped.
+ * - `pull_failed`: the image could not be pulled, so the node never tried it.
+ * - `failed`: the swap did not hold and the old agent was put back, or its helper did not start.
+ */
+export declare const AgentUpdateOutcome: z.ZodEnum<{
+    failed: "failed";
+    completed: "completed";
+    unchanged: "unchanged";
+    pull_failed: "pull_failed";
+}>;
+export type AgentUpdateOutcome = z.infer<typeof AgentUpdateOutcome>;
+/** An agent update: the one in progress, one this agent saw end, or the last one to fail. */
+export declare const AgentUpdate: z.ZodObject<{
+    image: z.ZodString;
+    step: z.ZodNullable<z.ZodEnum<{
+        pulling: "pulling";
+        switching: "switching";
+    }>>;
+    outcome: z.ZodNullable<z.ZodEnum<{
+        failed: "failed";
+        completed: "completed";
+        unchanged: "unchanged";
+        pull_failed: "pull_failed";
+    }>>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type AgentUpdate = z.infer<typeof AgentUpdate>;
+/** The machine the agent runs on. */
+export declare const HostInfo: z.ZodObject<{
+    cpu_count: z.ZodNumber;
+    os_name: z.ZodNullable<z.ZodString>;
+    kernel: z.ZodString;
+}, z.core.$strip>;
+export type HostInfo = z.infer<typeof HostInfo>;
+/**
+ * How thoroughly a CS2 install or update runs.
+ *
+ * - `update`: downloads what changed.
+ * - `verify`: also re-hashes every file.
+ * - `reinstall`: wipes the install volume first and downloads all of it.
+ */
+export declare const Cs2UpdateMode: z.ZodEnum<{
+    update: "update";
+    verify: "verify";
+    reinstall: "reinstall";
+}>;
+export type Cs2UpdateMode = z.infer<typeof Cs2UpdateMode>;
+/**
+ * How a CS2 install or update ended.
+ *
+ * - `completed`: the game files are installed.
+ * - `pull_failed`: the cs2 image could not be pulled.
+ * - `overlay_failed`: its addon overlay could not be extracted.
+ * - `failed`: any other failure, such as the update container exiting with an error.
+ * - `unobserved`: an update container that an earlier agent process started exited, and the agent
+ *   did not see the exit.
+ *
+ * An update container that an earlier agent process started reports progress again until it exits.
+ * It ends `completed` or `failed` by its exit code, or `unobserved`.
+ */
+export declare const Cs2UpdateOutcome: z.ZodEnum<{
+    failed: "failed";
+    completed: "completed";
+    pull_failed: "pull_failed";
+    overlay_failed: "overlay_failed";
+    unobserved: "unobserved";
+}>;
+export type Cs2UpdateOutcome = z.infer<typeof Cs2UpdateOutcome>;
+/** Longest `detail` a CS2 update carries. The agent cuts the failure's message to it. */
+export declare const CS2_UPDATE_DETAIL_MAX_CHARS = 512;
+/**
+ * Chosen by the agent for each CS2 install or update it runs or finds running. A lowercase UUID.
+ */
+export declare const UpdateId: z.ZodUUID;
+/**
+ * A CS2 install or update on the node: one running, or the last one to end since the agent started.
+ */
+export declare const Cs2Update: z.ZodObject<{
+    id: z.ZodUUID;
+    mode: z.ZodEnum<{
+        update: "update";
+        verify: "verify";
+        reinstall: "reinstall";
+    }>;
+    automatic: z.ZodBoolean;
+    outcome: z.ZodNullable<z.ZodEnum<{
+        failed: "failed";
+        completed: "completed";
+        pull_failed: "pull_failed";
+        overlay_failed: "overlay_failed";
+        unobserved: "unobserved";
+    }>>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Cs2Update = z.infer<typeof Cs2Update>;
+/**
+ * How an {@link ControllerUpdateCs2Image | update_cs2_image} ended.
+ *
+ * - `completed`: future launches use the image.
+ * - `pull_failed`: the image could not be pulled.
+ * - `overlay_failed`: its addon overlay could not be extracted.
+ * - `failed`: anything else, such as the agent not saving the image setting.
+ */
+export declare const Cs2ImageUpdateOutcome: z.ZodEnum<{
+    failed: "failed";
+    completed: "completed";
+    pull_failed: "pull_failed";
+    overlay_failed: "overlay_failed";
+}>;
+export type Cs2ImageUpdateOutcome = z.infer<typeof Cs2ImageUpdateOutcome>;
+/**
+ * A switch of the cs2 image: the one running now, or the last one to end since the agent started.
+ */
+export declare const Cs2ImageUpdate: z.ZodObject<{
+    image: z.ZodString;
+    step: z.ZodNullable<z.ZodEnum<{
+        pulling: "pulling";
+        switching: "switching";
+    }>>;
+    outcome: z.ZodNullable<z.ZodEnum<{
+        failed: "failed";
+        completed: "completed";
+        pull_failed: "pull_failed";
+        overlay_failed: "overlay_failed";
+    }>>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Cs2ImageUpdate = z.infer<typeof Cs2ImageUpdate>;
+/** The node's game install and image. */
+export declare const Cs2State: z.ZodObject<{
+    build_id: z.ZodNullable<z.ZodString>;
+    latest_build_id: z.ZodNullable<z.ZodString>;
+    image: z.ZodString;
+    image_id: z.ZodNullable<z.ZodString>;
+    update: z.ZodNullable<z.ZodObject<{
+        id: z.ZodUUID;
+        mode: z.ZodEnum<{
+            update: "update";
+            verify: "verify";
+            reinstall: "reinstall";
+        }>;
+        automatic: z.ZodBoolean;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            pull_failed: "pull_failed";
+            overlay_failed: "overlay_failed";
+            unobserved: "unobserved";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    image_update: z.ZodNullable<z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodNullable<z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            pull_failed: "pull_failed";
+            overlay_failed: "overlay_failed";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Cs2State = z.infer<typeof Cs2State>;
+/** An ISO 3166-1 alpha-2 country code: `DK`, `FR`, or `GB` for the United Kingdom. */
+export declare const CountryCode: z.ZodString;
+/** Longest `detail` a server's exit carries. The agent cuts the message to it. */
+export declare const SERVER_EXIT_DETAIL_MAX_CHARS = 512;
+/** A server whose container is gone, and why. */
+export declare const ServerExit: z.ZodObject<{
+    slot_id: z.ZodString;
+    allocation_id: z.ZodUUID;
+    reason: z.ZodEnum<{
+        idle_empty: "idle_empty";
+        config_rejected: "config_rejected";
+        start_timeout: "start_timeout";
+        quit_timeout: "quit_timeout";
+        slot_removed: "slot_removed";
+        requested: "requested";
+        clean_exit: "clean_exit";
+        crashed: "crashed";
+        launch_failed: "launch_failed";
+        lost: "lost";
+    }>;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    detail: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ServerExit = z.infer<typeof ServerExit>;
+/** Longest `reason` an event backlog carries. The agent cuts the failure's message to it. */
+export declare const EVENT_BACKLOG_REASON_MAX_CHARS = 512;
+/** A server whose events wait on the node. */
+export declare const StuckServer: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    pending: z.ZodNumber;
+}, z.core.$strip>;
+export type StuckServer = z.infer<typeof StuckServer>;
+/**
+ * The events that wait on the node because uploading them fails, as the agent read them. While
+ * uploads work, nothing is stuck, so `servers` is empty, the counts are zero and `reason` is
+ * `null`.
+ *
+ * Rejected unless `servers` holds as many entries as `server_count`, or
+ * {@link MAX_REPORTED_BACKLOGS} when `server_count` is larger. It is also rejected when
+ * `event_count` is below the sum of `pending` over `servers`. A `reason` is rejected when
+ * `server_count` is zero, and a null `reason` when it is not.
+ */
+export declare const EventBacklog: z.ZodObject<{
+    servers: z.ZodArray<z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        pending: z.ZodNumber;
+    }, z.core.$strip>>;
+    server_count: z.ZodNumber;
+    event_count: z.ZodNumber;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type EventBacklog = z.infer<typeof EventBacklog>;
+/**
+ * A server has ended and its container is gone. Sent ahead of the `idle`
+ * {@link AgentSlotStatus | slot_status} of its slot, also for a launch that failed before or while
+ * its container started.
+ *
+ * A server that ended while no connection was welcomed goes in `server_exits` of the next
+ * {@link AgentHello | hello} instead. If it ended after that {@link AgentHello | hello} went out,
+ * it is sent after the {@link ControllerWelcome | welcome}, ahead of the slot statuses.
+ *
+ * The agent keeps a {@link AgentServerExited | server_exited} until the socket takes its write,
+ * across its restarts, for up to {@link EVENT_SPOOL_RETENTION_MS}, so one may also come again after
+ * a restart. One the socket took is not sent again, even if the connection drops before the
+ * controller reads it. The agent does not keep them while it cannot open that store, which it reports as
+ * `unavailable` with `event_storage`. While the store does not answer, the agent keeps one only
+ * once the store answers again. A server that ends while the agent is not running is missing
+ * from its next {@link AgentHello | hello}.
+ */
+export declare const AgentServerExited: z.ZodObject<{
+    slot_id: z.ZodString;
+    allocation_id: z.ZodUUID;
+    reason: z.ZodEnum<{
+        idle_empty: "idle_empty";
+        config_rejected: "config_rejected";
+        start_timeout: "start_timeout";
+        quit_timeout: "quit_timeout";
+        slot_removed: "slot_removed";
+        requested: "requested";
+        clean_exit: "clean_exit";
+        crashed: "crashed";
+        launch_failed: "launch_failed";
+        lost: "lost";
+    }>;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    detail: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"server_exited">;
+}, z.core.$strip>;
+export type AgentServerExited = z.infer<typeof AgentServerExited>;
+/**
+ * The agent's first message on every connection, and sent only then. An applied
+ * {@link ControllerSetConfig | set_config} answers with the settings instead.
+ *
+ * Answer an accepted {@link AgentHello | hello} with {@link ControllerWelcome | welcome}. Until then the
+ * agent sends only replies, or a {@link AgentShutdown | shutdown} when it stops. Runtime changes
+ * use status messages. Reconnecting never changes the node's configuration.
+ *
+ * Rejected unless `slot_status` names each slot of `config.slots` once and names no other slot.
+ */
+export declare const AgentHello: z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    agent: z.ZodObject<{
+        version: z.ZodString;
+        image: z.ZodString;
+        image_id: z.ZodString;
+    }, z.core.$strip>;
+    host: z.ZodObject<{
+        cpu_count: z.ZodNumber;
+        os_name: z.ZodNullable<z.ZodString>;
+        kernel: z.ZodString;
+    }, z.core.$strip>;
+    public_ip: z.ZodNullable<z.ZodString>;
+    country: z.ZodNullable<z.ZodString>;
+    config: z.ZodObject<{
+        slots: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt_hint: z.ZodString;
+        }, z.core.$strip>>;
+        pinned_ip: z.ZodNullable<z.ZodString>;
+        controller: z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>;
+        auto_update: z.ZodBoolean;
+        demo_upload: z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value_sha256: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        memory_mb: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    slot_status: z.ZodArray<z.ZodObject<{
+        slot_id: z.ZodString;
+        state: z.ZodEnum<{
+            idle: "idle";
+            starting: "starting";
+            running: "running";
+            stopping: "stopping";
+        }>;
+        allocation_id: z.ZodNullable<z.ZodUUID>;
+        match_id: z.ZodNullable<z.ZodUUID>;
+        plugin_online: z.ZodBoolean;
+        gslt_state: z.ZodEnum<{
+            ok: "ok";
+            invalid: "invalid";
+            unchecked: "unchecked";
+        }>;
+        reserved: z.ZodBoolean;
+        server_steam_id: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    cs2: z.ZodObject<{
+        build_id: z.ZodNullable<z.ZodString>;
+        latest_build_id: z.ZodNullable<z.ZodString>;
+        image: z.ZodString;
+        image_id: z.ZodNullable<z.ZodString>;
+        update: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            mode: z.ZodEnum<{
+                update: "update";
+                verify: "verify";
+                reinstall: "reinstall";
+            }>;
+            automatic: z.ZodBoolean;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+                unobserved: "unobserved";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        image_update: z.ZodNullable<z.ZodObject<{
+            image: z.ZodString;
+            step: z.ZodNullable<z.ZodEnum<{
+                pulling: "pulling";
+                switching: "switching";
+            }>>;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    unavailable: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+            readonly maintenance: "maintenance";
+            /**
+             * The agent cannot use the local store that keeps gameplay events until the controller takes
+             * them. `detail` says why.
+             * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+             *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+             * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+             *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+             *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+             */
+            readonly eventStorage: "event_storage";
+            /**
+             * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+             * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+             * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+             * sooner is taken if the disk has room by then.
+             */
+            readonly diskSpace: "disk_space";
+        }>;
+        operation: z.ZodNullable<z.ZodEnum<{
+            cs2_update: "cs2_update";
+            agent_update: "agent_update";
+            cs2_image_update: "cs2_image_update";
+            image_cleanup: "image_cleanup";
+        }>>;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    demos: z.ZodArray<z.ZodObject<{
+        slot_id: z.ZodString;
+        file_name: z.ZodString;
+        size_bytes: z.ZodNumber;
+        modified_at: z.ZodNumber;
+        recording: z.ZodBoolean;
+        uploading: z.ZodBoolean;
+        upload_error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    server_exits: z.ZodArray<z.ZodObject<{
+        slot_id: z.ZodString;
+        allocation_id: z.ZodUUID;
+        reason: z.ZodEnum<{
+            idle_empty: "idle_empty";
+            config_rejected: "config_rejected";
+            start_timeout: "start_timeout";
+            quit_timeout: "quit_timeout";
+            slot_removed: "slot_removed";
+            requested: "requested";
+            clean_exit: "clean_exit";
+            crashed: "crashed";
+            launch_failed: "launch_failed";
+            lost: "lost";
+        }>;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    event_backlog: z.ZodObject<{
+        servers: z.ZodArray<z.ZodObject<{
+            allocation_id: z.ZodUUID;
+            pending: z.ZodNumber;
+        }, z.core.$strip>>;
+        server_count: z.ZodNumber;
+        event_count: z.ZodNumber;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    agent_update: z.ZodNullable<z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodNullable<z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            unchanged: "unchanged";
+            pull_failed: "pull_failed";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentHello = z.infer<typeof AgentHello>;
+/**
+ * Replaces `cs2`, `unavailable` and `agent_update` of the last {@link AgentHello | hello}.
+ *
+ * Sent when they change:
+ *
+ * - When a maintenance operation starts or ends, so also when a CS2 install or update finishes,
+ *   whoever started it, or {@link ControllerUpdateCs2Image | update_cs2_image} has switched the image.
+ * - When `agent_update` or `cs2.image_update` moves from `pulling` to `switching`.
+ * - When the newest public build changes.
+ * - When an agent swap that is still proving its replacement ends.
+ *
+ * Each frame is the node's state when it was read, not a step in a history, so a change that is
+ * over before its report reads the state may go unreported.
+ */
+export declare const AgentNodeStatus: z.ZodObject<{
+    type: z.ZodLiteral<"node_status">;
+    cs2: z.ZodObject<{
+        build_id: z.ZodNullable<z.ZodString>;
+        latest_build_id: z.ZodNullable<z.ZodString>;
+        image: z.ZodString;
+        image_id: z.ZodNullable<z.ZodString>;
+        update: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            mode: z.ZodEnum<{
+                update: "update";
+                verify: "verify";
+                reinstall: "reinstall";
+            }>;
+            automatic: z.ZodBoolean;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+                unobserved: "unobserved";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        image_update: z.ZodNullable<z.ZodObject<{
+            image: z.ZodString;
+            step: z.ZodNullable<z.ZodEnum<{
+                pulling: "pulling";
+                switching: "switching";
+            }>>;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    unavailable: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+            readonly maintenance: "maintenance";
+            /**
+             * The agent cannot use the local store that keeps gameplay events until the controller takes
+             * them. `detail` says why.
+             * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+             *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+             * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+             *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+             *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+             */
+            readonly eventStorage: "event_storage";
+            /**
+             * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+             * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+             * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+             * sooner is taken if the disk has room by then.
+             */
+            readonly diskSpace: "disk_space";
+        }>;
+        operation: z.ZodNullable<z.ZodEnum<{
+            cs2_update: "cs2_update";
+            agent_update: "agent_update";
+            cs2_image_update: "cs2_image_update";
+            image_cleanup: "image_cleanup";
+        }>>;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    agent_update: z.ZodNullable<z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodNullable<z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            unchanged: "unchanged";
+            pull_failed: "pull_failed";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentNodeStatus = z.infer<typeof AgentNodeStatus>;
+/**
+ * A slot's status changed since the last {@link AgentHello | hello} or
+ * {@link AgentSlotStatus | slot_status} for it. Rejected when it breaks a rule of
+ * {@link SlotStatus}.
+ */
+export declare const AgentSlotStatus: z.ZodObject<{
+    slot_id: z.ZodString;
+    state: z.ZodEnum<{
+        idle: "idle";
+        starting: "starting";
+        running: "running";
+        stopping: "stopping";
+    }>;
+    allocation_id: z.ZodNullable<z.ZodUUID>;
+    match_id: z.ZodNullable<z.ZodUUID>;
+    plugin_online: z.ZodBoolean;
+    gslt_state: z.ZodEnum<{
+        ok: "ok";
+        invalid: "invalid";
+        unchecked: "unchecked";
+    }>;
+    reserved: z.ZodBoolean;
+    server_steam_id: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"slot_status">;
+}, z.core.$strip>;
+export type AgentSlotStatus = z.infer<typeof AgentSlotStatus>;
+/** How serious an agent log line is. */
+export declare const AgentLogLevel: z.ZodEnum<{
+    error: "error";
+    info: "info";
+    warn: "warn";
+}>;
+export type AgentLogLevel = z.infer<typeof AgentLogLevel>;
+/** Longer log lines, from the agent, a server or a CS2 update, are cut to this many characters. */
+export declare const LOG_LINE_MAX_CHARS = 2000;
+/** The agent keeps this many lines of its log. */
+export declare const AGENT_LOG_LINES = 500;
+/**
+ * The agent keeps this many lines of each server's output and of each CS2 install or update's
+ * output.
+ */
+export declare const SERVER_LOG_LINES = 2000;
+/** Servers that ended and whose output the agent still keeps, oldest dropped first. */
+export declare const ENDED_SERVER_LOGS = 10;
+/**
+ * CS2 installs and updates that ended and whose output the agent still keeps, oldest dropped first.
+ */
+export declare const ENDED_UPDATE_LOGS = 1;
+/**
+ * A {@link AgentLogBatch | log_batch} stays under this many bytes of JSON, so a replay spans as
+ * many frames as it needs.
+ */
+export declare const LOG_BATCH_MAX_BYTES: number;
+/**
+ * One log of a node: the agent's log, one CS2 install or update's output, or one server's output.
+ */
+export declare const LogSource: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"agent">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"cs2_update">;
+    update_id: z.ZodUUID;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"server">;
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>], "kind">;
+export type LogSource = z.infer<typeof LogSource>;
+/** One log line. */
+export declare const LogLine: z.ZodObject<{
+    at: z.ZodNumber;
+    level: z.ZodNullable<z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+    }>>;
+    line: z.ZodString;
+}, z.core.$strip>;
+export type LogLine = z.infer<typeof LogLine>;
+/** Identifies one watcher's replay, so the frames answering it reach only that watcher. */
+export declare const ReplayId: z.ZodString;
+/**
+ * One source's lines, sent only while a {@link ControllerWatchLogs | watch_logs} holds the lease of that
+ * source. A replay of the source starts with `reset` and may span several frames. Between replays,
+ * new lines follow in batches. A replay larger than the remaining log budget of the agent leaves
+ * out the oldest lines.
+ */
+export declare const AgentLogBatch: z.ZodObject<{
+    type: z.ZodLiteral<"log_batch">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"cs2_update">;
+        update_id: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"server">;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>], "kind">;
+    replay_id: z.ZodNullable<z.ZodString>;
+    reset: z.ZodBoolean;
+    lines: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        level: z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+        }>>;
+        line: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentLogBatch = z.infer<typeof AgentLogBatch>;
+/** One source the agent keeps. */
+export declare const LogSourceSummary: z.ZodObject<{
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"cs2_update">;
+        update_id: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"server">;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>], "kind">;
+    line_count: z.ZodNumber;
+    last_line_at: z.ZodNullable<z.ZodNumber>;
+    ended: z.ZodBoolean;
+}, z.core.$strip>;
+export type LogSourceSummary = z.infer<typeof LogSourceSummary>;
+/**
+ * Milliseconds between {@link AgentLogIndex | log_index} frames that only bring counts and
+ * `last_line_at` up to date while lines arrive. A source's newest line shows in an index within
+ * this long.
+ */
+export declare const LOG_INDEX_REFRESH_MS = 30000;
+/**
+ * Every source the agent keeps, whole every time: its log, each CS2 install or update running or
+ * among the last {@link ENDED_UPDATE_LOGS} ended, and each server with output, running or among the
+ * last {@link ENDED_SERVER_LOGS} ended.
+ *
+ * Sent while any log lease runs, with each lease that starts and each replay asked for. Also sent
+ * when an update starts or ends, a server's first line arrives, a server ends, or a source's output
+ * is dropped, and every {@link LOG_INDEX_REFRESH_MS} while lines arrive. Counts and `last_line_at`
+ * are as of that frame. A source missing from it is no longer kept.
+ */
+export declare const AgentLogIndex: z.ZodObject<{
+    type: z.ZodLiteral<"log_index">;
+    sources: z.ZodArray<z.ZodObject<{
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"cs2_update">;
+            update_id: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"server">;
+            allocation_id: z.ZodUUID;
+        }, z.core.$strip>], "kind">;
+        line_count: z.ZodNumber;
+        last_line_at: z.ZodNullable<z.ZodNumber>;
+        ended: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentLogIndex = z.infer<typeof AgentLogIndex>;
+/** Longest `message` a CS2 update's progress carries. The agent cuts the line to it. */
+export declare const CS2_UPDATE_MESSAGE_MAX_CHARS = 512;
+/**
+ * Progress of a CS2 install or update while it runs. `cs2.update` in
+ * {@link AgentNodeStatus | node_status} says how it ended.
+ */
+export declare const AgentCs2UpdateProgress: z.ZodObject<{
+    type: z.ZodLiteral<"cs2_update_progress">;
+    update_id: z.ZodUUID;
+    percent: z.ZodNullable<z.ZodNumber>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type AgentCs2UpdateProgress = z.infer<typeof AgentCs2UpdateProgress>;
+/**
+ * One demo as it is now, sent when it appears or changes: its file, its upload starting or
+ * stopping, or its `upload_error`. It replaces the demo with the same `slot_id` and `file_name`, or
+ * adds it. {@link AgentHello | hello} lists the newest {@link MAX_REPORTED_DEMOS}. A demo that
+ * appears after the {@link AgentHello | hello} is added, however many the node keeps.
+ */
+export declare const AgentDemo: z.ZodObject<{
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    size_bytes: z.ZodNumber;
+    modified_at: z.ZodNumber;
+    recording: z.ZodBoolean;
+    uploading: z.ZodBoolean;
+    upload_error: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"demo">;
+}, z.core.$strip>;
+export type AgentDemo = z.infer<typeof AgentDemo>;
+/**
+ * Why a demo is no longer on the node.
+ *
+ * - `uploaded`: the target took it and the agent removed it.
+ * - `deleted`: {@link ControllerDeleteDemo | delete_demo} or anything else removed it.
+ */
+export declare const DemoRemovedReason: z.ZodEnum<{
+    uploaded: "uploaded";
+    deleted: "deleted";
+}>;
+export type DemoRemovedReason = z.infer<typeof DemoRemovedReason>;
+/** A demo that the controller knows of is no longer on the node. */
+export declare const AgentDemoRemoved: z.ZodObject<{
+    type: z.ZodLiteral<"demo_removed">;
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    reason: z.ZodEnum<{
+        uploaded: "uploaded";
+        deleted: "deleted";
+    }>;
+}, z.core.$strip>;
+export type AgentDemoRemoved = z.infer<typeof AgentDemoRemoved>;
+/** How far the uploading demo is, at most once a second while it uploads. */
+export declare const AgentDemoProgress: z.ZodObject<{
+    type: z.ZodLiteral<"demo_progress">;
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    sent_bytes: z.ZodNumber;
+    bytes_per_second: z.ZodNumber;
+}, z.core.$strip>;
+export type AgentDemoProgress = z.infer<typeof AgentDemoProgress>;
+/**
+ * Milliseconds between the agent's pings to the controller. The agent drops the connection when
+ * the last ping went unanswered.
+ */
+export declare const AGENT_PING_INTERVAL_MS = 30000;
+/**
+ * Milliseconds an agent may send nothing before the controller drops it, which allows two pings
+ * and slack.
+ */
+export declare const AGENT_PING_TIMEOUT_MS = 65000;
+/** Milliseconds each agent dial has to finish the WebSocket upgrade. */
+export declare const AGENT_HANDSHAKE_TIMEOUT_MS = 10000;
+/**
+ * Milliseconds of the agent's first redial delay. Each failed attempt doubles it, and a
+ * {@link ControllerWelcome | welcome} or a redial to a new address resets it.
+ */
+export declare const AGENT_RECONNECT_MIN_MS = 1000;
+/** Milliseconds of the agent's longest redial delay, before jitter. */
+export declare const AGENT_RECONNECT_MAX_MS = 30000;
+/**
+ * Each redial delay is randomised by up to this fraction either way, never below
+ * {@link AGENT_RECONNECT_MIN_MS}.
+ */
+export declare const AGENT_RECONNECT_JITTER = 0.25;
+/** Milliseconds between the agent's resource ticks, taken while it runs, watched or not. */
+export declare const RESOURCE_TICK_MS = 3000;
+/** Ticks that the agent holds and the controller shows per node, the newest last. */
+export declare const RESOURCE_TICKS_HELD = 100;
+/**
+ * Milliseconds a {@link ControllerWatchResources | watch_resources} or {@link ControllerWatchLogs | watch_logs}
+ * keeps its stream flowing. The next one resets it.
+ */
+export declare const WATCH_LEASE_MS = 120000;
+/** A capacity and how much of it is in use, in bytes. */
+export declare const ResourceUsage: z.ZodObject<{
+    cap: z.ZodNumber;
+    used: z.ZodNumber;
+}, z.core.$strip>;
+export type ResourceUsage = z.infer<typeof ResourceUsage>;
+/** One sample of the node's disk, memory and CPU, taken every {@link RESOURCE_TICK_MS}. */
+export declare const ResourceTick: z.ZodObject<{
+    at: z.ZodNumber;
+    disk: z.ZodNullable<z.ZodObject<{
+        cap: z.ZodNumber;
+        used: z.ZodNumber;
+    }, z.core.$strip>>;
+    memory: z.ZodObject<{
+        cap: z.ZodNumber;
+        used: z.ZodNumber;
+    }, z.core.$strip>;
+    cpu: z.ZodNullable<z.ZodObject<{
+        max: z.ZodNumber;
+        average: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ResourceTick = z.infer<typeof ResourceTick>;
+/**
+ * The agent's resource ticks, oldest first. A {@link ControllerWatchResources | watch_resources} lease
+ * that starts receives every tick the agent holds, then each new tick while it runs. The agent
+ * sends nothing while nobody watches, and nothing is stored.
+ */
+export declare const AgentResourceBatch: z.ZodObject<{
+    type: z.ZodLiteral<"resource_batch">;
+    ticks: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        disk: z.ZodNullable<z.ZodObject<{
+            cap: z.ZodNumber;
+            used: z.ZodNumber;
+        }, z.core.$strip>>;
+        memory: z.ZodObject<{
+            cap: z.ZodNumber;
+            used: z.ZodNumber;
+        }, z.core.$strip>;
+        cpu: z.ZodNullable<z.ZodObject<{
+            max: z.ZodNumber;
+            average: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    reset: z.ZodBoolean;
+}, z.core.$strip>;
+export type AgentResourceBatch = z.infer<typeof AgentResourceBatch>;
+/**
+ * The node's {@link EventBacklog} now, replacing the backlog of the last {@link AgentHello | hello}
+ * or {@link AgentEventBacklog | event_backlog}. Sent when it changes: after each failed upload, as
+ * its counts grow, and once, with nothing stuck, when uploads work again. Rejected when it breaks a
+ * rule of {@link EventBacklog}.
+ */
+export declare const AgentEventBacklog: z.ZodObject<{
+    servers: z.ZodArray<z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        pending: z.ZodNumber;
+    }, z.core.$strip>>;
+    server_count: z.ZodNumber;
+    event_count: z.ZodNumber;
+    reason: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"event_backlog">;
+}, z.core.$strip>;
+export type AgentEventBacklog = z.infer<typeof AgentEventBacklog>;
+/**
+ * Milliseconds a stopping agent waits for the requests it is running before it closes the socket,
+ * counted from its {@link AgentShutdown | shutdown}. A request still running then is cut off.
+ */
+export declare const SHUTDOWN_REQUEST_WAIT_MS = 5000;
+/**
+ * The agent is stopping cleanly and starts no new work. It answers a request that arrives after
+ * this frame with `shutting_down` at once. Replies to the requests it is running may still follow
+ * for up to {@link SHUTDOWN_REQUEST_WAIT_MS}, and then it closes with code `1000`.
+ *
+ * Send no new requests after it. A request without a reply when the socket closes may or may not
+ * have run; the node's reports after it reconnects say which. Its servers keep running, and the
+ * agent takes them over when it returns. It is sent whether or not the controller has welcomed the
+ * {@link AgentHello | hello}.
+ */
+export declare const AgentShutdown: z.ZodObject<{
+    type: z.ZodLiteral<"shutdown">;
+    signal: z.ZodEnum<{
+        SIGINT: "SIGINT";
+        SIGTERM: "SIGTERM";
+        SIGQUIT: "SIGQUIT";
+    }>;
+}, z.core.$strip>;
+/**
+ * Launch a server on an idle slot the agent picks. The server logs in with the slot's token. The
+ * agent reports the slot `starting` before any container work, so two launches never share one.
+ *
+ * The reply comes once the container has started, before the server is up, and
+ * {@link AgentSlotStatus | slot_status} reports it `running` later. The agent pulls no image here.
+ * A launch on a `cs2_image` whose plugin files the agent has not extracted yet waits while it does.
+ * Refused with:
+ *
+ * - A {@link StartRefusal} when the node cannot take the launch.
+ * - `allocation_in_use` when the node is already launching the allocation or its server holds a
+ *   slot.
+ * - `allocation_reused` when the node launched the allocation before.
+ * - `failed` when Docker fails the launch, once its container is gone, after a
+ *   {@link AgentServerExited | server_exited} with `launch_failed`.
+ */
+export declare const ControllerStartServer: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    launch: z.ZodObject<{
+        hostname: z.ZodDefault<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodString>>>;
+        steam_web_api_key: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>>;
+        game_password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        chat_tag: z.ZodPrefault<z.ZodObject<{
+            text: z.ZodDefault<z.ZodString>;
+            color: z.ZodDefault<z.ZodEnum<{
+                white: "white";
+                darkred: "darkred";
+                lightpurple: "lightpurple";
+                green: "green";
+                olive: "olive";
+                lime: "lime";
+                red: "red";
+                gray: "gray";
+                lightyellow: "lightyellow";
+                yellow: "yellow";
+                silver: "silver";
+                bluegrey: "bluegrey";
+                lightblue: "lightblue";
+                blue: "blue";
+                darkblue: "darkblue";
+                purple: "purple";
+                magenta: "magenta";
+                lightred: "lightred";
+                gold: "gold";
+                orange: "orange";
+            }>>;
+        }, z.core.$strip>>;
+        game_mode: z.ZodDefault<z.ZodEnum<{
+            custom: "custom";
+            casual: "casual";
+            competitive: "competitive";
+            wingman: "wingman";
+            rush: "rush";
+            arms_race: "arms_race";
+            demolition: "demolition";
+            deathmatch: "deathmatch";
+        }>>;
+        max_players: z.ZodNumber;
+        workshop_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        map_name: z.ZodNullable<z.ZodString>;
+        gotv: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            delay_seconds: z.ZodNumber;
+        }, z.core.$strip>>>;
+        idle_shutdown_seconds: z.ZodNullable<z.ZodNumber>;
+        exec: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodString>>;
+        match: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            match_id: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
+            send_statistics: z.ZodDefault<z.ZodBoolean>;
+            roster: z.ZodObject<{
+                team1: z.ZodObject<{
+                    name: z.ZodString;
+                    players: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+                team2: z.ZodObject<{
+                    name: z.ZodString;
+                    players: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+                spectators: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            sides: z.ZodEnum<{
+                knife: "knife";
+                team1_ct: "team1_ct";
+                team1_t: "team1_t";
+            }>;
+            knife_decision_seconds: z.ZodDefault<z.ZodNumber>;
+            ready_mode: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                manual: "manual";
+                external: "external";
+            }>>;
+            spectators_ready_up: z.ZodDefault<z.ZodBoolean>;
+            ready_timeout_seconds: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            record_demo: z.ZodBoolean;
+            debug_capture: z.ZodDefault<z.ZodBoolean>;
+            rules: z.ZodPrefault<z.ZodObject<{
+                max_rounds: z.ZodDefault<z.ZodNumber>;
+                overtime: z.ZodDefault<z.ZodBoolean>;
+                overtime_max_rounds: z.ZodDefault<z.ZodNumber>;
+                friendly_fire: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            restore: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                team1_side: z.ZodEnum<{
+                    t: "t";
+                    ct: "ct";
+                }>;
+                rules: z.ZodObject<{
+                    max_rounds: z.ZodNumber;
+                    overtime: z.ZodBoolean;
+                    overtime_max_rounds: z.ZodNumber;
+                    friendly_fire: z.ZodBoolean;
+                }, z.core.$strip>;
+                file: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"start_server">;
+}, z.core.$strip>;
+export type ControllerStartServer = z.infer<typeof ControllerStartServer>;
+/** The server that started, and the slot the agent picked for it. */
+export declare const StartServerReply: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    slot_id: z.ZodString;
+}, z.core.$strip>;
+export type StartServerReply = z.infer<typeof StartServerReply>;
+/** Seconds of grace before `SIGKILL` for an ordinary stop. */
+export declare const STOP_TIMEOUT_SECONDS = 10;
+/**
+ * Milliseconds the agent waits for an answer from the Docker daemon on its host before it fails the
+ * call. A stop waits its grace on top.
+ */
+export declare const DOCKER_ANSWER_TIMEOUT_MS = 30000;
+/**
+ * Seconds a stop's reply may take beyond its grace: Docker's answer to the stop, which the agent
+ * waits for up to {@link DOCKER_ANSWER_TIMEOUT_MS}, and the reply.
+ */
+export declare const STOP_REPLY_MARGIN_SECONDS = 35;
+/**
+ * Stop an allocation's server. Once asked, the agent stops it: a stop that Docker fails is answered
+ * with `failed`, and the agent tries it again until the server is gone. The slot stays held until
+ * then.
+ *
+ * The reply comes once its container has stopped: up to {@link STOP_TIMEOUT_SECONDS} before the kill, then up
+ * to {@link STOP_REPLY_MARGIN_SECONDS} seconds for the kill and the reply. A stop during a launch
+ * of the allocation first waits for the launch's current step to end. That step can take minutes on
+ * the first launch after an image switch, which extracts the overlay, so the reply can come after
+ * the session's wait. If the launch is stopped between its steps, it starts no server and its
+ * `start_server` fails. If it is stopped while Docker starts its container, its `start_server`
+ * succeeds and the server is then stopped. Refused with `unknown_allocation` for an allocation the
+ * node does not run.
+ */
+export declare const ControllerStopServer: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"stop_server">;
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>;
+/** The server that stopped. */
+export declare const StopServerReply: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>;
+export type StopServerReply = z.infer<typeof StopServerReply>;
+/**
+ * Install or update CS2 on the node's shared volume. The first install happens only through this
+ * request.
+ *
+ * The reply comes immediately with the update's id, as {@link UpdateCs2Reply}, and the update runs
+ * after it, which can take tens of minutes. Refused with `slots_held` while any slot is held and
+ * `maintenance_running` while a maintenance operation runs.
+ *
+ * `cs2.update` in {@link AgentNodeStatus | node_status} reports the update from `outcome: null` to
+ * how it ended, a failed pull of the cs2 image included. Meanwhile
+ * {@link AgentCs2UpdateProgress | cs2_update_progress} and {@link AgentLogBatch | log_batch} report
+ * on it, each naming it by that id.
+ *
+ * An installed node also updates itself to `cs2.latest_build_id` once every slot is idle, unless
+ * its `auto_update` is `false`.
+ */
+export declare const ControllerUpdateCs2: z.ZodObject<{
+    mode: z.ZodEnum<{
+        update: "update";
+        verify: "verify";
+        reinstall: "reinstall";
+    }>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"update_cs2">;
+}, z.core.$strip>;
+/** The update an accepted {@link ControllerUpdateCs2 | update_cs2} started. */
+export declare const UpdateCs2Reply: z.ZodObject<{
+    update_id: z.ZodUUID;
+}, z.core.$strip>;
+export type UpdateCs2Reply = z.infer<typeof UpdateCs2Reply>;
+/**
+ * Read the newest public CS2 build from Steam now instead of at the next scheduled read, which
+ * comes every {@link CS2_BUILD_POLL_INTERVAL_MS}.
+ *
+ * It receives no reply. The agent handles at most one per {@link CS2_BUILD_CHECK_INTERVAL_MS} and
+ * drops any sooner one. One sent during a scheduled read shares it. Neither busy slots nor
+ * maintenance stop it. A changed build arrives as {@link AgentNodeStatus | node_status}, and an
+ * installed node updates to it once every slot is idle, as it always does.
+ */
+export declare const ControllerCheckCs2Build: z.ZodObject<{
+    type: z.ZodLiteral<"check_cs2_build">;
+}, z.core.$strip>;
+/**
+ * Delete one demo by slot and file name.
+ *
+ * The reply comes once the file is removed. Refused with:
+ *
+ * - `unknown_slot` when the node has no directory for the slot.
+ * - `unknown_demo` when the slot has no demo of that name.
+ * - `demo_recording` while its server records the demo.
+ * - `demo_uploading` while the demo uploads.
+ * - `invalid_request` when the name is outside the slot's `demos/` directory.
+ * - `failed` when the removal fails.
+ */
+export declare const ControllerDeleteDemo: z.ZodObject<{
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"delete_demo">;
+}, z.core.$strip>;
+/** The demo that was removed. */
+export declare const DeleteDemoReply: z.ZodObject<{
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+}, z.core.$strip>;
+export type DeleteDemoReply = z.infer<typeof DeleteDemoReply>;
+/**
+ * Seconds a {@link ControllerReserveSlot | reserve_slot} lasts, unless a {@link ControllerSetConfig | set_config}
+ * with the slot's new token ends it first.
+ */
+export declare const SLOT_RESERVATION_SECONDS = 60;
+/**
+ * Keep an idle slot from launches while the controller replaces its token, so that no server
+ * starts on a token that the controller is about to revoke at Steam.
+ *
+ * The agent marks the slot `reserved` before it replies, the same way a launch marks its slot
+ * `starting`, so no {@link ControllerStartServer | start_server} can take the slot once the reply is sent.
+ * The reply comes immediately. Refused with `slot_held` for a slot holding a server, and with
+ * `unknown_slot` for a slot the node does not have.
+ *
+ * The reservation ends with the {@link ControllerSetConfig | set_config} that gives the slot a new token,
+ * with the slot's removal, after {@link SLOT_RESERVATION_SECONDS}, or with the agent's restart.
+ * Asking again restarts the wait.
+ */
+export declare const ControllerReserveSlot: z.ZodObject<{
+    slot_id: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"reserve_slot">;
+}, z.core.$strip>;
+export type ControllerReserveSlot = z.infer<typeof ControllerReserveSlot>;
+/** The slot that is reserved. */
+export declare const ReserveSlotReply: z.ZodObject<{
+    slot_id: z.ZodString;
+}, z.core.$strip>;
+export type ReserveSlotReply = z.infer<typeof ReserveSlotReply>;
+/**
+ * Apply an edit to `agent.yml`, or refuse it without saving any part. Nothing is queued.
+ *
+ * The reply comes once the edit is saved and applied, and carries the node's current settings, the
+ * {@link NodeSettings} that `hello.config` reports. An edit that changes nothing is not saved
+ * again. A slot missing from the reply's `slots` has been removed. Refused with:
+ *
+ * - `slot_held` when the edit would remove or re-port a held slot, or give its server's token to
+ *   another slot.
+ * - `slots_held` when the edit changes any key under `controller` (its address, TLS or paths) while any
+ *   slot is held.
+ * - `slot_token_required` or `demo_header_value_required` when the edit keeps a value that the
+ *   node does not have.
+ * - `invalid_request` when two slots have one token or anything else fails validation.
+ *
+ * After the reply, the agent sends a {@link AgentSlotStatus | slot_status} for each slot that the
+ * edit added or gave a new token. The slot reads `unchecked` until the agent has logged the new
+ * token on to Steam, which the agent starts then unless a server on the node is using the token. A
+ * change to `controller` closes the socket with `1000` once the reply has gone, and the agent sends its
+ * {@link AgentHello | hello} to the new address.
+ *
+ * Required of a controller that hands nodes an `agent.yml` without slots, because it is how they
+ * receive any.
+ */
+export declare const ControllerSetConfig: z.ZodObject<{
+    config: z.ZodObject<{
+        pinned_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        controller: z.ZodOptional<z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>>;
+        auto_update: z.ZodOptional<z.ZodBoolean>;
+        memory_mb: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        demo_upload: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"set_config">;
+}, z.core.$strip>;
+export type ControllerSetConfig = z.infer<typeof ControllerSetConfig>;
+/**
+ * Replace the agent container with another image. Running servers keep running.
+ *
+ * The reply comes immediately with what happens next, as {@link UpdateAgentReply}, and
+ * `agent_update` reports the rest: its `step` while it runs, then how it ended. Refused with
+ * `maintenance_running` while a maintenance operation runs, with `image_missing` for an image the
+ * node lacks without `pull`, and with `image_not_allowed` for an image outside the official agent
+ * repository while the node's `official_images_only` is on.
+ *
+ * Switching stops this agent, and the agent that comes up, the new one or the old one put back,
+ * reports how it went. The update counts as a maintenance operation until it ends, and a switch
+ * until its replacement has proved it stays up.
+ */
+export declare const ControllerUpdateAgent: z.ZodObject<{
+    image: z.ZodString;
+    pull: z.ZodBoolean;
+    id: z.ZodString;
+    type: z.ZodLiteral<"update_agent">;
+}, z.core.$strip>;
+/**
+ * What follows an accepted {@link ControllerUpdateAgent | update_agent}: the update's first
+ * {@link ImageUpdateStep}, or `unchanged` when the node runs that image already, as the registry or
+ * the local image says, and nothing more happens.
+ */
+export declare const UpdateAgentReply: z.ZodObject<{
+    image: z.ZodString;
+    step: z.ZodEnum<{
+        pulling: "pulling";
+        switching: "switching";
+        unchanged: "unchanged";
+    }>;
+}, z.core.$strip>;
+export type UpdateAgentReply = z.infer<typeof UpdateAgentReply>;
+/**
+ * Switch future launches to another cs2 image. Running servers keep theirs, and so does a launch
+ * that took its slot before the switch.
+ *
+ * The reply comes immediately with what happens next, as {@link UpdateCs2ImageReply}. Refused with
+ * `maintenance_running` while a maintenance operation runs, with `image_missing` for an image the
+ * node lacks without `pull`, and with `image_not_allowed` for an image outside the official cs2
+ * repository while the node's `official_images_only` is on.
+ *
+ * The agent then pulls the image when asked to, extracts its plugin files and removes the images
+ * it supersedes. `cs2.image_update` in {@link AgentNodeStatus | node_status} reports its `step`
+ * while it runs, then how it ended, in the same {@link AgentNodeStatus | node_status} as the new
+ * `cs2.image`.
+ */
+export declare const ControllerUpdateCs2Image: z.ZodObject<{
+    image: z.ZodString;
+    pull: z.ZodBoolean;
+    id: z.ZodString;
+    type: z.ZodLiteral<"update_cs2_image">;
+}, z.core.$strip>;
+/**
+ * What follows an accepted {@link ControllerUpdateCs2Image | update_cs2_image}: its first
+ * {@link ImageUpdateStep}.
+ */
+export declare const UpdateCs2ImageReply: z.ZodObject<{
+    image: z.ZodString;
+    step: z.ZodEnum<{
+        pulling: "pulling";
+        switching: "switching";
+    }>;
+}, z.core.$strip>;
+export type UpdateCs2ImageReply = z.infer<typeof UpdateCs2ImageReply>;
+/**
+ * Start or renew the resource lease, which lasts {@link WATCH_LEASE_MS}. It receives no reply.
+ *
+ * While the lease runs, the agent streams {@link AgentResourceBatch | resource_batch}. A lease that
+ * starts first sends every tick the agent holds.
+ */
+export declare const ControllerWatchResources: z.ZodObject<{
+    type: z.ZodLiteral<"watch_resources">;
+    replay: z.ZodBoolean;
+}, z.core.$strip>;
+export type ControllerWatchResources = z.infer<typeof ControllerWatchResources>;
+/**
+ * Start or renew the lease of one log source, which lasts {@link WATCH_LEASE_MS}. It receives no
+ * reply.
+ *
+ * While the lease runs, the agent streams the source's {@link AgentLogBatch | log_batch} frames.
+ * While any source's lease runs, the agent also sends {@link AgentLogIndex | log_index}. A lease
+ * that starts replays the source, to every watcher unless a `replay_id` names the one that asked.
+ * Any number of sources can be watched together, each on a lease of its own.
+ */
+export declare const ControllerWatchLogs: z.ZodObject<{
+    type: z.ZodLiteral<"watch_logs">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"cs2_update">;
+        update_id: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"server">;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>], "kind">;
+    replay_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ControllerWatchLogs = z.infer<typeof ControllerWatchLogs>;
+/**
+ * The controller's answer to a {@link AgentHello | hello} it accepted, before anything else on the
+ * socket. Without one the agent redials after {@link AGENT_WELCOME_TIMEOUT_MS}.
+ *
+ * After each {@link ControllerWelcome | welcome} the agent sends what changed since the
+ * {@link AgentHello | hello}, its pending {@link AgentServerExited | server_exited} first and then
+ * the changed statuses, demos, backlog and watched streams. It sends each state once, so a slot
+ * that went from `starting` to `running` arrives as `running`.
+ */
+export declare const ControllerWelcome: z.ZodObject<{
+    type: z.ZodLiteral<"welcome">;
+}, z.core.$strip>;
+/**
+ * Why the controller refused a {@link AgentHello | hello}: `invalid_hello`, the
+ * {@link AgentHello | hello} fails its schema. A controller refuses nothing else at hello: an agent
+ * on a version it does not support connects, so it can still be updated, and receives no launches.
+ */
+export declare const HelloRefusedReason: z.ZodEnum<{
+    invalid_hello: "invalid_hello";
+}>;
+export type HelloRefusedReason = z.infer<typeof HelloRefusedReason>;
+/**
+ * The controller's answer to a {@link AgentHello | hello} it will not accept, followed by a close
+ * with code `1008` and reason `hello_refused`. The agent stops dialling until it is restarted,
+ * because the same {@link AgentHello | hello} would be refused again.
+ */
+export declare const ControllerHelloRefused: z.ZodObject<{
+    type: z.ZodLiteral<"hello_refused">;
+    reason: z.ZodEnum<{
+        invalid_hello: "invalid_hello";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export type ControllerHelloRefused = z.infer<typeof ControllerHelloRefused>;
+/**
+ * Longest console command line, in characters. CS2 refuses a longer one with `Command too long...
+ * ignoring!` somewhere past 500 (tested in October 2026), and reports it only in its log.
+ */
+export declare const CONSOLE_COMMAND_MAX_CHARS = 500;
+/**
+ * Run a console command on a server through its plugin.
+ *
+ * The reply comes once the plugin has handed the command to the engine, which reports nothing
+ * back, so the reply cannot say that it worked. Refused with:
+ *
+ * - `unknown_allocation` when the node does not run the server.
+ * - `plugin_offline` while the slot's `plugin_online` is `false`.
+ * - `plugin_status_timeout` when the plugin does not answer.
+ *
+ * The output of the command joins the server's log, which {@link AgentLogBatch | log_batch} streams
+ * while a {@link ControllerWatchLogs | watch_logs} lease covers it and replays when one starts.
+ */
+export declare const ControllerConsoleCommand: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    command: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"console_command">;
+}, z.core.$strip>;
+export type ControllerConsoleCommand = z.infer<typeof ControllerConsoleCommand>;
+/** The server the command was handed to. */
+export declare const ConsoleCommandReply: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>;
+export type ConsoleCommandReply = z.infer<typeof ConsoleCommandReply>;
+/**
+ * Play a running match on from one of its earlier rounds, on the same server, without a new
+ * launch. The engine writes a backup as each live round starts, and the node keeps the backups for
+ * the server's life. This request loads the one for `round`.
+ *
+ * The reply comes once the plugin has asked the engine to load the backup. The
+ * {@link MatchRestored | match_restored} event, which the plugin sends ahead of the restored
+ * round's {@link RoundStart | round_start}, confirms that the engine did. Refused with:
+ *
+ * - `unknown_allocation` when the node does not run the server.
+ * - `no_backup` when the node has no backup of that round, as in a game mode without backups
+ *   ({@link GameMode}).
+ * - `plugin_offline` while the slot's `plugin_online` is `false`.
+ * - `plugin_status_timeout` when the plugin does not answer.
+ * - `no_match`, `not_live` or `at_halftime` when the plugin refuses the restore.
+ *
+ * The node keeps the backup of every round it has played, including rounds after one it was
+ * restored to. If `round` is past the current round, the server loads play that the match has
+ * since left. Whether to allow that is the controller's rule.
+ */
+export declare const ControllerRestoreRound: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    round: z.ZodNumber;
+    id: z.ZodString;
+    type: z.ZodLiteral<"restore_round">;
+}, z.core.$strip>;
+export type ControllerRestoreRound = z.infer<typeof ControllerRestoreRound>;
+/** The server and round the restore was handed to. */
+export declare const RestoreRoundReply: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    round: z.ZodNumber;
+}, z.core.$strip>;
+export type RestoreRoundReply = z.infer<typeof RestoreRoundReply>;
+/**
+ * Start a match in warmup whatever its `ready_mode`, without waiting for anyone to be ready. An
+ * admin can always start the match this way, and under `external` it is the only way to.
+ *
+ * The reply comes once the plugin has started the countdown to the knife round or live play.
+ * Refused with:
+ *
+ * - `unknown_allocation` when the node does not run the server.
+ * - `plugin_offline` while the slot's `plugin_online` is `false`.
+ * - `plugin_status_timeout` when the plugin does not answer.
+ * - `no_match`, `not_in_warmup` or `team_empty` when the plugin refuses the start.
+ *
+ * A repeat while the countdown runs is accepted and changes nothing.
+ */
+export declare const ControllerStartMatch: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    id: z.ZodString;
+    type: z.ZodLiteral<"start_match">;
+}, z.core.$strip>;
+export type ControllerStartMatch = z.infer<typeof ControllerStartMatch>;
+/** The server the start was handed to. */
+export declare const StartMatchReply: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>;
+export type StartMatchReply = z.infer<typeof StartMatchReply>;
+/**
+ * Milliseconds the agent waits for the plugin to answer
+ * {@link ControllerGetServerStatus | get_server_status}, {@link ControllerConsoleCommand | console_command},
+ * {@link ControllerRestoreRound | restore_round} or {@link ControllerStartMatch | start_match}. Past it, the
+ * request fails with `plugin_status_timeout`.
+ */
+export declare const SERVER_STATUS_TIMEOUT_MS = 10000;
+/**
+ * Read a server's state as its plugin reports it now.
+ *
+ * The reply comes within {@link SERVER_STATUS_TIMEOUT_MS}. Refused with:
+ *
+ * - `unknown_allocation` when the node does not run the server.
+ * - `plugin_offline` while the slot's `plugin_online` is `false` or when the plugin leaves before
+ *   answering.
+ * - `plugin_status_timeout` after {@link SERVER_STATUS_TIMEOUT_MS}.
+ */
+export declare const ControllerGetServerStatus: z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    id: z.ZodString;
+    type: z.ZodLiteral<"get_server_status">;
+}, z.core.$strip>;
+/**
+ * Where a match is.
+ *
+ * - `loading`: its map is loading.
+ * - `warmup`: warmup.
+ * - `pending_restore`: a launch with a restore went here from warmup while the engine loads the
+ *   backup, and goes to `live` once the restored round starts. A load that fails leaves the match
+ *   here, where the plugin reports nothing, until a load is tried again or the server is stopped.
+ * - `knife`: the knife round.
+ * - `side_choice`: the side choice.
+ * - `live`: live play.
+ * - `post_live`: after the last round.
+ */
+export declare const MatchPhase: z.ZodEnum<{
+    side_choice: "side_choice";
+    knife: "knife";
+    loading: "loading";
+    warmup: "warmup";
+    pending_restore: "pending_restore";
+    live: "live";
+    post_live: "post_live";
+}>;
+export type MatchPhase = z.infer<typeof MatchPhase>;
+/** Longest `map_name` a server's state carries. The plugin cuts the engine's name to it. */
+export declare const MAP_NAME_MAX_CHARS = 64;
+/** Longest `config_error` a server's state carries. The plugin cuts its reason to it. */
+export declare const CONFIG_ERROR_MAX_CHARS = 512;
+/** A game server's state as its plugin reports it. */
+export declare const ServerState: z.ZodObject<{
+    map_name: z.ZodString;
+    match: z.ZodNullable<z.ZodObject<{
+        match_id: z.ZodNullable<z.ZodUUID>;
+        phase: z.ZodEnum<{
+            side_choice: "side_choice";
+            knife: "knife";
+            loading: "loading";
+            warmup: "warmup";
+            pending_restore: "pending_restore";
+            live: "live";
+            post_live: "post_live";
+        }>;
+        team1_side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+        }>;
+        team2_side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+        }>;
+        team1_score: z.ZodNumber;
+        team2_score: z.ZodNumber;
+    }, z.core.$strip>>;
+    players: z.ZodArray<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+    }, z.core.$strip>>;
+    config_error: z.ZodNullable<z.ZodString>;
+    ready: z.ZodBoolean;
+    server_steam_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ServerState = z.infer<typeof ServerState>;
+/** The server asked about, and its state as its plugin reports it now. */
+export declare const GetServerStatusReply: z.ZodObject<{
+    map_name: z.ZodString;
+    match: z.ZodNullable<z.ZodObject<{
+        match_id: z.ZodNullable<z.ZodUUID>;
+        phase: z.ZodEnum<{
+            side_choice: "side_choice";
+            knife: "knife";
+            loading: "loading";
+            warmup: "warmup";
+            pending_restore: "pending_restore";
+            live: "live";
+            post_live: "post_live";
+        }>;
+        team1_side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+        }>;
+        team2_side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+        }>;
+        team1_score: z.ZodNumber;
+        team2_score: z.ZodNumber;
+    }, z.core.$strip>>;
+    players: z.ZodArray<z.ZodObject<{
+        steam_id: z.ZodString;
+        name: z.ZodString;
+        side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+            spec: "spec";
+        }>;
+    }, z.core.$strip>>;
+    config_error: z.ZodNullable<z.ZodString>;
+    ready: z.ZodBoolean;
+    server_steam_id: z.ZodNullable<z.ZodString>;
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>;
+export type GetServerStatusReply = z.infer<typeof GetServerStatusReply>;
+/**
+ * A match moved to another phase, as its plugin reports it, whether or not the match sends
+ * statistics. An {@link EventBatch | event_batch} carries the events behind it, such as
+ * {@link GoingLive | going_live} and {@link MapEnd | map_end}.
+ *
+ * The agent sends it once. If the plugin is not connected to the agent, or the controller has not
+ * welcomed the agent's {@link AgentHello | hello}, it is lost, and
+ * {@link ControllerGetServerStatus | get_server_status} reads the phase again.
+ */
+export declare const AgentPhaseChange: z.ZodObject<{
+    type: z.ZodLiteral<"phase_change">;
+    allocation_id: z.ZodUUID;
+    phase: z.ZodEnum<{
+        side_choice: "side_choice";
+        knife: "knife";
+        loading: "loading";
+        warmup: "warmup";
+        pending_restore: "pending_restore";
+        live: "live";
+        post_live: "post_live";
+    }>;
+}, z.core.$strip>;
+export type AgentPhaseChange = z.infer<typeof AgentPhaseChange>;
+/**
+ * A match's score changed, as its plugin reads it off the scoreboard, whether or not the match
+ * sends statistics: after a round, when going live resets it, or after a restore. An
+ * {@link EventBatch | event_batch} carries the rounds behind it as {@link RoundEnd | round_end}
+ * and {@link MatchRestored | match_restored}.
+ *
+ * Like {@link AgentPhaseChange | phase_change}, it is sent once, and
+ * {@link ControllerGetServerStatus | get_server_status} reads the score again.
+ */
+export declare const AgentScore: z.ZodObject<{
+    type: z.ZodLiteral<"score">;
+    allocation_id: z.ZodUUID;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+}, z.core.$strip>;
+export type AgentScore = z.infer<typeof AgentScore>;
+/**
+ * The {@link RoundBackup | round_backup} of a match that sends no statistics, which a match with
+ * statistics carries in its {@link EventBatch | event_batch} instead. Keep the newest of each match
+ * to restore it on a new server.
+ *
+ * The message wraps the complete event, unchanged, so code that reads a `round_backup` from the
+ * event stream reads `backup` the same way. The wrapper adds only the server that sent it.
+ *
+ * Like {@link AgentPhaseChange | phase_change}, it is sent once, so a backup is lost if the plugin
+ * or the agent is not connected when the round starts. The next round's backup replaces it.
+ */
+export declare const AgentBackup: z.ZodObject<{
+    type: z.ZodLiteral<"backup">;
+    allocation_id: z.ZodUUID;
+    backup: z.ZodObject<{
+        roster: z.ZodObject<{
+            team1: z.ZodObject<{
+                name: z.ZodString;
+                players: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            team2: z.ZodObject<{
+                name: z.ZodString;
+                players: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            spectators: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        team1_side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+        }>;
+        rules: z.ZodObject<{
+            max_rounds: z.ZodNumber;
+            overtime: z.ZodBoolean;
+            overtime_max_rounds: z.ZodNumber;
+            friendly_fire: z.ZodBoolean;
+        }, z.core.$strip>;
+        file: z.ZodString;
+        round: z.ZodNumber;
+        team1_score: z.ZodNumber;
+        team2_score: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        tick: z.ZodNumber;
+        type: z.ZodLiteral<"round_backup">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AgentBackup = z.infer<typeof AgentBackup>;
+/**
+ * What the controller sends:
+ *
+ * - The {@link ControllerWelcome | welcome} that accepts a {@link AgentHello | hello}, or the
+ *   {@link ControllerHelloRefused | hello_refused} that refuses it.
+ * - Requests, which carry an `id` and receive one {@link AgentReply | reply} each.
+ * - The watches that start or renew a stream of logs or resource samples.
+ * - {@link ControllerCheckCs2Build | check_cs2_build}, which receives no answer.
+ */
+export declare const ControllerToAgentMessage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    launch: z.ZodObject<{
+        hostname: z.ZodDefault<z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodString>>>;
+        steam_web_api_key: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>>;
+        game_password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        chat_tag: z.ZodPrefault<z.ZodObject<{
+            text: z.ZodDefault<z.ZodString>;
+            color: z.ZodDefault<z.ZodEnum<{
+                white: "white";
+                darkred: "darkred";
+                lightpurple: "lightpurple";
+                green: "green";
+                olive: "olive";
+                lime: "lime";
+                red: "red";
+                gray: "gray";
+                lightyellow: "lightyellow";
+                yellow: "yellow";
+                silver: "silver";
+                bluegrey: "bluegrey";
+                lightblue: "lightblue";
+                blue: "blue";
+                darkblue: "darkblue";
+                purple: "purple";
+                magenta: "magenta";
+                lightred: "lightred";
+                gold: "gold";
+                orange: "orange";
+            }>>;
+        }, z.core.$strip>>;
+        game_mode: z.ZodDefault<z.ZodEnum<{
+            custom: "custom";
+            casual: "casual";
+            competitive: "competitive";
+            wingman: "wingman";
+            rush: "rush";
+            arms_race: "arms_race";
+            demolition: "demolition";
+            deathmatch: "deathmatch";
+        }>>;
+        max_players: z.ZodNumber;
+        workshop_id: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        map_name: z.ZodNullable<z.ZodString>;
+        gotv: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            password: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            delay_seconds: z.ZodNumber;
+        }, z.core.$strip>>>;
+        idle_shutdown_seconds: z.ZodNullable<z.ZodNumber>;
+        exec: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodString>>;
+        match: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            match_id: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
+            send_statistics: z.ZodDefault<z.ZodBoolean>;
+            roster: z.ZodObject<{
+                team1: z.ZodObject<{
+                    name: z.ZodString;
+                    players: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+                team2: z.ZodObject<{
+                    name: z.ZodString;
+                    players: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
+                spectators: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            sides: z.ZodEnum<{
+                knife: "knife";
+                team1_ct: "team1_ct";
+                team1_t: "team1_t";
+            }>;
+            knife_decision_seconds: z.ZodDefault<z.ZodNumber>;
+            ready_mode: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                manual: "manual";
+                external: "external";
+            }>>;
+            spectators_ready_up: z.ZodDefault<z.ZodBoolean>;
+            ready_timeout_seconds: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            record_demo: z.ZodBoolean;
+            debug_capture: z.ZodDefault<z.ZodBoolean>;
+            rules: z.ZodPrefault<z.ZodObject<{
+                max_rounds: z.ZodDefault<z.ZodNumber>;
+                overtime: z.ZodDefault<z.ZodBoolean>;
+                overtime_max_rounds: z.ZodDefault<z.ZodNumber>;
+                friendly_fire: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            restore: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                team1_side: z.ZodEnum<{
+                    t: "t";
+                    ct: "ct";
+                }>;
+                rules: z.ZodObject<{
+                    max_rounds: z.ZodNumber;
+                    overtime: z.ZodBoolean;
+                    overtime_max_rounds: z.ZodNumber;
+                    friendly_fire: z.ZodBoolean;
+                }, z.core.$strip>;
+                file: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"start_server">;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"stop_server">;
+    allocation_id: z.ZodUUID;
+}, z.core.$strip>, z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    id: z.ZodString;
+    type: z.ZodLiteral<"get_server_status">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodEnum<{
+        update: "update";
+        verify: "verify";
+        reinstall: "reinstall";
+    }>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"update_cs2">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"check_cs2_build">;
+}, z.core.$strip>, z.ZodObject<{
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"delete_demo">;
+}, z.core.$strip>, z.ZodObject<{
+    slot_id: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"reserve_slot">;
+}, z.core.$strip>, z.ZodObject<{
+    config: z.ZodObject<{
+        pinned_ip: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        controller: z.ZodOptional<z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>>;
+        auto_update: z.ZodOptional<z.ZodBoolean>;
+        memory_mb: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        demo_upload: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    id: z.ZodString;
+    type: z.ZodLiteral<"set_config">;
+}, z.core.$strip>, z.ZodObject<{
+    image: z.ZodString;
+    pull: z.ZodBoolean;
+    id: z.ZodString;
+    type: z.ZodLiteral<"update_agent">;
+}, z.core.$strip>, z.ZodObject<{
+    image: z.ZodString;
+    pull: z.ZodBoolean;
+    id: z.ZodString;
+    type: z.ZodLiteral<"update_cs2_image">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"watch_resources">;
+    replay: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"watch_logs">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"cs2_update">;
+        update_id: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"server">;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>], "kind">;
+    replay_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"welcome">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"hello_refused">;
+    reason: z.ZodEnum<{
+        invalid_hello: "invalid_hello";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    command: z.ZodString;
+    id: z.ZodString;
+    type: z.ZodLiteral<"console_command">;
+}, z.core.$strip>, z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    round: z.ZodNumber;
+    id: z.ZodString;
+    type: z.ZodLiteral<"restore_round">;
+}, z.core.$strip>, z.ZodObject<{
+    allocation_id: z.ZodUUID;
+    id: z.ZodString;
+    type: z.ZodLiteral<"start_match">;
+}, z.core.$strip>], "type">;
+export type ControllerToAgentMessage = z.infer<typeof ControllerToAgentMessage>;
+/**
+ * The `type` of each request the controller sends, which its {@link AgentReply | reply} repeats as
+ * `request`.
+ */
+export declare const RequestType: z.ZodEnum<{
+    start_server: "start_server";
+    stop_server: "stop_server";
+    update_cs2: "update_cs2";
+    delete_demo: "delete_demo";
+    reserve_slot: "reserve_slot";
+    set_config: "set_config";
+    update_agent: "update_agent";
+    update_cs2_image: "update_cs2_image";
+    console_command: "console_command";
+    restore_round: "restore_round";
+    start_match: "start_match";
+    get_server_status: "get_server_status";
+}>;
+export type RequestType = z.infer<typeof RequestType>;
+/**
+ * A request that succeeded. `request` names the request, so `data` can be read without the request
+ * that `reply_to` answers. The settings in a {@link ControllerSetConfig | set_config} reply are the
+ * node's, whichever edit asked.
+ */
+export declare const AgentReplySuccess: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"start_server">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        slot_id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"stop_server">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"get_server_status">;
+    data: z.ZodObject<{
+        map_name: z.ZodString;
+        match: z.ZodNullable<z.ZodObject<{
+            match_id: z.ZodNullable<z.ZodUUID>;
+            phase: z.ZodEnum<{
+                side_choice: "side_choice";
+                knife: "knife";
+                loading: "loading";
+                warmup: "warmup";
+                pending_restore: "pending_restore";
+                live: "live";
+                post_live: "post_live";
+            }>;
+            team1_side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+            }>;
+            team2_side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+            }>;
+            team1_score: z.ZodNumber;
+            team2_score: z.ZodNumber;
+        }, z.core.$strip>>;
+        players: z.ZodArray<z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+        }, z.core.$strip>>;
+        config_error: z.ZodNullable<z.ZodString>;
+        ready: z.ZodBoolean;
+        server_steam_id: z.ZodNullable<z.ZodString>;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_cs2">;
+    data: z.ZodObject<{
+        update_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"delete_demo">;
+    data: z.ZodObject<{
+        slot_id: z.ZodString;
+        file_name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"reserve_slot">;
+    data: z.ZodObject<{
+        slot_id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"set_config">;
+    data: z.ZodObject<{
+        slots: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt_hint: z.ZodString;
+        }, z.core.$strip>>;
+        pinned_ip: z.ZodNullable<z.ZodString>;
+        controller: z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>;
+        auto_update: z.ZodBoolean;
+        demo_upload: z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value_sha256: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        memory_mb: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_agent">;
+    data: z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+            unchanged: "unchanged";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_cs2_image">;
+    data: z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"console_command">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"restore_round">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        round: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"start_match">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>], "request">;
+/** A request that failed. */
+export declare const AgentReplyFailure: z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    request: z.ZodNullable<z.ZodEnum<{
+        start_server: "start_server";
+        stop_server: "stop_server";
+        update_cs2: "update_cs2";
+        delete_demo: "delete_demo";
+        reserve_slot: "reserve_slot";
+        set_config: "set_config";
+        update_agent: "update_agent";
+        update_cs2_image: "update_cs2_image";
+        console_command: "console_command";
+        restore_round: "restore_round";
+        start_match: "start_match";
+        get_server_status: "get_server_status";
+    }>>;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            /** No slot is idle, unreserved and on a token Steam has not refused. */
+            readonly noFreeSlot: "no_free_slot";
+            /**
+             * A newer public CS2 build is out and the node has not updated to it yet, so its `cs2.build_id`
+             * is behind `cs2.latest_build_id`. The node takes launches again once it has updated. A node
+             * whose `auto_update` is `false` never refuses with this.
+             */
+            readonly cs2Outdated: "cs2_outdated";
+            /**
+             * CS2 is not installed on the node, so its `cs2.build_id` is `null`. The node takes launches once
+             * an {@link ControllerUpdateCs2 | update_cs2} has installed it.
+             */
+            readonly cs2NotInstalled: "cs2_not_installed";
+            /** The node reports `unavailable` for a reason other than `maintenance`. */
+            readonly nodeUnavailable: "node_unavailable";
+            /**
+             * An operation that needs every slot idle found one held: {@link ControllerUpdateCs2 | update_cs2}, or a
+             * {@link ControllerSetConfig | set_config} that changes any key under `controller`.
+             */
+            readonly slotsHeld: "slots_held";
+            /**
+             * A slot holds a server that is `starting`, `running` or `stopping`, and
+             * {@link ControllerSetConfig | set_config} would remove or re-port the slot or give its server's token
+             * to another slot, or {@link ControllerReserveSlot | reserve_slot} asked for it. `detail` names the
+             * slots.
+             */
+            readonly slotHeld: "slot_held";
+            /** The node has no slot with that id. */
+            readonly unknownSlot: "unknown_slot";
+            /**
+             * {@link ControllerSetConfig | set_config} kept the token of a slot the node does not have yet. A new
+             * slot needs a new token.
+             */
+            readonly slotTokenRequired: "slot_token_required";
+            /**
+             * {@link ControllerSetConfig | set_config} kept the value of a demo upload header the node does not
+             * send. A new header needs its value.
+             */
+            readonly demoHeaderValueRequired: "demo_header_value_required";
+            /** No server with that allocation id. */
+            readonly unknownAllocation: "unknown_allocation";
+            /**
+             * A maintenance operation runs on the node. That operation is unaffected, and `unavailable` shows
+             * it as `maintenance`.
+             */
+            readonly maintenanceRunning: "maintenance_running";
+            /**
+             * The image is not on the node and the request asked for no pull. Asking again with `pull`
+             * fetches it.
+             */
+            readonly imageMissing: "image_missing";
+            /**
+             * The image is not an official one, and the node's `official_images_only` is on. The node's
+             * operator decides which images it runs.
+             */
+            readonly imageNotAllowed: "image_not_allowed";
+            /** The demo is uploading. It can be deleted once the upload ends. */
+            readonly demoUploading: "demo_uploading";
+            /** The slot has no demo of that name, such as one an upload or a delete has already removed. */
+            readonly unknownDemo: "unknown_demo";
+            /** The demo is still being recorded. It can be deleted once its server ends the recording. */
+            readonly demoRecording: "demo_recording";
+            /** The server's plugin is not connected to the agent, or left before it answered. */
+            readonly pluginOffline: "plugin_offline";
+            /**
+             * The plugin did not answer {@link ControllerGetServerStatus | get_server_status},
+             * {@link ControllerConsoleCommand | console_command}, {@link ControllerStartMatch | start_match} or
+             * {@link ControllerRestoreRound | restore_round} within {@link SERVER_STATUS_TIMEOUT_MS}.
+             */
+            readonly pluginStatusTimeout: "plugin_status_timeout";
+            /** The server runs without a match. */
+            readonly noMatch: "no_match";
+            /** The match is past its warmup. */
+            readonly notInWarmup: "not_in_warmup";
+            /** A team has no player connected. */
+            readonly teamEmpty: "team_empty";
+            /** The match is not live, such as in warmup, during the knife round or after it ended. */
+            readonly notLive: "not_live";
+            /**
+             * The match is in its halftime break, while the sides are about to swap. Ask again once the next
+             * round has started.
+             */
+            readonly atHalftime: "at_halftime";
+            /**
+             * The node has no backup of the round that {@link ControllerRestoreRound | restore_round} named for that
+             * server.
+             */
+            readonly noBackup: "no_backup";
+            /** The request did not match its schema. */
+            readonly invalidRequest: "invalid_request";
+            /**
+             * {@link ControllerStartServer | start_server} named an allocation this node is already launching or
+             * running. Its server exists or is on its way, as after a {@link ControllerStartServer | start_server}
+             * sent again when its reply was slow.
+             */
+            readonly allocationInUse: "allocation_in_use";
+            /**
+             * {@link ControllerStartServer | start_server} named an allocation that this node launched before, among
+             * the last {@link REMEMBERED_ALLOCATIONS}. The node files a server's events and demos under its
+             * allocation, so every launch needs a new one.
+             */
+            readonly allocationReused: "allocation_reused";
+            /** The agent does not know the request's `type`, or the plugin the command's. */
+            readonly unsupportedRequest: "unsupported_request";
+            /**
+             * The agent is stopping and started no work for the request, as after its
+             * {@link AgentShutdown | shutdown}. Send the request again once the node reconnects.
+             */
+            readonly shuttingDown: "shutting_down";
+            /** Any failure that no other code names, such as a Docker failure. */
+            readonly failed: "failed";
+        }>;
+        detail: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * The answer to a request, in any order. A success carries the request's data, and a failure its
+ * reason.
+ */
+export declare const AgentReply: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"start_server">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        slot_id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"stop_server">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"get_server_status">;
+    data: z.ZodObject<{
+        map_name: z.ZodString;
+        match: z.ZodNullable<z.ZodObject<{
+            match_id: z.ZodNullable<z.ZodUUID>;
+            phase: z.ZodEnum<{
+                side_choice: "side_choice";
+                knife: "knife";
+                loading: "loading";
+                warmup: "warmup";
+                pending_restore: "pending_restore";
+                live: "live";
+                post_live: "post_live";
+            }>;
+            team1_side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+            }>;
+            team2_side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+            }>;
+            team1_score: z.ZodNumber;
+            team2_score: z.ZodNumber;
+        }, z.core.$strip>>;
+        players: z.ZodArray<z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+        }, z.core.$strip>>;
+        config_error: z.ZodNullable<z.ZodString>;
+        ready: z.ZodBoolean;
+        server_steam_id: z.ZodNullable<z.ZodString>;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_cs2">;
+    data: z.ZodObject<{
+        update_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"delete_demo">;
+    data: z.ZodObject<{
+        slot_id: z.ZodString;
+        file_name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"reserve_slot">;
+    data: z.ZodObject<{
+        slot_id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"set_config">;
+    data: z.ZodObject<{
+        slots: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt_hint: z.ZodString;
+        }, z.core.$strip>>;
+        pinned_ip: z.ZodNullable<z.ZodString>;
+        controller: z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>;
+        auto_update: z.ZodBoolean;
+        demo_upload: z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value_sha256: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        memory_mb: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_agent">;
+    data: z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+            unchanged: "unchanged";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_cs2_image">;
+    data: z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"console_command">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"restore_round">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        round: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"start_match">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>], "request">, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    request: z.ZodNullable<z.ZodEnum<{
+        start_server: "start_server";
+        stop_server: "stop_server";
+        update_cs2: "update_cs2";
+        delete_demo: "delete_demo";
+        reserve_slot: "reserve_slot";
+        set_config: "set_config";
+        update_agent: "update_agent";
+        update_cs2_image: "update_cs2_image";
+        console_command: "console_command";
+        restore_round: "restore_round";
+        start_match: "start_match";
+        get_server_status: "get_server_status";
+    }>>;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            /** No slot is idle, unreserved and on a token Steam has not refused. */
+            readonly noFreeSlot: "no_free_slot";
+            /**
+             * A newer public CS2 build is out and the node has not updated to it yet, so its `cs2.build_id`
+             * is behind `cs2.latest_build_id`. The node takes launches again once it has updated. A node
+             * whose `auto_update` is `false` never refuses with this.
+             */
+            readonly cs2Outdated: "cs2_outdated";
+            /**
+             * CS2 is not installed on the node, so its `cs2.build_id` is `null`. The node takes launches once
+             * an {@link ControllerUpdateCs2 | update_cs2} has installed it.
+             */
+            readonly cs2NotInstalled: "cs2_not_installed";
+            /** The node reports `unavailable` for a reason other than `maintenance`. */
+            readonly nodeUnavailable: "node_unavailable";
+            /**
+             * An operation that needs every slot idle found one held: {@link ControllerUpdateCs2 | update_cs2}, or a
+             * {@link ControllerSetConfig | set_config} that changes any key under `controller`.
+             */
+            readonly slotsHeld: "slots_held";
+            /**
+             * A slot holds a server that is `starting`, `running` or `stopping`, and
+             * {@link ControllerSetConfig | set_config} would remove or re-port the slot or give its server's token
+             * to another slot, or {@link ControllerReserveSlot | reserve_slot} asked for it. `detail` names the
+             * slots.
+             */
+            readonly slotHeld: "slot_held";
+            /** The node has no slot with that id. */
+            readonly unknownSlot: "unknown_slot";
+            /**
+             * {@link ControllerSetConfig | set_config} kept the token of a slot the node does not have yet. A new
+             * slot needs a new token.
+             */
+            readonly slotTokenRequired: "slot_token_required";
+            /**
+             * {@link ControllerSetConfig | set_config} kept the value of a demo upload header the node does not
+             * send. A new header needs its value.
+             */
+            readonly demoHeaderValueRequired: "demo_header_value_required";
+            /** No server with that allocation id. */
+            readonly unknownAllocation: "unknown_allocation";
+            /**
+             * A maintenance operation runs on the node. That operation is unaffected, and `unavailable` shows
+             * it as `maintenance`.
+             */
+            readonly maintenanceRunning: "maintenance_running";
+            /**
+             * The image is not on the node and the request asked for no pull. Asking again with `pull`
+             * fetches it.
+             */
+            readonly imageMissing: "image_missing";
+            /**
+             * The image is not an official one, and the node's `official_images_only` is on. The node's
+             * operator decides which images it runs.
+             */
+            readonly imageNotAllowed: "image_not_allowed";
+            /** The demo is uploading. It can be deleted once the upload ends. */
+            readonly demoUploading: "demo_uploading";
+            /** The slot has no demo of that name, such as one an upload or a delete has already removed. */
+            readonly unknownDemo: "unknown_demo";
+            /** The demo is still being recorded. It can be deleted once its server ends the recording. */
+            readonly demoRecording: "demo_recording";
+            /** The server's plugin is not connected to the agent, or left before it answered. */
+            readonly pluginOffline: "plugin_offline";
+            /**
+             * The plugin did not answer {@link ControllerGetServerStatus | get_server_status},
+             * {@link ControllerConsoleCommand | console_command}, {@link ControllerStartMatch | start_match} or
+             * {@link ControllerRestoreRound | restore_round} within {@link SERVER_STATUS_TIMEOUT_MS}.
+             */
+            readonly pluginStatusTimeout: "plugin_status_timeout";
+            /** The server runs without a match. */
+            readonly noMatch: "no_match";
+            /** The match is past its warmup. */
+            readonly notInWarmup: "not_in_warmup";
+            /** A team has no player connected. */
+            readonly teamEmpty: "team_empty";
+            /** The match is not live, such as in warmup, during the knife round or after it ended. */
+            readonly notLive: "not_live";
+            /**
+             * The match is in its halftime break, while the sides are about to swap. Ask again once the next
+             * round has started.
+             */
+            readonly atHalftime: "at_halftime";
+            /**
+             * The node has no backup of the round that {@link ControllerRestoreRound | restore_round} named for that
+             * server.
+             */
+            readonly noBackup: "no_backup";
+            /** The request did not match its schema. */
+            readonly invalidRequest: "invalid_request";
+            /**
+             * {@link ControllerStartServer | start_server} named an allocation this node is already launching or
+             * running. Its server exists or is on its way, as after a {@link ControllerStartServer | start_server}
+             * sent again when its reply was slow.
+             */
+            readonly allocationInUse: "allocation_in_use";
+            /**
+             * {@link ControllerStartServer | start_server} named an allocation that this node launched before, among
+             * the last {@link REMEMBERED_ALLOCATIONS}. The node files a server's events and demos under its
+             * allocation, so every launch needs a new one.
+             */
+            readonly allocationReused: "allocation_reused";
+            /** The agent does not know the request's `type`, or the plugin the command's. */
+            readonly unsupportedRequest: "unsupported_request";
+            /**
+             * The agent is stopping and started no work for the request, as after its
+             * {@link AgentShutdown | shutdown}. Send the request again once the node reconnects.
+             */
+            readonly shuttingDown: "shutting_down";
+            /** Any failure that no other code names, such as a Docker failure. */
+            readonly failed: "failed";
+        }>;
+        detail: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>], "ok">;
+/** What a request comes to, without the correlation fields of the frame. */
+export type AgentReplyOutcome = {
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+    error: AgentError;
+};
+/** What a successful reply to that request carries as `data`. */
+export type ReplyData<T extends RequestType> = Extract<z.infer<typeof AgentReplySuccess>, {
+    request: T;
+}>['data'];
+/**
+ * What the agent sends: its {@link AgentHello | hello}, one {@link AgentReply | reply} to each
+ * request, and reports of the node as it changes. Until a {@link ControllerWelcome | welcome} answers the
+ * {@link AgentHello | hello}, only replies follow it, and a {@link AgentShutdown | shutdown} if the
+ * agent stops.
+ */
+export declare const AgentToControllerMessage: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    agent: z.ZodObject<{
+        version: z.ZodString;
+        image: z.ZodString;
+        image_id: z.ZodString;
+    }, z.core.$strip>;
+    host: z.ZodObject<{
+        cpu_count: z.ZodNumber;
+        os_name: z.ZodNullable<z.ZodString>;
+        kernel: z.ZodString;
+    }, z.core.$strip>;
+    public_ip: z.ZodNullable<z.ZodString>;
+    country: z.ZodNullable<z.ZodString>;
+    config: z.ZodObject<{
+        slots: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt_hint: z.ZodString;
+        }, z.core.$strip>>;
+        pinned_ip: z.ZodNullable<z.ZodString>;
+        controller: z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>;
+        auto_update: z.ZodBoolean;
+        demo_upload: z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value_sha256: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        memory_mb: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    slot_status: z.ZodArray<z.ZodObject<{
+        slot_id: z.ZodString;
+        state: z.ZodEnum<{
+            idle: "idle";
+            starting: "starting";
+            running: "running";
+            stopping: "stopping";
+        }>;
+        allocation_id: z.ZodNullable<z.ZodUUID>;
+        match_id: z.ZodNullable<z.ZodUUID>;
+        plugin_online: z.ZodBoolean;
+        gslt_state: z.ZodEnum<{
+            ok: "ok";
+            invalid: "invalid";
+            unchecked: "unchecked";
+        }>;
+        reserved: z.ZodBoolean;
+        server_steam_id: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    cs2: z.ZodObject<{
+        build_id: z.ZodNullable<z.ZodString>;
+        latest_build_id: z.ZodNullable<z.ZodString>;
+        image: z.ZodString;
+        image_id: z.ZodNullable<z.ZodString>;
+        update: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            mode: z.ZodEnum<{
+                update: "update";
+                verify: "verify";
+                reinstall: "reinstall";
+            }>;
+            automatic: z.ZodBoolean;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+                unobserved: "unobserved";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        image_update: z.ZodNullable<z.ZodObject<{
+            image: z.ZodString;
+            step: z.ZodNullable<z.ZodEnum<{
+                pulling: "pulling";
+                switching: "switching";
+            }>>;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    unavailable: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+            readonly maintenance: "maintenance";
+            /**
+             * The agent cannot use the local store that keeps gameplay events until the controller takes
+             * them. `detail` says why.
+             * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+             *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+             * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+             *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+             *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+             */
+            readonly eventStorage: "event_storage";
+            /**
+             * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+             * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+             * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+             * sooner is taken if the disk has room by then.
+             */
+            readonly diskSpace: "disk_space";
+        }>;
+        operation: z.ZodNullable<z.ZodEnum<{
+            cs2_update: "cs2_update";
+            agent_update: "agent_update";
+            cs2_image_update: "cs2_image_update";
+            image_cleanup: "image_cleanup";
+        }>>;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    demos: z.ZodArray<z.ZodObject<{
+        slot_id: z.ZodString;
+        file_name: z.ZodString;
+        size_bytes: z.ZodNumber;
+        modified_at: z.ZodNumber;
+        recording: z.ZodBoolean;
+        uploading: z.ZodBoolean;
+        upload_error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    server_exits: z.ZodArray<z.ZodObject<{
+        slot_id: z.ZodString;
+        allocation_id: z.ZodUUID;
+        reason: z.ZodEnum<{
+            idle_empty: "idle_empty";
+            config_rejected: "config_rejected";
+            start_timeout: "start_timeout";
+            quit_timeout: "quit_timeout";
+            slot_removed: "slot_removed";
+            requested: "requested";
+            clean_exit: "clean_exit";
+            crashed: "crashed";
+            launch_failed: "launch_failed";
+            lost: "lost";
+        }>;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    event_backlog: z.ZodObject<{
+        servers: z.ZodArray<z.ZodObject<{
+            allocation_id: z.ZodUUID;
+            pending: z.ZodNumber;
+        }, z.core.$strip>>;
+        server_count: z.ZodNumber;
+        event_count: z.ZodNumber;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    agent_update: z.ZodNullable<z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodNullable<z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            unchanged: "unchanged";
+            pull_failed: "pull_failed";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"node_status">;
+    cs2: z.ZodObject<{
+        build_id: z.ZodNullable<z.ZodString>;
+        latest_build_id: z.ZodNullable<z.ZodString>;
+        image: z.ZodString;
+        image_id: z.ZodNullable<z.ZodString>;
+        update: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            mode: z.ZodEnum<{
+                update: "update";
+                verify: "verify";
+                reinstall: "reinstall";
+            }>;
+            automatic: z.ZodBoolean;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+                unobserved: "unobserved";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        image_update: z.ZodNullable<z.ZodObject<{
+            image: z.ZodString;
+            step: z.ZodNullable<z.ZodEnum<{
+                pulling: "pulling";
+                switching: "switching";
+            }>>;
+            outcome: z.ZodNullable<z.ZodEnum<{
+                failed: "failed";
+                completed: "completed";
+                pull_failed: "pull_failed";
+                overlay_failed: "overlay_failed";
+            }>>;
+            detail: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    unavailable: z.ZodNullable<z.ZodObject<{
+        code: z.ZodEnum<{
+            /** The {@link MaintenanceOperation} in `operation` runs. It clears when the operation ends. */
+            readonly maintenance: "maintenance";
+            /**
+             * The agent cannot use the local store that keeps gameplay events until the controller takes
+             * them. `detail` says why.
+             * - If a call to the store waits past its limit, as on a disk that hangs, the code clears once
+             *   the store answers. Deleting the store or restarting the agent loses what waits to be written.
+             * - If the agent cannot open the store, such as one that a newer agent wrote, a corrupt file or
+             *   one it cannot write, the code lasts until a restart. Update the agent, or delete the store on
+             *   the host and restart the agent. Deleting it loses the events and server exits it keeps.
+             */
+            readonly eventStorage: "event_storage";
+            /**
+             * The disk under the agent's data directory has less than {@link DISK_SPACE_MIN_BYTES} free, too
+             * little for a match's events and demo. The agent asks the disk every 30 seconds and before each
+             * launch, so the code clears within 30 seconds of space being freed, and a launch that arrives
+             * sooner is taken if the disk has room by then.
+             */
+            readonly diskSpace: "disk_space";
+        }>;
+        operation: z.ZodNullable<z.ZodEnum<{
+            cs2_update: "cs2_update";
+            agent_update: "agent_update";
+            cs2_image_update: "cs2_image_update";
+            image_cleanup: "image_cleanup";
+        }>>;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    agent_update: z.ZodNullable<z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodNullable<z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>>;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            completed: "completed";
+            unchanged: "unchanged";
+            pull_failed: "pull_failed";
+        }>>;
+        detail: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"shutdown">;
+    signal: z.ZodEnum<{
+        SIGINT: "SIGINT";
+        SIGTERM: "SIGTERM";
+        SIGQUIT: "SIGQUIT";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    slot_id: z.ZodString;
+    state: z.ZodEnum<{
+        idle: "idle";
+        starting: "starting";
+        running: "running";
+        stopping: "stopping";
+    }>;
+    allocation_id: z.ZodNullable<z.ZodUUID>;
+    match_id: z.ZodNullable<z.ZodUUID>;
+    plugin_online: z.ZodBoolean;
+    gslt_state: z.ZodEnum<{
+        ok: "ok";
+        invalid: "invalid";
+        unchecked: "unchecked";
+    }>;
+    reserved: z.ZodBoolean;
+    server_steam_id: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"slot_status">;
+}, z.core.$strip>, z.ZodObject<{
+    slot_id: z.ZodString;
+    allocation_id: z.ZodUUID;
+    reason: z.ZodEnum<{
+        idle_empty: "idle_empty";
+        config_rejected: "config_rejected";
+        start_timeout: "start_timeout";
+        quit_timeout: "quit_timeout";
+        slot_removed: "slot_removed";
+        requested: "requested";
+        clean_exit: "clean_exit";
+        crashed: "crashed";
+        launch_failed: "launch_failed";
+        lost: "lost";
+    }>;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    detail: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"server_exited">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"log_batch">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"cs2_update">;
+        update_id: z.ZodUUID;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"server">;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>], "kind">;
+    replay_id: z.ZodNullable<z.ZodString>;
+    reset: z.ZodBoolean;
+    lines: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        level: z.ZodNullable<z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+        }>>;
+        line: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"log_index">;
+    sources: z.ZodArray<z.ZodObject<{
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"cs2_update">;
+            update_id: z.ZodUUID;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"server">;
+            allocation_id: z.ZodUUID;
+        }, z.core.$strip>], "kind">;
+        line_count: z.ZodNumber;
+        last_line_at: z.ZodNullable<z.ZodNumber>;
+        ended: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cs2_update_progress">;
+    update_id: z.ZodUUID;
+    percent: z.ZodNullable<z.ZodNumber>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    size_bytes: z.ZodNumber;
+    modified_at: z.ZodNumber;
+    recording: z.ZodBoolean;
+    uploading: z.ZodBoolean;
+    upload_error: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"demo">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"demo_removed">;
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    reason: z.ZodEnum<{
+        uploaded: "uploaded";
+        deleted: "deleted";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"demo_progress">;
+    slot_id: z.ZodString;
+    file_name: z.ZodString;
+    sent_bytes: z.ZodNumber;
+    bytes_per_second: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"resource_batch">;
+    ticks: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        disk: z.ZodNullable<z.ZodObject<{
+            cap: z.ZodNumber;
+            used: z.ZodNumber;
+        }, z.core.$strip>>;
+        memory: z.ZodObject<{
+            cap: z.ZodNumber;
+            used: z.ZodNumber;
+        }, z.core.$strip>;
+        cpu: z.ZodNullable<z.ZodObject<{
+            max: z.ZodNumber;
+            average: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    reset: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    servers: z.ZodArray<z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        pending: z.ZodNumber;
+    }, z.core.$strip>>;
+    server_count: z.ZodNumber;
+    event_count: z.ZodNumber;
+    reason: z.ZodNullable<z.ZodString>;
+    type: z.ZodLiteral<"event_backlog">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"phase_change">;
+    allocation_id: z.ZodUUID;
+    phase: z.ZodEnum<{
+        side_choice: "side_choice";
+        knife: "knife";
+        loading: "loading";
+        warmup: "warmup";
+        pending_restore: "pending_restore";
+        live: "live";
+        post_live: "post_live";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"score">;
+    allocation_id: z.ZodUUID;
+    team1_score: z.ZodNumber;
+    team2_score: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"backup">;
+    allocation_id: z.ZodUUID;
+    backup: z.ZodObject<{
+        roster: z.ZodObject<{
+            team1: z.ZodObject<{
+                name: z.ZodString;
+                players: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            team2: z.ZodObject<{
+                name: z.ZodString;
+                players: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            spectators: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        team1_side: z.ZodEnum<{
+            t: "t";
+            ct: "ct";
+        }>;
+        rules: z.ZodObject<{
+            max_rounds: z.ZodNumber;
+            overtime: z.ZodBoolean;
+            overtime_max_rounds: z.ZodNumber;
+            friendly_fire: z.ZodBoolean;
+        }, z.core.$strip>;
+        file: z.ZodString;
+        round: z.ZodNumber;
+        team1_score: z.ZodNumber;
+        team2_score: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        tick: z.ZodNumber;
+        type: z.ZodLiteral<"round_backup">;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"start_server">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        slot_id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"stop_server">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"get_server_status">;
+    data: z.ZodObject<{
+        map_name: z.ZodString;
+        match: z.ZodNullable<z.ZodObject<{
+            match_id: z.ZodNullable<z.ZodUUID>;
+            phase: z.ZodEnum<{
+                side_choice: "side_choice";
+                knife: "knife";
+                loading: "loading";
+                warmup: "warmup";
+                pending_restore: "pending_restore";
+                live: "live";
+                post_live: "post_live";
+            }>;
+            team1_side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+            }>;
+            team2_side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+            }>;
+            team1_score: z.ZodNumber;
+            team2_score: z.ZodNumber;
+        }, z.core.$strip>>;
+        players: z.ZodArray<z.ZodObject<{
+            steam_id: z.ZodString;
+            name: z.ZodString;
+            side: z.ZodEnum<{
+                t: "t";
+                ct: "ct";
+                spec: "spec";
+            }>;
+        }, z.core.$strip>>;
+        config_error: z.ZodNullable<z.ZodString>;
+        ready: z.ZodBoolean;
+        server_steam_id: z.ZodNullable<z.ZodString>;
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_cs2">;
+    data: z.ZodObject<{
+        update_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"delete_demo">;
+    data: z.ZodObject<{
+        slot_id: z.ZodString;
+        file_name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"reserve_slot">;
+    data: z.ZodObject<{
+        slot_id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"set_config">;
+    data: z.ZodObject<{
+        slots: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            port: z.ZodNumber;
+            tv_port: z.ZodNumber;
+            gslt_hint: z.ZodString;
+        }, z.core.$strip>>;
+        pinned_ip: z.ZodNullable<z.ZodString>;
+        controller: z.ZodObject<{
+            host: z.ZodString;
+            tls: z.ZodBoolean;
+            socket_path: z.ZodString;
+            events_path: z.ZodString;
+        }, z.core.$strip>;
+        auto_update: z.ZodBoolean;
+        demo_upload: z.ZodNullable<z.ZodObject<{
+            url: z.ZodURL;
+            limit_mbit: z.ZodNullable<z.ZodNumber>;
+            header: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                value_sha256: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        memory_mb: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_agent">;
+    data: z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+            unchanged: "unchanged";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"update_cs2_image">;
+    data: z.ZodObject<{
+        image: z.ZodString;
+        step: z.ZodEnum<{
+            pulling: "pulling";
+            switching: "switching";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"console_command">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"restore_round">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+        round: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    ok: z.ZodLiteral<true>;
+    request: z.ZodLiteral<"start_match">;
+    data: z.ZodObject<{
+        allocation_id: z.ZodUUID;
+    }, z.core.$strip>;
+}, z.core.$strip>], "request">, z.ZodObject<{
+    type: z.ZodLiteral<"reply">;
+    reply_to: z.ZodString;
+    request: z.ZodNullable<z.ZodEnum<{
+        start_server: "start_server";
+        stop_server: "stop_server";
+        update_cs2: "update_cs2";
+        delete_demo: "delete_demo";
+        reserve_slot: "reserve_slot";
+        set_config: "set_config";
+        update_agent: "update_agent";
+        update_cs2_image: "update_cs2_image";
+        console_command: "console_command";
+        restore_round: "restore_round";
+        start_match: "start_match";
+        get_server_status: "get_server_status";
+    }>>;
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            /** No slot is idle, unreserved and on a token Steam has not refused. */
+            readonly noFreeSlot: "no_free_slot";
+            /**
+             * A newer public CS2 build is out and the node has not updated to it yet, so its `cs2.build_id`
+             * is behind `cs2.latest_build_id`. The node takes launches again once it has updated. A node
+             * whose `auto_update` is `false` never refuses with this.
+             */
+            readonly cs2Outdated: "cs2_outdated";
+            /**
+             * CS2 is not installed on the node, so its `cs2.build_id` is `null`. The node takes launches once
+             * an {@link ControllerUpdateCs2 | update_cs2} has installed it.
+             */
+            readonly cs2NotInstalled: "cs2_not_installed";
+            /** The node reports `unavailable` for a reason other than `maintenance`. */
+            readonly nodeUnavailable: "node_unavailable";
+            /**
+             * An operation that needs every slot idle found one held: {@link ControllerUpdateCs2 | update_cs2}, or a
+             * {@link ControllerSetConfig | set_config} that changes any key under `controller`.
+             */
+            readonly slotsHeld: "slots_held";
+            /**
+             * A slot holds a server that is `starting`, `running` or `stopping`, and
+             * {@link ControllerSetConfig | set_config} would remove or re-port the slot or give its server's token
+             * to another slot, or {@link ControllerReserveSlot | reserve_slot} asked for it. `detail` names the
+             * slots.
+             */
+            readonly slotHeld: "slot_held";
+            /** The node has no slot with that id. */
+            readonly unknownSlot: "unknown_slot";
+            /**
+             * {@link ControllerSetConfig | set_config} kept the token of a slot the node does not have yet. A new
+             * slot needs a new token.
+             */
+            readonly slotTokenRequired: "slot_token_required";
+            /**
+             * {@link ControllerSetConfig | set_config} kept the value of a demo upload header the node does not
+             * send. A new header needs its value.
+             */
+            readonly demoHeaderValueRequired: "demo_header_value_required";
+            /** No server with that allocation id. */
+            readonly unknownAllocation: "unknown_allocation";
+            /**
+             * A maintenance operation runs on the node. That operation is unaffected, and `unavailable` shows
+             * it as `maintenance`.
+             */
+            readonly maintenanceRunning: "maintenance_running";
+            /**
+             * The image is not on the node and the request asked for no pull. Asking again with `pull`
+             * fetches it.
+             */
+            readonly imageMissing: "image_missing";
+            /**
+             * The image is not an official one, and the node's `official_images_only` is on. The node's
+             * operator decides which images it runs.
+             */
+            readonly imageNotAllowed: "image_not_allowed";
+            /** The demo is uploading. It can be deleted once the upload ends. */
+            readonly demoUploading: "demo_uploading";
+            /** The slot has no demo of that name, such as one an upload or a delete has already removed. */
+            readonly unknownDemo: "unknown_demo";
+            /** The demo is still being recorded. It can be deleted once its server ends the recording. */
+            readonly demoRecording: "demo_recording";
+            /** The server's plugin is not connected to the agent, or left before it answered. */
+            readonly pluginOffline: "plugin_offline";
+            /**
+             * The plugin did not answer {@link ControllerGetServerStatus | get_server_status},
+             * {@link ControllerConsoleCommand | console_command}, {@link ControllerStartMatch | start_match} or
+             * {@link ControllerRestoreRound | restore_round} within {@link SERVER_STATUS_TIMEOUT_MS}.
+             */
+            readonly pluginStatusTimeout: "plugin_status_timeout";
+            /** The server runs without a match. */
+            readonly noMatch: "no_match";
+            /** The match is past its warmup. */
+            readonly notInWarmup: "not_in_warmup";
+            /** A team has no player connected. */
+            readonly teamEmpty: "team_empty";
+            /** The match is not live, such as in warmup, during the knife round or after it ended. */
+            readonly notLive: "not_live";
+            /**
+             * The match is in its halftime break, while the sides are about to swap. Ask again once the next
+             * round has started.
+             */
+            readonly atHalftime: "at_halftime";
+            /**
+             * The node has no backup of the round that {@link ControllerRestoreRound | restore_round} named for that
+             * server.
+             */
+            readonly noBackup: "no_backup";
+            /** The request did not match its schema. */
+            readonly invalidRequest: "invalid_request";
+            /**
+             * {@link ControllerStartServer | start_server} named an allocation this node is already launching or
+             * running. Its server exists or is on its way, as after a {@link ControllerStartServer | start_server}
+             * sent again when its reply was slow.
+             */
+            readonly allocationInUse: "allocation_in_use";
+            /**
+             * {@link ControllerStartServer | start_server} named an allocation that this node launched before, among
+             * the last {@link REMEMBERED_ALLOCATIONS}. The node files a server's events and demos under its
+             * allocation, so every launch needs a new one.
+             */
+            readonly allocationReused: "allocation_reused";
+            /** The agent does not know the request's `type`, or the plugin the command's. */
+            readonly unsupportedRequest: "unsupported_request";
+            /**
+             * The agent is stopping and started no work for the request, as after its
+             * {@link AgentShutdown | shutdown}. Send the request again once the node reconnects.
+             */
+            readonly shuttingDown: "shutting_down";
+            /** Any failure that no other code names, such as a Docker failure. */
+            readonly failed: "failed";
+        }>;
+        detail: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>], "ok">], "type">;
+export type AgentToControllerMessage = z.infer<typeof AgentToControllerMessage>;