@leaflow/sdk 0.0.0-dev.51.g1857c7d → 0.0.0-dev.513.g3807ace

package/dist/fleet/v1/generated/models.d.ts

@@ -0,0 +1,1730 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Fleet API
+ * Machines that run the Leaflow Fleet Agent (`leaflow-fleet-agent`): adding machines, the
+ * accounts and groups that log in to them, running commands, opening and closing sessions, with
+ * or without a desktop, and admitting participants to them.
+ *
+ * ## What this API sees
+ *
+ * This API coordinates. It admits participants to sessions and passes the signaling of their
+ * PeerConnections, but everything a session shows or receives — terminals, files, the screen,
+ * input, the clipboard, printing and privilege approvals on a participant — travels end to end
+ * between the participant and the session, encrypted with keys that never leave them. The
+ * platform sees which machine, which session and who is connected, and nothing of what happens
+ * inside.
+ *
+ * Commands and privilege requests decided on the platform are the exception: the platform passes
+ * a command and its output between the caller and the machine, and keeps the command line of a
+ * privilege request it asks the owner about; it sees both.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * **Neither the path nor the headers carry a `project_id`**: the current project is determined by
+ * the token.
+ *
+ * ## Adding a machine
+ *
+ * 1. Install the Agent and run `leaflow-fleet-agent daemon enroll` on the machine. The command
+ *    carries no secret. The machine shows a pairing code such as `7K2QM-9XWTD`.
+ * 2. Find the request with `GET /api/v1/enrollments:find?pairing_code=…`. Compare its `hostname`
+ *    and `source_address` with the machine in front of you: the pairing code is not a secret,
+ *    and anyone can request enrollment.
+ * 3. Approve it with `POST /api/v1/enrollments/{enrollmentId}:approve`. The machine joins the
+ *    current project within its next polling interval.
+ *
+ * ## Adding a machine without interaction
+ *
+ * A machine that is set up unattended, such as by cloud-init on first boot, joins with a
+ * registration token instead of a pairing code:
+ *
+ * 1. Create a registration with `POST /api/v1/machine-registrations`. It reserves a machine in
+ *    the current project under the given name and returns its `machine_id` and a `token`. The
+ *    token is returned only in this response.
+ * 2. Give the token to the machine in a file that only root can read, and run
+ *    `leaflow-fleet-agent daemon enroll --url <control endpoint> --token-file <path>`. The
+ *    machine joins the current project as `machine_id` at once, and the Agent deletes the file.
+ *
+ * A token enrolls one machine once, and only until the registration expires. Anyone who reads
+ * the token before the machine uses it can enroll a key of their own instead, so pass it only
+ * to the machine, keep its lifetime short, and compare the `public_key` of the used
+ * registration with the key the machine shows when that matters. Revoke a registration that
+ * will not be used with `DELETE /api/v1/machine-registrations/{registrationId}`.
+ *
+ * ## Trusting a machine's key
+ *
+ * Each machine has an Ed25519 key that it generates itself and that never leaves it. Participants
+ * verify that key end to end before they exchange any data with a session, so a client must
+ * decide which key belongs to a machine without relying on any party in between:
+ *
+ * - When approving an enrollment, recompute the pairing code from `public_key` and compare it
+ *   with the code the machine shows. The code is derived as documented for
+ *   `EnrollMachineResponse.pairing_code` in `leaflow/fleet/machine/v1/machine.proto`.
+ *   Approve only when they match, and remember the key for the machine.
+ * - On any other client, remember the key the first time it connects to the machine, and
+ *   refuse to continue whenever the machine later proves a different key. The fingerprint can
+ *   be compared with the one the Agent prints on the machine.
+ *
+ * A machine that is reinstalled enrolls again as a new machine with a new key.
+ *
+ * ## Features
+ *
+ * A machine reports what it offers in `features`, each named after the protocol package that
+ * defines it:
+ *
+ * - `leaflow.fleet.directory.v1`: the accounts of the project's members and the project's groups
+ *   exist on the machine; members log in over SSH with their keys and become root through sudo
+ *   as their permissions allow;
+ * - `leaflow.fleet.command.v1`: running commands;
+ * - `leaflow.fleet.mcp.v1`: the MCP servers each account configures on the machine, local ones
+ *   and remote ones it connects to;
+ * - `leaflow.fleet.host.v1`: terminal sessions, with programs, files, ports, sound, devices,
+ *   printers and privilege approvals;
+ * - `leaflow.fleet.virtualdesktop.host.v1`: sessions with a graphical backend;
+ * - `leaflow.fleet.tool.v1`: live session tools. Builtin `computer.*` tools are exposed only while
+ *   the virtual desktop capability is actually available; MCP is a separate source.
+ *
+ * A graphical backend does not require a full desktop environment. When the machine reports
+ * graphical capability available, terminal logins and commands prepare or reuse the account's
+ * lightweight graphical context, in addition to their own session or job. Without graphical
+ * capability, ordinary commands and terminal sessions run without creating a graphical context
+ * or injecting X environment variables. MCP server initialization prepares or reuses a graphical
+ * context; configuration reads and writes do not initialize a server or require this preparation.
+ * A request that needs a feature the machine does not report available fails with
+ * `FEATURE_UNAVAILABLE`, whose `metadata.feature` names it.
+ *
+ * ## Directory
+ *
+ * Every user has one account, as with Google Cloud OS Login: a username and a uid that are the
+ * same on every machine of every project. The account is created the first time the user may log
+ * in to a machine or opens a session; its username comes from the email address, such as
+ * `alice_example_com` for `alice@example.com`, and its owner can change it. A project's machines
+ * know the accounts of the project's members and the groups the project defines. A member who
+ * leaves the project can no longer log in, and files keep their owner.
+ *
+ * Who may log in to which machines, and who may become root there through sudo, are permissions
+ * of the project's roles: `fleet:machines.login` and `fleet:machines.admin`, each for all
+ * machines or for chosen ones. Changes reach the machines within about a minute, and every login
+ * and elevation is checked against the current permissions while the machine is connected. To
+ * keep a member out of some machines, deny them `fleet:machines.login` on those machines.
+ * Elevation through sudo is never approved by a password; see "Approving sudo".
+ *
+ * Members log in over SSH with the SSH keys of their own accounts (`/account/v1/me/ssh-keys` on
+ * the account API), while they may log in to the machine.
+ *
+ * Machines resolve directory accounts and groups themselves and never write them into their local
+ * account files. A local account or group that already uses a name or id of the directory keeps
+ * it, and the machine records the conflict among its events.
+ *
+ * ## Running commands
+ *
+ * `POST /api/v1/machines/{machineId}:runCommand` runs one command line on the machine as the
+ * caller's account, as `ssh machine 'command'` would, but without SSH: the machine needs no open
+ * port, no distributed key and no address the caller can reach. Like logging in, it requires
+ * `fleet:machines.login` on the machine. Inside the command, `sudo` works without a prompt for
+ * a caller with `fleet:machines.admin` on the machine: the request approves the elevation.
+ *
+ * ## MCP servers
+ *
+ * A machine that offers `leaflow.fleet.mcp.v1` reaches the MCP servers its accounts configure:
+ * servers it runs itself and remote servers it connects to. Each account configures them in
+ * `~/.local/share/leaflow/agent/mcp.json` in its home directory, in the `mcpServers` format other
+ * MCP clients use, by hand or through this API; the machine picks up every change by itself.
+ * The caller's servers run as the caller's account, and the requests below act on them only.
+ *
+ * The configuration stays on the machine. The values of `env` and `headers` often hold
+ * credentials: this API writes them, and they then pass through the platform, but never returns
+ * them. Arguments, URLs, tool arguments and tool results pass through the platform as they are.
+ *
+ * ## Approving sudo
+ *
+ * An account may become root through sudo on a machine while its user has
+ * `fleet:machines.admin` there. Each elevation is approved, in the first of these ways that
+ * applies:
+ *
+ * - inside a command run through this API, by the request itself;
+ * - by the user's automatic approval for the machine, for a while or until removed
+ *   (`PUT /api/v1/machines/{machineId}/privilege-auto-approval`), in one of two modes:
+ *   - `automatic_review`, the recommended one: a large language model reviews each request and
+ *     approves or denies it with a reason. It stops most dangerous requests, but not all of
+ *     them. Each review is a request to Canopy, the model platform, through the project's
+ *     Canopy service, and may incur Canopy charges; the project needs Canopy enabled. A
+ *     request that cannot be reviewed, such as when the project has not enabled Canopy or the
+ *     review does not complete in time, is denied with a reason saying so;
+ *   - `always_approve`: every request is approved at once. This is dangerous: any program that
+ *     runs as the account, such as a script or an AI agent, becomes root without anyone being
+ *     asked;
+ * - by the user, on any of their devices, for a request listed by `GET /api/v1/privilege-requests`
+ *   (`POST …:approve` or `…:deny`), or on a participant of the session the asking process belongs
+ *   to. A request nobody decides expires, and sudo fails.
+ *
+ * A denied sudo shows whoever ran it the reason, when the denial gave one.
+ *
+ * Requests reach the user's devices as they happen through EventBus: the event
+ * `leaflow.fleet.privilege.requested` when one waits for the user and
+ * `leaflow.fleet.privilege.decided` when it ends, each addressed to the user in the current
+ * project and carrying the request's `id`. Requests decided without asking the user raise
+ * neither. A client that subscribes to them needs no polling; one that does not can list the
+ * pending requests.
+ *
+ * ## Connections that drop
+ *
+ * A machine's Agent and a session's process each keep a connection to the service, and on a poor
+ * network it may drop and come back within seconds. Requests do not fail for that:
+ *
+ * - A request that needs the machine or the session's process waits while it connects again,
+ *   for as long as the request would wait for its answer, and fails with `MACHINE_OFFLINE` or
+ *   `SESSION_UNAVAILABLE` only when it does not come back in that time.
+ * - What the machine or the session's process received before its connection dropped, such as a
+ *   command or a session being opened, goes on, and its result is returned once it has
+ *   connected again within that time.
+ *
+ * A machine stays `online` for up to a minute after its connection was lost, while its Agent
+ * connects again; a machine whose Agent stops is offline at once.
+ *
+ * ## Operations that do not exist
+ *
+ * Some resources lack an operation on purpose:
+ *
+ * - Accounts are created when they are first needed and are never deleted, so that files keep
+ *   their owner.
+ * - Enrollment requests are made only by machines.
+ * - A machine registration cannot be changed; revoke it and create another.
+ * - Machine events are a log: they are listed, never changed, and kept for 30 days.
+ * - A privilege request is decided only by the user whose account asks, or on a participant of
+ *   the session it comes from.
+ *
+ * ## Joining a session
+ *
+ * 1. Have an Ed25519 key, for as long as the client wants: one per participant or one kept by
+ *    the client. The private key must never leave the client; in a browser, use a
+ *    non-extractable WebCrypto key.
+ * 2. Get the ICE servers with `GET /api/v1/sessions/{sessionId}/rtc-configuration`, create a
+ *    PeerConnection with them and its data channels (`leaflow/fleet/transport/v1/transport.proto`)
+ *    and make an offer. Wait briefly for ICE candidates, such as until gathering completes or
+ *    one second has passed, so that the offer carries them.
+ * 3. Join with `POST /api/v1/sessions/{sessionId}/participants`, sending the public key and the
+ *    offer. The answer carries the participant's signed authorization, the keys the service
+ *    signs with, and the first PeerConnection: the session's SDP answer, the ICE candidates it
+ *    has passed so far and the signed PeerAuthorization. Pass candidates gathered later with
+ *    `POST …/participants/{participantId}/peer-connections/{peerConnectionId}/candidates`, and
+ *    read the session's later ones with
+ *    `GET …/participants/{participantId}/peer-connections/{peerConnectionId}` until
+ *    `candidates_complete`.
+ * 4. Renew the participant with `POST …/participants/{participantId}:renew` well before
+ *    `lease_expires_at`, every 15 seconds, presenting the PeerAuthorization of each
+ *    PeerConnection; the answer renews them. A participant whose lease runs out ends, and its
+ *    PeerConnections stop within 30 seconds of their last lease.
+ * 5. When a path fails, start another PeerConnection with
+ *    `POST …/participants/{participantId}/peer-connections` and move the connection to it with
+ *    `:prepareMigration` and `:commitMigration`. Abandon a PeerConnection that does not
+ *    connect with `DELETE …/peer-connections/{peerConnectionId}`.
+ * 6. Leave with `DELETE …/participants/{participantId}`.
+ *
+ * Signaling travels only through these requests; a participant holds no other connection to
+ * the service.
+ *
+ * What a participant may do in a session is decided when it is created, from the caller's
+ * permissions and what the request asks for, and does not change afterwards. Participants are not
+ * told apart by kind: a person in a browser and a program that operates the session are both
+ * participants, named by the `client_name` they choose, and either can be disconnected.
+ *
+ * Every participant that ends, including through `DELETE`, is announced through EventBus as
+ * `leaflow.fleet.participant.ended`, addressed to its user in the current project, with its
+ * `session_id`, `participant_id` (a decimal string) and `reason`: `left` when its user ended it,
+ * `removed` when someone else did, `lease_expired` when it was not renewed in time,
+ * `session_ended` when its session ended, `session_process_lost` when the session's process did
+ * not come back in time, `permission_revoked` when a permission it was created with was revoked
+ * from its user, `membership_ended` when its user is no longer a member of the project,
+ * `user_inactive` when its user's account was suspended or banned or its deletion was requested,
+ * `project_deletion_requested` when deletion of the project was requested, `machine_removed` when
+ * its machine was removed, or `key_revoked` when the key that signed its authorization was
+ * revoked. A participant whose creation failed is not announced.
+ * OpenAPI spec version: 1.0.0
+ */
+export interface FieldViolation {
+    /** The path to the rejected field in the request body, such as `items[2].price_id`. */
+    field: string;
+    /** Why the field was rejected, such as `REQUIRED` or `OUT_OF_RANGE`. */
+    reason?: string;
+}
+/**
+ * Values that belong to `reason`, one set per reason. Clients use them to fill in
+ * localized text and never parse `message` to obtain them. Keys are documented per
+ * reason; a key that has appeared once keeps appearing.
+ */
+export type ErrorStatusMetadata = {
+    [key: string]: string;
+};
+export interface ErrorStatus {
+    /** The HTTP status code of the response. */
+    code: number;
+    /** The canonical name of the status, such as `INVALID_ARGUMENT` or `UNAVAILABLE`. */
+    status: string;
+    /**
+     * A description of the failure for developers. It is always English and is not meant
+     * to be shown to end users as is.
+     */
+    message: string;
+    /**
+     * A stable machine-readable code identifying the failure. Clients branch on this value
+     * and render their own text; it does not change once published.
+     */
+    reason?: string;
+    /**
+     * Values that belong to `reason`, one set per reason. Clients use them to fill in
+     * localized text and never parse `message` to obtain them. Keys are documented per
+     * reason; a key that has appeared once keeps appearing.
+     */
+    metadata?: ErrorStatusMetadata;
+    /**
+     * Request fields rejected by the request's constraints. Present on validation
+     * failures; one request may violate several fields.
+     */
+    field_violations?: FieldViolation[];
+    /**
+     * How long the client should wait before retrying, as a duration string such as
+     * `30s`. Present only when waiting can succeed.
+     */
+    retry_delay?: string;
+    /**
+     * The identifier of the request in the service's logs. Quote it when reporting a
+     * failure.
+     */
+    request_id?: string;
+}
+/**
+ * A failed request. The envelope follows the Google REST error format: `code` is the HTTP
+ * status, `status` is its canonical name, and `reason` is the stable machine-readable code
+ * that identifies the failure.
+ */
+export interface Error {
+    error: ErrorStatus;
+}
+/**
+ * Which object this is, together with what a person currently calls it.
+ *
+ * The name is for display. It is chosen by whoever owns the object, it changes, it is not unique
+ * between objects, and it may be empty when nobody has named it yet — so it must not be used to
+ * address, match or deduplicate anything. Addressing is by id.
+ *
+ * This differs from an identity carrying a lookup key: a lookup key is written once by an operator,
+ * is unique, and can be used to fetch the object. A name cannot.
+ */
+export interface NamedIdentity {
+    id: string;
+    /** @maxLength 255 */
+    name: string;
+}
+/**
+ * An Ed25519 public key (RFC 8032), 32 bytes in standard Base64 (RFC 4648)
+ * @pattern ^[A-Za-z0-9+/]{43}=$
+ */
+export type PublicKey = string;
+/**
+ * The operating system, from the machine's /etc/os-release
+ */
+export interface OperatingSystem {
+    /** ID=, such as `debian` */
+    id: string;
+    /** VERSION_ID=, such as `13` */
+    version_id: string;
+    /** PRETTY_NAME=, such as `Debian GNU/Linux 13 (trixie)` */
+    pretty_name: string;
+}
+/**
+ * `available` can be used now. `unavailable` is installed but cannot be used, as `reason` says.
+ */
+export type FeatureState = (typeof FeatureState)[keyof typeof FeatureState];
+export declare const FeatureState: {
+    readonly available: "available";
+    readonly unavailable: "unavailable";
+};
+export interface MachineFeature {
+    /** The protocol package that defines the feature, such as `leaflow.fleet.command.v1` */
+    name: string;
+    state: FeatureState;
+    /** Why it cannot be used, such as `Xwayland is not installed`; empty while available */
+    reason: string;
+    /** What it can do on this machine, as the dotted names its package defines, such as `audio.pipewire` */
+    details: string[];
+}
+export interface MachineResource {
+    id: string;
+    /** @maxLength 128 */
+    name: string;
+    /** The host name the machine last reported */
+    hostname: string;
+    public_key: PublicKey;
+    /**
+     * The machine's Agent is connected, or lost its connection less than a minute ago and
+     * may connect again
+     */
+    online: boolean;
+    /** Null until the machine has reported once */
+    operating_system: OperatingSystem | null;
+    /** Such as `6.12.43+deb13-amd64`; empty until the machine has reported once */
+    kernel_release: string;
+    /** Such as `x86_64`; empty until the machine has reported once */
+    architecture: string;
+    /** What the machine offers; empty until the machine has reported once */
+    features: MachineFeature[];
+    /** The Agent software the machine last connected with */
+    agent_version: string;
+    /** The machine serves the project's current directory */
+    directory_synced: boolean;
+    /** When the machine was added to the project */
+    created_at: string;
+    updated_at: string;
+}
+export interface MachineList {
+    items: MachineResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+/**
+ * `directory_account_conflict`: an account is not served on the machine because a local
+ * account uses its name or uid, or its uid is among the subordinate ids of a local user;
+ * metadata `username`, and `conflict` `name`, `uid` or `subordinate`.
+ * `directory_group_conflict`: a group is not served because a local group uses its name or
+ * gid, or its gid is among the subordinate ids of a local user; metadata `groupName`, and
+ * `conflict` `name`, `gid` or `subordinate`.
+ */
+export type MachineEventType = (typeof MachineEventType)[keyof typeof MachineEventType];
+export declare const MachineEventType: {
+    readonly directory_account_conflict: "directory_account_conflict";
+    readonly directory_group_conflict: "directory_group_conflict";
+};
+/**
+ * The values of the event, with the keys its type names
+ */
+export type MachineEventResourceMetadata = {
+    [key: string]: string;
+};
+export interface MachineEventResource {
+    id: string;
+    type: MachineEventType;
+    /** The values of the event, with the keys its type names */
+    metadata: MachineEventResourceMetadata;
+    /** When it happened, on the machine's clock */
+    occurred_at: string;
+    /** When the service recorded it */
+    created_at: string;
+}
+export interface MachineEventList {
+    items: MachineEventResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+export interface UpdateMachineRequest {
+    /**
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+/**
+ * `pending` waits for a decision. `approved` added the machine to a project. `denied` is
+ * final for the machine's key.
+ */
+export type EnrollmentState = (typeof EnrollmentState)[keyof typeof EnrollmentState];
+export declare const EnrollmentState: {
+    readonly pending: "pending";
+    readonly approved: "approved";
+    readonly denied: "denied";
+};
+export interface EnrollmentResource {
+    id: string;
+    /** The code the machine shows, `XXXXX-XXXXX` */
+    pairing_code: string;
+    public_key: PublicKey;
+    /** The host name the machine reported; chosen by whoever runs the machine */
+    hostname: string;
+    /** The IP address the request came from */
+    source_address: string;
+    state: EnrollmentState;
+    /**
+     * The machine, once the request is approved
+     * @nullable
+     */
+    machine_id?: string | null;
+    /** When the machine first asked to enroll */
+    created_at: string;
+    /** When the machine last polled */
+    last_seen_at: string;
+}
+/**
+ * `enrollment` is the pending request with that pairing code, absent when there is none.
+ */
+export interface FindEnrollmentResponse {
+    enrollment?: EnrollmentResource;
+}
+export interface ApproveEnrollmentRequest {
+    /**
+     * The name of the machine in the project
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+}
+/**
+ * `pending` waits for a machine to use the token; `used` enrolled a machine; `expired` was not
+ * used in time; `revoked` was revoked before it was used.
+ */
+export type MachineRegistrationState = (typeof MachineRegistrationState)[keyof typeof MachineRegistrationState];
+export declare const MachineRegistrationState: {
+    readonly pending: "pending";
+    readonly used: "used";
+    readonly expired: "expired";
+    readonly revoked: "revoked";
+};
+export interface MachineRegistrationResource {
+    id: string;
+    /** The machine that the registration's token enrolls */
+    machine_id: string;
+    /** The name of the machine in the project */
+    name: string;
+    state: MachineRegistrationState;
+    created_at: string;
+    /** When the token stops enrolling a machine */
+    expires_at: string;
+    /**
+     * When a machine used the token; null until then
+     * @nullable
+     */
+    used_at: string | null;
+    /** The key of the machine that used the token; null until then */
+    public_key: PublicKey | null;
+    /**
+     * The IP address the machine used the token from; null until then
+     * @nullable
+     */
+    source_address: string | null;
+}
+export interface MachineRegistrationList {
+    items: MachineRegistrationResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+export interface CreateMachineRegistrationRequest {
+    /**
+     * The name of the machine in the project
+     * @minLength 1
+     * @maxLength 128
+     */
+    name: string;
+    /**
+     * How long the token can be used, from now
+     * @minimum 60
+     * @maximum 86400
+     */
+    expires_in_seconds?: number;
+}
+export interface CreateMachineRegistrationResponse {
+    registration: MachineRegistrationResource;
+    /**
+     * The token to give to the machine, returned only in this response. A secret: anyone who
+     * has it can enroll a machine into the current project until it is used, expires or is
+     * revoked. Never put it in a URL.
+     */
+    token: string;
+}
+/**
+ * A username or a group name, as useradd(8) and groupadd(8) accept it
+ * @minLength 1
+ * @maxLength 32
+ * @pattern ^[a-z_][a-z0-9_-]*$
+ */
+export type DirectoryName = string;
+export interface AccountResource {
+    id: string;
+    user: NamedIdentity;
+    /** The login name on every machine */
+    username: string;
+    /** The user id on every machine */
+    uid: number;
+    /** The id of the account's own group, which has its username as name */
+    gid: number;
+    /** The full name on the machines */
+    display_name: string;
+    home_directory: string;
+    shell: string;
+    /** The names of the project's groups the account is in, besides its own */
+    groups: string[];
+    created_at: string;
+    updated_at: string;
+}
+export interface AccountList {
+    items: AccountResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+export interface UpdateAccountRequest {
+    username?: DirectoryName;
+    /**
+     * An absolute path, such as `/bin/bash`
+     * @minLength 2
+     * @maxLength 255
+     * @pattern ^/[^\s:]+$
+     */
+    shell?: string;
+}
+export interface GroupResource {
+    id: string;
+    name: string;
+    /** The group id on every machine of the project */
+    gid: number;
+    /** @minimum 0 */
+    member_count: number;
+    created_at: string;
+    updated_at: string;
+}
+export interface GroupList {
+    items: GroupResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+export interface CreateGroupRequest {
+    name: DirectoryName;
+}
+export interface UpdateGroupRequest {
+    name: DirectoryName;
+}
+export interface CreateGroupMemberRequest {
+    account_id: string;
+}
+/**
+ * `desktop` runs a desktop environment and shows it as one canvas. `seamless` shows every
+ * application window on its own.
+ */
+export type SessionMode = (typeof SessionMode)[keyof typeof SessionMode];
+export declare const SessionMode: {
+    readonly desktop: "desktop";
+    readonly seamless: "seamless";
+};
+/**
+ * `opening` starts; `open` runs; `closing` is ending; `closed` has ended.
+ */
+export type SessionState = (typeof SessionState)[keyof typeof SessionState];
+export declare const SessionState: {
+    readonly opening: "opening";
+    readonly open: "open";
+    readonly closing: "closing";
+    readonly closed: "closed";
+};
+/**
+ * Why a session ended. `close_requested` and `terminate_requested` follow a request;
+ * `logout` the user logged out, such as when the shell of a terminal session exited;
+ * `disconnected_timeout`, `no_participant_timeout` and `max_lifetime` a time limit passed;
+ * `display_exit` and `process_lost` the session failed; `open_failed` it never opened;
+ * `access_revoked` its user may no longer log in;
+ * `machine_restarted` the machine restarted; `unknown` the machine no longer reports it.
+ */
+export type SessionCloseReason = (typeof SessionCloseReason)[keyof typeof SessionCloseReason];
+export declare const SessionCloseReason: {
+    readonly close_requested: "close_requested";
+    readonly terminate_requested: "terminate_requested";
+    readonly logout: "logout";
+    readonly disconnected_timeout: "disconnected_timeout";
+    readonly no_participant_timeout: "no_participant_timeout";
+    readonly max_lifetime: "max_lifetime";
+    readonly display_exit: "display_exit";
+    readonly process_lost: "process_lost";
+    readonly open_failed: "open_failed";
+    readonly access_revoked: "access_revoked";
+    readonly machine_restarted: "machine_restarted";
+    readonly unknown: "unknown";
+};
+export interface DesktopState {
+    mode: SessionMode;
+    /** The X display, such as `:100` */
+    display: string;
+}
+export interface SessionResource {
+    id: string;
+    machine_id: string;
+    user: NamedIdentity;
+    /** The Linux user the session runs as; `user` is the project member who owns the session */
+    username: string;
+    state: SessionState;
+    /** The session's desktop; null for a session without one */
+    desktop: DesktopState | null;
+    /**
+     * The session's process is connected to the service, so participants can join and start
+     * PeerConnections. False while it connects again, such as after it restarted; such
+     * requests then wait for it and fail with `SESSION_UNAVAILABLE` only if it does not come
+     * back in time.
+     */
+    process_connected: boolean;
+    /**
+     * The last input of a person in the session
+     * @nullable
+     */
+    last_input_at: string | null;
+    /** Null until the session is closed */
+    close_reason: SessionCloseReason | null;
+    created_at: string;
+    /** @nullable */
+    closed_at: string | null;
+}
+export interface SessionList {
+    items: SessionResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+/**
+ * A desktop for the session, on a machine that offers `leaflow.fleet.virtualdesktop.host.v1`
+ */
+export interface DesktopOptions {
+    mode: SessionMode;
+    /**
+     * The first width of the canvas, normally the participant's; the machine's default when omitted
+     * @minimum 320
+     * @maximum 16384
+     */
+    width?: number;
+    /**
+     * The first height of the canvas; given together with `width`
+     * @minimum 200
+     * @maximum 16384
+     */
+    height?: number;
+    /**
+     * In `desktop` mode, the desktop environment to start: a detail of the machine's
+     * `leaflow.fleet.virtualdesktop.host.v1` feature without its `desktop.` prefix, such as
+     * `XFCE`; the machine's default when omitted
+     * @maxLength 128
+     */
+    session_desktop?: string;
+}
+export interface CreateSessionRequest {
+    machine_id: string;
+    desktop?: DesktopOptions;
+}
+export interface RunCommandRequest {
+    /**
+     * The command line, which the account's login shell runs with `-c`; at most 65536 bytes and no NUL
+     * @minLength 1
+     * @maxLength 65536
+     */
+    command: string;
+    /**
+     * Kills the command, and every process it started, this long after it started
+     * @minimum 1
+     * @maximum 300
+     */
+    timeout_seconds?: number;
+}
+export interface RunCommandResponse {
+    /**
+     * The status it exited with, 0 being success; null when a signal ended it
+     * @nullable
+     */
+    exit_status: number | null;
+    /**
+     * The signal that ended it, such as 9 when the timeout killed it; null when it exited
+     * @nullable
+     */
+    signal: number | null;
+    /** The timeout ended it */
+    timed_out: boolean;
+    /** What it wrote to standard output, at most 1 MiB, in standard Base64 */
+    stdout: string;
+    /** `stdout` is cut short */
+    stdout_truncated: boolean;
+    /** What it wrote to standard error, at most 1 MiB, in standard Base64 */
+    stderr: string;
+    /** `stderr` is cut short */
+    stderr_truncated: boolean;
+}
+/**
+ * `ok` when the file was read in full; `missing` when there is none, which is no server;
+ * `unreadable` when it cannot be read and `invalid` when it is not an object with an
+ * object `mcpServers`: then the machine serves the servers of the file it last read in
+ * full, if any, and none otherwise.
+ */
+export type McpConfigurationFileState = (typeof McpConfigurationFileState)[keyof typeof McpConfigurationFileState];
+export declare const McpConfigurationFileState: {
+    readonly ok: "ok";
+    readonly missing: "missing";
+    readonly unreadable: "unreadable";
+    readonly invalid: "invalid";
+};
+export interface McpConfigurationFile {
+    /**
+     * `ok` when the file was read in full; `missing` when there is none, which is no server;
+     * `unreadable` when it cannot be read and `invalid` when it is not an object with an
+     * object `mcpServers`: then the machine serves the servers of the file it last read in
+     * full, if any, and none otherwise.
+     */
+    state: McpConfigurationFileState;
+    /**
+     * SHA-256 of the file in lower-case hex, empty while it is `missing`. Edits carry it as
+     * `expected_revision`, so that they fail rather than undo an edit made in between.
+     */
+    revision: string;
+    /**
+     * With `invalid`, the line of the first error, counted from 1; null otherwise
+     * @nullable
+     */
+    invalid_line: number | null;
+    /**
+     * With `invalid`, the column of the first error, counted from 1; null otherwise
+     * @nullable
+     */
+    invalid_column: number | null;
+    /**
+     * The name, in the file's directory, under which the machine set aside a file that was not
+     * valid when it started to serve the account, and put an empty configuration in its place;
+     * null when it did not
+     * @nullable
+     */
+    set_aside: string | null;
+}
+/**
+ * `stdio` for a program the machine starts as the account, `http` for Streamable HTTP
+ */
+export type McpTransport = (typeof McpTransport)[keyof typeof McpTransport];
+export declare const McpTransport: {
+    readonly stdio: "stdio";
+    readonly http: "http";
+};
+/**
+ * `stopped` before its first use or after it was idle, `starting`, `running`, `failed`
+ * (it is tried again when next used), `disabled` or `invalid`
+ */
+export type McpServerResourceState = (typeof McpServerResourceState)[keyof typeof McpServerResourceState];
+export declare const McpServerResourceState: {
+    readonly stopped: "stopped";
+    readonly starting: "starting";
+    readonly running: "running";
+    readonly failed: "failed";
+    readonly disabled: "disabled";
+    readonly invalid: "invalid";
+};
+/**
+ * Why a server failed or is not valid: `invalid_definition`, `start_failed` (its program could
+ * not be started), `exited`, `unreachable`, `unauthorized` (it asked for authorization the
+ * headers do not give, such as through OAuth), `protocol_error` or `timeout`
+ */
+export type McpServerFailure = (typeof McpServerFailure)[keyof typeof McpServerFailure];
+export declare const McpServerFailure: {
+    readonly invalid_definition: "invalid_definition";
+    readonly start_failed: "start_failed";
+    readonly exited: "exited";
+    readonly unreachable: "unreachable";
+    readonly unauthorized: "unauthorized";
+    readonly protocol_error: "protocol_error";
+    readonly timeout: "timeout";
+};
+export interface McpImplementation {
+    name: string;
+    version: string;
+    title?: string;
+}
+export interface McpServerResource {
+    /** Its key in `mcpServers` */
+    name: string;
+    transport: McpTransport;
+    /** With `stdio`, the program */
+    command: string;
+    args: string[];
+    /** The variables `env` sets; their values are never returned */
+    env_keys: string[];
+    /** With `http`, the endpoint */
+    url: string;
+    /** The headers `headers` sends; their values are never returned */
+    header_keys: string[];
+    /** Configured but kept stopped */
+    disabled: boolean;
+    /**
+     * `stopped` before its first use or after it was idle, `starting`, `running`, `failed`
+     * (it is tried again when next used), `disabled` or `invalid`
+     */
+    state: McpServerResourceState;
+    /** With `failed` and `invalid`, why; null otherwise */
+    failure: McpServerFailure | null;
+    /** With `running`, what the server said of itself; null otherwise */
+    implementation: McpImplementation | null;
+    /**
+     * With `running`, how many tools it offers; null otherwise
+     * @nullable
+     */
+    tool_count: number | null;
+}
+export interface McpConfigurationResource {
+    file: McpConfigurationFile;
+    servers: McpServerResource[];
+}
+/**
+ * With `stdio`, variables added to the account's environment
+ */
+export type UpdateMcpServerRequestEnv = {
+    [key: string]: string;
+};
+/**
+ * With `http`, headers sent with every request
+ */
+export type UpdateMcpServerRequestHeaders = {
+    [key: string]: string;
+};
+export interface UpdateMcpServerRequest {
+    /** Unset for `stdio` with `command` and `http` with `url` */
+    transport?: McpTransport;
+    /**
+     * With `stdio`, the program, looked up in the account's `PATH`
+     * @maxLength 4096
+     */
+    command?: string;
+    /**
+     * With `stdio`; shown to anyone who reads the configuration, so no place for credentials
+     * @maxItems 256
+     * @items.maxLength 65536
+     */
+    args?: string[];
+    /** With `stdio`, variables added to the account's environment */
+    env?: UpdateMcpServerRequestEnv;
+    /**
+     * With `http`, the endpoint; shown to anyone who reads the configuration
+     * @maxLength 4096
+     */
+    url?: string;
+    /** With `http`, headers sent with every request */
+    headers?: UpdateMcpServerRequestHeaders;
+    /** Configured but kept stopped */
+    disabled?: boolean;
+    /**
+     * Variables of the server's current `env` whose values stay as they are
+     * @maxItems 256
+     */
+    keep_env?: string[];
+    /**
+     * Headers of the server's current `headers` whose values stay as they are
+     * @maxItems 256
+     */
+    keep_headers?: string[];
+    /**
+     * The configuration's `revision` as last read; absent only for one that was `missing`
+     * @maxLength 64
+     */
+    expected_revision?: string;
+}
+export interface UpdateMcpServerResponse {
+    file: McpConfigurationFile;
+    server: McpServerResource;
+}
+/**
+ * The new file, an object with an object `mcpServers`, at most 1 MiB as JSON
+ */
+export type ReplaceMcpConfigurationRequestContent = {
+    [key: string]: unknown;
+};
+export interface ReplaceMcpConfigurationRequest {
+    /** The new file, an object with an object `mcpServers`, at most 1 MiB as JSON */
+    content: ReplaceMcpConfigurationRequestContent;
+    /**
+     * The configuration's `revision` as last read; absent replaces whatever is there, such as
+     * a file that cannot be read
+     * @maxLength 64
+     */
+    expected_revision?: string;
+}
+/**
+ * One JSON-RPC 2.0 request of MCP, at most 4 MiB
+ */
+export type SendMcpRequestRequestRequest = {
+    [key: string]: unknown;
+};
+export interface SendMcpRequestRequest {
+    /** One JSON-RPC 2.0 request of MCP, at most 4 MiB */
+    request: SendMcpRequestRequestRequest;
+    /**
+     * How long to wait for the response
+     * @minimum 1
+     * @maximum 300
+     */
+    timeout_seconds?: number;
+}
+/**
+ * The server's JSON-RPC 2.0 response, with the id of the request
+ */
+export type SendMcpRequestResponseResponse = {
+    [key: string]: unknown;
+};
+export interface SendMcpRequestResponse {
+    /** The server's JSON-RPC 2.0 response, with the id of the request */
+    response: SendMcpRequestResponseResponse;
+}
+/**
+ * Whether the tool is builtin or comes from an MCP server. For filtering only.
+ */
+export type ToolDescriptorSource = (typeof ToolDescriptorSource)[keyof typeof ToolDescriptorSource];
+export declare const ToolDescriptorSource: {
+    readonly builtin: "builtin";
+    readonly mcp: "mcp";
+};
+export type ToolDescriptorInputSchema = {
+    [key: string]: unknown;
+};
+export type ToolDescriptorOutputSchema = {
+    [key: string]: unknown;
+};
+/**
+ * Untrusted display metadata; never grants authorization
+ */
+export type ToolDescriptorMetadata = {
+    [key: string]: unknown;
+};
+export interface ToolDescriptor {
+    /**
+     * The name to call it by. Builtin tools are named computer.*; MCP tools are named
+     * `<server>__<tool>`, so a name selects exactly one tool.
+     * @minLength 1
+     * @maxLength 194
+     */
+    name: string;
+    /** Whether the tool is builtin or comes from an MCP server. For filtering only. */
+    source: ToolDescriptorSource;
+    title: string;
+    description: string;
+    input_schema: ToolDescriptorInputSchema;
+    output_schema?: ToolDescriptorOutputSchema;
+    /** Untrusted display metadata; never grants authorization */
+    metadata?: ToolDescriptorMetadata;
+}
+export type ToolListUnavailableSourcesItemSource = (typeof ToolListUnavailableSourcesItemSource)[keyof typeof ToolListUnavailableSourcesItemSource];
+export declare const ToolListUnavailableSourcesItemSource: {
+    readonly builtin: "builtin";
+    readonly mcp: "mcp";
+};
+export type ToolListUnavailableSourcesItem = {
+    source: ToolListUnavailableSourcesItemSource;
+    mcp_server: string;
+    code: number;
+    reason: string;
+};
+export interface ToolList {
+    session_id: string;
+    items: ToolDescriptor[];
+    next_page_token: string;
+    unavailable_sources: ToolListUnavailableSourcesItem[];
+}
+/**
+ * A JSON object, at most 256 KiB when encoded
+ */
+export type CallToolRequestArguments = {
+    [key: string]: unknown;
+};
+export interface CallToolRequest {
+    client_instance_id: string;
+    /**
+     * The name from list-tools. Builtin tools are computer.*; MCP tools are
+     * `<server>__<tool>`. The name selects the tool; source is not part of the call.
+     * @minLength 1
+     * @maxLength 194
+     */
+    tool: string;
+    /** A JSON object, at most 256 KiB when encoded */
+    arguments: CallToolRequestArguments;
+    read_only?: boolean;
+    /**
+     * @minimum 1
+     * @maximum 240
+     */
+    timeout_seconds?: number;
+}
+/**
+ * Untrusted content extensions such as MCP annotations or _meta, without duplicated body or image data
+ */
+export type ToolContentMetadata = {
+    [key: string]: unknown;
+};
+/**
+ * An unrecognized external content block, preserved as data
+ */
+export type ToolContentJson = {
+    [key: string]: unknown;
+};
+export type ToolImageMimeType = (typeof ToolImageMimeType)[keyof typeof ToolImageMimeType];
+export declare const ToolImageMimeType: {
+    readonly "image/png": "image/png";
+    readonly "image/jpeg": "image/jpeg";
+    readonly "image/webp": "image/webp";
+};
+/**
+ * ScreenshotContext in protobuf JSON with original field names: reference, window_id,
+ * area, windows (including resize_counter and shape_counter), captured_at, revision,
+ * quiet. uint64 values are decimal strings to preserve precision. Images do not change
+ * this original geometry. The opaque reference binds coordinate actions to this capture.
+ */
+export type ToolImageScreenshot = {
+    [key: string]: unknown;
+};
+export interface ToolImage {
+    /** Base64 of Agent's original encoded image bytes, never a URL */
+    data: string;
+    mime_type: ToolImageMimeType;
+    /** @minimum 1 */
+    width: number;
+    /** @minimum 1 */
+    height: number;
+    /**
+     * ScreenshotContext in protobuf JSON with original field names: reference, window_id,
+     * area, windows (including resize_counter and shape_counter), captured_at, revision,
+     * quiet. uint64 values are decimal strings to preserve precision. Images do not change
+     * this original geometry. The opaque reference binds coordinate actions to this capture.
+     */
+    screenshot?: ToolImageScreenshot;
+}
+/**
+ * Exactly one of text, image or json is present
+ */
+export interface ToolContent {
+    /** Untrusted content extensions such as MCP annotations or _meta, without duplicated body or image data */
+    metadata?: ToolContentMetadata;
+    text?: string;
+    image?: ToolImage;
+    /** An unrecognized external content block, preserved as data */
+    json?: ToolContentJson;
+}
+export type CallToolResponseStructuredContent = {
+    [key: string]: unknown;
+};
+/**
+ * Untrusted result extensions such as MCP _meta, without duplicated content or images
+ */
+export type CallToolResponseMetadata = {
+    [key: string]: unknown;
+};
+export interface CallToolResponse {
+    session_id: string;
+    operation_id: string;
+    content: ToolContent[];
+    structured_content?: CallToolResponseStructuredContent;
+    /** Untrusted result extensions such as MCP _meta, without duplicated content or images */
+    metadata?: CallToolResponseMetadata;
+    is_error: boolean;
+}
+/**
+ * ToolActivity in protobuf JSON with original field names. Includes session_id,
+ * participant_id, operation_id, instance_id, sequence, observed_at, phase, action and
+ * optional target (window_id, position x/y, resize_counter, shape_counter). All uint64
+ * values are decimal strings. No input text, key values, arguments or image data.
+ */
+export type ToolActivityListItemsItem = {
+    [key: string]: unknown;
+};
+export interface ToolActivityList {
+    /** @maxItems 64 */
+    items: ToolActivityListItemsItem[];
+}
+/**
+ * The tool's arguments, as its `input_schema` describes them
+ */
+export type CallMcpToolRequestArguments = {
+    [key: string]: unknown;
+};
+export interface CallMcpToolRequest {
+    /** The tool's arguments, as its `input_schema` describes them */
+    arguments?: CallMcpToolRequestArguments;
+    /**
+     * How long to wait for the result
+     * @minimum 1
+     * @maximum 300
+     */
+    timeout_seconds?: number;
+}
+/**
+ * The tool's MCP `CallToolResult`, with `content`, `structuredContent` and `isError`
+ */
+export type CallMcpToolResponseResult = {
+    [key: string]: unknown;
+};
+export interface CallMcpToolResponse {
+    /** The tool's MCP `CallToolResult`, with `content`, `structuredContent` and `isError` */
+    result: CallMcpToolResponseResult;
+}
+/**
+ * How the caller's privilege requests on the machine are decided without asking them:
+ * - `automatic_review`, recommended: a large language model reviews each request from what
+ *   the machine reports about it, chiefly the command line, and approves or denies it with
+ *   a reason. It stops most dangerous requests, but not all of them. Each review is a
+ *   request to Canopy through the project's Canopy service and may incur Canopy charges. A
+ *   request that cannot be reviewed, such as when the project has not enabled Canopy, is
+ *   denied.
+ * - `always_approve`: every request is approved at once. Dangerous: any program that runs
+ *   as the account, such as a script or an AI agent, becomes root without anyone being
+ *   asked.
+ */
+export type PrivilegeAutoApprovalMode = (typeof PrivilegeAutoApprovalMode)[keyof typeof PrivilegeAutoApprovalMode];
+export declare const PrivilegeAutoApprovalMode: {
+    readonly automatic_review: "automatic_review";
+    readonly always_approve: "always_approve";
+};
+export interface UpdatePrivilegeAutoApprovalRequest {
+    mode: PrivilegeAutoApprovalMode;
+    /**
+     * When the automatic approval ends; null for one that lasts until removed
+     * @nullable
+     */
+    expires_at: string | null;
+}
+export interface PrivilegeAutoApprovalResource {
+    id: string;
+    machine_id: string;
+    mode: PrivilegeAutoApprovalMode;
+    /**
+     * When the automatic approval ends; null for one that lasts until removed
+     * @nullable
+     */
+    expires_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface PrivilegeAutoApprovalList {
+    items: PrivilegeAutoApprovalResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+/**
+ * Who decided a request on the platform: `user` the user, `always_approve` the user's
+ * automatic approval that approves every request, or `automatic_review` the large language
+ * model that reviewed it.
+ */
+export type PrivilegeDecider = (typeof PrivilegeDecider)[keyof typeof PrivilegeDecider];
+export declare const PrivilegeDecider: {
+    readonly user: "user";
+    readonly always_approve: "always_approve";
+    readonly automatic_review: "automatic_review";
+};
+export interface DenyPrivilegeRequestRequest {
+    /**
+     * Why, shown to whoever ran sudo: plain text without control characters
+     * @maxLength 200
+     */
+    reason?: string;
+}
+/**
+ * `pending` waits for a decision; `approved` and `denied` were decided on the platform, as
+ * `decided_by` tells; `expired` was not decided in time; `cancelled` means the machine
+ * stopped waiting for the platform, because a participant of the session decided first or
+ * the asking program gave up.
+ */
+export type PrivilegeRequestState = (typeof PrivilegeRequestState)[keyof typeof PrivilegeRequestState];
+export declare const PrivilegeRequestState: {
+    readonly pending: "pending";
+    readonly approved: "approved";
+    readonly denied: "denied";
+    readonly expired: "expired";
+    readonly cancelled: "cancelled";
+};
+export interface PrivilegeRequestResource {
+    id: string;
+    machine_id: string;
+    /**
+     * The session the asking program runs in; null when it runs in none, such as after an
+     * SSH login
+     * @maxLength 40
+     * @nullable
+     */
+    session_id: string | null;
+    /** The account that asks to become root */
+    username: string;
+    /** The PAM service that asks, such as `sudo` */
+    pam_service: string;
+    /**
+     * What the machine reports the asking program runs, at most 4 KiB, such as
+     * `sudo apt install foo`. A claim of the machine.
+     */
+    command_line: string;
+    /** Where the login came from, when the machine knows it */
+    remote_host: string;
+    /** The terminal, when the machine knows it, such as `/dev/pts/3` */
+    tty: string;
+    state: PrivilegeRequestState;
+    /** Who decided an `approved` or `denied` request; null in any other state */
+    decided_by: PrivilegeDecider | null;
+    /**
+     * Why the request was decided so: as the user gave it when denying, or as the automatic
+     * review gave it, including why a review could not be made; null when none was given
+     * @maxLength 200
+     * @nullable
+     */
+    reason: string | null;
+    created_at: string;
+    expires_at: string;
+    /**
+     * When the request stopped pending; null while pending
+     * @nullable
+     */
+    decided_at: string | null;
+}
+export interface PrivilegeRequestList {
+    items: PrivilegeRequestResource[];
+    /** @minimum 0 */
+    total_count: number;
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+}
+export interface ParticipantResource {
+    /** The participant; `participant_id` of the protocol */
+    id: number;
+    user: NamedIdentity;
+    /** The name the participant's client gave itself, such as `console` or `assistant`; neither unique nor verified */
+    client_name: string;
+    /** The participant may only watch */
+    read_only: boolean;
+    /** The capabilities granted to the participant, as permission names such as `fleet:files.transfer` */
+    permissions: string[];
+    /** The IP address the participant joined from; empty when it joined through a platform service */
+    source_address: string;
+    /** When the participant joined */
+    created_at: string;
+}
+export interface ParticipantList {
+    items: ParticipantResource[];
+}
+/**
+ * A message the service signed: the serialized message, the key that signed it and the
+ * signature, as in `SignedAuthorization` and `SignedPeerAuthorization` of the protocol. Each
+ * byte string is standard Base64.
+ */
+export interface SignedMessage {
+    key_id: string;
+    /** The serialized message; decode it only after the signature verified */
+    message: string;
+    signature: string;
+}
+/**
+ * A key the service signs with, as `SigningKeys` of the protocol
+ */
+export interface SigningKey {
+    key_id: string;
+    public_key: PublicKey;
+}
+/**
+ * A STUN or TURN server, as W3C RTCIceServer
+ */
+export interface IceServer {
+    urls: string[];
+    /** TURN only */
+    username?: string;
+    /** TURN only. A secret for the relay; never log it. */
+    credential?: string;
+}
+export type RtcConfigurationIceTransportPolicy = (typeof RtcConfigurationIceTransportPolicy)[keyof typeof RtcConfigurationIceTransportPolicy];
+export declare const RtcConfigurationIceTransportPolicy: {
+    readonly all: "all";
+    readonly relay: "relay";
+};
+/**
+ * The ICE servers for the PeerConnections the caller starts, as W3C RTCConfiguration
+ */
+export interface RtcConfiguration {
+    ice_servers: IceServer[];
+    ice_transport_policy: RtcConfigurationIceTransportPolicy;
+    /** No PeerConnection starts with these servers after this time */
+    expires_at: string;
+}
+/**
+ * An ICE candidate (RFC 8445), as W3C RTCIceCandidateInit
+ */
+export interface IceCandidate {
+    /**
+     * The candidate attribute; it names network addresses, so never log it
+     * @maxLength 4096
+     */
+    candidate: string;
+    /**
+     * The media stream identification tag of the candidate (RFC 5888)
+     * @maxLength 64
+     */
+    sdp_mid?: string;
+}
+/**
+ * One PeerConnection of a participant, as the session answered it. Set the answer as the
+ * remote description, add the candidates, and verify the authorization before sending
+ * application data; the SHA-256 of its `message` goes into `Hello.authorization_sha256`.
+ */
+export interface PeerConnection {
+    /** The PeerConnection; its 16 bytes are `peer_connection_id` of the transport protocol */
+    id: string;
+    /** The session's SDP answer (RFC 8866); it holds ICE credentials, so never log it */
+    answer: string;
+    /**
+     * The session's ICE candidates passed so far, at most 64, in the order the session sent
+     * them. Later reads return the same ones first.
+     * @maxItems 64
+     */
+    candidates: IceCandidate[];
+    /** The session reported that it has gathered all its candidates; no more follow */
+    candidates_complete: boolean;
+    /** The signed `PeerAuthorization` of the PeerConnection, the same one the session holds */
+    authorization: SignedMessage;
+}
+export interface CreateParticipantResponse {
+    participant: ParticipantResource;
+    /** The participant's signed `Authorization`, the same one the session holds */
+    authorization: SignedMessage;
+    /** The ICE servers for later PeerConnections of the participant */
+    rtc_configuration: RtcConfiguration;
+    signing_keys: SigningKey[];
+    /** When the participant ends unless renewed */
+    lease_expires_at: string;
+    /** The first PeerConnection, started with the request's offer */
+    peer_connection: PeerConnection;
+}
+export interface RenewParticipantRequest {
+    /**
+     * The current signed `PeerAuthorization` of each PeerConnection to renew
+     * @maxItems 8
+     */
+    peer_authorizations?: SignedMessage[];
+}
+export interface RenewParticipantResponse {
+    lease_expires_at: string;
+    /** The renewed signed `PeerAuthorization`s, in the order of the request */
+    peer_authorizations: SignedMessage[];
+    /** A renewed signed `Authorization`, when the current one nears its end */
+    authorization?: SignedMessage;
+    rtc_configuration: RtcConfiguration;
+    signing_keys: SigningKey[];
+}
+export type CreateParticipantRequestPermissionsItem = (typeof CreateParticipantRequestPermissionsItem)[keyof typeof CreateParticipantRequestPermissionsItem];
+export declare const CreateParticipantRequestPermissionsItem: {
+    readonly "fleet:filestransfer": "fleet:files.transfer";
+    readonly "fleet:clipboarduse": "fleet:clipboard.use";
+    readonly "fleet:terminaluse": "fleet:terminal.use";
+    readonly "fleet:portsforward": "fleet:ports.forward";
+    readonly "fleet:devicesuse": "fleet:devices.use";
+    readonly "fleet:printinguse": "fleet:printing.use";
+    readonly "fleet:ssh_agentuse": "fleet:ssh_agent.use";
+    readonly "fleet:privilegeapprove": "fleet:privilege.approve";
+    readonly "fleet:logsread": "fleet:logs.read";
+};
+export interface CreateParticipantRequest {
+    public_key: PublicKey;
+    /**
+     * A name for the client that joins, such as `console` or `assistant`, shown to the other participants. It is neither unique nor verified.
+     * @maxLength 64
+     */
+    client_name?: string;
+    /** The participant only watches, even if the caller may operate the session */
+    read_only?: boolean;
+    /**
+     * The capabilities the participant may use, as permission names such as
+     * `fleet:files.transfer`; when omitted, every capability the caller holds. A
+     * capability the caller does not hold is not granted.
+     * @maxItems 16
+     */
+    permissions?: CreateParticipantRequestPermissionsItem[];
+    /**
+     * The SDP offer (RFC 8866) of the first PeerConnection, with the ICE candidates gathered
+     * so far; it holds ICE credentials, so never log it
+     * @maxLength 65536
+     */
+    offer: string;
+}
+export interface CreatePeerConnectionRequest {
+    /**
+     * The SDP offer (RFC 8866) of the PeerConnection, with the ICE candidates gathered so
+     * far; it holds ICE credentials, so never log it
+     * @maxLength 65536
+     */
+    offer: string;
+}
+export interface CreatePeerConnectionCandidatesRequest {
+    /** @maxItems 64 */
+    candidates?: IceCandidate[];
+    /** The participant has gathered all its candidates */
+    end_of_candidates?: boolean;
+}
+export interface MigrationStep {
+    /**
+     * A serialized `Checkpoint` of `leaflow/fleet/transport/v1/transport.proto`
+     * @maxLength 262144
+     */
+    checkpoint: string;
+}
+/**
+ * Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan.
+ */
+export interface OffsetPagination {
+    /** @minimum 1 */
+    page: number;
+    /** @minimum 1 */
+    page_size: number;
+    /** @minimum 0 */
+    total_count?: number;
+}
+/**
+ * Pagination metadata for keyset traversal. Pass next_cursor as cursor to read the following page; null means there is no following page.
+ */
+export interface CursorPagination {
+    /** @minimum 1 */
+    page_size: number;
+    /** @nullable */
+    next_cursor?: string | null;
+}
+export type ListMachinesParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Match the machine name or host name, case-insensitively
+     * @maxLength 128
+     */
+    keyword?: string;
+};
+export type ListMachineEventsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Return only events of this type
+     */
+    type?: MachineEventType;
+};
+export type DeleteMcpServerParams = {
+    /**
+     * The configuration's `revision` as last read; absent only for one that was `missing`
+     * @maxLength 64
+     */
+    expected_revision?: string;
+};
+export type ListToolsParams = {
+    /**
+     * A UUID generated once per running client and reused for its lifetime. It separates
+     * concurrent callers of the same user and is not an authorization credential.
+     */
+    client_instance_id: string;
+    /**
+     * Return only tools of this source. A filter, not part of a tool's identity.
+     */
+    source?: ListToolsSource;
+    /**
+     * Return only this MCP server's tools.
+     * @maxLength 64
+     */
+    mcp_server?: string;
+    /**
+     * Words that each must occur in a tool's name, title or description, ignoring case.
+     * @maxLength 256
+     */
+    query?: string;
+    /**
+     * Sign the control authorization as read-only, so mutating tools are refused.
+     */
+    read_only?: boolean;
+    /**
+     * @minimum 1
+     * @maximum 100
+     */
+    page_size?: number;
+    /**
+     * @maxLength 4096
+     */
+    page_token?: string;
+};
+export type ListToolsSource = (typeof ListToolsSource)[keyof typeof ListToolsSource];
+export declare const ListToolsSource: {
+    readonly all: "all";
+    readonly builtin: "builtin";
+    readonly mcp: "mcp";
+};
+export type ListPrivilegeAutoApprovalsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListPrivilegeRequestsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Return only the requests in this state
+     */
+    state?: PrivilegeRequestState;
+    /**
+     * Return only the requests on this machine
+     */
+    machine_id?: string;
+};
+export type FindEnrollmentByPairingCodeParams = {
+    /**
+     * The code the machine shows, such as `7K2QM-9XWTD`
+     * @minLength 1
+     * @maxLength 32
+     */
+    pairing_code: string;
+};
+export type ListMachineRegistrationsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListAccountsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Return only the account of this member
+     */
+    user_id?: string;
+    /**
+     * Match the username or the display name, case-insensitively
+     * @maxLength 128
+     */
+    keyword?: string;
+};
+export type ListGroupsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListGroupMembersParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+};
+export type ListSessionsParams = {
+    /**
+     * 1-based page number. Defaults to 1.
+     * @minimum 1
+     * @maximum 2147483647
+     */
+    page?: number;
+    /**
+     * Items per page. Defaults to 50; at most 200.
+     * @minimum 1
+     * @maximum 200
+     */
+    page_size?: number;
+    /**
+     * Return only the sessions of this machine
+     */
+    machine_id?: string;
+    /**
+     * Return only the sessions of this member
+     */
+    user_id?: string;
+    /**
+     * Include closed sessions; defaults to false
+     */
+    include_closed?: boolean;
+};
+export type GetPeerConnectionParams = {
+    /**
+     * The number of the session's candidates the caller already has. The request waits until
+     * there are more or the session reported the end of its candidates, for at most 20
+     * seconds. Without it, the request returns at once.
+     * @minimum 0
+     * @maximum 64
+     */
+    known_candidates?: number;
+};