@leaflow/sdk 0.0.0-dev.47.g94a977a → 0.0.0-dev.472.g83cc4b9

package/dist/fleet/v1/generated/functions.js

@@ -0,0 +1,1681 @@
+export const getListMachinesUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/machines?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/machines`;
+};
+/**
+ * Returns the machines of the current project, newest first.
+ * @summary List machines
+ */
+export const listMachines = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMachinesUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetMachineUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}`;
+};
+/**
+ * @summary Get a machine
+ */
+export const getMachine = async (machineId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetMachineUrl(machineId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateMachineUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}`;
+};
+/**
+ * Changes the machine's name. Requires `fleet:machines.manage`.
+ * @summary Update a machine
+ */
+export const updateMachine = async (machineId, updateMachineRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateMachineUrl(machineId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateMachineRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteMachineUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}`;
+};
+/**
+ * Removes the machine from the project. Every participant of its sessions is disconnected at
+ * once and the Agent is refused from then on; to use the machine again, enroll it again.
+ * Sessions still open on the machine can no longer be reached and end according to their own
+ * timeouts. Nothing on the machine is deleted.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary Remove a machine
+ */
+export const deleteMachine = async (machineId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteMachineUrl(machineId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListMachineEventsUrl = (machineId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/events?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/events`;
+};
+/**
+ * Returns what the machine reported about itself, newest first, such as a directory account
+ * it does not serve because a local account uses its name. Events are kept for 30 days.
+ * @summary List the events of a machine
+ */
+export const listMachineEvents = async (machineId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMachineEventsUrl(machineId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRunMachineCommandUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}:runCommand`;
+};
+/**
+ * Runs one command line on the machine as the caller's account, with its login shell, and
+ * returns once it exited or was killed, with its exit status and what it wrote. Pipes,
+ * redirection and `&&` work; there is no terminal and no standard input. The machine admits
+ * the account through PAM as for a login. The account is created if the caller has none yet.
+ * A command that fails is still a successful request: its exit status is its result.
+ *
+ * Inside the command, `sudo` works without a prompt while the caller has
+ * `fleet:machines.admin` on the machine, and refuses otherwise.
+ *
+ * The request is held until the command ends, at most `timeout_seconds` and a few seconds
+ * more. Neither the command nor its output is hidden from the platform: do not put secrets
+ * into either.
+ *
+ * Requires `fleet:machines.login` on the machine.
+ *
+ * Fails with:
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer `leaflow.fleet.command.v1`;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, as for opening a session;
+ * - `COMMAND_START_FAILED` when the shell could not start; nothing ran;
+ * - `COMMAND_LOST` when the machine lost the command while it ran. The command may have run
+ *   in part, and its output is lost;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time. The command may have run.
+ * @summary Run a command
+ */
+export const runMachineCommand = async (machineId, runCommandRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRunMachineCommandUrl(machineId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(runCommandRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetMcpConfigurationUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-configuration`;
+};
+/**
+ * Returns the caller's MCP configuration file on the machine and every server in it, with
+ * what each is doing now. The values of `env` and `headers` are never returned, only their
+ * keys. Requires `fleet:machines.login` on the machine.
+ *
+ * Fails with:
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer `leaflow.fleet.mcp.v1`;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, as for opening a session;
+ * - `MCP_START_FAILED` when the machine could not start MCP for the caller's account;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time.
+ * @summary Get the caller's MCP configuration on a machine
+ */
+export const getMcpConfiguration = async (machineId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetMcpConfigurationUrl(machineId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getReplaceMcpConfigurationUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-configuration`;
+};
+/**
+ * Replaces the caller's MCP configuration file on the machine as a whole, also one that cannot
+ * be read or is not valid. The machine starts the servers that were added, stops the ones
+ * that were removed and restarts the ones that changed when they are next used. The account
+ * is created if the caller has none yet. The content, secrets included, passes through the
+ * platform. Requires `fleet:machines.login` on the machine.
+ *
+ * Fails with:
+ * - `MCP_CONFIGURATION_CHANGED` when the file is no longer at `expected_revision`;
+ * - `MCP_CONFIGURATION_INVALID` when `content` is not an object with an object `mcpServers`,
+ *   with `metadata.line` and `metadata.column`;
+ * - `MCP_CONFIGURATION_WRITE_FAILED` when the machine could not write the file;
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer `leaflow.fleet.mcp.v1`;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, as for opening a session;
+ * - `MCP_START_FAILED` when the machine could not start MCP for the caller's account;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time.
+ * @summary Replace the caller's MCP configuration on a machine
+ */
+export const replaceMcpConfiguration = async (machineId, replaceMcpConfigurationRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getReplaceMcpConfigurationUrl(machineId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(replaceMcpConfigurationRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateMcpServerUrl = (machineId, serverName) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-servers/${encodeURIComponent(String(serverName))}`;
+};
+/**
+ * Adds a server to the caller's MCP configuration on the machine, or replaces the one with
+ * the same name. The values of `env` and `headers` the request gives, secrets included, pass
+ * through the platform; those named in `keep_env` and `keep_headers` stay as they are on the
+ * machine. The account is created if the caller has none yet. Requires
+ * `fleet:machines.login` on the machine.
+ *
+ * Fails with:
+ * - `MCP_CONFIGURATION_CHANGED` when the file is no longer at `expected_revision`;
+ * - `MCP_CONFIGURATION_INVALID` when the file cannot be read or is not valid; replace it
+ *   whole first;
+ * - `MCP_CONFIGURATION_WRITE_FAILED` when the machine could not write the file;
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer `leaflow.fleet.mcp.v1`;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, as for opening a session;
+ * - `MCP_START_FAILED` when the machine could not start MCP for the caller's account;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time.
+ * @summary Add or replace an MCP server
+ */
+export const updateMcpServer = async (machineId, serverName, updateMcpServerRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateMcpServerUrl(machineId, serverName), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateMcpServerRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteMcpServerUrl = (machineId, serverName, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-servers/${encodeURIComponent(String(serverName))}?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-servers/${encodeURIComponent(String(serverName))}`;
+};
+/**
+ * Removes a server from the caller's MCP configuration on the machine and stops it. Removing
+ * one that is not configured succeeds. Requires `fleet:machines.login` on the machine.
+ *
+ * Fails as replacing a server does.
+ * @summary Remove an MCP server
+ */
+export const deleteMcpServer = async (machineId, serverName, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteMcpServerUrl(machineId, serverName, params), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getSendMcpRequestUrl = (machineId, serverName) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-servers/${encodeURIComponent(String(serverName))}:send`;
+};
+/**
+ * Sends one JSON-RPC request of MCP to one of the caller's servers on the machine, such as
+ * `tools/call`, `resources/read` or `prompts/get`, and returns the server's response. The
+ * machine starts or connects to the server if it is not running, and handles its
+ * initialization itself; a request still running when `timeout_seconds` passes is cancelled
+ * at the server. Requests the server makes of the client are answered as by a client that
+ * offers no sampling, elicitation or roots, and its notifications, such as of progress, are
+ * dropped. A response with a JSON-RPC error is a successful request. Neither the request nor
+ * the response is hidden from the platform. Requires `fleet:machines.login` on the machine.
+ *
+ * Fails with:
+ * - `MCP_SERVER_NOT_FOUND` when the server is not configured;
+ * - `MCP_SERVER_UNAVAILABLE` when it could not be started or reached, with
+ *   `metadata.failure`, an `McpServerFailure`;
+ * - `INVALID_ARGUMENT` when `request` is not one JSON-RPC request, such as a notification, or
+ *   is one of initialization;
+ * - `RESULT_TOO_LARGE` when the response is larger than 8 MiB;
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer `leaflow.fleet.mcp.v1`;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, as for opening a session;
+ * - `MCP_START_FAILED` when the machine could not start MCP for the caller's account;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time.
+ * @summary Send an MCP request to a server
+ */
+export const sendMcpRequest = async (machineId, serverName, sendMcpRequestRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getSendMcpRequestUrl(machineId, serverName), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(sendMcpRequestRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCallMcpToolUrl = (machineId, serverName, toolName) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-servers/${encodeURIComponent(String(serverName))}/tools/${encodeURIComponent(String(toolName))}:call`;
+};
+/**
+ * Calls one tool of one of the caller's servers on the machine and returns its MCP
+ * `CallToolResult`. A tool that reports an error, with `isError`, is a successful request. A
+ * tool whose name cannot appear in a path is called with `send-mcp-request`. Neither the
+ * arguments nor the result is hidden from the platform. Requires `fleet:machines.login` on
+ * the machine.
+ *
+ * Fails as sending a request does, and with `MCP_REQUEST_FAILED` when the server answers
+ * with a JSON-RPC error, such as for a tool it does not offer or arguments it does not
+ * accept, with the error's `metadata.code` and `metadata.message`.
+ * @summary Call an MCP tool
+ */
+export const callMcpTool = async (machineId, serverName, toolName, callMcpToolRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCallMcpToolUrl(machineId, serverName, toolName), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(callMcpToolRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListMcpToolsUrl = (machineId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-tools?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/mcp-tools`;
+};
+/**
+ * Lists the tools of the caller's servers on the machine, or of one of them, that match
+ * `query`: every word of it, ignoring case, in the tool's name, title or description. They
+ * are ordered by server, then by tool name. Servers that are not running are started to
+ * learn their tools; one that cannot be is named in `unavailable_servers`, and the others are
+ * listed anyway. Slow servers do not hold the request up: those still starting are named
+ * with `timeout` and go on starting, so that a later request lists their tools. Requires
+ * `fleet:machines.login` on the machine.
+ *
+ * Fails with:
+ * - `MCP_SERVER_NOT_FOUND` when `server` is not configured;
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer `leaflow.fleet.mcp.v1`;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, as for opening a session;
+ * - `MCP_START_FAILED` when the machine could not start MCP for the caller's account;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time.
+ * @summary List the caller's MCP tools on a machine
+ */
+export const listMcpTools = async (machineId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMcpToolsUrl(machineId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPrivilegeAutoApprovalUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/privilege-auto-approval`;
+};
+/**
+ * Returns the caller's automatic approval of their privilege requests on the machine. Fails
+ * with `PRIVILEGE_AUTO_APPROVAL_NOT_FOUND` while the caller is asked every time, including
+ * after its `expires_at` has passed.
+ * @summary Get the caller's automatic approval for a machine
+ */
+export const getPrivilegeAutoApproval = async (machineId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetPrivilegeAutoApprovalUrl(machineId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdatePrivilegeAutoApprovalUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/privilege-auto-approval`;
+};
+/**
+ * Has the caller's privilege requests on the machine decided without asking them, in
+ * `mode`, until `expires_at`, or until removed when `expires_at` is null, replacing any
+ * earlier automatic approval. `automatic_review` is recommended; with `always_approve` any
+ * program that runs as the account becomes root without anyone being asked. It applies to
+ * the caller's own account only, which is created if the caller has none yet, and only
+ * while they may become root on the machine. Fails with `INVALID_ARGUMENT` when
+ * `expires_at` has passed.
+ * @summary Decide the caller's privilege requests on a machine without asking
+ */
+export const updatePrivilegeAutoApproval = async (machineId, updatePrivilegeAutoApprovalRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdatePrivilegeAutoApprovalUrl(machineId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updatePrivilegeAutoApprovalRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeletePrivilegeAutoApprovalUrl = (machineId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machines/${encodeURIComponent(String(machineId))}/privilege-auto-approval`;
+};
+/**
+ * Removes it: the caller is asked about every later privilege request on the machine.
+ * Removing one that does not exist succeeds.
+ * @summary Remove the caller's automatic approval for a machine
+ */
+export const deletePrivilegeAutoApproval = async (machineId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeletePrivilegeAutoApprovalUrl(machineId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPrivilegeAutoApprovalsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/privilege-auto-approvals?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/privilege-auto-approvals`;
+};
+/**
+ * Returns the caller's automatic approvals on the machines of the current project that are
+ * in effect, the most recently set first.
+ * @summary List the caller's automatic approvals
+ */
+export const listPrivilegeAutoApprovals = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPrivilegeAutoApprovalsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListPrivilegeRequestsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/privilege-requests?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/privilege-requests`;
+};
+/**
+ * Returns the caller's privilege requests on the project's machines, newest first. Requests
+ * are kept for 30 days.
+ * @summary List the caller's privilege requests
+ */
+export const listPrivilegeRequests = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListPrivilegeRequestsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetPrivilegeRequestUrl = (requestId) => {
+    return `https://fleet.leaflow.cloud/api/v1/privilege-requests/${encodeURIComponent(String(requestId))}`;
+};
+/**
+ * Returns one of the caller's privilege requests.
+ * @summary Get a privilege request
+ */
+export const getPrivilegeRequest = async (requestId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetPrivilegeRequestUrl(requestId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getApprovePrivilegeRequestUrl = (requestId) => {
+    return `https://fleet.leaflow.cloud/api/v1/privilege-requests/${encodeURIComponent(String(requestId))}:approve`;
+};
+/**
+ * Approves one of the caller's pending requests; the waiting sudo goes on as root. Fails with
+ * `PRIVILEGE_REQUEST_CLOSED` when the request is no longer pending, with `metadata.state`
+ * giving how it ended.
+ * @summary Approve a privilege request
+ */
+export const approvePrivilegeRequest = async (requestId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getApprovePrivilegeRequestUrl(requestId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDenyPrivilegeRequestUrl = (requestId) => {
+    return `https://fleet.leaflow.cloud/api/v1/privilege-requests/${encodeURIComponent(String(requestId))}:deny`;
+};
+/**
+ * Denies one of the caller's pending requests; the waiting sudo fails and shows `reason`,
+ * when given, to whoever ran it. Fails with `PRIVILEGE_REQUEST_CLOSED` as for approving.
+ * @summary Deny a privilege request
+ */
+export const denyPrivilegeRequest = async (requestId, denyPrivilegeRequestRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getDenyPrivilegeRequestUrl(requestId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(denyPrivilegeRequestRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getFindEnrollmentByPairingCodeUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/enrollments:find?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/enrollments:find`;
+};
+/**
+ * Returns the pending enrollment request whose pairing code matches, or no enrollment when
+ * none does. Mistyped codes are expected and are not an error. Letters are matched
+ * case-insensitively, `I` and `L` are read as `1`, `O` as `0`, and spaces and hyphens are
+ * ignored.
+ *
+ * Only requests that are still pending are found. A request is pending while its machine
+ * keeps polling; one it stops polling expires after a few hours.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary Find an enrollment request by its pairing code
+ */
+export const findEnrollmentByPairingCode = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getFindEnrollmentByPairingCodeUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getApproveEnrollmentUrl = (enrollmentId) => {
+    return `https://fleet.leaflow.cloud/api/v1/enrollments/${encodeURIComponent(String(enrollmentId))}:approve`;
+};
+/**
+ * Adds the machine to the current project under the given name and returns it. The Agent
+ * learns the decision the next time it polls.
+ *
+ * A request that is no longer pending is rejected with `ENROLLMENT_NOT_PENDING`.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary Approve an enrollment request
+ */
+export const approveEnrollment = async (enrollmentId, approveEnrollmentRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getApproveEnrollmentUrl(enrollmentId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(approveEnrollmentRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDenyEnrollmentUrl = (enrollmentId) => {
+    return `https://fleet.leaflow.cloud/api/v1/enrollments/${encodeURIComponent(String(enrollmentId))}:deny`;
+};
+/**
+ * Refuses the request. The decision is final for the machine's key: the Agent stops
+ * polling and reports that it was denied.
+ *
+ * A request that is no longer pending is rejected with `ENROLLMENT_NOT_PENDING`.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary Deny an enrollment request
+ */
+export const denyEnrollment = async (enrollmentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDenyEnrollmentUrl(enrollmentId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListMachineRegistrationsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/machine-registrations?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/machine-registrations`;
+};
+/**
+ * Returns the registrations of the current project, newest first. Registrations are kept
+ * for 30 days.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary List machine registrations
+ */
+export const listMachineRegistrations = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMachineRegistrationsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateMachineRegistrationUrl = () => {
+    return `https://fleet.leaflow.cloud/api/v1/machine-registrations`;
+};
+/**
+ * Reserves a machine in the current project under the given name and returns the
+ * registration with a one-time token. A machine that presents the token when it enrolls
+ * joins the project as `registration.machine_id` without approval. The token is returned
+ * only in this response and cannot be read again.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary Create a machine registration
+ */
+export const createMachineRegistration = async (createMachineRegistrationRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateMachineRegistrationUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createMachineRegistrationRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetMachineRegistrationUrl = (registrationId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machine-registrations/${encodeURIComponent(String(registrationId))}`;
+};
+/**
+ * Requires `fleet:machines.manage`.
+ * @summary Get a machine registration
+ */
+export const getMachineRegistration = async (registrationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetMachineRegistrationUrl(registrationId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteMachineRegistrationUrl = (registrationId) => {
+    return `https://fleet.leaflow.cloud/api/v1/machine-registrations/${encodeURIComponent(String(registrationId))}`;
+};
+/**
+ * Revokes the registration: its token no longer enrolls a machine. Revoking a registration
+ * that is already revoked or expired succeeds and changes nothing else. A registration that
+ * a machine has used is rejected with `MACHINE_REGISTRATION_USED`; to remove that machine,
+ * delete the machine.
+ *
+ * Requires `fleet:machines.manage`.
+ * @summary Revoke a machine registration
+ */
+export const deleteMachineRegistration = async (registrationId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteMachineRegistrationUrl(registrationId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListAccountsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/accounts?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/accounts`;
+};
+/**
+ * Returns the accounts of the project's members, ordered by username. A member who has never
+ * been able to log in to a machine has no account yet.
+ * @summary List accounts
+ */
+export const listAccounts = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListAccountsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetAccountUrl = (accountId) => {
+    return `https://fleet.leaflow.cloud/api/v1/accounts/${encodeURIComponent(String(accountId))}`;
+};
+/**
+ * Returns the account of a member of the project.
+ * @summary Get an account
+ */
+export const getAccount = async (accountId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetAccountUrl(accountId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateAccountUrl = (accountId) => {
+    return `https://fleet.leaflow.cloud/api/v1/accounts/${encodeURIComponent(String(accountId))}`;
+};
+/**
+ * Changes the caller's own account, only the fields present in the request. The account is
+ * the same in every project, and a new username takes effect on the machines of all of them
+ * within about a minute; the uid stays, so files keep their owner.
+ *
+ * Fails with:
+ * - `ACCOUNT_NOT_OWNED` when the account is another member's;
+ * - `DIRECTORY_NAME_TAKEN` when another account or a group uses the username.
+ * @summary Update an account
+ */
+export const updateAccount = async (accountId, updateAccountRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateAccountUrl(accountId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateAccountRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListGroupsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/groups?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/groups`;
+};
+/**
+ * Returns the groups of the project's directory, ordered by name.
+ * @summary List groups
+ */
+export const listGroups = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListGroupsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateGroupUrl = () => {
+    return `https://fleet.leaflow.cloud/api/v1/groups`;
+};
+/**
+ * Creates a group in the project's directory. It reaches the machines within about a minute.
+ *
+ * Fails with `DIRECTORY_NAME_TAKEN` when an account, or another group of the project, uses the
+ * name.
+ *
+ * Requires `fleet:directory.manage`.
+ * @summary Create a group
+ */
+export const createGroup = async (createGroupRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateGroupUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createGroupRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetGroupUrl = (groupId) => {
+    return `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}`;
+};
+/**
+ * @summary Get a group
+ */
+export const getGroup = async (groupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetGroupUrl(groupId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getUpdateGroupUrl = (groupId) => {
+    return `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}`;
+};
+/**
+ * The gid stays, so files keep their group. Fails with `DIRECTORY_NAME_TAKEN` as for creating
+ * a group.
+ *
+ * Requires `fleet:directory.manage`.
+ * @summary Rename a group
+ */
+export const updateGroup = async (groupId, updateGroupRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getUpdateGroupUrl(groupId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateGroupRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteGroupUrl = (groupId) => {
+    return `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}`;
+};
+/**
+ * Removes the group from the directory. Machines stop resolving it within about a minute;
+ * files keep its gid.
+ *
+ * Requires `fleet:directory.manage`.
+ * @summary Delete a group
+ */
+export const deleteGroup = async (groupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteGroupUrl(groupId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListGroupMembersUrl = (groupId, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}/members?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}/members`;
+};
+/**
+ * Returns the accounts in the group, ordered by username.
+ * @summary List the members of a group
+ */
+export const listGroupMembers = async (groupId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListGroupMembersUrl(groupId, params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateGroupMemberUrl = (groupId) => {
+    return `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}/members`;
+};
+/**
+ * The account must be a member's. Fails with `GROUP_MEMBER_EXISTS` when the account is
+ * already in the group.
+ *
+ * Requires `fleet:directory.manage`.
+ * @summary Add an account to a group
+ */
+export const createGroupMember = async (groupId, createGroupMemberRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateGroupMemberUrl(groupId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createGroupMemberRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteGroupMemberUrl = (groupId, accountId) => {
+    return `https://fleet.leaflow.cloud/api/v1/groups/${encodeURIComponent(String(groupId))}/members/${encodeURIComponent(String(accountId))}`;
+};
+/**
+ * Removing an account that is not in the group succeeds.
+ *
+ * Requires `fleet:directory.manage`.
+ * @summary Remove an account from a group
+ */
+export const deleteGroupMember = async (groupId, accountId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteGroupMemberUrl(groupId, accountId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSessionsUrl = (params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? "null" : String(value));
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0
+        ? `https://fleet.leaflow.cloud/api/v1/sessions?${stringifiedParams}`
+        : `https://fleet.leaflow.cloud/api/v1/sessions`;
+};
+/**
+ * Returns the sessions of the current project's machines, newest first. Closed sessions are
+ * omitted unless `include_closed` is true.
+ * @summary List sessions
+ */
+export const listSessions = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSessionsUrl(params), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateSessionUrl = () => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions`;
+};
+/**
+ * Opens a session for the caller on a machine, as the caller's account, and returns once it
+ * is ready. With `desktop` the session has a desktop. Without, it is a terminal session: its
+ * one terminal runs the caller's login shell from the start, every participant attaches to
+ * that terminal, and the session ends when the shell exits; a caller who wants another
+ * terminal opens another session. Either kind also offers programs, files, ports, sound,
+ * devices, printers and privilege approvals. The account is created if the caller has none
+ * yet. Requires `fleet:machines.login` on the machine.
+ *
+ * On a machine an account has at most one session with a desktop and at most 8 sessions in
+ * all. Sessions without a desktop run side by side, such as one for a program and one for a
+ * person; several participants can also share one session.
+ *
+ * Fails with:
+ * - `MACHINE_OFFLINE` when the machine is not connected and does not connect again in time;
+ * - `FEATURE_UNAVAILABLE` when the machine does not offer sessions, or with `desktop`,
+ *   desktops;
+ * - `USER_HAS_DESKTOP_SESSION` with `desktop` when the account already has a session with a
+ *   desktop on the machine, which `metadata.sessionId` names; connect to it instead;
+ * - `SESSION_LIMIT_REACHED` when the account already has 8 open sessions on the machine;
+ *   close one first;
+ * - `USER_NOT_FOUND`, `USER_NOT_ALLOWED`, `ACCOUNT_EXPIRED` or `PAM_PERMISSION_DENIED` when
+ *   the machine refuses the account, such as while it has not received the account yet or a
+ *   local account uses its name; `PAM_PERMISSION_DENIED` carries the machine's message in
+ *   `metadata.pamMessage`;
+ * - `SESSION_CONFLICT` with `desktop` when the account has a graphical session on the
+ *   machine that Fleet did not open;
+ * - `DISPLAY_UNAVAILABLE` or `SESSION_START_FAILED` when the machine could not start it;
+ * - `MACHINE_TIMEOUT` when the machine did not answer in time. The session may still open;
+ *   list the sessions before trying again.
+ * @summary Open a session
+ */
+export const createSession = async (createSessionRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateSessionUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createSessionRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSessionUrl = (sessionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}`;
+};
+/**
+ * @summary Get a session
+ */
+export const getSession = async (sessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSessionUrl(sessionId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCloseSessionUrl = (sessionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}:close`;
+};
+/**
+ * Ends the session in order: its applications are asked to exit and get a grace period
+ * before the session is terminated. Returns once the session is closed. Closing a closed
+ * session succeeds.
+ *
+ * The owner may close their own session; closing another member's requires
+ * `fleet:sessions.manage`. Fails with `MACHINE_OFFLINE` or `MACHINE_TIMEOUT` as
+ * for opening a session.
+ * @summary Close a session
+ */
+export const closeSession = async (sessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCloseSessionUrl(sessionId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getTerminateSessionUrl = (sessionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}:terminate`;
+};
+/**
+ * Ends the session at once, killing every process in it. Returns once the session is
+ * closed. Terminating a closed session succeeds.
+ *
+ * The owner may terminate their own session; terminating another member's requires
+ * `fleet:sessions.manage`. Fails with `MACHINE_OFFLINE` or `MACHINE_TIMEOUT` as
+ * for opening a session.
+ * @summary Terminate a session
+ */
+export const terminateSession = async (sessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getTerminateSessionUrl(sessionId), {
+        ...options,
+        method: "POST",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getGetSessionRtcConfigurationUrl = (sessionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/rtc-configuration`;
+};
+/**
+ * Returns the STUN and TURN servers for the PeerConnections the caller starts to the session,
+ * with TURN credentials of its own, and the policy for using them. Ask again once
+ * `expires_at` has passed; the credentials of a PeerConnection already relayed last longer.
+ *
+ * Requires that the caller may join the session, as for `create-participant`.
+ *
+ * Fails with:
+ * - `SESSION_CLOSED` when the session has ended;
+ * - `SESSION_ACCESS_DENIED` when the caller may not join the session.
+ * @summary Get the ICE servers for a session
+ */
+export const getSessionRtcConfiguration = async (sessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSessionRtcConfigurationUrl(sessionId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreateParticipantUrl = (sessionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants`;
+};
+/**
+ * Admits one participant with the given public key to the session: signs its authorization,
+ * has the session accept it, and starts its first PeerConnection with the offer. The answer
+ * carries the participant, its authorization and the PeerConnection with the session's
+ * answer. The participant lasts while it is renewed.
+ *
+ * Joining again with the public key of one of the caller's participants of the session that
+ * has not ended, with the same `client_name`, `read_only` and `permissions`, returns that
+ * participant with a new PeerConnection for the offer, and the session gains no second
+ * participant: a request whose answer was lost, such as on an unreliable network, is sent
+ * again as it was. Its earlier PeerConnection, whose answer the client never received, is
+ * given up by the session once it fails.
+ *
+ * The owner of a session may operate it. Joining another member's session requires
+ * `fleet:sessions.view`, which admits watching only, or
+ * `fleet:sessions.control`, which also admits operating it. Each further capability
+ * of the session — file transfer, the clipboard, terminals and programs, port forwarding,
+ * devices and audio, printing, SSH agent forwarding, approving privilege requests and
+ * reading logs — is granted only with its permission; a participant that may only watch gets
+ * none of them. A request may ask for less: to watch only, or for some of the capabilities.
+ *
+ * Fails with the following, and then no participant was created:
+ * - `SESSION_CLOSED` when the session has ended;
+ * - `SESSION_ACCESS_DENIED` when the caller may not join the session;
+ * - `OFFER_INVALID` when the offer is not an SDP offer that names a SHA-256 DTLS fingerprint;
+ * - `SESSION_UNAVAILABLE` when the session's process is not connected and does not connect
+ *   again in time, or did not answer in time; try again after the error's `retry_delay`;
+ * - `PARTICIPANT_LIMIT_REACHED` when the session has as many participants as it admits;
+ * - `PARTICIPANT_REFUSED` when the session refused the participant;
+ * - `PARTICIPANT_KEY_IN_USE` when the public key belongs to a participant of the session that
+ *   another user holds, or that was created with another `client_name`, `read_only` or
+ *   `permissions`; join with a new key;
+ * - `PEER_CONNECTION_ABORTED` when the session gave up the PeerConnection; try again with a
+ *   new offer. The participant of a repeated request stays.
+ * @summary Join a session
+ */
+export const createParticipant = async (sessionId, createParticipantRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreateParticipantUrl(sessionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createParticipantRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getListSessionParticipantsUrl = (sessionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants`;
+};
+/**
+ * Returns the participants of the session, in the order they joined.
+ * @summary List the participants of a session
+ */
+export const listSessionParticipants = async (sessionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListSessionParticipantsUrl(sessionId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getRenewParticipantUrl = (sessionId, participantId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}:renew`;
+};
+/**
+ * Extends the participant's lease and returns renewed PeerAuthorizations for the
+ * PeerConnections whose current ones the request presents. The service sends them to the
+ * session as well, and the participant passes each one to the session over its PeerConnection
+ * (`Packet.peer_authorization` of the transport protocol), so that the lease holds while
+ * either path to the session is down. A
+ * presented authorization that the service did not sign for this participant, or whose
+ * PeerConnection has ended, is left out of the answer. When the participant's authorization
+ * nears its end, the answer carries a renewed one, which the session already holds.
+ *
+ * Only the participant's user may renew it.
+ *
+ * Fails with:
+ * - `PARTICIPANT_NOT_FOUND` when the participant has ended; create another;
+ * - `PARTICIPANT_PERMISSION_REVOKED` when a permission the participant was created with has
+ *   been revoked from the caller; it has ended, and another can be created with the
+ *   permissions the caller holds now;
+ * - `PROJECT_MEMBERSHIP_REQUIRED` when the caller is no longer a member of the project; the
+ *   participant has ended.
+ * @summary Renew a participant
+ */
+export const renewParticipant = async (sessionId, participantId, renewParticipantRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getRenewParticipantUrl(sessionId, participantId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(renewParticipantRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getPrepareParticipantMigrationUrl = (sessionId, participantId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}:prepareMigration`;
+};
+/**
+ * Passes the participant's checkpoint for the next epoch to the session and returns the
+ * session's checkpoint for it: the `prepare` and `prepared` steps of `Migration` in
+ * `leaflow/fleet/transport/v1/transport.proto`. Repeating the step returns the same answer.
+ *
+ * Only the participant's user may migrate it.
+ *
+ * Fails with:
+ * - `PARTICIPANT_NOT_FOUND` when the participant has ended;
+ * - `CHECKPOINT_INVALID` when the checkpoint is not a serialized `Checkpoint`;
+ * - `SESSION_UNAVAILABLE` when the session's process is not connected and does not connect
+ *   again in time, or did not answer in time; try again after the error's `retry_delay`.
+ * @summary Prepare a migration
+ */
+export const prepareParticipantMigration = async (sessionId, participantId, migrationStep, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getPrepareParticipantMigrationUrl(sessionId, participantId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(migrationStep),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCommitParticipantMigrationUrl = (sessionId, participantId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}:commitMigration`;
+};
+/**
+ * Commits the epoch the participant prepared and returns the session's checkpoint once it
+ * committed it: the `commit` and `committed` steps of `Migration` in
+ * `leaflow/fleet/transport/v1/transport.proto`. Repeating the step returns the same answer.
+ *
+ * Only the participant's user may migrate it.
+ *
+ * Fails with:
+ * - `PARTICIPANT_NOT_FOUND` when the participant has ended;
+ * - `CHECKPOINT_INVALID` when the checkpoint is not a serialized `Checkpoint`;
+ * - `SESSION_UNAVAILABLE` when the session's process is not connected and does not connect
+ *   again in time, or did not answer in time; try again after the error's `retry_delay`.
+ * @summary Commit a migration
+ */
+export const commitParticipantMigration = async (sessionId, participantId, migrationStep, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCommitParticipantMigrationUrl(sessionId, participantId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(migrationStep),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePeerConnectionUrl = (sessionId, participantId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}/peer-connections`;
+};
+/**
+ * Starts another PeerConnection of the participant with the offer, such as after a path
+ * failed, and returns the session's answer, its ICE candidates and the signed
+ * PeerAuthorization. Move the participant's connection to it with
+ * `prepare-participant-migration` and `commit-participant-migration`.
+ *
+ * Only the participant's user may start one.
+ *
+ * Fails with:
+ * - `PARTICIPANT_NOT_FOUND` when the participant has ended;
+ * - `OFFER_INVALID` when the offer is not an SDP offer that names a SHA-256 DTLS fingerprint;
+ * - `RATE_LIMIT_EXCEEDED` when the participant started too many PeerConnections in the
+ *   last minute; try again after the error's `retry_delay`;
+ * - `SESSION_UNAVAILABLE` when the session's process is not connected and does not connect
+ *   again in time, or did not answer in time; try again after the error's `retry_delay`;
+ * - `PEER_CONNECTION_ABORTED` when the session gave up the PeerConnection; start another.
+ * @summary Start a PeerConnection
+ */
+export const createPeerConnection = async (sessionId, participantId, createPeerConnectionRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePeerConnectionUrl(sessionId, participantId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createPeerConnectionRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeletePeerConnectionUrl = (sessionId, participantId, peerConnectionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}/peer-connections/${encodeURIComponent(String(peerConnectionId))}`;
+};
+/**
+ * Tells the session to give up the PeerConnection and close it. Abandoning a PeerConnection
+ * that has ended succeeds.
+ *
+ * Only the participant's user may abandon it.
+ *
+ * Fails with `PARTICIPANT_NOT_FOUND` when the participant has ended.
+ * @summary Abandon a PeerConnection
+ */
+export const deletePeerConnection = async (sessionId, participantId, peerConnectionId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeletePeerConnectionUrl(sessionId, participantId, peerConnectionId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};
+export const getCreatePeerConnectionCandidatesUrl = (sessionId, participantId, peerConnectionId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}/peer-connections/${encodeURIComponent(String(peerConnectionId))}/candidates`;
+};
+/**
+ * Passes the ICE candidates the participant gathered after its offer to the session, and with
+ * `end_of_candidates`, that it has gathered all (RFC 8838). The session ignores those of a
+ * PeerConnection that has ended.
+ *
+ * Only the participant's user may add them.
+ *
+ * Fails with:
+ * - `PARTICIPANT_NOT_FOUND` when the participant has ended;
+ * - `SESSION_UNAVAILABLE` when the session's process is not connected and does not connect
+ *   again in time; try again after the error's `retry_delay`.
+ * @summary Add ICE candidates to a PeerConnection
+ */
+export const createPeerConnectionCandidates = async (sessionId, participantId, peerConnectionId, createPeerConnectionCandidatesRequest, options, fetchFn) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
+    const res = await (fetchFn ?? fetch)(getCreatePeerConnectionCandidatesUrl(sessionId, participantId, peerConnectionId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(createPeerConnectionCandidatesRequest),
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return {
+        data,
+        status: res.status,
+        headers: res.headers,
+    };
+};
+export const getGetParticipantUrl = (sessionId, participantId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}`;
+};
+/**
+ * Returns a participant of the session.
+ * @summary Get a participant of a session
+ */
+export const getParticipant = async (sessionId, participantId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetParticipantUrl(sessionId, participantId), {
+        ...options,
+        method: "GET",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : {};
+    return { data, status: res.status, headers: res.headers };
+};
+export const getDeleteParticipantUrl = (sessionId, participantId) => {
+    return `https://fleet.leaflow.cloud/api/v1/sessions/${encodeURIComponent(String(sessionId))}/participants/${encodeURIComponent(String(participantId))}`;
+};
+/**
+ * Ends the participant: the session detaches it and closes its PeerConnections, and the
+ * session goes on. A participant leaves this way; others are disconnected this way.
+ *
+ * The participant's user and the owner of the session may end it; otherwise this
+ * requires `fleet:sessions.manage`.
+ * @summary End a participant
+ */
+export const deleteParticipant = async (sessionId, participantId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteParticipantUrl(sessionId, participantId), {
+        ...options,
+        method: "DELETE",
+    });
+    const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+    const data = body ? JSON.parse(body) : undefined;
+    return { data, status: res.status, headers: res.headers };
+};