@leaflow/sdk 0.106.0 → 0.107.0

package/dist/gen/monitoring/v1/functions.js

@@ -0,0 +1,1581 @@
+export const getListIncidentsUrl = (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://monitoring.leaflow.cloud/api/v1/incidents?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/incidents`;
+};
+/**
+ * `incident_status` reports whether monitoring considers the problem recovered; `closed` reports whether someone has finished handling it. The two are independent and can be filtered separately.
+ * @summary List incidents
+ */
+export const listIncidents = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListIncidentsUrl(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 getGetIncidentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}`;
+};
+/**
+ * @summary Get an incident
+ */
+export const getIncident = async (incidentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetIncidentUrl(incidentId), {
+        ...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 getAcknowledgeIncidentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/acknowledge`;
+};
+/**
+ * The incident is also marked as acknowledged in the monitoring system, so that other channels can see it already has an owner.
+ * @summary Acknowledge an incident
+ */
+export const acknowledgeIncident = async (incidentId, acknowledgeIncidentRequestBody, 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)(getAcknowledgeIncidentUrl(incidentId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(acknowledgeIncidentRequestBody),
+    });
+    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 getAssignIncidentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/assignee`;
+};
+/**
+ * Leave `assignee_user_id` empty to clear the assignment.
+ *
+ * **Project membership of the assignee is not verified.** Any user identifier is accepted and recorded as given.
+ * @summary Assign an incident, or clear its assignee
+ */
+export const assignIncident = async (incidentId, assignIncidentRequestBody, 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)(getAssignIncidentUrl(incidentId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(assignIncidentRequestBody),
+    });
+    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 getCloseIncidentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/close`;
+};
+/**
+ * Closing records **that the handling process is finished on this platform**; it does not change the state of the incident itself. An incident that has not recovered may still be closed as an accepted risk, and remains unrecovered in the monitoring system.
+ * @summary Close an incident
+ */
+export const closeIncident = async (incidentId, closeIncidentRequestBody, 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)(getCloseIncidentUrl(incidentId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(closeIncidentRequestBody),
+    });
+    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 getAddIncidentCommentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/comments`;
+};
+/**
+ * @summary Add a note to the timeline
+ */
+export const addIncidentComment = async (incidentId, addCommentRequestBody, 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)(getAddIncidentCommentUrl(incidentId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(addCommentRequestBody),
+    });
+    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 getSetIncidentFollowingUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/following`;
+};
+/**
+ * You follow **yourself**: the caller is the user added to or removed from the follower list.
+ * @summary Follow an incident, or stop following it
+ */
+export const setIncidentFollowing = async (incidentId, setFollowingRequestBody, 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)(getSetIncidentFollowingUrl(incidentId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(setFollowingRequestBody),
+    });
+    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 getReopenIncidentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/reopen`;
+};
+/**
+ * @summary Reopen a closed incident
+ */
+export const reopenIncident = async (incidentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getReopenIncidentUrl(incidentId), {
+        ...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 getListIncidentTimelineUrl = (incidentId, 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://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/timeline?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/incidents/${encodeURIComponent(String(incidentId))}/timeline`;
+};
+/**
+ * Cursor paging rather than offset paging: the timeline is append-only, and offset paging would skip or repeat entries whenever a new one is written.
+ * @summary List the timeline of an incident
+ */
+export const listIncidentTimeline = async (incidentId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListIncidentTimelineUrl(incidentId, 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 getListMaintenanceWindowsUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/maintenance-windows`;
+};
+/**
+ * @summary List maintenance windows
+ */
+export const listMaintenanceWindows = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListMaintenanceWindowsUrl(), {
+        ...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 getGetMaintenanceWindowUrl = (windowId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/maintenance-windows/${encodeURIComponent(String(windowId))}`;
+};
+/**
+ * @summary Get a maintenance window
+ */
+export const getMaintenanceWindow = async (windowId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetMaintenanceWindowUrl(windowId), {
+        ...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 getPutMaintenanceWindowUrl = (windowId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/maintenance-windows/${encodeURIComponent(String(windowId))}`;
+};
+/**
+ * **Create or replace**: extending a window that is already running means calling this endpoint again with the same id.
+ *
+ * While the window is open, problems on these machines do not alert and do not count against SLA availability. Leave `server_ids` empty to cover the entire project, including machines enrolled after the window opens.
+ * @summary Create a maintenance window, or replace it by the same id
+ */
+export const putMaintenanceWindow = async (windowId, putMaintenanceWindowRequestBody, 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)(getPutMaintenanceWindowUrl(windowId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putMaintenanceWindowRequestBody),
+    });
+    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 getDeleteMaintenanceWindowUrl = (windowId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/maintenance-windows/${encodeURIComponent(String(windowId))}`;
+};
+/**
+ * Alerting resumes immediately, even if the window has not yet expired.
+ * @summary Cancel a maintenance window
+ */
+export const deleteMaintenanceWindow = async (windowId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteMaintenanceWindowUrl(windowId), {
+        ...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 getGetProjectOverviewUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/overview`;
+};
+/**
+ * A project with no machines yet returns an overview with every figure at zero rather than a 404 — an empty project is a normal state.
+ * @summary Project overview
+ */
+export const getProjectOverview = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetProjectOverviewUrl(), {
+        ...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 getListServerItemsUrl = (serverId, 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://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/items?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/items`;
+};
+/**
+ * Items are returned exactly as collected, without filtering or renaming. Which of them count as important is for the caller to decide from the tags carried by each item.
+ * @summary List the monitoring items of a machine
+ */
+export const listServerItems = async (serverId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListServerItemsUrl(serverId, 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 getGetServerMetricUrl = (serverId, 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://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/metrics?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/metrics`;
+};
+/**
+ * `item_key` is matched **by prefix**. Keys discovered per partition or per interface carry parameters (`vfs.fs.size[/var,pused]`), so a single request for `vfs.fs.size` returns one series per mount point.
+ * @summary Get the time series of a monitoring item
+ */
+export const getServerMetric = async (serverId, params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetServerMetricUrl(serverId, 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 getGetServerResourcesUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/resources`;
+};
+/**
+ * @summary Hardware and interfaces of a machine
+ */
+export const getServerResources = async (serverId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetServerResourcesUrl(serverId), {
+        ...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 getGetServerSnapshotUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/snapshot`;
+};
+/**
+ * @summary Current state of a machine
+ */
+export const getServerSnapshot = async (serverId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetServerSnapshotUrl(serverId), {
+        ...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 getListProjectTopItemsUrl = (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://monitoring.leaflow.cloud/api/v1/top-items?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/top-items`;
+};
+/**
+ * @summary Machines ranked highest by a given metric
+ */
+export const listProjectTopItems = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListProjectTopItemsUrl(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 getListTemplatesUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/templates`;
+};
+/**
+ * The catalog every template binding is validated against — which templates exist, which parameters each of them accepts, and what each parameter defaults to. It is identical for every project and changes only when this deployment is upgraded. Read it rather than keeping a copy. A copy drifts, and only one of the ways it drifts fails loudly — an unknown parameter name is rejected, but a stale `default` and a stale `required` both look correct on screen.
+ * @summary List the monitoring templates that can be bound to a machine
+ */
+export const listTemplates = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListTemplatesUrl(), {
+        ...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 getListServersUrl = (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://monitoring.leaflow.cloud/api/v1/servers?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/servers`;
+};
+/**
+ * @summary List the machines in the project
+ */
+export const listServers = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListServersUrl(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 getGetServerUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}`;
+};
+/**
+ * @summary Get the enrollment state of a machine
+ */
+export const getServer = async (serverId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetServerUrl(serverId), {
+        ...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 getEnableServerMonitoringUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}`;
+};
+/**
+ * **Repeated calls with the same server id are idempotent**: given identical parameters, the already-enrolled machine is returned and no duplicate host is created, so a failed enrollment is safe to retry.
+ *
+ * To change enrollment settings, use PATCH. This endpoint returns an error when the parameters differ, and does not update an existing configuration.
+ *
+ * A failed call leaves the machine recorded with `monitoring_status: FAILED`; the reason is reported in `last_error` via `GET /servers/{serverId}`.
+ *
+ * The `tls_psk` in the response is **returned only this once**; store it immediately. If it is lost, it must be rotated.
+ *
+ * It is also how collection is resumed after `/disable`. On a machine that already exists, **omitting `template_bindings` keeps the bindings it already has**; it does not fall back to the default of Linux alone, which would silently drop every other template together with its parameters. Secret parameters are likewise carried over — see `parameters` on the binding.
+ * @summary Enroll a machine into monitoring
+ */
+export const enableServerMonitoring = async (serverId, enableMonitoringRequestBody, 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)(getEnableServerMonitoringUrl(serverId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(enableMonitoringRequestBody),
+    });
+    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 getUpdateServerUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}`;
+};
+/**
+ * Only the fields present in the request body are updated. `address` and `address_kind` must be supplied together: changing one without the other produces a contradictory configuration that is not reported as an error and shows up only as an agent that cannot connect.
+ * @summary Update the enrollment settings of a machine
+ */
+export const updateServer = async (serverId, updateServerRequestBody, 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)(getUpdateServerUrl(serverId), {
+        ...options,
+        method: "PATCH",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(updateServerRequestBody),
+    });
+    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 getDeleteServerUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}`;
+};
+/**
+ * **Irreversible**: the monitored host, its history and every incident recorded against this machine are removed together. To stop collection temporarily, use `/disable` instead.
+ * @summary Delete a machine
+ */
+export const deleteServer = async (serverId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteServerUrl(serverId), {
+        ...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 getDisableServerMonitoringUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/disable`;
+};
+/**
+ * Reversible: the monitored host is retained, only collection stops, and history is unaffected. Enrolling again resumes collection. To remove the history as well, use DELETE.
+ * @summary Stop monitoring a machine
+ */
+export const disableServerMonitoring = async (serverId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDisableServerMonitoringUrl(serverId), {
+        ...options,
+        method: "POST",
+    });
+    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 getRotateAgentPskUrl = (serverId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/psk`;
+};
+/**
+ * The agent configuration must be updated to match, otherwise the machine loses contact immediately. The new key is likewise **returned in clear text only in this response**.
+ * @summary Rotate the agent PSK
+ */
+export const rotateAgentPsk = async (serverId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getRotateAgentPskUrl(serverId), {
+        ...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 getGetWebCheckUrl = (serverId, checkId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/web-checks/${encodeURIComponent(String(checkId))}`;
+};
+/**
+ * @summary Get a web check
+ */
+export const getWebCheck = async (serverId, checkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetWebCheckUrl(serverId, checkId), {
+        ...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 getPutWebCheckUrl = (serverId, checkId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/web-checks/${encodeURIComponent(String(checkId))}`;
+};
+/**
+ * **Create or replace**: to modify a check, call this endpoint again with the same id. There is no need to determine first whether it already exists.
+ * @summary Create a web check, or replace it by the same id
+ */
+export const putWebCheck = async (serverId, checkId, putWebCheckRequestBody, 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)(getPutWebCheckUrl(serverId, checkId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putWebCheckRequestBody),
+    });
+    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 getDeleteWebCheckUrl = (serverId, checkId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/servers/${encodeURIComponent(String(serverId))}/web-checks/${encodeURIComponent(String(checkId))}`;
+};
+/**
+ * The corresponding check task and trigger are removed from the monitoring system as well, so no permanently unrecoverable alert is left behind.
+ * @summary Delete a web check
+ */
+export const deleteWebCheck = async (serverId, checkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteWebCheckUrl(serverId, checkId), {
+        ...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 getListWebChecksUrl = (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://monitoring.leaflow.cloud/api/v1/web-checks?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/web-checks`;
+};
+/**
+ * @summary List web checks
+ */
+export const listWebChecks = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListWebChecksUrl(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 getGetSliReportUrl = (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://monitoring.leaflow.cloud/api/v1/sli-report?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/sli-report`;
+};
+/**
+ * SLI is what was measured; SLO is what was promised — this endpoint returns the former.
+ *
+ * The row with an empty `server_id` covers the project as a whole.
+ * @summary Get measured availability
+ */
+export const getSliReport = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSliReportUrl(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 getGetSloUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/slo`;
+};
+/**
+ * A project that has never set one returns 404 rather than a default target: making no promise and promising 99.9% are different things.
+ * @summary Get the availability target of this project
+ */
+export const getSlo = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetSloUrl(), {
+        ...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 getPutSloUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/slo`;
+};
+/**
+ * One SLO per project, **create or replace**.
+ *
+ * `min_severity` must be chosen explicitly: it defines what counts as unavailable, which is half of what the target means.
+ * @summary Set the availability target of this project, or change it
+ */
+export const putSlo = async (putSLORequestBody, 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)(getPutSloUrl(), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putSLORequestBody),
+    });
+    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 getDeleteSloUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/slo`;
+};
+/**
+ * Availability is no longer tracked from this point on.
+ * @summary Remove the availability target of this project
+ */
+export const deleteSlo = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteSloUrl(), {
+        ...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 getGetStatusPageUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page`;
+};
+/**
+ * A project has at most one status page. A project that has never created one returns 404.
+ * @summary Get the status page of this project
+ */
+export const getStatusPage = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatusPageUrl(), {
+        ...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 getPutStatusPageUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page`;
+};
+/**
+ * **Create or replace**: changing the title, switching the domain, publishing and unpublishing are all done by sending the complete configuration again.
+ *
+ * While `published` is false the public address returns 404, including any custom domain already bound. A newly created page is unpublished by default, so that a page still being configured has no address that opens.
+ *
+ * `slug` and `custom_domain` are **globally unique**; a value already taken returns 409.
+ * @summary Create the status page, or replace its configuration
+ */
+export const putStatusPage = async (putStatusPageRequestBody, 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)(getPutStatusPageUrl(), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageRequestBody),
+    });
+    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 getDeleteStatusPageUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page`;
+};
+/**
+ * Its groups, components, availability history, incident notices and scheduled maintenance are removed together, and cannot be recovered. The slug and custom domain are released.
+ * @summary Delete the status page
+ */
+export const deleteStatusPage = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteStatusPageUrl(), {
+        ...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 getPutStatusPageOrderUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/order`;
+};
+/**
+ * Submits the **entire** top-level order in one call rather than moving a single entry to a given position.
+ *
+ * The top level interleaves groups and ungrouped components, so the order is expressed as one list covering both.
+ *
+ * Each entry carries either `group_id` or `component_id`. Entries not listed are placed after those that are.
+ * @summary Set the order of the top level of the page
+ */
+export const putStatusPageOrder = async (putStatusPageOrderRequestBody, 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)(getPutStatusPageOrderUrl(), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageOrderRequestBody),
+    });
+    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 getListStatusPageGroupsUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/groups`;
+};
+/**
+ * @summary List groups
+ */
+export const listStatusPageGroups = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListStatusPageGroupsUrl(), {
+        ...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 getCreateStatusPageGroupUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/groups`;
+};
+/**
+ * A group is one level of collapsing applied to components on the page. There is exactly one level; groups cannot be nested.
+ * @summary Create a group
+ */
+export const createStatusPageGroup = async (putStatusPageGroupRequestBody, 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)(getCreateStatusPageGroupUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageGroupRequestBody),
+    });
+    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 getUpdateStatusPageGroupUrl = (groupId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/groups/${encodeURIComponent(String(groupId))}`;
+};
+/**
+ * @summary Update a group
+ */
+export const updateStatusPageGroup = async (groupId, putStatusPageGroupRequestBody, 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)(getUpdateStatusPageGroupUrl(groupId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageGroupRequestBody),
+    });
+    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 getDeleteStatusPageGroupUrl = (groupId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/groups/${encodeURIComponent(String(groupId))}`;
+};
+/**
+ * The components in it are **not deleted**. They return to the top level as ungrouped components, keeping their availability history and the incident notices that reference them.
+ * @summary Delete a group
+ */
+export const deleteStatusPageGroup = async (groupId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteStatusPageGroupUrl(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 getPutStatusPageGroupOrderUrl = (groupId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/groups/${encodeURIComponent(String(groupId))}/order`;
+};
+/**
+ * @summary Set the order of components within a group
+ */
+export const putStatusPageGroupOrder = async (groupId, putStatusPageGroupOrderRequestBody, 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)(getPutStatusPageGroupOrderUrl(groupId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageGroupOrderRequestBody),
+    });
+    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 getListStatusPageComponentsUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components`;
+};
+/**
+ * A component is one row on the status page: an externally promised capability. It is not a machine — a single component may be backed by several machines and several web checks.
+ * @summary List components
+ */
+export const listStatusPageComponents = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListStatusPageComponentsUrl(), {
+        ...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 getCreateStatusPageComponentUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components`;
+};
+/**
+ * `name` is **customer-facing copy** and appears verbatim on the public page; do not use machine names.
+ *
+ * `auto_status_min_severity` sets how severe an alert must be before it changes the status of this row; anything below it has no effect. The default is AVERAGE. Lower settings tend to keep the page permanently off-green, at which point people stop reading it.
+ * @summary Create a component
+ */
+export const createStatusPageComponent = async (putStatusPageComponentRequestBody, 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)(getCreateStatusPageComponentUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageComponentRequestBody),
+    });
+    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 getGetStatusPageComponentUrl = (componentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components/${encodeURIComponent(String(componentId))}`;
+};
+/**
+ * @summary Get a component
+ */
+export const getStatusPageComponent = async (componentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatusPageComponentUrl(componentId), {
+        ...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 getUpdateStatusPageComponentUrl = (componentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components/${encodeURIComponent(String(componentId))}`;
+};
+/**
+ * `started_on` cannot be changed: it determines where the availability bar stops showing as unmeasured, and changing it would rewrite history that has already been published.
+ * @summary Update a component
+ */
+export const updateStatusPageComponent = async (componentId, putStatusPageComponentRequestBody, 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)(getUpdateStatusPageComponentUrl(componentId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageComponentRequestBody),
+    });
+    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 getDeleteStatusPageComponentUrl = (componentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components/${encodeURIComponent(String(componentId))}`;
+};
+/**
+ * Its availability history is removed along with it. Passages in already-published notices that refer to it are retained, since customers may already have read them.
+ * @summary Delete a component
+ */
+export const deleteStatusPageComponent = async (componentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteStatusPageComponentUrl(componentId), {
+        ...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 getListStatusPageComponentSourcesUrl = (componentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components/${encodeURIComponent(String(componentId))}/sources`;
+};
+/**
+ * Monitored sources are internal information and **never appear on the public page**.
+ * @summary List the monitored sources bound to a component
+ */
+export const listStatusPageComponentSources = async (componentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListStatusPageComponentSourcesUrl(componentId), {
+        ...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 getPutStatusPageComponentSourcesUrl = (componentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/components/${encodeURIComponent(String(componentId))}/sources`;
+};
+/**
+ * Submits the **complete** set of sources; anything not listed is unbound.
+ *
+ * Once bound, alerts on these machines and web checks drive the status of the component automatically: DISASTER and HIGH are reported as a major outage, AVERAGE as a partial outage, and WARNING as degraded performance. Alerts below `auto_status_min_severity` have no effect.
+ *
+ * `show_url` controls whether the checked address is shown on the public page. It is off by default.
+ * @summary Set the complete list of monitored sources for a component
+ */
+export const putStatusPageComponentSources = async (componentId, putStatusPageComponentSourcesRequestBody, 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)(getPutStatusPageComponentSourcesUrl(componentId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageComponentSourcesRequestBody),
+    });
+    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 getListStatusPageIncidentsUrl = (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://monitoring.leaflow.cloud/api/v1/status-page/incidents?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/status-page/incidents`;
+};
+/**
+ * These are **customer-facing notices**, distinct from the monitoring incidents under `/incidents`. Nothing from the latter is carried over; the text here is written by your team.
+ * @summary List the incident notices on the status page
+ */
+export const listStatusPageIncidents = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListStatusPageIncidentsUrl(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 getPublishStatusPageIncidentUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/incidents`;
+};
+/**
+ * Publishing a notice and writing its first update are a single operation: a notice with no updates would appear as a bare title on a page that has already been delivered to readers.
+ *
+ * `started_at` is when the **incident began**, not when the notice was published. The two are usually minutes to hours apart, and using the publication time would understate the impact window that customers can compare against their own logs. Backfilling a past incident relies on the same field.
+ *
+ * The statuses given in `components` take effect on the public page immediately and count towards availability.
+ * @summary Publish an incident notice
+ */
+export const publishStatusPageIncident = async (publishStatusPageIncidentRequestBody, 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)(getPublishStatusPageIncidentUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(publishStatusPageIncidentRequestBody),
+    });
+    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 getGetStatusPageIncidentUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/incidents/${encodeURIComponent(String(incidentId))}`;
+};
+/**
+ * @summary Get an incident notice
+ */
+export const getStatusPageIncident = async (incidentId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatusPageIncidentUrl(incidentId), {
+        ...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 getPostStatusPageIncidentUpdateUrl = (incidentId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/incidents/${encodeURIComponent(String(incidentId))}/updates`;
+};
+/**
+ * Published updates are never modified; a correction is issued as a new update. Customers may already have forwarded the original, and a silent rewrite would leave the two sides with different histories.
+ *
+ * `components` lists only the components **being changed** by this update; those not listed keep their current status. Setting `status` to `RESOLVED` returns every component this notice has affected to operational and closes the notice. A closed notice accepts no further updates.
+ * @summary Append an update to an incident notice
+ */
+export const postStatusPageIncidentUpdate = async (incidentId, postStatusPageIncidentUpdateRequestBody, 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)(getPostStatusPageIncidentUpdateUrl(incidentId), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(postStatusPageIncidentUpdateRequestBody),
+    });
+    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 getListStatusPageMaintenancesUrl = (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://monitoring.leaflow.cloud/api/v1/status-page/maintenances?${stringifiedParams}`
+        : `https://monitoring.leaflow.cloud/api/v1/status-page/maintenances`;
+};
+/**
+ * @summary List scheduled maintenance
+ */
+export const listStatusPageMaintenances = async (params, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getListStatusPageMaintenancesUrl(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 getScheduleStatusPageMaintenanceUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/maintenances`;
+};
+/**
+ * Maintenance starts and finishes automatically at the scheduled times; nobody needs to be present. While it runs, the affected components are shown as under maintenance and **availability is not reduced** — planned work should not consume the availability you promise to customers, which is the point of announcing it in advance.
+ *
+ * This is separate from `/maintenance-windows`, which suppresses alerting for a period. This endpoint announces the work to your customers. The two are usually created together: without suppression, restarts during the maintenance raise alerts and mark the components unavailable.
+ * @summary Schedule maintenance
+ */
+export const scheduleStatusPageMaintenance = async (scheduleStatusPageMaintenanceRequestBody, 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)(getScheduleStatusPageMaintenanceUrl(), {
+        ...options,
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(scheduleStatusPageMaintenanceRequestBody),
+    });
+    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 getGetStatusPageMaintenanceUrl = (maintenanceId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/maintenances/${encodeURIComponent(String(maintenanceId))}`;
+};
+/**
+ * @summary Get a scheduled maintenance
+ */
+export const getStatusPageMaintenance = async (maintenanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatusPageMaintenanceUrl(maintenanceId), {
+        ...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 getCancelStatusPageMaintenanceUrl = (maintenanceId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/maintenances/${encodeURIComponent(String(maintenanceId))}/cancel`;
+};
+/**
+ * Cancelled rather than deleted, so that readers who saw the announcement have an explanation. Maintenance that has already started cannot be cancelled; finish it early instead.
+ * @summary Cancel a maintenance that has not started
+ */
+export const cancelStatusPageMaintenance = async (maintenanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCancelStatusPageMaintenanceUrl(maintenanceId), {
+        ...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 getCompleteStatusPageMaintenanceUrl = (maintenanceId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/maintenances/${encodeURIComponent(String(maintenanceId))}/complete`;
+};
+/**
+ * Optional: maintenance finishes on its own at the scheduled end time. Use this endpoint when the work is done ahead of schedule; the affected components return to operational immediately.
+ * @summary Finish a running maintenance early
+ */
+export const completeStatusPageMaintenance = async (maintenanceId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getCompleteStatusPageMaintenanceUrl(maintenanceId), {
+        ...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 getGetProjectWebCheckUrl = (checkId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/web-checks/${encodeURIComponent(String(checkId))}`;
+};
+/**
+ * @summary Get a project-level web check
+ */
+export const getProjectWebCheck = async (checkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetProjectWebCheckUrl(checkId), {
+        ...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 getPutProjectWebCheckUrl = (checkId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/web-checks/${encodeURIComponent(String(checkId))}`;
+};
+/**
+ * **Create or replace**: to modify a check, call this endpoint again with the same id.
+ *
+ * Unlike `/servers/{serverId}/web-checks/{checkId}`, this check does not belong to any machine — use it when the target is simply a URL. Nothing needs to be enrolled first.
+ *
+ * A check bound to a machine is removed together with that machine; a project-level check is not. Where a check belongs cannot be changed afterwards: move it by deleting and recreating it.
+ * @summary Create a web check that is not tied to a machine, or replace it by the same id
+ */
+export const putProjectWebCheck = async (checkId, putWebCheckRequestBody, 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)(getPutProjectWebCheckUrl(checkId), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putWebCheckRequestBody),
+    });
+    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 getDeleteProjectWebCheckUrl = (checkId) => {
+    return `https://monitoring.leaflow.cloud/api/v1/web-checks/${encodeURIComponent(String(checkId))}`;
+};
+/**
+ * The corresponding check task and trigger are removed from the monitoring system as well.
+ * @summary Delete a project-level web check
+ */
+export const deleteProjectWebCheck = async (checkId, options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteProjectWebCheckUrl(checkId), {
+        ...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 getGetStatusPageDomainUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/domain`;
+};
+/**
+ * Reports whether the domain currently resolves to the status page and where its certificate stands.
+ *
+ * `expected_cname` is the value the domain must point at. `observed_cname` is what it currently resolves to, which is what to show the user when verification fails — "verification failed" on its own tells them nothing about what to fix.
+ * @summary Get the custom domain and its certificate state
+ */
+export const getStatusPageDomain = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getGetStatusPageDomainUrl(), {
+        ...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 getPutStatusPageDomainUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/domain`;
+};
+/**
+ * The domain must already point at the status page by CNAME. Binding is rejected until it does, and the error carries both the expected and the observed target.
+ *
+ * Ownership is verified before the domain is stored, and it is verified again before each certificate is issued: a domain whose CNAME is later removed stops being served.
+ *
+ * A certificate is requested in the background — this call does not wait for it. Poll GET on this endpoint to follow its progress; until a certificate is active, the domain does not serve HTTPS while the page remains reachable at its shared address.
+ * @summary Bind a custom domain to this status page
+ */
+export const putStatusPageDomain = async (putStatusPageDomainRequestBody, 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)(getPutStatusPageDomainUrl(), {
+        ...options,
+        method: "PUT",
+        headers: { "Content-Type": "application/json", ...getHeaders(options?.headers) },
+        body: JSON.stringify(putStatusPageDomainRequestBody),
+    });
+    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 getDeleteStatusPageDomainUrl = () => {
+    return `https://monitoring.leaflow.cloud/api/v1/status-page/domain`;
+};
+/**
+ * The page stays reachable at its shared address. Certificate renewal for the domain stops; the certificate already issued is left to expire.
+ * @summary Unbind the custom domain
+ */
+export const deleteStatusPageDomain = async (options, fetchFn) => {
+    const res = await (fetchFn ?? fetch)(getDeleteStatusPageDomainUrl(), {
+        ...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 };
+};