@leaflow/sdk 0.0.0-dev.29.g8fe6a71 → 0.0.0-dev.291.gcde7444

package/dist/monitoring/v1/generated/schemas.zod.js

@@ -0,0 +1,626 @@
+/**
+ * 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 * as zod from "zod";
+import { AcknowledgeIncidentRequestBody } from "./validators/acknowledgeIncidentRequestBody.zod.js";
+import { AddCommentRequestBody } from "./validators/addCommentRequestBody.zod.js";
+import { AssignIncidentRequestBody } from "./validators/assignIncidentRequestBody.zod.js";
+import { CloseIncidentRequestBody } from "./validators/closeIncidentRequestBody.zod.js";
+import { EnableMonitoringRequestBody } from "./validators/enableMonitoringRequestBody.zod.js";
+import { PostStatusPageIncidentUpdateRequestBody } from "./validators/postStatusPageIncidentUpdateRequestBody.zod.js";
+import { PublishStatusPageIncidentRequestBody } from "./validators/publishStatusPageIncidentRequestBody.zod.js";
+import { PutMaintenanceWindowRequestBody } from "./validators/putMaintenanceWindowRequestBody.zod.js";
+import { PutSLORequestBody } from "./validators/putSLORequestBody.zod.js";
+import { PutStatusPageComponentRequestBody } from "./validators/putStatusPageComponentRequestBody.zod.js";
+import { PutStatusPageComponentSourcesRequestBody } from "./validators/putStatusPageComponentSourcesRequestBody.zod.js";
+import { PutStatusPageDomainRequestBody } from "./validators/putStatusPageDomainRequestBody.zod.js";
+import { PutStatusPageGroupOrderRequestBody } from "./validators/putStatusPageGroupOrderRequestBody.zod.js";
+import { PutStatusPageGroupRequestBody } from "./validators/putStatusPageGroupRequestBody.zod.js";
+import { PutStatusPageOrderRequestBody } from "./validators/putStatusPageOrderRequestBody.zod.js";
+import { PutStatusPageRequestBody } from "./validators/putStatusPageRequestBody.zod.js";
+import { PutWebCheckRequestBody } from "./validators/putWebCheckRequestBody.zod.js";
+import { ScheduleStatusPageMaintenanceRequestBody } from "./validators/scheduleStatusPageMaintenanceRequestBody.zod.js";
+import { SetFollowingRequestBody } from "./validators/setFollowingRequestBody.zod.js";
+import { UpdateServerRequestBody } from "./validators/updateServerRequestBody.zod.js";
+/**
+ * `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 listIncidentsQueryLimitDefault = 50;
+export const listIncidentsQueryLimitMax = 200;
+export const listIncidentsQueryOffsetDefault = 0;
+export const listIncidentsQueryOffsetMin = 0;
+export const listIncidentsQueryOffsetMax = 10000;
+export const listIncidentsQueryKeywordMax = 255;
+export const ListIncidentsQueryParams = zod.strictObject({
+    limit: zod
+        .int()
+        .min(1)
+        .max(listIncidentsQueryLimitMax)
+        .default(listIncidentsQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+    offset: zod
+        .int()
+        .min(listIncidentsQueryOffsetMin)
+        .max(listIncidentsQueryOffsetMax)
+        .default(listIncidentsQueryOffsetDefault)
+        .describe("Items to skip. Defaults to 0; at most 10000."),
+    server_id: zod.string().optional().describe("Restrict to a single machine"),
+    web_check_id: zod.string().optional().describe("Restrict to a single web check"),
+    incident_status: zod.enum(["PROBLEM", "RESOLVED"]).optional(),
+    min_severity: zod
+        .enum(["NOT_CLASSIFIED", "INFORMATION", "WARNING", "AVERAGE", "HIGH", "DISASTER"])
+        .optional()
+        .describe("Matches at or above this severity, not exactly this severity"),
+    started_after: zod.iso.datetime({ offset: true }).optional(),
+    started_before: zod.iso.datetime({ offset: true }).optional(),
+    active_from: zod.iso
+        .datetime({ offset: true })
+        .optional()
+        .describe("Incidents that **overlap** [active_from, active_to]. This is what you want when overlaying incident bands on a metric chart"),
+    active_to: zod.iso.datetime({ offset: true }).optional(),
+    tag: zod
+        .array(zod.string())
+        .nullish()
+        .describe("Given as `key` or `key=value`, repeatable. Multiple tags are combined with AND"),
+    assignee_user_id: zod.string().optional(),
+    closed: zod
+        .enum(["true", "false"])
+        .optional()
+        .describe("Whether someone has finished handling it here. Independent of `incident_status`"),
+    acknowledged: zod.enum(["true", "false"]).optional(),
+    unassigned: zod.enum(["true", "false"]).optional(),
+    keyword: zod.string().max(listIncidentsQueryKeywordMax).optional(),
+});
+/**
+ * @summary Get an incident
+ */
+export const GetIncidentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+/**
+ * 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 AcknowledgeIncidentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const AcknowledgeIncidentBody = AcknowledgeIncidentRequestBody;
+/**
+ * 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 AssignIncidentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const AssignIncidentBody = AssignIncidentRequestBody;
+/**
+ * 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 CloseIncidentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const CloseIncidentBody = CloseIncidentRequestBody;
+/**
+ * @summary Add a note to the timeline
+ */
+export const AddIncidentCommentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const AddIncidentCommentBody = AddCommentRequestBody;
+/**
+ * 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 SetIncidentFollowingParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const SetIncidentFollowingBody = SetFollowingRequestBody;
+/**
+ * @summary Reopen a closed incident
+ */
+export const ReopenIncidentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+/**
+ * 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.
+ *
+ * Omit cursor on the first page. An empty next_cursor means there is no following page; do not send an empty cursor.
+ * @summary List the timeline of an incident
+ */
+export const ListIncidentTimelineParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const listIncidentTimelineQueryLimitDefault = 50;
+export const listIncidentTimelineQueryLimitMax = 200;
+export const listIncidentTimelineQueryCursorMax = 1024;
+export const ListIncidentTimelineQueryParams = zod.strictObject({
+    limit: zod
+        .int()
+        .min(1)
+        .max(listIncidentTimelineQueryLimitMax)
+        .default(listIncidentTimelineQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+    cursor: zod
+        .string()
+        .min(1)
+        .max(listIncidentTimelineQueryCursorMax)
+        .optional()
+        .describe("The next_cursor returned by the previous page. Omit it for the first page."),
+});
+/**
+ * @summary Get a maintenance window
+ */
+export const GetMaintenanceWindowParams = zod.strictObject({
+    windowId: zod.uuid(),
+});
+/**
+ * **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 PutMaintenanceWindowParams = zod.strictObject({
+    windowId: zod.uuid(),
+});
+export const PutMaintenanceWindowBody = PutMaintenanceWindowRequestBody;
+/**
+ * Alerting resumes immediately, even if the window has not yet expired.
+ * @summary Cancel a maintenance window
+ */
+export const DeleteMaintenanceWindowParams = zod.strictObject({
+    windowId: zod.uuid(),
+});
+/**
+ * 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 ListServerItemsParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+export const listServerItemsQueryKeywordMax = 255;
+export const ListServerItemsQueryParams = zod.strictObject({
+    keyword: zod
+        .string()
+        .max(listServerItemsQueryKeywordMax)
+        .optional()
+        .describe("Fuzzy match on key or name"),
+    tag: zod
+        .array(zod.string())
+        .nullish()
+        .describe("Given as `key` or `key=value`, repeatable. The `component` tags applied by the official templates (cpu, memory, filesystem and so on) are filtered through this"),
+});
+/**
+ * `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 GetServerMetricParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+export const getServerMetricQueryMaxPointsMin = 0;
+export const GetServerMetricQueryParams = zod.strictObject({
+    item_key: zod
+        .string()
+        .optional()
+        .describe("**Prefix match**: `vfs.fs.size` returns one series per mount point. Supply this or `item_id`"),
+    item_id: zod.string().optional(),
+    from: zod.iso.datetime({ offset: true }).optional().describe("Defaults to one hour ago"),
+    to: zod.iso.datetime({ offset: true }).optional(),
+    max_points: zod
+        .int()
+        .min(getServerMetricQueryMaxPointsMin)
+        .optional()
+        .describe("Number of downsampling buckets. 0 returns the collected data points unchanged"),
+    include_thresholds: zod
+        .boolean()
+        .optional()
+        .describe("Also return the thresholds currently in effect for these items"),
+});
+/**
+ * @summary Hardware and interfaces of a machine
+ */
+export const GetServerResourcesParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+/**
+ * @summary Current state of a machine
+ */
+export const GetServerSnapshotParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+/**
+ * @summary Machines ranked highest by a given metric
+ */
+export const listProjectTopItemsQueryLimitMin = 0;
+export const listProjectTopItemsQueryLimitMax = 100;
+export const ListProjectTopItemsQueryParams = zod.strictObject({
+    kind: zod.enum(["CPU_UTILIZATION", "MEMORY_UTILIZATION", "ROOT_FILESYSTEM_USED"]),
+    limit: zod
+        .int()
+        .min(listProjectTopItemsQueryLimitMin)
+        .max(listProjectTopItemsQueryLimitMax)
+        .optional()
+        .describe("0 uses the default"),
+});
+/**
+ * @summary List the machines in the project
+ */
+export const listServersQueryLimitDefault = 50;
+export const listServersQueryLimitMax = 200;
+export const listServersQueryOffsetDefault = 0;
+export const listServersQueryOffsetMin = 0;
+export const listServersQueryOffsetMax = 10000;
+export const listServersQueryKeywordMax = 255;
+export const ListServersQueryParams = zod.strictObject({
+    limit: zod
+        .int()
+        .min(1)
+        .max(listServersQueryLimitMax)
+        .default(listServersQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+    offset: zod
+        .int()
+        .min(listServersQueryOffsetMin)
+        .max(listServersQueryOffsetMax)
+        .default(listServersQueryOffsetDefault)
+        .describe("Items to skip. Defaults to 0; at most 10000."),
+    keyword: zod
+        .string()
+        .max(listServersQueryKeywordMax)
+        .optional()
+        .describe("Fuzzy match on name or address"),
+    monitoring_status: zod.enum(["PENDING", "ACTIVE", "DISABLED", "FAILED"]).optional(),
+});
+/**
+ * @summary Get the enrollment state of a machine
+ */
+export const GetServerParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+/**
+ * **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 EnableServerMonitoringParams = zod.strictObject({
+    serverId: zod
+        .uuid()
+        .describe("Supplied by the caller; no operation issues one. Reuse the identifier the machine already carries in the originating system — a Leaflow Compute instance id, or the caller's own inventory identifier — or allocate a UUID and persist it before the first call. It is the idempotency key of the enrollment."),
+});
+export const EnableServerMonitoringBody = EnableMonitoringRequestBody;
+/**
+ * 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 UpdateServerParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+export const UpdateServerBody = UpdateServerRequestBody;
+/**
+ * **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 DeleteServerParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+/**
+ * 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 DisableServerMonitoringParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+/**
+ * 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 RotateAgentPskParams = zod.strictObject({
+    serverId: zod.uuid(),
+});
+/**
+ * @summary Get a web check
+ */
+export const GetWebCheckParams = zod.strictObject({
+    serverId: zod.uuid(),
+    checkId: zod.uuid(),
+});
+/**
+ * **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 PutWebCheckParams = zod.strictObject({
+    serverId: zod.uuid(),
+    checkId: zod.uuid(),
+});
+export const PutWebCheckBody = PutWebCheckRequestBody;
+/**
+ * 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 DeleteWebCheckParams = zod.strictObject({
+    serverId: zod.uuid(),
+    checkId: zod.uuid(),
+});
+/**
+ * @summary List web checks
+ */
+export const ListWebChecksQueryParams = zod.strictObject({
+    server_id: zod
+        .string()
+        .optional()
+        .describe("Restrict to the checks of a single machine. Omit for the whole project"),
+});
+/**
+ * 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 getSliReportQueryPeriodsMin = 0;
+export const getSliReportQueryPeriodsMax = 100;
+export const GetSliReportQueryParams = zod.strictObject({
+    from: zod.iso.datetime({ offset: true }).optional(),
+    to: zod.iso.datetime({ offset: true }).optional(),
+    periods: zod
+        .int()
+        .min(getSliReportQueryPeriodsMin)
+        .max(getSliReportQueryPeriodsMax)
+        .optional()
+        .describe("Return the most recent N complete periods. Use this or from/to, not both"),
+});
+/**
+ * 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 PutSloBody = PutSLORequestBody;
+/**
+ * **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 PutStatusPageBody = PutStatusPageRequestBody;
+/**
+ * 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 PutStatusPageOrderBody = PutStatusPageOrderRequestBody;
+/**
+ * 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 CreateStatusPageGroupBody = PutStatusPageGroupRequestBody;
+/**
+ * @summary Update a group
+ */
+export const UpdateStatusPageGroupParams = zod.strictObject({
+    groupId: zod.uuid(),
+});
+export const UpdateStatusPageGroupBody = PutStatusPageGroupRequestBody;
+/**
+ * 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 DeleteStatusPageGroupParams = zod.strictObject({
+    groupId: zod.uuid(),
+});
+/**
+ * @summary Set the order of components within a group
+ */
+export const PutStatusPageGroupOrderParams = zod.strictObject({
+    groupId: zod.uuid(),
+});
+export const PutStatusPageGroupOrderBody = PutStatusPageGroupOrderRequestBody;
+/**
+ * `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 CreateStatusPageComponentBody = PutStatusPageComponentRequestBody;
+/**
+ * @summary Get a component
+ */
+export const GetStatusPageComponentParams = zod.strictObject({
+    componentId: zod.uuid(),
+});
+/**
+ * `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 UpdateStatusPageComponentParams = zod.strictObject({
+    componentId: zod.uuid(),
+});
+export const UpdateStatusPageComponentBody = PutStatusPageComponentRequestBody;
+/**
+ * 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 DeleteStatusPageComponentParams = zod.strictObject({
+    componentId: zod.uuid(),
+});
+/**
+ * Monitored sources are internal information and **never appear on the public page**.
+ * @summary List the monitored sources bound to a component
+ */
+export const ListStatusPageComponentSourcesParams = zod.strictObject({
+    componentId: zod.uuid(),
+});
+/**
+ * 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 PutStatusPageComponentSourcesParams = zod.strictObject({
+    componentId: zod.uuid(),
+});
+export const PutStatusPageComponentSourcesBody = PutStatusPageComponentSourcesRequestBody;
+/**
+ * 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 listStatusPageIncidentsQueryLimitDefault = 50;
+export const listStatusPageIncidentsQueryLimitMax = 200;
+export const listStatusPageIncidentsQueryOffsetDefault = 0;
+export const listStatusPageIncidentsQueryOffsetMin = 0;
+export const listStatusPageIncidentsQueryOffsetMax = 10000;
+export const ListStatusPageIncidentsQueryParams = zod.strictObject({
+    limit: zod
+        .int()
+        .min(1)
+        .max(listStatusPageIncidentsQueryLimitMax)
+        .default(listStatusPageIncidentsQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+    offset: zod
+        .int()
+        .min(listStatusPageIncidentsQueryOffsetMin)
+        .max(listStatusPageIncidentsQueryOffsetMax)
+        .default(listStatusPageIncidentsQueryOffsetDefault)
+        .describe("Items to skip. Defaults to 0; at most 10000."),
+});
+/**
+ * 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 PublishStatusPageIncidentBody = PublishStatusPageIncidentRequestBody;
+/**
+ * @summary Get an incident notice
+ */
+export const GetStatusPageIncidentParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+/**
+ * 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 PostStatusPageIncidentUpdateParams = zod.strictObject({
+    incidentId: zod.uuid(),
+});
+export const PostStatusPageIncidentUpdateBody = PostStatusPageIncidentUpdateRequestBody;
+/**
+ * @summary List scheduled maintenance
+ */
+export const listStatusPageMaintenancesQueryLimitDefault = 50;
+export const listStatusPageMaintenancesQueryLimitMax = 200;
+export const listStatusPageMaintenancesQueryOffsetDefault = 0;
+export const listStatusPageMaintenancesQueryOffsetMin = 0;
+export const listStatusPageMaintenancesQueryOffsetMax = 10000;
+export const ListStatusPageMaintenancesQueryParams = zod.strictObject({
+    limit: zod
+        .int()
+        .min(1)
+        .max(listStatusPageMaintenancesQueryLimitMax)
+        .default(listStatusPageMaintenancesQueryLimitDefault)
+        .describe("Items returned in this page. Defaults to 50; at most 200."),
+    offset: zod
+        .int()
+        .min(listStatusPageMaintenancesQueryOffsetMin)
+        .max(listStatusPageMaintenancesQueryOffsetMax)
+        .default(listStatusPageMaintenancesQueryOffsetDefault)
+        .describe("Items to skip. Defaults to 0; at most 10000."),
+});
+/**
+ * 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 ScheduleStatusPageMaintenanceBody = ScheduleStatusPageMaintenanceRequestBody;
+/**
+ * @summary Get a scheduled maintenance
+ */
+export const GetStatusPageMaintenanceParams = zod.strictObject({
+    maintenanceId: zod.uuid(),
+});
+/**
+ * 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 CancelStatusPageMaintenanceParams = zod.strictObject({
+    maintenanceId: zod.uuid(),
+});
+/**
+ * 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 CompleteStatusPageMaintenanceParams = zod.strictObject({
+    maintenanceId: zod.uuid(),
+});
+/**
+ * @summary Get a project-level web check
+ */
+export const GetProjectWebCheckParams = zod.strictObject({
+    checkId: zod.uuid(),
+});
+/**
+ * **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 PutProjectWebCheckParams = zod.strictObject({
+    checkId: zod.uuid(),
+});
+export const PutProjectWebCheckBody = PutWebCheckRequestBody;
+/**
+ * The corresponding check task and trigger are removed from the monitoring system as well.
+ * @summary Delete a project-level web check
+ */
+export const DeleteProjectWebCheckParams = zod.strictObject({
+    checkId: zod.uuid(),
+});
+/**
+ * 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 PutStatusPageDomainBody = PutStatusPageDomainRequestBody;

package/dist/monitoring/v1/generated/validators/acknowledgeIncidentRequestBody.zod.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 * as zod from "zod";
+export declare const acknowledgeIncidentRequestBodyMessageMax = 2000;
+export declare const AcknowledgeIncidentRequestBody: zod.ZodObject<{
+    message: zod.ZodOptional<zod.ZodString>;
+}, zod.z.core.$strict>;
+export type AcknowledgeIncidentRequestBody = zod.input<typeof AcknowledgeIncidentRequestBody>;
+export type AcknowledgeIncidentRequestBodyOutput = zod.output<typeof AcknowledgeIncidentRequestBody>;

package/dist/monitoring/v1/generated/validators/acknowledgeIncidentRequestBody.zod.js

@@ -0,0 +1,29 @@
+/**
+ * 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 * as zod from "zod";
+export const acknowledgeIncidentRequestBodyMessageMax = 2000;
+export const AcknowledgeIncidentRequestBody = zod.strictObject({
+    message: zod
+        .string()
+        .max(acknowledgeIncidentRequestBodyMessageMax)
+        .optional()
+        .describe("Also written to the acknowledgement record in the monitoring system"),
+});