@leaflow/sdk 0.106.0 → 0.108.0

package/dist/monitoring/v1/generated/functions.d.ts

@@ -0,0 +1,1503 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Monitoring API
+ * Monitoring for your own project: enroll machines, read metrics, work through incidents, schedule maintenance windows, and set availability targets.
+ *
+ * ## Authentication
+ *
+ * Every request carries a scoped token; see the `bearerAuth` security scheme.
+ *
+ * ## Two distinctions worth keeping straight
+ *
+ * - **Disabling is not deleting.** `POST /servers/{id}/disable` is reversible and preserves all history. `DELETE /servers/{id}` also removes the monitored host, its history and every incident recorded against it, and cannot be undone.
+ * - **Recovery is not closure.** `incident_status` reports whether monitoring considers the problem recovered; `closed_at` reports whether someone has finished handling it. An incident that has not recovered may still be closed as an accepted risk.
+ *
+ * ## The PSK is returned once
+ *
+ * Enrollment and rotation responses include `tls_psk`. No other endpoint will return it again, so store it immediately. If it is lost, rotate once more — at the cost of updating the agent configuration on the monitored machine.
+ * OpenAPI spec version: 1.0.0
+ */
+import type { AcknowledgeIncidentRequestBody } from "./models/acknowledgeIncidentRequestBody.js";
+import type { AddCommentRequestBody } from "./models/addCommentRequestBody.js";
+import type { AssignIncidentRequestBody } from "./models/assignIncidentRequestBody.js";
+import type { CloseIncidentRequestBody } from "./models/closeIncidentRequestBody.js";
+import type { CursorPageIncidentActivityResource } from "./models/cursorPageIncidentActivityResource.js";
+import type { EnableMonitoringRequestBody } from "./models/enableMonitoringRequestBody.js";
+import type { EnrollmentResource } from "./models/enrollmentResource.js";
+import type { Error } from "./models/error.js";
+import type { GetServerMetricParams } from "./models/getServerMetricParams.js";
+import type { GetSliReportParams } from "./models/getSliReportParams.js";
+import type { IncidentActivityResource } from "./models/incidentActivityResource.js";
+import type { IncidentResource } from "./models/incidentResource.js";
+import type { ItemListResponseBody } from "./models/itemListResponseBody.js";
+import type { LengthAwarePageIncidentResource } from "./models/lengthAwarePageIncidentResource.js";
+import type { LengthAwarePageServerResource } from "./models/lengthAwarePageServerResource.js";
+import type { LengthAwarePageStatusPageIncidentResource } from "./models/lengthAwarePageStatusPageIncidentResource.js";
+import type { LengthAwarePageStatusPageMaintenanceResource } from "./models/lengthAwarePageStatusPageMaintenanceResource.js";
+import type { ListIncidentTimelineParams } from "./models/listIncidentTimelineParams.js";
+import type { ListIncidentsParams } from "./models/listIncidentsParams.js";
+import type { ListProjectTopItemsParams } from "./models/listProjectTopItemsParams.js";
+import type { ListServerItemsParams } from "./models/listServerItemsParams.js";
+import type { ListServersParams } from "./models/listServersParams.js";
+import type { ListStatusPageIncidentsParams } from "./models/listStatusPageIncidentsParams.js";
+import type { ListStatusPageMaintenancesParams } from "./models/listStatusPageMaintenancesParams.js";
+import type { ListWebChecksParams } from "./models/listWebChecksParams.js";
+import type { MaintenanceWindowListResponseBody } from "./models/maintenanceWindowListResponseBody.js";
+import type { MaintenanceWindowResource } from "./models/maintenanceWindowResource.js";
+import type { MetricResponseBody } from "./models/metricResponseBody.js";
+import type { PostStatusPageIncidentUpdateRequestBody } from "./models/postStatusPageIncidentUpdateRequestBody.js";
+import type { ProjectOverviewResource } from "./models/projectOverviewResource.js";
+import type { PublishStatusPageIncidentRequestBody } from "./models/publishStatusPageIncidentRequestBody.js";
+import type { PutMaintenanceWindowRequestBody } from "./models/putMaintenanceWindowRequestBody.js";
+import type { PutSLORequestBody } from "./models/putSLORequestBody.js";
+import type { PutStatusPageComponentRequestBody } from "./models/putStatusPageComponentRequestBody.js";
+import type { PutStatusPageComponentSourcesRequestBody } from "./models/putStatusPageComponentSourcesRequestBody.js";
+import type { PutStatusPageDomainRequestBody } from "./models/putStatusPageDomainRequestBody.js";
+import type { PutStatusPageGroupOrderRequestBody } from "./models/putStatusPageGroupOrderRequestBody.js";
+import type { PutStatusPageGroupRequestBody } from "./models/putStatusPageGroupRequestBody.js";
+import type { PutStatusPageOrderRequestBody } from "./models/putStatusPageOrderRequestBody.js";
+import type { PutStatusPageRequestBody } from "./models/putStatusPageRequestBody.js";
+import type { PutWebCheckRequestBody } from "./models/putWebCheckRequestBody.js";
+import type { SLIReportResponseBody } from "./models/sLIReportResponseBody.js";
+import type { SLOResource } from "./models/sLOResource.js";
+import type { ScheduleStatusPageMaintenanceRequestBody } from "./models/scheduleStatusPageMaintenanceRequestBody.js";
+import type { ServerEnrollmentResponseBody } from "./models/serverEnrollmentResponseBody.js";
+import type { ServerResource } from "./models/serverResource.js";
+import type { ServerResourcesResource } from "./models/serverResourcesResource.js";
+import type { SetFollowingRequestBody } from "./models/setFollowingRequestBody.js";
+import type { SnapshotResource } from "./models/snapshotResource.js";
+import type { StatusPageComponentListResponseBody } from "./models/statusPageComponentListResponseBody.js";
+import type { StatusPageComponentResource } from "./models/statusPageComponentResource.js";
+import type { StatusPageComponentSourcesResource } from "./models/statusPageComponentSourcesResource.js";
+import type { StatusPageDomainResource } from "./models/statusPageDomainResource.js";
+import type { StatusPageGroupListResponseBody } from "./models/statusPageGroupListResponseBody.js";
+import type { StatusPageGroupResource } from "./models/statusPageGroupResource.js";
+import type { StatusPageIncidentResource } from "./models/statusPageIncidentResource.js";
+import type { StatusPageMaintenanceResource } from "./models/statusPageMaintenanceResource.js";
+import type { StatusPageResource } from "./models/statusPageResource.js";
+import type { TemplateCatalogResponseBody } from "./models/templateCatalogResponseBody.js";
+import type { TopItemListResponseBody } from "./models/topItemListResponseBody.js";
+import type { UpdateServerRequestBody } from "./models/updateServerRequestBody.js";
+import type { WebCheckListResponseBody } from "./models/webCheckListResponseBody.js";
+import type { WebCheckResource } from "./models/webCheckResource.js";
+export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
+export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
+export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
+export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
+export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type listIncidentsResponse200 = {
+    data: LengthAwarePageIncidentResource;
+    status: 200;
+};
+export type listIncidentsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listIncidentsResponseSuccess = listIncidentsResponse200 & {
+    headers: Headers;
+};
+export type listIncidentsResponseError = listIncidentsResponseDefault & {
+    headers: Headers;
+};
+export type listIncidentsResponse = listIncidentsResponseSuccess | listIncidentsResponseError;
+export declare const getListIncidentsUrl: (params?: ListIncidentsParams) => string;
+/**
+ * `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 declare const listIncidents: (params?: ListIncidentsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listIncidentsResponse>;
+export type getIncidentResponse200 = {
+    data: IncidentResource;
+    status: 200;
+};
+export type getIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getIncidentResponseSuccess = getIncidentResponse200 & {
+    headers: Headers;
+};
+export type getIncidentResponseError = getIncidentResponseDefault & {
+    headers: Headers;
+};
+export type getIncidentResponse = getIncidentResponseSuccess | getIncidentResponseError;
+export declare const getGetIncidentUrl: (incidentId: string) => string;
+/**
+ * @summary Get an incident
+ */
+export declare const getIncident: (incidentId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getIncidentResponse>;
+export type acknowledgeIncidentResponse200 = {
+    data: IncidentResource;
+    status: 200;
+};
+export type acknowledgeIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type acknowledgeIncidentResponseSuccess = acknowledgeIncidentResponse200 & {
+    headers: Headers;
+};
+export type acknowledgeIncidentResponseError = acknowledgeIncidentResponseDefault & {
+    headers: Headers;
+};
+export type acknowledgeIncidentResponse = acknowledgeIncidentResponseSuccess | acknowledgeIncidentResponseError;
+export declare const getAcknowledgeIncidentUrl: (incidentId: string) => string;
+/**
+ * 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 declare const acknowledgeIncident: (incidentId: string, acknowledgeIncidentRequestBody: AcknowledgeIncidentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<acknowledgeIncidentResponse>;
+export type assignIncidentResponse200 = {
+    data: IncidentResource;
+    status: 200;
+};
+export type assignIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type assignIncidentResponseSuccess = assignIncidentResponse200 & {
+    headers: Headers;
+};
+export type assignIncidentResponseError = assignIncidentResponseDefault & {
+    headers: Headers;
+};
+export type assignIncidentResponse = assignIncidentResponseSuccess | assignIncidentResponseError;
+export declare const getAssignIncidentUrl: (incidentId: string) => string;
+/**
+ * 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 declare const assignIncident: (incidentId: string, assignIncidentRequestBody: AssignIncidentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<assignIncidentResponse>;
+export type closeIncidentResponse200 = {
+    data: IncidentResource;
+    status: 200;
+};
+export type closeIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type closeIncidentResponseSuccess = closeIncidentResponse200 & {
+    headers: Headers;
+};
+export type closeIncidentResponseError = closeIncidentResponseDefault & {
+    headers: Headers;
+};
+export type closeIncidentResponse = closeIncidentResponseSuccess | closeIncidentResponseError;
+export declare const getCloseIncidentUrl: (incidentId: string) => string;
+/**
+ * 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 declare const closeIncident: (incidentId: string, closeIncidentRequestBody: CloseIncidentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<closeIncidentResponse>;
+export type addIncidentCommentResponse200 = {
+    data: IncidentActivityResource;
+    status: 200;
+};
+export type addIncidentCommentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type addIncidentCommentResponseSuccess = addIncidentCommentResponse200 & {
+    headers: Headers;
+};
+export type addIncidentCommentResponseError = addIncidentCommentResponseDefault & {
+    headers: Headers;
+};
+export type addIncidentCommentResponse = addIncidentCommentResponseSuccess | addIncidentCommentResponseError;
+export declare const getAddIncidentCommentUrl: (incidentId: string) => string;
+/**
+ * @summary Add a note to the timeline
+ */
+export declare const addIncidentComment: (incidentId: string, addCommentRequestBody: AddCommentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<addIncidentCommentResponse>;
+export type setIncidentFollowingResponse200 = {
+    data: IncidentResource;
+    status: 200;
+};
+export type setIncidentFollowingResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setIncidentFollowingResponseSuccess = setIncidentFollowingResponse200 & {
+    headers: Headers;
+};
+export type setIncidentFollowingResponseError = setIncidentFollowingResponseDefault & {
+    headers: Headers;
+};
+export type setIncidentFollowingResponse = setIncidentFollowingResponseSuccess | setIncidentFollowingResponseError;
+export declare const getSetIncidentFollowingUrl: (incidentId: string) => string;
+/**
+ * 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 declare const setIncidentFollowing: (incidentId: string, setFollowingRequestBody: SetFollowingRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setIncidentFollowingResponse>;
+export type reopenIncidentResponse200 = {
+    data: IncidentResource;
+    status: 200;
+};
+export type reopenIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type reopenIncidentResponseSuccess = reopenIncidentResponse200 & {
+    headers: Headers;
+};
+export type reopenIncidentResponseError = reopenIncidentResponseDefault & {
+    headers: Headers;
+};
+export type reopenIncidentResponse = reopenIncidentResponseSuccess | reopenIncidentResponseError;
+export declare const getReopenIncidentUrl: (incidentId: string) => string;
+/**
+ * @summary Reopen a closed incident
+ */
+export declare const reopenIncident: (incidentId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<reopenIncidentResponse>;
+export type listIncidentTimelineResponse200 = {
+    data: CursorPageIncidentActivityResource;
+    status: 200;
+};
+export type listIncidentTimelineResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listIncidentTimelineResponseSuccess = listIncidentTimelineResponse200 & {
+    headers: Headers;
+};
+export type listIncidentTimelineResponseError = listIncidentTimelineResponseDefault & {
+    headers: Headers;
+};
+export type listIncidentTimelineResponse = listIncidentTimelineResponseSuccess | listIncidentTimelineResponseError;
+export declare const getListIncidentTimelineUrl: (incidentId: string, params?: ListIncidentTimelineParams) => string;
+/**
+ * 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 declare const listIncidentTimeline: (incidentId: string, params?: ListIncidentTimelineParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listIncidentTimelineResponse>;
+export type listMaintenanceWindowsResponse200 = {
+    data: MaintenanceWindowListResponseBody;
+    status: 200;
+};
+export type listMaintenanceWindowsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listMaintenanceWindowsResponseSuccess = listMaintenanceWindowsResponse200 & {
+    headers: Headers;
+};
+export type listMaintenanceWindowsResponseError = listMaintenanceWindowsResponseDefault & {
+    headers: Headers;
+};
+export type listMaintenanceWindowsResponse = listMaintenanceWindowsResponseSuccess | listMaintenanceWindowsResponseError;
+export declare const getListMaintenanceWindowsUrl: () => string;
+/**
+ * @summary List maintenance windows
+ */
+export declare const listMaintenanceWindows: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listMaintenanceWindowsResponse>;
+export type getMaintenanceWindowResponse200 = {
+    data: MaintenanceWindowResource;
+    status: 200;
+};
+export type getMaintenanceWindowResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getMaintenanceWindowResponseSuccess = getMaintenanceWindowResponse200 & {
+    headers: Headers;
+};
+export type getMaintenanceWindowResponseError = getMaintenanceWindowResponseDefault & {
+    headers: Headers;
+};
+export type getMaintenanceWindowResponse = getMaintenanceWindowResponseSuccess | getMaintenanceWindowResponseError;
+export declare const getGetMaintenanceWindowUrl: (windowId: string) => string;
+/**
+ * @summary Get a maintenance window
+ */
+export declare const getMaintenanceWindow: (windowId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getMaintenanceWindowResponse>;
+export type putMaintenanceWindowResponse200 = {
+    data: MaintenanceWindowResource;
+    status: 200;
+};
+export type putMaintenanceWindowResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putMaintenanceWindowResponseSuccess = putMaintenanceWindowResponse200 & {
+    headers: Headers;
+};
+export type putMaintenanceWindowResponseError = putMaintenanceWindowResponseDefault & {
+    headers: Headers;
+};
+export type putMaintenanceWindowResponse = putMaintenanceWindowResponseSuccess | putMaintenanceWindowResponseError;
+export declare const getPutMaintenanceWindowUrl: (windowId: string) => string;
+/**
+ * **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 declare const putMaintenanceWindow: (windowId: string, putMaintenanceWindowRequestBody: PutMaintenanceWindowRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putMaintenanceWindowResponse>;
+export type deleteMaintenanceWindowResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteMaintenanceWindowResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteMaintenanceWindowResponseSuccess = deleteMaintenanceWindowResponse204 & {
+    headers: Headers;
+};
+export type deleteMaintenanceWindowResponseError = deleteMaintenanceWindowResponseDefault & {
+    headers: Headers;
+};
+export type deleteMaintenanceWindowResponse = deleteMaintenanceWindowResponseSuccess | deleteMaintenanceWindowResponseError;
+export declare const getDeleteMaintenanceWindowUrl: (windowId: string) => string;
+/**
+ * Alerting resumes immediately, even if the window has not yet expired.
+ * @summary Cancel a maintenance window
+ */
+export declare const deleteMaintenanceWindow: (windowId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteMaintenanceWindowResponse>;
+export type getProjectOverviewResponse200 = {
+    data: ProjectOverviewResource;
+    status: 200;
+};
+export type getProjectOverviewResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getProjectOverviewResponseSuccess = getProjectOverviewResponse200 & {
+    headers: Headers;
+};
+export type getProjectOverviewResponseError = getProjectOverviewResponseDefault & {
+    headers: Headers;
+};
+export type getProjectOverviewResponse = getProjectOverviewResponseSuccess | getProjectOverviewResponseError;
+export declare const getGetProjectOverviewUrl: () => string;
+/**
+ * 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 declare const getProjectOverview: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getProjectOverviewResponse>;
+export type listServerItemsResponse200 = {
+    data: ItemListResponseBody;
+    status: 200;
+};
+export type listServerItemsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listServerItemsResponseSuccess = listServerItemsResponse200 & {
+    headers: Headers;
+};
+export type listServerItemsResponseError = listServerItemsResponseDefault & {
+    headers: Headers;
+};
+export type listServerItemsResponse = listServerItemsResponseSuccess | listServerItemsResponseError;
+export declare const getListServerItemsUrl: (serverId: string, params?: ListServerItemsParams) => string;
+/**
+ * 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 declare const listServerItems: (serverId: string, params?: ListServerItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listServerItemsResponse>;
+export type getServerMetricResponse200 = {
+    data: MetricResponseBody;
+    status: 200;
+};
+export type getServerMetricResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getServerMetricResponseSuccess = getServerMetricResponse200 & {
+    headers: Headers;
+};
+export type getServerMetricResponseError = getServerMetricResponseDefault & {
+    headers: Headers;
+};
+export type getServerMetricResponse = getServerMetricResponseSuccess | getServerMetricResponseError;
+export declare const getGetServerMetricUrl: (serverId: string, params?: GetServerMetricParams) => string;
+/**
+ * `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 declare const getServerMetric: (serverId: string, params?: GetServerMetricParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getServerMetricResponse>;
+export type getServerResourcesResponse200 = {
+    data: ServerResourcesResource;
+    status: 200;
+};
+export type getServerResourcesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getServerResourcesResponseSuccess = getServerResourcesResponse200 & {
+    headers: Headers;
+};
+export type getServerResourcesResponseError = getServerResourcesResponseDefault & {
+    headers: Headers;
+};
+export type getServerResourcesResponse = getServerResourcesResponseSuccess | getServerResourcesResponseError;
+export declare const getGetServerResourcesUrl: (serverId: string) => string;
+/**
+ * @summary Hardware and interfaces of a machine
+ */
+export declare const getServerResources: (serverId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getServerResourcesResponse>;
+export type getServerSnapshotResponse200 = {
+    data: SnapshotResource;
+    status: 200;
+};
+export type getServerSnapshotResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getServerSnapshotResponseSuccess = getServerSnapshotResponse200 & {
+    headers: Headers;
+};
+export type getServerSnapshotResponseError = getServerSnapshotResponseDefault & {
+    headers: Headers;
+};
+export type getServerSnapshotResponse = getServerSnapshotResponseSuccess | getServerSnapshotResponseError;
+export declare const getGetServerSnapshotUrl: (serverId: string) => string;
+/**
+ * @summary Current state of a machine
+ */
+export declare const getServerSnapshot: (serverId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getServerSnapshotResponse>;
+export type listProjectTopItemsResponse200 = {
+    data: TopItemListResponseBody;
+    status: 200;
+};
+export type listProjectTopItemsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listProjectTopItemsResponseSuccess = listProjectTopItemsResponse200 & {
+    headers: Headers;
+};
+export type listProjectTopItemsResponseError = listProjectTopItemsResponseDefault & {
+    headers: Headers;
+};
+export type listProjectTopItemsResponse = listProjectTopItemsResponseSuccess | listProjectTopItemsResponseError;
+export declare const getListProjectTopItemsUrl: (params: ListProjectTopItemsParams) => string;
+/**
+ * @summary Machines ranked highest by a given metric
+ */
+export declare const listProjectTopItems: (params: ListProjectTopItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listProjectTopItemsResponse>;
+export type listTemplatesResponse200 = {
+    data: TemplateCatalogResponseBody;
+    status: 200;
+};
+export type listTemplatesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listTemplatesResponseSuccess = listTemplatesResponse200 & {
+    headers: Headers;
+};
+export type listTemplatesResponseError = listTemplatesResponseDefault & {
+    headers: Headers;
+};
+export type listTemplatesResponse = listTemplatesResponseSuccess | listTemplatesResponseError;
+export declare const getListTemplatesUrl: () => string;
+/**
+ * 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 declare const listTemplates: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listTemplatesResponse>;
+export type listServersResponse200 = {
+    data: LengthAwarePageServerResource;
+    status: 200;
+};
+export type listServersResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listServersResponseSuccess = listServersResponse200 & {
+    headers: Headers;
+};
+export type listServersResponseError = listServersResponseDefault & {
+    headers: Headers;
+};
+export type listServersResponse = listServersResponseSuccess | listServersResponseError;
+export declare const getListServersUrl: (params?: ListServersParams) => string;
+/**
+ * @summary List the machines in the project
+ */
+export declare const listServers: (params?: ListServersParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listServersResponse>;
+export type getServerResponse200 = {
+    data: ServerResource;
+    status: 200;
+};
+export type getServerResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getServerResponseSuccess = getServerResponse200 & {
+    headers: Headers;
+};
+export type getServerResponseError = getServerResponseDefault & {
+    headers: Headers;
+};
+export type getServerResponse = getServerResponseSuccess | getServerResponseError;
+export declare const getGetServerUrl: (serverId: string) => string;
+/**
+ * @summary Get the enrollment state of a machine
+ */
+export declare const getServer: (serverId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getServerResponse>;
+export type enableServerMonitoringResponse200 = {
+    data: ServerEnrollmentResponseBody;
+    status: 200;
+};
+export type enableServerMonitoringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type enableServerMonitoringResponseSuccess = enableServerMonitoringResponse200 & {
+    headers: Headers;
+};
+export type enableServerMonitoringResponseError = enableServerMonitoringResponseDefault & {
+    headers: Headers;
+};
+export type enableServerMonitoringResponse = enableServerMonitoringResponseSuccess | enableServerMonitoringResponseError;
+export declare const getEnableServerMonitoringUrl: (serverId: string) => string;
+/**
+ * **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 declare const enableServerMonitoring: (serverId: string, enableMonitoringRequestBody: EnableMonitoringRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<enableServerMonitoringResponse>;
+export type updateServerResponse200 = {
+    data: ServerResource;
+    status: 200;
+};
+export type updateServerResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateServerResponseSuccess = updateServerResponse200 & {
+    headers: Headers;
+};
+export type updateServerResponseError = updateServerResponseDefault & {
+    headers: Headers;
+};
+export type updateServerResponse = updateServerResponseSuccess | updateServerResponseError;
+export declare const getUpdateServerUrl: (serverId: string) => string;
+/**
+ * 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 declare const updateServer: (serverId: string, updateServerRequestBody: UpdateServerRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateServerResponse>;
+export type deleteServerResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteServerResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteServerResponseSuccess = deleteServerResponse204 & {
+    headers: Headers;
+};
+export type deleteServerResponseError = deleteServerResponseDefault & {
+    headers: Headers;
+};
+export type deleteServerResponse = deleteServerResponseSuccess | deleteServerResponseError;
+export declare const getDeleteServerUrl: (serverId: string) => string;
+/**
+ * **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 declare const deleteServer: (serverId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteServerResponse>;
+export type disableServerMonitoringResponse204 = {
+    data: void;
+    status: 204;
+};
+export type disableServerMonitoringResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type disableServerMonitoringResponseSuccess = disableServerMonitoringResponse204 & {
+    headers: Headers;
+};
+export type disableServerMonitoringResponseError = disableServerMonitoringResponseDefault & {
+    headers: Headers;
+};
+export type disableServerMonitoringResponse = disableServerMonitoringResponseSuccess | disableServerMonitoringResponseError;
+export declare const getDisableServerMonitoringUrl: (serverId: string) => string;
+/**
+ * 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 declare const disableServerMonitoring: (serverId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<disableServerMonitoringResponse>;
+export type rotateAgentPskResponse200 = {
+    data: EnrollmentResource;
+    status: 200;
+};
+export type rotateAgentPskResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type rotateAgentPskResponseSuccess = rotateAgentPskResponse200 & {
+    headers: Headers;
+};
+export type rotateAgentPskResponseError = rotateAgentPskResponseDefault & {
+    headers: Headers;
+};
+export type rotateAgentPskResponse = rotateAgentPskResponseSuccess | rotateAgentPskResponseError;
+export declare const getRotateAgentPskUrl: (serverId: string) => string;
+/**
+ * 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 declare const rotateAgentPsk: (serverId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<rotateAgentPskResponse>;
+export type getWebCheckResponse200 = {
+    data: WebCheckResource;
+    status: 200;
+};
+export type getWebCheckResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getWebCheckResponseSuccess = getWebCheckResponse200 & {
+    headers: Headers;
+};
+export type getWebCheckResponseError = getWebCheckResponseDefault & {
+    headers: Headers;
+};
+export type getWebCheckResponse = getWebCheckResponseSuccess | getWebCheckResponseError;
+export declare const getGetWebCheckUrl: (serverId: string, checkId: string) => string;
+/**
+ * @summary Get a web check
+ */
+export declare const getWebCheck: (serverId: string, checkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getWebCheckResponse>;
+export type putWebCheckResponse200 = {
+    data: WebCheckResource;
+    status: 200;
+};
+export type putWebCheckResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putWebCheckResponseSuccess = putWebCheckResponse200 & {
+    headers: Headers;
+};
+export type putWebCheckResponseError = putWebCheckResponseDefault & {
+    headers: Headers;
+};
+export type putWebCheckResponse = putWebCheckResponseSuccess | putWebCheckResponseError;
+export declare const getPutWebCheckUrl: (serverId: string, checkId: string) => string;
+/**
+ * **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 declare const putWebCheck: (serverId: string, checkId: string, putWebCheckRequestBody: PutWebCheckRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putWebCheckResponse>;
+export type deleteWebCheckResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteWebCheckResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteWebCheckResponseSuccess = deleteWebCheckResponse204 & {
+    headers: Headers;
+};
+export type deleteWebCheckResponseError = deleteWebCheckResponseDefault & {
+    headers: Headers;
+};
+export type deleteWebCheckResponse = deleteWebCheckResponseSuccess | deleteWebCheckResponseError;
+export declare const getDeleteWebCheckUrl: (serverId: string, checkId: string) => string;
+/**
+ * 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 declare const deleteWebCheck: (serverId: string, checkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteWebCheckResponse>;
+export type listWebChecksResponse200 = {
+    data: WebCheckListResponseBody;
+    status: 200;
+};
+export type listWebChecksResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listWebChecksResponseSuccess = listWebChecksResponse200 & {
+    headers: Headers;
+};
+export type listWebChecksResponseError = listWebChecksResponseDefault & {
+    headers: Headers;
+};
+export type listWebChecksResponse = listWebChecksResponseSuccess | listWebChecksResponseError;
+export declare const getListWebChecksUrl: (params?: ListWebChecksParams) => string;
+/**
+ * @summary List web checks
+ */
+export declare const listWebChecks: (params?: ListWebChecksParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listWebChecksResponse>;
+export type getSliReportResponse200 = {
+    data: SLIReportResponseBody;
+    status: 200;
+};
+export type getSliReportResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSliReportResponseSuccess = getSliReportResponse200 & {
+    headers: Headers;
+};
+export type getSliReportResponseError = getSliReportResponseDefault & {
+    headers: Headers;
+};
+export type getSliReportResponse = getSliReportResponseSuccess | getSliReportResponseError;
+export declare const getGetSliReportUrl: (params?: GetSliReportParams) => string;
+/**
+ * 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 declare const getSliReport: (params?: GetSliReportParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSliReportResponse>;
+export type getSloResponse200 = {
+    data: SLOResource;
+    status: 200;
+};
+export type getSloResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSloResponseSuccess = getSloResponse200 & {
+    headers: Headers;
+};
+export type getSloResponseError = getSloResponseDefault & {
+    headers: Headers;
+};
+export type getSloResponse = getSloResponseSuccess | getSloResponseError;
+export declare const getGetSloUrl: () => string;
+/**
+ * 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 declare const getSlo: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSloResponse>;
+export type putSloResponse200 = {
+    data: SLOResource;
+    status: 200;
+};
+export type putSloResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putSloResponseSuccess = putSloResponse200 & {
+    headers: Headers;
+};
+export type putSloResponseError = putSloResponseDefault & {
+    headers: Headers;
+};
+export type putSloResponse = putSloResponseSuccess | putSloResponseError;
+export declare const getPutSloUrl: () => string;
+/**
+ * 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 declare const putSlo: (putSLORequestBody: PutSLORequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putSloResponse>;
+export type deleteSloResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteSloResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteSloResponseSuccess = deleteSloResponse204 & {
+    headers: Headers;
+};
+export type deleteSloResponseError = deleteSloResponseDefault & {
+    headers: Headers;
+};
+export type deleteSloResponse = deleteSloResponseSuccess | deleteSloResponseError;
+export declare const getDeleteSloUrl: () => string;
+/**
+ * Availability is no longer tracked from this point on.
+ * @summary Remove the availability target of this project
+ */
+export declare const deleteSlo: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSloResponse>;
+export type getStatusPageResponse200 = {
+    data: StatusPageResource;
+    status: 200;
+};
+export type getStatusPageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatusPageResponseSuccess = getStatusPageResponse200 & {
+    headers: Headers;
+};
+export type getStatusPageResponseError = getStatusPageResponseDefault & {
+    headers: Headers;
+};
+export type getStatusPageResponse = getStatusPageResponseSuccess | getStatusPageResponseError;
+export declare const getGetStatusPageUrl: () => string;
+/**
+ * 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 declare const getStatusPage: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatusPageResponse>;
+export type putStatusPageResponse200 = {
+    data: StatusPageResource;
+    status: 200;
+};
+export type putStatusPageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putStatusPageResponseSuccess = putStatusPageResponse200 & {
+    headers: Headers;
+};
+export type putStatusPageResponseError = putStatusPageResponseDefault & {
+    headers: Headers;
+};
+export type putStatusPageResponse = putStatusPageResponseSuccess | putStatusPageResponseError;
+export declare const getPutStatusPageUrl: () => string;
+/**
+ * **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 declare const putStatusPage: (putStatusPageRequestBody: PutStatusPageRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putStatusPageResponse>;
+export type deleteStatusPageResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteStatusPageResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteStatusPageResponseSuccess = deleteStatusPageResponse204 & {
+    headers: Headers;
+};
+export type deleteStatusPageResponseError = deleteStatusPageResponseDefault & {
+    headers: Headers;
+};
+export type deleteStatusPageResponse = deleteStatusPageResponseSuccess | deleteStatusPageResponseError;
+export declare const getDeleteStatusPageUrl: () => string;
+/**
+ * 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 declare const deleteStatusPage: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteStatusPageResponse>;
+export type putStatusPageOrderResponse204 = {
+    data: void;
+    status: 204;
+};
+export type putStatusPageOrderResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type putStatusPageOrderResponseSuccess = putStatusPageOrderResponse204 & {
+    headers: Headers;
+};
+export type putStatusPageOrderResponseError = putStatusPageOrderResponseDefault & {
+    headers: Headers;
+};
+export type putStatusPageOrderResponse = putStatusPageOrderResponseSuccess | putStatusPageOrderResponseError;
+export declare const getPutStatusPageOrderUrl: () => string;
+/**
+ * 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 declare const putStatusPageOrder: (putStatusPageOrderRequestBody: PutStatusPageOrderRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putStatusPageOrderResponse>;
+export type listStatusPageGroupsResponse200 = {
+    data: StatusPageGroupListResponseBody;
+    status: 200;
+};
+export type listStatusPageGroupsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listStatusPageGroupsResponseSuccess = listStatusPageGroupsResponse200 & {
+    headers: Headers;
+};
+export type listStatusPageGroupsResponseError = listStatusPageGroupsResponseDefault & {
+    headers: Headers;
+};
+export type listStatusPageGroupsResponse = listStatusPageGroupsResponseSuccess | listStatusPageGroupsResponseError;
+export declare const getListStatusPageGroupsUrl: () => string;
+/**
+ * @summary List groups
+ */
+export declare const listStatusPageGroups: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listStatusPageGroupsResponse>;
+export type createStatusPageGroupResponse201 = {
+    data: StatusPageGroupResource;
+    status: 201;
+};
+export type createStatusPageGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createStatusPageGroupResponseSuccess = createStatusPageGroupResponse201 & {
+    headers: Headers;
+};
+export type createStatusPageGroupResponseError = createStatusPageGroupResponseDefault & {
+    headers: Headers;
+};
+export type createStatusPageGroupResponse = createStatusPageGroupResponseSuccess | createStatusPageGroupResponseError;
+export declare const getCreateStatusPageGroupUrl: () => string;
+/**
+ * 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 declare const createStatusPageGroup: (putStatusPageGroupRequestBody: PutStatusPageGroupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createStatusPageGroupResponse>;
+export type updateStatusPageGroupResponse200 = {
+    data: StatusPageGroupResource;
+    status: 200;
+};
+export type updateStatusPageGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateStatusPageGroupResponseSuccess = updateStatusPageGroupResponse200 & {
+    headers: Headers;
+};
+export type updateStatusPageGroupResponseError = updateStatusPageGroupResponseDefault & {
+    headers: Headers;
+};
+export type updateStatusPageGroupResponse = updateStatusPageGroupResponseSuccess | updateStatusPageGroupResponseError;
+export declare const getUpdateStatusPageGroupUrl: (groupId: string) => string;
+/**
+ * @summary Update a group
+ */
+export declare const updateStatusPageGroup: (groupId: string, putStatusPageGroupRequestBody: PutStatusPageGroupRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateStatusPageGroupResponse>;
+export type deleteStatusPageGroupResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteStatusPageGroupResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteStatusPageGroupResponseSuccess = deleteStatusPageGroupResponse204 & {
+    headers: Headers;
+};
+export type deleteStatusPageGroupResponseError = deleteStatusPageGroupResponseDefault & {
+    headers: Headers;
+};
+export type deleteStatusPageGroupResponse = deleteStatusPageGroupResponseSuccess | deleteStatusPageGroupResponseError;
+export declare const getDeleteStatusPageGroupUrl: (groupId: string) => string;
+/**
+ * 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 declare const deleteStatusPageGroup: (groupId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteStatusPageGroupResponse>;
+export type putStatusPageGroupOrderResponse204 = {
+    data: void;
+    status: 204;
+};
+export type putStatusPageGroupOrderResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type putStatusPageGroupOrderResponseSuccess = putStatusPageGroupOrderResponse204 & {
+    headers: Headers;
+};
+export type putStatusPageGroupOrderResponseError = putStatusPageGroupOrderResponseDefault & {
+    headers: Headers;
+};
+export type putStatusPageGroupOrderResponse = putStatusPageGroupOrderResponseSuccess | putStatusPageGroupOrderResponseError;
+export declare const getPutStatusPageGroupOrderUrl: (groupId: string) => string;
+/**
+ * @summary Set the order of components within a group
+ */
+export declare const putStatusPageGroupOrder: (groupId: string, putStatusPageGroupOrderRequestBody: PutStatusPageGroupOrderRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putStatusPageGroupOrderResponse>;
+export type listStatusPageComponentsResponse200 = {
+    data: StatusPageComponentListResponseBody;
+    status: 200;
+};
+export type listStatusPageComponentsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listStatusPageComponentsResponseSuccess = listStatusPageComponentsResponse200 & {
+    headers: Headers;
+};
+export type listStatusPageComponentsResponseError = listStatusPageComponentsResponseDefault & {
+    headers: Headers;
+};
+export type listStatusPageComponentsResponse = listStatusPageComponentsResponseSuccess | listStatusPageComponentsResponseError;
+export declare const getListStatusPageComponentsUrl: () => string;
+/**
+ * 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 declare const listStatusPageComponents: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listStatusPageComponentsResponse>;
+export type createStatusPageComponentResponse201 = {
+    data: StatusPageComponentResource;
+    status: 201;
+};
+export type createStatusPageComponentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createStatusPageComponentResponseSuccess = createStatusPageComponentResponse201 & {
+    headers: Headers;
+};
+export type createStatusPageComponentResponseError = createStatusPageComponentResponseDefault & {
+    headers: Headers;
+};
+export type createStatusPageComponentResponse = createStatusPageComponentResponseSuccess | createStatusPageComponentResponseError;
+export declare const getCreateStatusPageComponentUrl: () => string;
+/**
+ * `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 declare const createStatusPageComponent: (putStatusPageComponentRequestBody: PutStatusPageComponentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createStatusPageComponentResponse>;
+export type getStatusPageComponentResponse200 = {
+    data: StatusPageComponentResource;
+    status: 200;
+};
+export type getStatusPageComponentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatusPageComponentResponseSuccess = getStatusPageComponentResponse200 & {
+    headers: Headers;
+};
+export type getStatusPageComponentResponseError = getStatusPageComponentResponseDefault & {
+    headers: Headers;
+};
+export type getStatusPageComponentResponse = getStatusPageComponentResponseSuccess | getStatusPageComponentResponseError;
+export declare const getGetStatusPageComponentUrl: (componentId: string) => string;
+/**
+ * @summary Get a component
+ */
+export declare const getStatusPageComponent: (componentId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatusPageComponentResponse>;
+export type updateStatusPageComponentResponse200 = {
+    data: StatusPageComponentResource;
+    status: 200;
+};
+export type updateStatusPageComponentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateStatusPageComponentResponseSuccess = updateStatusPageComponentResponse200 & {
+    headers: Headers;
+};
+export type updateStatusPageComponentResponseError = updateStatusPageComponentResponseDefault & {
+    headers: Headers;
+};
+export type updateStatusPageComponentResponse = updateStatusPageComponentResponseSuccess | updateStatusPageComponentResponseError;
+export declare const getUpdateStatusPageComponentUrl: (componentId: string) => string;
+/**
+ * `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 declare const updateStatusPageComponent: (componentId: string, putStatusPageComponentRequestBody: PutStatusPageComponentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateStatusPageComponentResponse>;
+export type deleteStatusPageComponentResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteStatusPageComponentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteStatusPageComponentResponseSuccess = deleteStatusPageComponentResponse204 & {
+    headers: Headers;
+};
+export type deleteStatusPageComponentResponseError = deleteStatusPageComponentResponseDefault & {
+    headers: Headers;
+};
+export type deleteStatusPageComponentResponse = deleteStatusPageComponentResponseSuccess | deleteStatusPageComponentResponseError;
+export declare const getDeleteStatusPageComponentUrl: (componentId: string) => string;
+/**
+ * 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 declare const deleteStatusPageComponent: (componentId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteStatusPageComponentResponse>;
+export type listStatusPageComponentSourcesResponse200 = {
+    data: StatusPageComponentSourcesResource;
+    status: 200;
+};
+export type listStatusPageComponentSourcesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listStatusPageComponentSourcesResponseSuccess = listStatusPageComponentSourcesResponse200 & {
+    headers: Headers;
+};
+export type listStatusPageComponentSourcesResponseError = listStatusPageComponentSourcesResponseDefault & {
+    headers: Headers;
+};
+export type listStatusPageComponentSourcesResponse = listStatusPageComponentSourcesResponseSuccess | listStatusPageComponentSourcesResponseError;
+export declare const getListStatusPageComponentSourcesUrl: (componentId: string) => string;
+/**
+ * Monitored sources are internal information and **never appear on the public page**.
+ * @summary List the monitored sources bound to a component
+ */
+export declare const listStatusPageComponentSources: (componentId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listStatusPageComponentSourcesResponse>;
+export type putStatusPageComponentSourcesResponse200 = {
+    data: StatusPageComponentSourcesResource;
+    status: 200;
+};
+export type putStatusPageComponentSourcesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putStatusPageComponentSourcesResponseSuccess = putStatusPageComponentSourcesResponse200 & {
+    headers: Headers;
+};
+export type putStatusPageComponentSourcesResponseError = putStatusPageComponentSourcesResponseDefault & {
+    headers: Headers;
+};
+export type putStatusPageComponentSourcesResponse = putStatusPageComponentSourcesResponseSuccess | putStatusPageComponentSourcesResponseError;
+export declare const getPutStatusPageComponentSourcesUrl: (componentId: string) => string;
+/**
+ * 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 declare const putStatusPageComponentSources: (componentId: string, putStatusPageComponentSourcesRequestBody: PutStatusPageComponentSourcesRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putStatusPageComponentSourcesResponse>;
+export type listStatusPageIncidentsResponse200 = {
+    data: LengthAwarePageStatusPageIncidentResource;
+    status: 200;
+};
+export type listStatusPageIncidentsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listStatusPageIncidentsResponseSuccess = listStatusPageIncidentsResponse200 & {
+    headers: Headers;
+};
+export type listStatusPageIncidentsResponseError = listStatusPageIncidentsResponseDefault & {
+    headers: Headers;
+};
+export type listStatusPageIncidentsResponse = listStatusPageIncidentsResponseSuccess | listStatusPageIncidentsResponseError;
+export declare const getListStatusPageIncidentsUrl: (params?: ListStatusPageIncidentsParams) => string;
+/**
+ * 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 declare const listStatusPageIncidents: (params?: ListStatusPageIncidentsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listStatusPageIncidentsResponse>;
+export type publishStatusPageIncidentResponse201 = {
+    data: StatusPageIncidentResource;
+    status: 201;
+};
+export type publishStatusPageIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type publishStatusPageIncidentResponseSuccess = publishStatusPageIncidentResponse201 & {
+    headers: Headers;
+};
+export type publishStatusPageIncidentResponseError = publishStatusPageIncidentResponseDefault & {
+    headers: Headers;
+};
+export type publishStatusPageIncidentResponse = publishStatusPageIncidentResponseSuccess | publishStatusPageIncidentResponseError;
+export declare const getPublishStatusPageIncidentUrl: () => string;
+/**
+ * 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 declare const publishStatusPageIncident: (publishStatusPageIncidentRequestBody: PublishStatusPageIncidentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<publishStatusPageIncidentResponse>;
+export type getStatusPageIncidentResponse200 = {
+    data: StatusPageIncidentResource;
+    status: 200;
+};
+export type getStatusPageIncidentResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatusPageIncidentResponseSuccess = getStatusPageIncidentResponse200 & {
+    headers: Headers;
+};
+export type getStatusPageIncidentResponseError = getStatusPageIncidentResponseDefault & {
+    headers: Headers;
+};
+export type getStatusPageIncidentResponse = getStatusPageIncidentResponseSuccess | getStatusPageIncidentResponseError;
+export declare const getGetStatusPageIncidentUrl: (incidentId: string) => string;
+/**
+ * @summary Get an incident notice
+ */
+export declare const getStatusPageIncident: (incidentId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatusPageIncidentResponse>;
+export type postStatusPageIncidentUpdateResponse200 = {
+    data: StatusPageIncidentResource;
+    status: 200;
+};
+export type postStatusPageIncidentUpdateResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type postStatusPageIncidentUpdateResponseSuccess = postStatusPageIncidentUpdateResponse200 & {
+    headers: Headers;
+};
+export type postStatusPageIncidentUpdateResponseError = postStatusPageIncidentUpdateResponseDefault & {
+    headers: Headers;
+};
+export type postStatusPageIncidentUpdateResponse = postStatusPageIncidentUpdateResponseSuccess | postStatusPageIncidentUpdateResponseError;
+export declare const getPostStatusPageIncidentUpdateUrl: (incidentId: string) => string;
+/**
+ * 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 declare const postStatusPageIncidentUpdate: (incidentId: string, postStatusPageIncidentUpdateRequestBody: PostStatusPageIncidentUpdateRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<postStatusPageIncidentUpdateResponse>;
+export type listStatusPageMaintenancesResponse200 = {
+    data: LengthAwarePageStatusPageMaintenanceResource;
+    status: 200;
+};
+export type listStatusPageMaintenancesResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listStatusPageMaintenancesResponseSuccess = listStatusPageMaintenancesResponse200 & {
+    headers: Headers;
+};
+export type listStatusPageMaintenancesResponseError = listStatusPageMaintenancesResponseDefault & {
+    headers: Headers;
+};
+export type listStatusPageMaintenancesResponse = listStatusPageMaintenancesResponseSuccess | listStatusPageMaintenancesResponseError;
+export declare const getListStatusPageMaintenancesUrl: (params?: ListStatusPageMaintenancesParams) => string;
+/**
+ * @summary List scheduled maintenance
+ */
+export declare const listStatusPageMaintenances: (params?: ListStatusPageMaintenancesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listStatusPageMaintenancesResponse>;
+export type scheduleStatusPageMaintenanceResponse201 = {
+    data: StatusPageMaintenanceResource;
+    status: 201;
+};
+export type scheduleStatusPageMaintenanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type scheduleStatusPageMaintenanceResponseSuccess = scheduleStatusPageMaintenanceResponse201 & {
+    headers: Headers;
+};
+export type scheduleStatusPageMaintenanceResponseError = scheduleStatusPageMaintenanceResponseDefault & {
+    headers: Headers;
+};
+export type scheduleStatusPageMaintenanceResponse = scheduleStatusPageMaintenanceResponseSuccess | scheduleStatusPageMaintenanceResponseError;
+export declare const getScheduleStatusPageMaintenanceUrl: () => string;
+/**
+ * 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 declare const scheduleStatusPageMaintenance: (scheduleStatusPageMaintenanceRequestBody: ScheduleStatusPageMaintenanceRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<scheduleStatusPageMaintenanceResponse>;
+export type getStatusPageMaintenanceResponse200 = {
+    data: StatusPageMaintenanceResource;
+    status: 200;
+};
+export type getStatusPageMaintenanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatusPageMaintenanceResponseSuccess = getStatusPageMaintenanceResponse200 & {
+    headers: Headers;
+};
+export type getStatusPageMaintenanceResponseError = getStatusPageMaintenanceResponseDefault & {
+    headers: Headers;
+};
+export type getStatusPageMaintenanceResponse = getStatusPageMaintenanceResponseSuccess | getStatusPageMaintenanceResponseError;
+export declare const getGetStatusPageMaintenanceUrl: (maintenanceId: string) => string;
+/**
+ * @summary Get a scheduled maintenance
+ */
+export declare const getStatusPageMaintenance: (maintenanceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatusPageMaintenanceResponse>;
+export type cancelStatusPageMaintenanceResponse200 = {
+    data: StatusPageMaintenanceResource;
+    status: 200;
+};
+export type cancelStatusPageMaintenanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type cancelStatusPageMaintenanceResponseSuccess = cancelStatusPageMaintenanceResponse200 & {
+    headers: Headers;
+};
+export type cancelStatusPageMaintenanceResponseError = cancelStatusPageMaintenanceResponseDefault & {
+    headers: Headers;
+};
+export type cancelStatusPageMaintenanceResponse = cancelStatusPageMaintenanceResponseSuccess | cancelStatusPageMaintenanceResponseError;
+export declare const getCancelStatusPageMaintenanceUrl: (maintenanceId: string) => string;
+/**
+ * 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 declare const cancelStatusPageMaintenance: (maintenanceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelStatusPageMaintenanceResponse>;
+export type completeStatusPageMaintenanceResponse200 = {
+    data: StatusPageMaintenanceResource;
+    status: 200;
+};
+export type completeStatusPageMaintenanceResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type completeStatusPageMaintenanceResponseSuccess = completeStatusPageMaintenanceResponse200 & {
+    headers: Headers;
+};
+export type completeStatusPageMaintenanceResponseError = completeStatusPageMaintenanceResponseDefault & {
+    headers: Headers;
+};
+export type completeStatusPageMaintenanceResponse = completeStatusPageMaintenanceResponseSuccess | completeStatusPageMaintenanceResponseError;
+export declare const getCompleteStatusPageMaintenanceUrl: (maintenanceId: string) => string;
+/**
+ * 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 declare const completeStatusPageMaintenance: (maintenanceId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<completeStatusPageMaintenanceResponse>;
+export type getProjectWebCheckResponse200 = {
+    data: WebCheckResource;
+    status: 200;
+};
+export type getProjectWebCheckResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getProjectWebCheckResponseSuccess = getProjectWebCheckResponse200 & {
+    headers: Headers;
+};
+export type getProjectWebCheckResponseError = getProjectWebCheckResponseDefault & {
+    headers: Headers;
+};
+export type getProjectWebCheckResponse = getProjectWebCheckResponseSuccess | getProjectWebCheckResponseError;
+export declare const getGetProjectWebCheckUrl: (checkId: string) => string;
+/**
+ * @summary Get a project-level web check
+ */
+export declare const getProjectWebCheck: (checkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getProjectWebCheckResponse>;
+export type putProjectWebCheckResponse200 = {
+    data: WebCheckResource;
+    status: 200;
+};
+export type putProjectWebCheckResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putProjectWebCheckResponseSuccess = putProjectWebCheckResponse200 & {
+    headers: Headers;
+};
+export type putProjectWebCheckResponseError = putProjectWebCheckResponseDefault & {
+    headers: Headers;
+};
+export type putProjectWebCheckResponse = putProjectWebCheckResponseSuccess | putProjectWebCheckResponseError;
+export declare const getPutProjectWebCheckUrl: (checkId: string) => string;
+/**
+ * **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 declare const putProjectWebCheck: (checkId: string, putWebCheckRequestBody: PutWebCheckRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putProjectWebCheckResponse>;
+export type deleteProjectWebCheckResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteProjectWebCheckResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteProjectWebCheckResponseSuccess = deleteProjectWebCheckResponse204 & {
+    headers: Headers;
+};
+export type deleteProjectWebCheckResponseError = deleteProjectWebCheckResponseDefault & {
+    headers: Headers;
+};
+export type deleteProjectWebCheckResponse = deleteProjectWebCheckResponseSuccess | deleteProjectWebCheckResponseError;
+export declare const getDeleteProjectWebCheckUrl: (checkId: string) => string;
+/**
+ * The corresponding check task and trigger are removed from the monitoring system as well.
+ * @summary Delete a project-level web check
+ */
+export declare const deleteProjectWebCheck: (checkId: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteProjectWebCheckResponse>;
+export type getStatusPageDomainResponse200 = {
+    data: StatusPageDomainResource;
+    status: 200;
+};
+export type getStatusPageDomainResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getStatusPageDomainResponseSuccess = getStatusPageDomainResponse200 & {
+    headers: Headers;
+};
+export type getStatusPageDomainResponseError = getStatusPageDomainResponseDefault & {
+    headers: Headers;
+};
+export type getStatusPageDomainResponse = getStatusPageDomainResponseSuccess | getStatusPageDomainResponseError;
+export declare const getGetStatusPageDomainUrl: () => string;
+/**
+ * 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 declare const getStatusPageDomain: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getStatusPageDomainResponse>;
+export type putStatusPageDomainResponse200 = {
+    data: StatusPageDomainResource;
+    status: 200;
+};
+export type putStatusPageDomainResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putStatusPageDomainResponseSuccess = putStatusPageDomainResponse200 & {
+    headers: Headers;
+};
+export type putStatusPageDomainResponseError = putStatusPageDomainResponseDefault & {
+    headers: Headers;
+};
+export type putStatusPageDomainResponse = putStatusPageDomainResponseSuccess | putStatusPageDomainResponseError;
+export declare const getPutStatusPageDomainUrl: () => string;
+/**
+ * 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 declare const putStatusPageDomain: (putStatusPageDomainRequestBody: PutStatusPageDomainRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putStatusPageDomainResponse>;
+export type deleteStatusPageDomainResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteStatusPageDomainResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteStatusPageDomainResponseSuccess = deleteStatusPageDomainResponse204 & {
+    headers: Headers;
+};
+export type deleteStatusPageDomainResponseError = deleteStatusPageDomainResponseDefault & {
+    headers: Headers;
+};
+export type deleteStatusPageDomainResponse = deleteStatusPageDomainResponseSuccess | deleteStatusPageDomainResponseError;
+export declare const getDeleteStatusPageDomainUrl: () => string;
+/**
+ * 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 declare const deleteStatusPageDomain: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteStatusPageDomainResponse>;