From 6a9a2b08cc93f931d252d095c1067bbfb1d5b046 Mon Sep 17 00:00:00 2001 From: caballeto Date: Wed, 6 May 2026 00:02:32 +0200 Subject: [PATCH] chore: regen API types with MCP+API managedBy enum Auto-regen workflow failed because src/generated/ is gitignored; fixed by force-adding the generated file and updating spec-check.yml to use git add -f for future runs. Co-authored-by: Cursor --- .github/workflows/spec-check.yml | 2 +- docs/openapi/monitoring-api.json | 22 +- src/generated/api.ts | 25125 +++++++++++++++++++++++++++++ 3 files changed, 25141 insertions(+), 8 deletions(-) create mode 100644 src/generated/api.ts diff --git a/.github/workflows/spec-check.yml b/.github/workflows/spec-check.yml index 6bdf0fd..1642852 100644 --- a/.github/workflows/spec-check.yml +++ b/.github/workflows/spec-check.yml @@ -50,7 +50,7 @@ jobs: git config user.email "github-actions[bot]@users.noreply.github.com" branch="chore/update-api-types-$(date +%Y%m%d%H%M%S)" git checkout -b "$branch" - git add src/generated/api.ts docs/openapi/monitoring-api.json + git add -f src/generated/api.ts docs/openapi/monitoring-api.json git commit -m "chore: update generated API types from latest spec" git push -u origin "$branch" gh pr create \ diff --git a/docs/openapi/monitoring-api.json b/docs/openapi/monitoring-api.json index 41903c1..02f8524 100644 --- a/docs/openapi/monitoring-api.json +++ b/docs/openapi/monitoring-api.json @@ -6412,7 +6412,9 @@ "enum": [ "DASHBOARD", "CLI", - "TERRAFORM" + "TERRAFORM", + "MCP", + "API" ] } }, @@ -23307,11 +23309,13 @@ }, "managedBy": { "type": "string", - "description": "Who manages this monitor: DASHBOARD or CLI", + "description": "Source that created/owns this monitor: DASHBOARD, CLI, TERRAFORM, MCP, or API. Use the value matching your surface so audit logs, drift detection, and analytics attribute correctly.", "enum": [ "DASHBOARD", "CLI", - "TERRAFORM" + "TERRAFORM", + "MCP", + "API" ] }, "environmentId": { @@ -27194,11 +27198,13 @@ }, "managedBy": { "type": "string", - "description": "Management source: DASHBOARD or CLI", + "description": "Source that created/owns this monitor: DASHBOARD, CLI, TERRAFORM, MCP, or API", "enum": [ "DASHBOARD", "CLI", - "TERRAFORM" + "TERRAFORM", + "MCP", + "API" ] }, "createdAt": { @@ -33345,12 +33351,14 @@ }, "managedBy": { "type": "string", - "description": "New management source; null preserves current", + "description": "New ownership source: DASHBOARD, CLI, TERRAFORM, MCP, or API; null preserves current value", "nullable": true, "enum": [ "DASHBOARD", "CLI", - "TERRAFORM" + "TERRAFORM", + "MCP", + "API" ] }, "environmentId": { diff --git a/src/generated/api.ts b/src/generated/api.ts new file mode 100644 index 0000000..2f2f685 --- /dev/null +++ b/src/generated/api.ts @@ -0,0 +1,25125 @@ +/** + * This file was auto-generated by openapi-typescript. + * Do not make direct changes to the file. + */ + +export interface paths { + "/api/v1/alert-channels": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List active alert channels for the authenticated org */ + get: operations["list_14"]; + put?: never; + /** Create a new alert channel with encrypted config */ + post: operations["create_15"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/alert-channels/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a single alert channel by id */ + get: operations["get_8"]; + /** Update an alert channel's name and re-encrypt config */ + put: operations["update_14"]; + post?: never; + /** Soft-delete an alert channel and return affected policy summary */ + delete: operations["delete_10"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/alert-channels/{id}/deliveries": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List delivery history for an alert channel */ + get: operations["listDeliveries_1"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/alert-channels/{id}/test": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Test a saved alert channel's connectivity */ + post: operations["test_2"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/alert-channels/test": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Test alert channel connectivity using raw config (no saved channel required) */ + post: operations["testConfig"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/alert-deliveries/{id}/attempts": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List delivery attempts for a specific alert delivery + * @description Returns the ordered list of delivery attempts (request/response audit data) for the given delivery ID. + */ + get: operations["listAttempts"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/alert-deliveries/{id}/retry": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Retry a failed delivery + * @description Resets a FAILED delivery to RETRY_PENDING so the delivery worker re-attempts it. + */ + post: operations["retry"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/api-keys": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List API keys */ + get: operations["list_13"]; + put?: never; + /** Create API key */ + post: operations["create_14"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/api-keys/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** Delete API key */ + delete: operations["delete_11"]; + options?: never; + head?: never; + /** Update API key */ + patch: operations["update_15"]; + trace?: never; + }; + "/api/v1/api-keys/{id}/regenerate": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Regenerate API key */ + post: operations["regenerate"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/api-keys/{id}/revoke": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Revoke API key */ + post: operations["revoke_1"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/audit-log": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List audit events for the current organization */ + get: operations["list_19"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/auth/me": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get current API key identity + * @description Returns the authenticated API key's metadata, organization, billing plan, entitlements with usage, and current rate-limit quota. Only available for API key authentication (Bearer dh_live_...). + */ + get: operations["me_1"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/categories": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List categories with service counts */ + get: operations["listCategories"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/dashboard/overview": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Dashboard overview + * @description Returns monitor status counts, average uptime windows, and incident aggregates for the authenticated org. Results are cached for 1 minute. + */ + get: operations["overview"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/deploy/lock": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get current deploy lock + * @description Returns the active deploy lock for the current workspace, if any. + */ + get: operations["current"]; + put?: never; + /** + * Acquire deploy lock + * @description Acquires an exclusive deploy lock for the current workspace. Returns 409 Conflict if the workspace is already locked by another session. + */ + post: operations["acquire"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/deploy/lock/{lockId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** + * Release deploy lock + * @description Releases a deploy lock by ID. Only the lock holder should call this. + */ + delete: operations["release"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/deploy/lock/force": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** + * Force-release deploy lock + * @description Forcibly removes any deploy lock on the current workspace. Use to break stale locks. + */ + delete: operations["forceRelease"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/environments": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List environments */ + get: operations["list_12"]; + put?: never; + /** Create environment */ + post: operations["create_13"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/environments/{slug}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get environment by slug */ + get: operations["get_7"]; + /** Update environment */ + put: operations["update_13"]; + post?: never; + /** Delete environment */ + delete: operations["delete_9"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/forensics/incidents/{id}/timeline": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Full forensic timeline for an incident + * @description Returns every state-machine transition for this incident plus the rule evaluations that caused each transition, plus the policy snapshot that triggered confirmation. Correlate evaluations to transitions via evaluation.triggeringTransitionId == transition.id. + */ + get: operations["getTimeline"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/forensics/monitors/{id}/rule-evaluations": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Paged list of rule evaluations for a monitor + * @description Filter by ruleType (e.g. consecutive_failures), region, onlyMatched=true to narrow to firing evaluations, and occurredAt window. + */ + get: operations["listMonitorRuleEvaluations"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/forensics/monitors/{id}/transitions": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Paged list of state transitions for a monitor (optionally time-bounded) */ + get: operations["listMonitorTransitions"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/forensics/policy-snapshots/{hashHex}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Fetch a policy snapshot by its content hash + * @description Hash is SHA-256 over canonical policy JSON, hex-encoded. Access is gated: caller's org must have evaluated against this hash at least once. + */ + get: operations["getPolicySnapshot"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/forensics/traces/{checkId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Replay a single check execution + * @description Returns every rule evaluation and state transition emitted for this scheduler-minted check_id (V92), plus the policy snapshot that governed them. + */ + get: operations["getTrace"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/heartbeat/{token}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Record a heartbeat ping (GET) + * @description Called by external systems (cron jobs, scheduled tasks) to signal liveness. Always returns 200 OK. + */ + get: operations["pingGet"]; + put?: never; + /** + * Record a heartbeat ping (POST) + * @description Called by external systems to signal liveness with an optional JSON payload. The payload can be inspected by heartbeat_payload_contains assertions. Always returns 200 OK. + */ + post: operations["pingPost"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/incidents": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List incidents for the authenticated org */ + get: operations["list_11"]; + put?: never; + /** Create a manual incident */ + post: operations["create_12"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/incidents/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get incident details including update timeline */ + get: operations["get_11"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/incidents/{id}/resolve": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Resolve an incident */ + post: operations["resolve"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/incidents/{id}/updates": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Add an update to an incident (optionally change status) */ + post: operations["addUpdate"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/integrations": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List all supported integration types + * @description Returns the full static catalog of supported alert channel integration types with their metadata and config field schemas. Used by the frontend to dynamically render the 'Add Alert Channel' form. + */ + get: operations["list_18"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/invites": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List invites */ + get: operations["list_10"]; + put?: never; + /** Create invite */ + post: operations["create_11"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/invites/{inviteId}/resend": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Resend invite */ + post: operations["resend"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/invites/{inviteId}/revoke": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Revoke invite */ + post: operations["revoke"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/maintenance-windows": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List maintenance windows for the authenticated org + * @description Returns maintenance windows for the caller's organisation. Optionally filter by monitor_id, and/or by status: 'active' (currently in window) or 'upcoming' (starts in the future). + */ + get: operations["list_9"]; + put?: never; + /** + * Create a maintenance window + * @description Creates a new maintenance window. Set monitorId to null to create an org-wide window that suppresses alerts for all monitors. + */ + post: operations["create_10"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/maintenance-windows/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a single maintenance window by ID */ + get: operations["getById_2"]; + /** Update a maintenance window */ + put: operations["update_12"]; + post?: never; + /** Delete a maintenance window */ + delete: operations["delete_8"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/members": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List organization members */ + get: operations["list_17"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/members/{userId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** Remove member from organization */ + delete: operations["remove_2"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/members/{userId}/role": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Change member role */ + put: operations["changeRole"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/members/{userId}/status": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Change member status */ + put: operations["changeStatus"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List monitors for the authenticated org */ + get: operations["list_8"]; + put?: never; + /** Create a new monitor */ + post: operations["create_9"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a single monitor by id */ + get: operations["get_6"]; + /** Update a monitor */ + put: operations["update_11"]; + post?: never; + /** Soft-delete a monitor */ + delete: operations["delete_7"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/pause": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Pause a monitor (set enabled=false) */ + post: operations["pause"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/results": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List raw check results + * @description Returns check results for the given monitor with optional time-range, region, and pass/fail filtering. Uses cursor-based pagination — pass the returned `cursor` value on subsequent requests to retrieve the next page. The cursor encodes the original time bounds, so `from`/`to` are ignored when a cursor is present. + */ + get: operations["getResults"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/results/summary": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get results summary + * @description Returns a dashboard summary for the monitor: current status derived from the latest result per region, time-bucketed chart data, the 24-hour uptime percentage, and the selected window's uptime percentage. + */ + get: operations["getSummary"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/resume": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Resume a monitor (set enabled=true) */ + post: operations["resume"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/rotate-token": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Rotate the ping token for a heartbeat monitor + * @description Generates a new ping token. The old token remains valid for 24 hours to allow cron jobs to be updated without downtime. Only supported for HEARTBEAT monitors. + */ + post: operations["rotateToken"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/tags": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get all tags applied to a monitor */ + get: operations["getMonitorTags"]; + put?: never; + /** Add tags to a monitor; supports existing tag IDs and inline creation of new tags */ + post: operations["addMonitorTags"]; + /** Remove tags from a monitor by their IDs */ + delete: operations["removeMonitorTags"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/test": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Test an existing monitor + * @description Runs the saved config and assertions of an existing monitor once, without persisting any result. Runs synchronously and returns the same shape as the ad-hoc test. + */ + post: operations["testExisting"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/uptime": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get uptime statistics + * @description Returns uptime percentage and latency statistics for the requested time window, computed from continuous aggregates. Uses hourly aggregates for 24h/7d windows and daily aggregates for 30d/90d windows. + */ + get: operations["getUptime"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/versions": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List version history for a monitor + * @description Returns a paginated list of mutation snapshots for the monitor, newest first. Each version captures the full monitor config at the time of a PUT /monitors/{id} call. + */ + get: operations["listVersions"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{id}/versions/{version}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get a specific version snapshot for a monitor + * @description Returns the full monitor config snapshot captured at the given version number. + */ + get: operations["getVersion"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{monitorId}/alert-channels": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Replace the linked alert channel set for a monitor */ + put: operations["setChannels"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{monitorId}/assertions": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Add an assertion to a monitor */ + post: operations["add"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{monitorId}/assertions/{assertionId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Update an assertion on a monitor */ + put: operations["update_10"]; + post?: never; + /** Remove an assertion from a monitor */ + delete: operations["remove_1"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{monitorId}/auth": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Update authentication config for a monitor */ + put: operations["update_9"]; + /** Set authentication config for a monitor */ + post: operations["set"]; + /** Remove authentication config from a monitor */ + delete: operations["remove"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/{monitorId}/policy": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get incident policy for a monitor + * @description Returns the trigger rules, confirmation settings, and recovery settings for the given monitor. + */ + get: operations["get_5"]; + /** + * Update incident policy for a monitor + * @description Replaces the trigger rules, confirmation settings, and recovery settings. All fields are validated before saving. + */ + put: operations["update_8"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/bulk": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Bulk action on monitors + * @description Applies PAUSE, RESUME, DELETE, ADD_TAG, or REMOVE_TAG to a list of monitors. Returns a partial-success response indicating which monitors succeeded and which failed. + */ + post: operations["bulkAction"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/monitors/test": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Ad-hoc monitor test + * @description Executes a one-off check from an inline config without saving the monitor. Runs synchronously and returns status code, response time, assertion results, body preview, and headers. + */ + post: operations["testAdHoc"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-dispatches": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List all dispatches for an incident + * @description Returns all notification dispatches for the given incident that belong to the authenticated org's policies. Each dispatch includes delivery records for all associated channels. + */ + get: operations["listByIncident"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-dispatches/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get a single dispatch with full escalation and delivery history + * @description Returns the dispatch state including current escalation step, acknowledgment info, and all delivery attempts made across every step. + */ + get: operations["getById_3"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-dispatches/{id}/acknowledge": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Acknowledge a notification dispatch + * @description Marks the dispatch as acknowledged. The dispatch must be in DELIVERED or ESCALATING state. Sets acknowledgedAt, acknowledgedBy (actor email), and acknowledgedVia (DASHBOARD). + */ + post: operations["acknowledge"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-policies": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List all notification policies for the authenticated org */ + get: operations["list_7"]; + put?: never; + /** Create a notification policy with match rules and escalation chain */ + post: operations["create_8"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-policies/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a notification policy by ID */ + get: operations["getById_1"]; + /** Update a notification policy */ + put: operations["update_7"]; + post?: never; + /** Delete a notification policy */ + delete: operations["delete_6"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-policies/{id}/dispatches": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List all dispatches (firing history) for a notification policy */ + get: operations["listDispatches"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notification-policies/{id}/test": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Dry-run: evaluate a policy's match rules against a supplied incident context */ + post: operations["test_1"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notifications": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List notifications for the current user */ + get: operations["list_16"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notifications/{id}/read": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Mark a notification as read */ + put: operations["markRead"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notifications/read-all": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Mark all notifications as read */ + put: operations["markAllRead"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/notifications/unread-count": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get unread notification count */ + get: operations["unreadCount"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/org": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get the current organization */ + get: operations["get_4"]; + /** Update the current organization */ + put: operations["update_6"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/resource-groups": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List all resource groups for the authenticated org with health summaries */ + get: operations["list_6"]; + put?: never; + /** Create a new resource group */ + post: operations["create_7"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/resource-groups/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get a resource group by id with member statuses and inherited settings + * @description Pass includeMetrics=true to enrich each member with 24h uptime, chart data, and latency metrics. + */ + get: operations["get_3"]; + /** Update a resource group's name, description, alert policy, inherited settings, and health threshold */ + put: operations["update_5"]; + post?: never; + /** Delete a resource group (cascades to member rows) */ + delete: operations["delete_5"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/resource-groups/{id}/health": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get the detailed health breakdown for a resource group + * @description Returns member counts, worst-of status, and threshold-based health evaluation. The thresholdStatus field is populated only when a health threshold is configured. + */ + get: operations["getHealth"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/resource-groups/{id}/members": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Add a monitor or service member to a resource group */ + post: operations["addMember_1"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/resource-groups/{id}/members/{memberId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** Remove a member from a resource group */ + delete: operations["removeMember_1"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/secrets": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List secrets */ + get: operations["list_5"]; + put?: never; + /** Create secret */ + post: operations["create_6"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/secrets/{key}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Update secret */ + put: operations["update_4"]; + post?: never; + /** Delete secret */ + delete: operations["delete_4"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/service-subscriptions": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List all service subscriptions for the organization */ + get: operations["list_15"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/service-subscriptions/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a subscription by its ID */ + get: operations["get_10"]; + put?: never; + post?: never; + /** + * Remove a subscription by its ID + * @description Removes a specific subscription (whole-service or component-level). No-op if not found. + */ + delete: operations["unsubscribe_1"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/service-subscriptions/{id}/alert-sensitivity": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + /** + * Update alert sensitivity for a subscription + * @description Controls which external incidents trigger alerts: ALL (any status change), INCIDENTS_ONLY (real vendor incidents, default), MAJOR_ONLY (only DOWN-level incidents). + */ + patch: operations["updateAlertSensitivity"]; + trace?: never; + }; + "/api/v1/service-subscriptions/{slug}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Subscribe to a service or a component of a service + * @description Idempotent — returns the existing subscription if an identical one exists. Omit the request body or set componentId to null for a whole-service subscription. Free tier: max 10 subscriptions. Paid tier: unlimited. + */ + post: operations["subscribe_1"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List all enabled services (cursor-paginated) */ + get: operations["listServices"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get a single service by slug or UUID with current status, components, and recent incidents + * @description When ``summary=true``, the inline ``components`` list is trimmed to groups + showcase leaves + currently-impacted leaves + ungrouped leaves, and a ``componentsSummary`` block is added with the trimmed counts. Powers SSR for vendors with hundreds of components (Snowflake, Cloudflare, DigitalOcean) without OOM-ing the renderer. Default false for full back-compat. + */ + get: operations["getService"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/components": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List active components for a service with current status and inline uptime + * @description When ``groupId`` is supplied, only direct children of that group are returned — used by the pSEO renderer to lazy-load the leaves under a group that summary mode trimmed. Without ``groupId`` the response includes every active component for the service. + */ + get: operations["getComponents"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/components/{componentId}/uptime": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get daily uptime data for a component + * @description Pass either ``period`` (preset window) or an explicit ``from``/``to`` calendar window (ISO yyyy-MM-dd, max 730 days, ``to`` defaults to today). When both are supplied, the explicit window wins. + */ + get: operations["getComponentUptime"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/components/uptime": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Batch daily uptime data for all leaf components + * @description Returns daily uptime for every active non-group component with uptime data, keyed by component ID. Replaces N individual per-component uptime calls with a single request. Supports either a preset ``period`` or an explicit ``from``/``to`` window (ISO yyyy-MM-dd, max 730 days). The explicit window wins when both are supplied — this is what powers the sliding 90-day navigator on the public uptime history page. + */ + get: operations["getBatchComponentUptime"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/days/{date}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * One-day rollup for a service: aggregated uptime, per-component impacts, and overlapping incidents + * @description Powers the click/hover-to-expand panel under each uptime bar on the public status page. Single round-trip — components, sums, and overlapping incidents (with affected component names) are returned in one response. + */ + get: operations["getServiceDayDetail"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/incidents": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List incident history for a service (paginated) */ + get: operations["listIncidents_1"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/incidents/{incidentId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get incident detail with full update timeline */ + get: operations["getIncident_1"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/live-status": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Lightweight live-status snapshot for polling + * @description Returns only the current overall status, component statuses, and active incident count. Designed for frequent polling with minimal payload. + */ + get: operations["getServiceLiveStatus"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/maintenances": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List scheduled maintenances for a service */ + get: operations["getScheduledMaintenances"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/poll-results": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List poll results for a service (cursor-paginated) */ + get: operations["listPollResults"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/poll-summary": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get aggregated poll metrics and chart data for a service */ + get: operations["getPollSummary"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/{slugOrId}/uptime": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Get uptime statistics for a service + * @description Uptime data aggregated across active non-group components. + */ + get: operations["getServiceUptime"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/incidents": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List vendor incidents across all services (paginated) + * @description Cross-service vendor incident feed ordered by start date descending. + */ + get: operations["listCrossServiceIncidents"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/services/summary": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * Global status summary across all services + * @description Returns aggregate counts of services by status and a list of services currently experiencing issues. + */ + get: operations["getGlobalStatusSummary"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List status pages for the workspace */ + get: operations["list_4"]; + put?: never; + /** Create a status page */ + post: operations["create_5"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a status page */ + get: operations["get_2"]; + /** Update a status page */ + put: operations["update_3"]; + post?: never; + /** Delete a status page */ + delete: operations["delete_3"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/components": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List all components */ + get: operations["listComponents"]; + put?: never; + /** Add a component to the status page */ + post: operations["createComponent"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/components/{componentId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Update a component */ + put: operations["updateComponent"]; + post?: never; + /** Remove a component from the status page */ + delete: operations["deleteComponent"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/components/{componentId}/uptime": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get component uptime history (daily rollups) */ + get: operations["componentUptime_1"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/components/reorder": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Batch reorder components (and optionally move between groups) */ + put: operations["reorderComponents"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/domains": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List custom domains */ + get: operations["listDomains"]; + put?: never; + /** Add a custom domain */ + post: operations["addDomain"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/domains/{domainId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** Remove a custom domain */ + delete: operations["removeDomain"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/domains/{domainId}/primary": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Mark a verified custom domain as the page's primary host */ + post: operations["setPrimaryDomain"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/domains/{domainId}/verify": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Trigger domain verification check */ + post: operations["verifyDomain"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/groups": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List component groups with nested components */ + get: operations["listGroups"]; + put?: never; + /** Create a component group */ + post: operations["createGroup"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/groups/{groupId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Update a component group */ + put: operations["updateGroup"]; + post?: never; + /** Delete a component group (components become ungrouped) */ + delete: operations["deleteGroup"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/incidents": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List incidents for this status page (filterable by status, paginated) */ + get: operations["listIncidents"]; + put?: never; + /** Create a status page incident (manual) */ + post: operations["createIncident"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/incidents/{incidentId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get incident details with timeline */ + get: operations["getIncident"]; + /** Update an incident */ + put: operations["updateIncident"]; + post?: never; + /** Delete an incident */ + delete: operations["deleteIncident"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/incidents/{incidentId}/dismiss": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Dismiss a draft incident (deletes it permanently) */ + post: operations["dismissIncident"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/incidents/{incidentId}/publish": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Publish a draft incident (sets publishedAt, applies component statuses, notifies subscribers) */ + post: operations["publishIncident"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/incidents/{incidentId}/updates": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Post an incident timeline update */ + post: operations["postIncidentUpdate"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/layout/reorder": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + /** Reorder page-level layout: groups and ungrouped components share one ordering */ + put: operations["reorderLayout"]; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/subscribers": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List confirmed subscribers (paginated) */ + get: operations["listSubscribers"]; + put?: never; + /** Add a subscriber (immediately confirmed, skips double opt-in) */ + post: operations["addSubscriber"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/status-pages/{id}/subscribers/{subscriberId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + post?: never; + /** Remove a subscriber */ + delete: operations["removeSubscriber"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/tags": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List tags for the authenticated organization */ + get: operations["list_3"]; + put?: never; + /** Create a new tag */ + post: operations["create_4"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/tags/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a tag by ID */ + get: operations["getById"]; + /** Update a tag's name and/or color */ + put: operations["update_2"]; + post?: never; + /** Delete a tag (cascades to all monitor associations) */ + delete: operations["delete_2"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/vaults/rotate": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** + * Rotate DEK + * @description Generates a new Data Encryption Key, re-encrypts all secrets and alert-channel configs, and bumps the vault version. Admin-only. Pipeline DEK caches expire within ~10 minutes. + */ + post: operations["rotateDek"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List webhook endpoints for the authenticated org */ + get: operations["list_2"]; + put?: never; + /** Register a new webhook endpoint */ + post: operations["create_3"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks/{id}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get a single webhook endpoint */ + get: operations["get_1"]; + /** Update a webhook endpoint */ + put: operations["update_1"]; + post?: never; + /** Delete a webhook endpoint */ + delete: operations["delete_1"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks/{id}/deliveries": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List recent deliveries for a webhook endpoint */ + get: operations["listDeliveries"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks/{id}/test": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Send a test delivery to a webhook endpoint */ + post: operations["test"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks/events": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** + * List all available webhook event types + * @description Returns the full catalog of supported outbound webhook event types with their surface grouping and human-readable descriptions. Use this to populate subscription checkboxes when creating or updating a webhook endpoint. + */ + get: operations["listEvents"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks/signing-secret": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get signing secret metadata for the authenticated org */ + get: operations["getSigningSecretInfo"]; + put?: never; + post?: never; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/webhooks/signing-secret/rotate": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + get?: never; + put?: never; + /** Generate or rotate the organization webhook signing secret */ + post: operations["rotateSigningSecret"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/workspaces": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** List workspaces */ + get: operations["list_1"]; + put?: never; + /** Create workspace */ + post: operations["create_2"]; + delete?: never; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; + "/api/v1/workspaces/{workspaceId}": { + parameters: { + query?: never; + header?: never; + path?: never; + cookie?: never; + }; + /** Get workspace by ID */ + get: operations["get"]; + /** Update workspace */ + put: operations["update"]; + post?: never; + /** Delete workspace */ + delete: operations["delete"]; + options?: never; + head?: never; + patch?: never; + trace?: never; + }; +} +export type webhooks = Record; +export interface components { + schemas: { + /** @description Request to acquire a deploy lock for the current workspace */ + AcquireDeployLockRequest: { + /** @description Identity of the lock requester (e.g. hostname, CI job ID) */ + lockedBy: string; + /** + * Format: int32 + * @description Lock TTL in minutes (default: 30, max: 60) + * @example 30 + */ + ttlMinutes?: number | null; + }; + AddCustomDomainRequest: { + /** @description Custom hostname, e.g. status.acme.com */ + hostname: string; + }; + AddIncidentUpdateRequest: { + /** @description Update message or post-mortem notes */ + body?: string | null; + /** + * @description Updated incident status; null to keep current status + * @enum {string|null} + */ + newStatus?: "WATCHING" | "TRIGGERED" | "CONFIRMED" | "RESOLVED" | null; + /** @description Whether to notify subscribers of this update */ + notifySubscribers: boolean; + }; + /** @description Request body for adding tags to a monitor. Provide existing tag IDs, inline new tags, or both. */ + AddMonitorTagsRequest: { + /** @description IDs of existing org tags to attach */ + tagIds?: string[] | null; + /** @description New tags to create (if not already present) and attach */ + newTags?: components["schemas"]["NewTagRequest"][] | null; + }; + /** @description Request body for adding a member to a resource group */ + AddResourceGroupMemberRequest: { + /** @description Type of member: 'monitor' or 'service' */ + memberType: string; + /** + * Format: uuid + * @description ID of the monitor or service to add + */ + memberId: string; + }; + AdminAddSubscriberRequest: { + /** + * Format: email + * @description Email address to add as a confirmed subscriber + */ + email: string; + }; + /** @description Updated affected components; null preserves current */ + AffectedComponent: { + /** + * Format: uuid + * @description Status page component ID + */ + componentId: string; + /** + * @description Component status during this incident + * @enum {string} + */ + status: "OPERATIONAL" | "DEGRADED_PERFORMANCE" | "PARTIAL_OUTAGE" | "MAJOR_OUTAGE" | "UNDER_MAINTENANCE"; + }; + /** @description Non-sensitive alert channel configuration metadata */ + AlertChannelDisplayConfig: { + /** @description Email recipients list (email channels) */ + recipients?: string[] | null; + /** @description OpsGenie API region: us or eu */ + region?: string | null; + /** @description PagerDuty severity override (critical, error, warning, info) */ + severityOverride?: string | null; + /** @description Discord role ID to mention in notifications */ + mentionRoleId?: string | null; + /** @description Custom HTTP headers for webhook requests */ + customHeaders?: { + [key: string]: string | null; + } | null; + }; + /** @description Alert channel with non-sensitive configuration metadata */ + AlertChannelDto: { + /** + * Format: uuid + * @description Unique alert channel identifier + */ + id: string; + /** @description Human-readable channel name */ + name: string; + /** + * @description Channel integration type (e.g. SLACK, PAGERDUTY, EMAIL) + * @enum {string} + */ + channelType: "email" | "webhook" | "slack" | "pagerduty" | "opsgenie" | "teams" | "discord"; + displayConfig?: components["schemas"]["AlertChannelDisplayConfig"] | null; + /** + * Format: date-time + * @description Timestamp when the channel was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the channel was last updated + */ + updatedAt: string; + /** @description SHA-256 hash of the channel config; use for change detection */ + configHash?: string | null; + /** + * Format: date-time + * @description Timestamp of the most recent delivery attempt + */ + lastDeliveryAt?: string | null; + /** @description Outcome of the most recent delivery (SUCCESS, FAILED, etc.) */ + lastDeliveryStatus?: string | null; + }; + /** @description Delivery record for a single channel within a notification dispatch */ + AlertDeliveryDto: { + /** Format: uuid */ + id: string; + /** + * Format: uuid + * @description Incident that triggered this delivery + */ + incidentId: string; + /** + * Format: uuid + * @description Notification dispatch that created this delivery + */ + dispatchId?: string | null; + /** + * Format: uuid + * @description Alert channel ID + */ + channelId: string; + /** @description Human-readable channel name */ + channel: string; + /** @description Alert channel type (e.g. slack, email, webhook) */ + channelType: string; + /** + * @description Current delivery status + * @enum {string} + */ + status: "PENDING" | "DELIVERED" | "RETRY_PENDING" | "FAILED" | "CANCELLED"; + /** + * @description Incident lifecycle event that triggered this delivery + * @enum {string} + */ + eventType: "INCIDENT_CREATED" | "INCIDENT_RESOLVED" | "INCIDENT_REOPENED"; + /** + * Format: int32 + * @description 1-based escalation step this delivery belongs to + */ + stepNumber: number; + /** + * Format: int32 + * @description Fire sequence within the step: 1 = initial, 2+ = repeat re-fires + */ + fireCount: number; + /** + * Format: int32 + * @description Number of delivery attempts made + */ + attemptCount: number; + /** + * Format: date-time + * @description When the last attempt was made + */ + lastAttemptAt?: string | null; + /** + * Format: date-time + * @description When the next retry is scheduled (null if not retrying) + */ + nextRetryAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the delivery was confirmed (null if not yet delivered) + */ + deliveredAt?: string | null; + /** @description Error message from the last failed attempt */ + errorMessage?: string | null; + /** Format: date-time */ + createdAt: string; + }; + ApiKeyAuthConfig: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + type: "api_key"; + /** @description HTTP header name that carries the API key */ + headerName: string; + /** + * Format: uuid + * @description Vault secret ID for the API key value + */ + vaultSecretId?: string | null; + }; + /** @description Created API key with the full key value — store it now, it won't be shown again */ + ApiKeyCreateResponse: { + /** + * Format: int32 + * @description Unique API key identifier + */ + id: number; + /** @description Human-readable name for this API key */ + name: string; + /** @description Full API key value in dh_live_* format; store this now */ + key: string; + /** + * Format: date-time + * @description Timestamp when the key was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the key expires; null if no expiration + */ + expiresAt?: string | null; + }; + /** @description API key for programmatic access to the DevHelm API */ + ApiKeyDto: { + /** + * Format: int32 + * @description Unique API key identifier + */ + id: number; + /** @description Human-readable name for this API key */ + name: string; + /** @description Full API key value in dh_live_* format */ + key: string; + /** + * Format: date-time + * @description Timestamp when the key was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the key was last updated + */ + updatedAt: string; + /** + * Format: date-time + * @description Timestamp of the most recent API call; null if never used + */ + lastUsedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the key was revoked; null if active + */ + revokedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the key expires; null if no expiration + */ + expiresAt?: string | null; + }; + /** @description Result of evaluating a single assertion against a check result */ + AssertionResultDto: { + /** + * @description Assertion type + * @example status_code + */ + type: string; + /** @description Whether the assertion passed */ + passed: boolean; + /** + * @description Assertion severity + * @enum {string} + */ + severity: "fail" | "warn"; + /** @description Human-readable result message */ + message?: string | null; + /** + * @description Expected value + * @example 200 + */ + expected?: string | null; + /** + * @description Actual value observed + * @example 503 + */ + actual?: string | null; + }; + AssertionTestResultDto: { + /** + * @description Assertion type evaluated + * @enum {string} + */ + assertionType: "status_code" | "response_time" | "body_contains" | "json_path" | "header_value" | "regex_body" | "dns_resolves" | "dns_response_time" | "dns_expected_ips" | "dns_expected_cname" | "dns_record_contains" | "dns_record_equals" | "dns_txt_contains" | "dns_min_answers" | "dns_max_answers" | "dns_response_time_warn" | "dns_ttl_low" | "dns_ttl_high" | "mcp_connects" | "mcp_response_time" | "mcp_has_capability" | "mcp_tool_available" | "mcp_min_tools" | "mcp_protocol_version" | "mcp_response_time_warn" | "mcp_tool_count_changed" | "ssl_expiry" | "response_size" | "redirect_count" | "redirect_target" | "response_time_warn" | "tcp_connects" | "tcp_response_time" | "tcp_response_time_warn" | "icmp_reachable" | "icmp_response_time" | "icmp_response_time_warn" | "icmp_packet_loss" | "heartbeat_received" | "heartbeat_max_interval" | "heartbeat_interval_drift" | "heartbeat_payload_contains"; + /** @description Whether the assertion passed */ + passed: boolean; + /** + * @description Assertion severity: FAIL or WARN + * @enum {string} + */ + severity: "fail" | "warn"; + /** @description Human-readable result description */ + message: string; + /** @description Expected value */ + expected?: string | null; + /** @description Actual value observed during the test */ + actual?: string | null; + }; + AuditEventDto: { + /** + * Format: int64 + * @description Unique audit event identifier + */ + id: number; + /** + * Format: int32 + * @description User ID who performed the action; null for system actions + */ + actorId?: number | null; + /** @description Email of the actor; null for system actions */ + actorEmail?: string | null; + /** @description Audit action type (e.g. monitor.created, api_key.revoked) */ + action: string; + /** @description Type of resource affected (e.g. monitor, api_key) */ + resourceType?: string | null; + /** @description ID of the affected resource */ + resourceId?: string | null; + /** @description Human-readable name of the affected resource */ + resourceName?: string | null; + metadata?: Omit | null; + /** + * Format: date-time + * @description Timestamp when the action was performed + */ + createdAt: string; + }; + /** @description Typed metadata payload attached to an audit event; null for actions that carry no extra context. */ + AuditMetadata: components["schemas"]["MemberRoleChangedMetadata"] | null; + /** @description Identity, organization, plan, and rate-limit info for the authenticated API key */ + AuthMeResponse: { + key: components["schemas"]["KeyInfo"]; + organization: components["schemas"]["OrgInfo"]; + plan: components["schemas"]["PlanInfo"]; + rateLimits: components["schemas"]["RateLimitInfo"]; + }; + BasicAuthConfig: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + type: "basic"; + /** + * Format: uuid + * @description Vault secret ID holding Basic auth username and password + */ + vaultSecretId?: string | null; + }; + /** @description Batch daily uptime per component, keyed by component ID */ + BatchComponentUptimeDto: { + /** @description Map of component ID → list of per-day uptime entries (oldest → newest) */ + components: { + [key: string]: components["schemas"]["ComponentUptimeDayDto"][]; + }; + }; + BearerAuthConfig: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + type: "bearer"; + /** + * Format: uuid + * @description Vault secret ID holding the bearer token value + */ + vaultSecretId?: string | null; + }; + BodyContainsAssertion: { + /** @enum {string} */ + type: "body_contains"; + /** @description Substring that must appear in the response body */ + substring: string; + }; + /** @description Request body for performing a bulk action on multiple monitors */ + BulkMonitorActionRequest: { + /** @description IDs of monitors to act on (max 200) */ + monitorIds: string[]; + /** + * @description Action to apply to every monitor in the bulk request + * @enum {string} + */ + action: "PAUSE" | "RESUME" | "DELETE" | "ADD_TAG" | "REMOVE_TAG"; + /** @description Tag IDs to attach or detach (required for ADD_TAG and REMOVE_TAG) */ + tagIds?: string[] | null; + /** @description New tags to create and attach (only for ADD_TAG) */ + newTags?: components["schemas"]["NewTagRequest"][] | null; + }; + /** @description Result of a bulk monitor action, including partial-success details */ + BulkMonitorActionResult: { + /** @description IDs of monitors on which the action succeeded */ + succeeded: string[]; + /** @description Monitors on which the action failed, with the reason for each failure */ + failed: components["schemas"]["FailureDetail"][]; + }; + /** @description Service category with its count of catalog entries */ + CategoryDto: { + /** @description Category name (e.g. CI/CD, Cloud, Payments) */ + category: string; + /** + * Format: int64 + * @description Number of services in this category + */ + serviceCount: number; + }; + /** @description Update an organization member's role */ + ChangeRoleRequest: { + /** + * @description New role to assign + * @enum {string} + */ + orgRole: "OWNER" | "ADMIN" | "MEMBER"; + }; + /** @description Update an organization member's status */ + ChangeStatusRequest: { + /** + * @description New membership status (ACTIVE or SUSPENDED) + * @enum {string} + */ + status: "INVITED" | "ACTIVE" | "SUSPENDED" | "LEFT" | "REMOVED" | "DECLINED"; + }; + /** @description Aggregated metrics for a time bucket */ + ChartBucketDto: { + /** + * Format: date-time + * @description Start of the time bucket (ISO 8601) + * @example 2026-03-12T10:00:00Z + */ + bucket: string; + /** + * Format: double + * @description Uptime percentage for this bucket; null when no data + * @example 100 + */ + uptimePercent?: number | null; + /** + * Format: double + * @description Weighted average latency in milliseconds for this bucket + * @example 120.3 + */ + avgLatencyMs?: number | null; + /** + * Format: double + * @description 95th percentile latency in milliseconds (max across regions) + * @example 250 + */ + p95LatencyMs?: number | null; + /** + * Format: double + * @description 99th percentile latency in milliseconds (max across regions) + * @example 480 + */ + p99LatencyMs?: number | null; + }; + /** @description Type-specific details captured during a check execution */ + CheckResultDetailsDto: { + /** + * Format: int32 + * @description HTTP status code of the response + * @example 200 + */ + statusCode?: number | null; + /** @description HTTP response headers */ + responseHeaders?: { + [key: string]: (string | null)[] | null; + } | null; + /** @description Raw response body snapshot (may be HTML, XML, JSON, or plain text) */ + responseBodySnapshot?: string | null; + /** @description Individual assertion evaluation results */ + assertionResults?: components["schemas"]["AssertionResultDto"][] | null; + tlsInfo?: components["schemas"]["TlsInfoDto"] | null; + /** + * Format: int32 + * @description Number of HTTP redirects followed + * @example 2 + */ + redirectCount?: number | null; + /** @description Final URL after redirects */ + redirectTarget?: string | null; + /** + * Format: int32 + * @description Response body size in bytes + * @example 4096 + */ + responseSizeBytes?: number | null; + checkDetails?: Omit | null; + }; + /** @description A single check result from a monitor run */ + CheckResultDto: { + /** + * Format: uuid + * @description Unique identifier of the check result + */ + id: string; + /** + * Format: date-time + * @description Timestamp when the check was executed (ISO 8601) + */ + timestamp: string; + /** + * @description Region where the check was executed + * @example us-east + */ + region: string; + /** + * Format: int32 + * @description Response time in milliseconds + * @example 123 + */ + responseTimeMs?: number | null; + /** + * @description Whether the check passed + * @example true + */ + passed: boolean; + /** @description Reason for failure when passed=false */ + failureReason?: string | null; + /** @description Severity hint: 'down' for hard failures, 'degraded' for warn-only failures, null when passing */ + severityHint?: string | null; + details?: components["schemas"]["CheckResultDetailsDto"] | null; + /** + * Format: uuid + * @description Unique execution trace ID for cross-service correlation + */ + checkId?: string | null; + }; + CheckTraceDto: { + /** + * Format: uuid + * @description The check execution ID this trace is keyed by + */ + checkId: string; + /** @description All rule evaluations that ran for this check */ + evaluations: components["schemas"]["RuleEvaluationDto"][]; + /** @description State-machine transitions this check caused (may be empty if nothing fired) */ + transitions: components["schemas"]["IncidentStateTransitionDto"][]; + policySnapshot?: components["schemas"]["PolicySnapshotDto"] | null; + }; + /** @description Check-type-specific details — polymorphic by check_type discriminator */ + CheckTypeDetailsDto: components["schemas"]["Http"] | components["schemas"]["Tcp"] | components["schemas"]["Icmp"] | components["schemas"]["Dns"] | components["schemas"]["McpServer"]; + /** @description One component's uptime contribution for the day */ + ComponentImpact: { + /** + * Format: uuid + * @description Status page component UUID + */ + componentId: string; + /** @description Component display name */ + componentName: string; + /** @description Parent group display name when the component belongs to a group */ + groupName?: string | null; + /** + * Format: double + * @description Computed uptime % for this component on this day + */ + uptimePercentage: number; + /** + * Format: int32 + * @description Seconds of partial outage observed on this day + */ + partialOutageSeconds: number; + /** + * Format: int32 + * @description Seconds of major outage observed on this day + */ + majorOutageSeconds: number; + }; + /** @description A single component position */ + ComponentPosition: { + /** + * Format: uuid + * @description Component ID + */ + componentId: string; + /** + * Format: int32 + * @description New display order (0-based) + */ + displayOrder: number; + /** + * Format: uuid + * @description Target group ID, null for ungrouped + */ + groupId?: string | null; + }; + ComponentsSummaryDto: { + /** + * Format: int32 + * @description Total active components for this service across all groups + */ + totalCount: number; + /** + * Format: int32 + * @description Number of components actually returned in the inline ``components`` list + */ + includedCount: number; + /** @description Per-group active leaf count, keyed by group component id (UUID stringified). Empty when the service has no groups; lets the UI render "show all N" affordances without a second round trip */ + groupComponentCounts: { + [key: string]: number; + }; + }; + /** @description Current status of each active component */ + ComponentStatusDto: { + /** @description Component UUID */ + id: string; + /** @description Human-readable component name */ + name: string; + /** @description Current component status, e.g. operational, degraded_performance */ + status: string; + }; + /** @description Daily uptime data for a component */ + ComponentUptimeDayDto: { + /** + * Format: date-time + * @description Start-of-day timestamp for this bucket (UTC midnight, ISO 8601) + */ + date: string; + /** + * Format: int32 + * @description Seconds of partial outage observed on this day + */ + partialOutageSeconds: number; + /** + * Format: int32 + * @description Seconds of major outage observed on this day + */ + majorOutageSeconds: number; + /** + * Format: int32 + * @description Seconds the component spent in degraded performance on this day + */ + degradedSeconds: number; + /** + * Format: double + * @description Computed uptime percentage using the weighted formula (degraded does not lower it) + */ + uptimePercentage: number; + /** @description Incidents that overlapped this day, in display order */ + incidents?: components["schemas"]["IncidentRef"][] | null; + }; + /** @description Inline uptime percentages for 24h, 7d, 30d */ + ComponentUptimeSummaryDto: { + /** + * Format: double + * @description Uptime percentage over the last 24 hours + * @example 99.95 + */ + day?: number | null; + /** + * Format: double + * @description Uptime percentage over the last 7 days + * @example 99.98 + */ + week?: number | null; + /** + * Format: double + * @description Uptime percentage over the last 30 days + * @example 99.92 + */ + month?: number | null; + /** + * @description Data source: vendor_reported or incident_derived + * @example vendor_reported + */ + source: string; + }; + /** @description Multi-region confirmation settings */ + ConfirmationPolicy: { + /** + * @description How incident confirmation is coordinated across regions + * @enum {string} + */ + type: "multi_region"; + /** + * Format: int32 + * @description Minimum failing regions required to confirm an incident + */ + minRegionsFailing: number; + /** + * Format: int32 + * @description Maximum seconds to wait for enough regions to fail after first trigger + */ + maxWaitSeconds: number; + }; + CreateAlertChannelRequest: { + /** @description Human-readable name for this alert channel */ + name: string; + config: components["schemas"]["DiscordChannelConfig"] | components["schemas"]["EmailChannelConfig"] | components["schemas"]["OpsGenieChannelConfig"] | components["schemas"]["PagerDutyChannelConfig"] | components["schemas"]["SlackChannelConfig"] | components["schemas"]["TeamsChannelConfig"] | components["schemas"]["WebhookChannelConfig"]; + }; + CreateApiKeyRequest: { + /** @description Human-readable name to identify this API key */ + name: string; + /** + * Format: date-time + * @description Optional expiration timestamp in ISO 8601 format + */ + expiresAt?: string | null; + }; + /** @description Replace all assertions; null preserves current */ + CreateAssertionRequest: { + config: components["schemas"]["BodyContainsAssertion"] | components["schemas"]["DnsExpectedCnameAssertion"] | components["schemas"]["DnsExpectedIpsAssertion"] | components["schemas"]["DnsMaxAnswersAssertion"] | components["schemas"]["DnsMinAnswersAssertion"] | components["schemas"]["DnsRecordContainsAssertion"] | components["schemas"]["DnsRecordEqualsAssertion"] | components["schemas"]["DnsResolvesAssertion"] | components["schemas"]["DnsResponseTimeAssertion"] | components["schemas"]["DnsResponseTimeWarnAssertion"] | components["schemas"]["DnsTtlHighAssertion"] | components["schemas"]["DnsTtlLowAssertion"] | components["schemas"]["DnsTxtContainsAssertion"] | components["schemas"]["HeaderValueAssertion"] | components["schemas"]["HeartbeatIntervalDriftAssertion"] | components["schemas"]["HeartbeatMaxIntervalAssertion"] | components["schemas"]["HeartbeatPayloadContainsAssertion"] | components["schemas"]["HeartbeatReceivedAssertion"] | components["schemas"]["IcmpPacketLossAssertion"] | components["schemas"]["IcmpReachableAssertion"] | components["schemas"]["IcmpResponseTimeAssertion"] | components["schemas"]["IcmpResponseTimeWarnAssertion"] | components["schemas"]["JsonPathAssertion"] | components["schemas"]["McpConnectsAssertion"] | components["schemas"]["McpHasCapabilityAssertion"] | components["schemas"]["McpMinToolsAssertion"] | components["schemas"]["McpProtocolVersionAssertion"] | components["schemas"]["McpResponseTimeAssertion"] | components["schemas"]["McpResponseTimeWarnAssertion"] | components["schemas"]["McpToolAvailableAssertion"] | components["schemas"]["McpToolCountChangedAssertion"] | components["schemas"]["RedirectCountAssertion"] | components["schemas"]["RedirectTargetAssertion"] | components["schemas"]["RegexBodyAssertion"] | components["schemas"]["ResponseSizeAssertion"] | components["schemas"]["ResponseTimeAssertion"] | components["schemas"]["ResponseTimeWarnAssertion"] | components["schemas"]["SslExpiryAssertion"] | components["schemas"]["StatusCodeAssertion"] | components["schemas"]["TcpConnectsAssertion"] | components["schemas"]["TcpResponseTimeAssertion"] | components["schemas"]["TcpResponseTimeWarnAssertion"]; + /** + * @description Outcome severity: FAIL (fails the check) or WARN (warns without failing, default: FAIL) + * @enum {string|null} + */ + severity?: "fail" | "warn" | null; + }; + CreateEnvironmentRequest: { + /** @description Human-readable environment name */ + name: string; + /** @description URL-safe identifier (lowercase alphanumeric, hyphens, underscores) */ + slug: string; + /** @description Initial key-value variable pairs for this environment */ + variables?: { + [key: string]: string | null; + } | null; + /** @description Whether this is the default environment for new monitors (default: false) */ + isDefault?: boolean | null; + }; + /** @description Invite a new member to the organization by email */ + CreateInviteRequest: { + /** + * Format: email + * @description Email address to invite + */ + email: string; + /** + * @description Role to assign on acceptance + * @enum {string} + */ + roleOffered: "OWNER" | "ADMIN" | "MEMBER"; + }; + CreateMaintenanceWindowRequest: { + /** + * Format: uuid + * @description Monitor to attach this maintenance window to; null for org-wide + */ + monitorId?: string | null; + /** + * Format: date-time + * @description Scheduled start of the maintenance window (ISO 8601) + */ + startsAt: string; + /** + * Format: date-time + * @description Scheduled end of the maintenance window (ISO 8601) + */ + endsAt: string; + /** @description iCal RRULE for recurring windows (max 100 chars); null for one-time */ + repeatRule?: string | null; + /** @description Human-readable reason for the maintenance */ + reason?: string | null; + /** @description Whether to suppress alerts during this window (default: true) */ + suppressAlerts?: boolean | null; + }; + CreateManualIncidentRequest: { + /** @description Short summary of the incident */ + title: string; + /** + * @description Incident severity: DOWN, DEGRADED, or MAINTENANCE + * @enum {string} + */ + severity: "DOWN" | "DEGRADED" | "MAINTENANCE"; + /** + * Format: uuid + * @description Monitor to associate with this incident + */ + monitorId?: string | null; + /** @description Detailed description or context for the incident */ + body?: string | null; + }; + CreateMonitorRequest: { + /** @description Human-readable name for this monitor */ + name: string; + /** + * @description Monitor protocol type + * @enum {string} + */ + type: "HTTP" | "DNS" | "MCP_SERVER" | "TCP" | "ICMP" | "HEARTBEAT"; + config: components["schemas"]["DnsMonitorConfig"] | components["schemas"]["HeartbeatMonitorConfig"] | components["schemas"]["HttpMonitorConfig"] | components["schemas"]["IcmpMonitorConfig"] | components["schemas"]["McpServerMonitorConfig"] | components["schemas"]["TcpMonitorConfig"]; + /** + * Format: int32 + * @description Check frequency in seconds (30–86400); null defaults to plan minimum (60s on most paid plans) + */ + frequencySeconds?: number | null; + /** @description Whether the monitor is active (default: true) */ + enabled?: boolean | null; + /** @description Probe regions to run checks from, e.g. us-east, eu-west */ + regions?: string[] | null; + /** + * @description Source that created/owns this monitor: DASHBOARD, CLI, TERRAFORM, MCP, or API. Use the value matching your surface so audit logs, drift detection, and analytics attribute correctly. + * @enum {string} + */ + managedBy: "DASHBOARD" | "CLI" | "TERRAFORM" | "MCP" | "API"; + /** + * Format: uuid + * @description Environment to associate with this monitor + */ + environmentId?: string | null; + /** @description Assertions to evaluate against each check result */ + assertions?: components["schemas"]["CreateAssertionRequest"][] | null; + auth?: Omit | null; + incidentPolicy?: components["schemas"]["UpdateIncidentPolicyRequest"] | null; + /** @description Alert channels to notify when this monitor triggers */ + alertChannelIds?: string[] | null; + tags?: components["schemas"]["AddMonitorTagsRequest"] | null; + }; + /** @description Request body for creating a notification policy */ + CreateNotificationPolicyRequest: { + /** @description Human-readable name for this policy */ + name: string; + /** @description Match rules to evaluate (all must pass; omit or empty for catch-all) */ + matchRules?: components["schemas"]["MatchRule"][] | null; + escalation: components["schemas"]["EscalationChain"]; + /** + * @description Whether this policy is enabled (default true) + * @default true + */ + enabled: boolean | null; + /** + * Format: int32 + * @description Evaluation priority; higher value = evaluated first (default 0) + * @default 0 + */ + priority: number | null; + }; + /** @description Request body for creating a resource group */ + CreateResourceGroupRequest: { + /** @description Human-readable name for this group */ + name: string; + /** @description Optional description */ + description?: string | null; + /** + * Format: uuid + * @description Optional notification policy to apply for this group + */ + alertPolicyId?: string | null; + /** + * Format: int32 + * @description Default check frequency in seconds applied to members (30–86400) + */ + defaultFrequency?: number | null; + /** @description Default regions applied to member monitors */ + defaultRegions?: string[] | null; + defaultRetryStrategy?: components["schemas"]["RetryStrategy"] | null; + /** @description Default alert channel IDs applied to member monitors */ + defaultAlertChannels?: string[] | null; + /** + * Format: uuid + * @description Default environment ID applied to member monitors + */ + defaultEnvironmentId?: string | null; + /** + * @description Health threshold type: COUNT or PERCENTAGE + * @enum {string|null} + */ + healthThresholdType?: "COUNT" | "PERCENTAGE" | null; + /** @description Health threshold value: count (0+) or percentage (0–100) */ + healthThresholdValue?: number | null; + /** @description Suppress member-level alert notifications when group manages alerting */ + suppressMemberAlerts?: boolean | null; + /** + * Format: int32 + * @description Confirmation delay in seconds before group incident creation (0–600) + */ + confirmationDelaySeconds?: number | null; + /** + * Format: int32 + * @description Recovery cooldown in minutes after group incident resolves (0–60) + */ + recoveryCooldownMinutes?: number | null; + }; + CreateSecretRequest: { + /** @description Unique secret key within the workspace (max 255 chars) */ + key: string; + /** @description Secret value, stored encrypted (max 32KB) */ + value: string; + }; + CreateStatusPageComponentGroupRequest: { + /** @description Group display name */ + name: string; + /** @description Optional group description */ + description?: string | null; + /** + * Format: int32 + * @description Position in the group list + */ + displayOrder?: number | null; + /** @description Initial expand/collapse state when a visitor first loads the page; renderer may auto-expand on active incidents (default: true) */ + defaultOpen?: boolean | null; + }; + CreateStatusPageComponentRequest: { + /** @description Component display name */ + name: string; + /** @description Optional description shown on expand */ + description?: string | null; + /** + * @description Component type: MONITOR, GROUP, or STATIC + * @enum {string} + */ + type: "MONITOR" | "GROUP" | "STATIC"; + /** + * Format: uuid + * @description Monitor ID (required when type=MONITOR) + */ + monitorId?: string | null; + /** + * Format: uuid + * @description Resource group ID (required when type=GROUP) + */ + resourceGroupId?: string | null; + /** + * Format: uuid + * @description Component group ID for visual grouping + */ + groupId?: string | null; + /** @description Whether to show the uptime bar (default: true) */ + showUptime?: boolean | null; + /** + * Format: int32 + * @description Position in the component list + */ + displayOrder?: number | null; + /** @description Exclude from overall status calculation (default: false, use true for third-party deps) */ + excludeFromOverall?: boolean | null; + /** + * Format: date + * @description Date from which to start showing uptime; defaults to component creation. Set earlier to backdate (e.g. launch day); clamped at the monitor's createdAt for MONITOR-type components + */ + startDate?: string | null; + }; + CreateStatusPageIncidentRequest: { + /** @description Customer-facing incident title */ + title: string; + /** + * @description Initial status (default: INVESTIGATING) + * @enum {string|null} + */ + status?: "INVESTIGATING" | "IDENTIFIED" | "MONITORING" | "RESOLVED" | null; + /** + * @description Impact level: NONE, MINOR, MAJOR, or CRITICAL + * @enum {string} + */ + impact: "NONE" | "MINOR" | "MAJOR" | "CRITICAL"; + /** @description Initial update body in markdown */ + body: string; + /** @description Component IDs affected by this incident */ + affectedComponents?: components["schemas"]["AffectedComponent"][] | null; + /** @description Whether this is a scheduled maintenance (default: false) */ + scheduled?: boolean | null; + /** + * Format: date-time + * @description Maintenance start time (required when scheduled=true) + */ + scheduledFor?: string | null; + /** + * Format: date-time + * @description Maintenance end time + */ + scheduledUntil?: string | null; + /** @description Auto-resolve at scheduledUntil (default: false) */ + autoResolve?: boolean | null; + /** @description Whether to email confirmed subscribers about this incident (default: true) */ + notifySubscribers?: boolean | null; + }; + CreateStatusPageIncidentUpdateRequest: { + /** + * @description Incident status at this point in the timeline + * @enum {string} + */ + status: "INVESTIGATING" | "IDENTIFIED" | "MONITORING" | "RESOLVED"; + /** @description Update body in markdown */ + body: string; + /** @description Whether to email confirmed subscribers about this update (default: true) */ + notifySubscribers?: boolean | null; + /** @description Updated affected components; null preserves current */ + affectedComponents?: components["schemas"]["AffectedComponent"][] | null; + }; + CreateStatusPageRequest: { + /** @description Human-readable name for this status page */ + name: string; + /** @description URL slug (lowercase, hyphens, globally unique) */ + slug: string; + /** @description Optional description shown below the page header */ + description?: string | null; + branding?: components["schemas"]["StatusPageBranding"] | null; + /** + * @description Page visibility: PUBLIC, PASSWORD, or IP_RESTRICTED (default: PUBLIC) + * @enum {string|null} + */ + visibility?: "PUBLIC" | "PASSWORD" | "IP_RESTRICTED" | null; + /** @description Whether the page is enabled (default: true) */ + enabled?: boolean | null; + /** + * @description Incident mode: MANUAL, REVIEW, or AUTOMATIC (default: AUTOMATIC) + * @enum {string|null} + */ + incidentMode?: "MANUAL" | "REVIEW" | "AUTOMATIC" | null; + }; + /** @description Request body for creating a tag */ + CreateTagRequest: { + /** @description Tag name, unique within the org */ + name: string; + /** @description Hex color code (defaults to #6B7280 if omitted) */ + color?: string | null; + }; + CreateWebhookEndpointRequest: { + /** @description HTTPS endpoint that receives webhook event payloads */ + url: string; + /** @description Optional human-readable description */ + description?: string | null; + /** @description Event types to deliver */ + subscribedEvents: ("monitor.created" | "monitor.updated" | "monitor.deleted" | "incident.created" | "incident.resolved" | "incident.reopened" | "service.status_changed" | "service.component_changed" | "service.incident_created" | "service.incident_updated" | "service.incident_resolved")[]; + }; + /** @description Create a new workspace within the organization */ + CreateWorkspaceRequest: { + /** @description Workspace name */ + name: string; + }; + /** @description Cursor-paginated response for time-series and append-only data */ + CursorPageCheckResultDto: { + /** @description Items on this page */ + data: components["schemas"]["CheckResultDto"][]; + /** @description Opaque cursor for the next page; null when there are no more results */ + nextCursor?: string | null; + /** @description Whether more results exist beyond this page */ + hasMore: boolean; + }; + /** @description Cursor-paginated response for time-series and append-only data */ + CursorPageServiceCatalogDto: { + /** @description Items on this page */ + data: components["schemas"]["ServiceCatalogDto"][]; + /** @description Opaque cursor for the next page; null when there are no more results */ + nextCursor?: string | null; + /** @description Whether more results exist beyond this page */ + hasMore: boolean; + }; + /** @description Cursor-paginated response for time-series and append-only data */ + CursorPageServicePollResultDto: { + /** @description Items on this page */ + data: components["schemas"]["ServicePollResultDto"][]; + /** @description Opaque cursor for the next page; null when there are no more results */ + nextCursor?: string | null; + /** @description Whether more results exist beyond this page */ + hasMore: boolean; + }; + /** @description Combined dashboard overview for monitors and incidents */ + DashboardOverviewDto: { + monitors: components["schemas"]["MonitorsSummaryDto"]; + incidents: components["schemas"]["IncidentsSummaryDto"]; + }; + /** @description Incident that overlapped the day */ + DayIncident: { + /** + * Format: uuid + * @description Status page incident UUID + */ + id: string; + /** @description Incident title */ + title: string; + /** + * @description Lifecycle status (investigating, identified, monitoring, resolved, …) + * @enum {string} + */ + status: "INVESTIGATING" | "IDENTIFIED" | "MONITORING" | "RESOLVED"; + /** + * @description Severity bucket (none, minor, major, critical) + * @enum {string} + */ + impact: "NONE" | "MINOR" | "MAJOR" | "CRITICAL"; + /** @description True for scheduled maintenances; false for unplanned incidents */ + scheduled: boolean; + /** + * Format: date-time + * @description Incident start timestamp + */ + startedAt?: string | null; + /** + * Format: date-time + * @description Incident resolved timestamp; null while still active + */ + resolvedAt?: string | null; + /** @description Display names of components affected by this incident (deduplicated) */ + affectedComponentNames: string[]; + }; + /** @description Result of a data encryption key rotation operation */ + DekRotationResultDto: { + /** + * Format: int32 + * @description DEK version before rotation + */ + previousDekVersion: number; + /** + * Format: int32 + * @description DEK version after rotation + */ + newDekVersion: number; + /** + * Format: int32 + * @description Number of secrets re-encrypted with the new DEK + */ + secretsReEncrypted: number; + /** + * Format: int32 + * @description Number of alert channels re-encrypted with the new DEK + */ + channelsReEncrypted: number; + /** + * Format: date-time + * @description Timestamp when the rotation was performed + */ + rotatedAt: string; + }; + /** @description Summary of policies affected by channel deletion */ + DeleteChannelResult: { + /** + * Format: int32 + * @description Number of notification policies whose escalation steps were modified + */ + affectedPolicies: number; + /** + * Format: int32 + * @description Number of notification policies disabled because they had no remaining channels + */ + disabledPolicies: number; + }; + /** @description Single delivery attempt with request/response audit data */ + DeliveryAttemptDto: { + /** Format: uuid */ + id: string; + /** Format: uuid */ + deliveryId: string; + /** + * Format: int32 + * @description 1-based attempt number + */ + attemptNumber: number; + /** @description Outcome: SUCCESS, FAILED, TIMEOUT, ERROR */ + status: string; + /** + * Format: int32 + * @description HTTP response status code from the external service + */ + responseStatusCode?: number | null; + /** @description JSON payload sent to the external service */ + requestPayload?: string | null; + /** @description Response body from the external service (truncated) */ + responseBody?: string | null; + /** @description Error message if the attempt failed */ + errorMessage?: string | null; + /** + * Format: int32 + * @description Round-trip time in milliseconds + */ + responseTimeMs?: number | null; + /** @description External identifier (e.g. PagerDuty dedup_key, SES MessageId, webhook delivery UUID) */ + externalId?: string | null; + /** @description HTTP request headers sent to the external service */ + requestHeaders?: { + [key: string]: string | null; + } | null; + /** Format: date-time */ + attemptedAt: string; + }; + /** @description Represents an active deploy lock for a workspace */ + DeployLockDto: { + /** + * Format: uuid + * @description Unique lock identifier + */ + id: string; + /** @description Identity of the lock holder (e.g. CLI session ID, username) */ + lockedBy: string; + /** + * Format: date-time + * @description Timestamp when the lock was acquired + */ + lockedAt: string; + /** + * Format: date-time + * @description Timestamp when the lock automatically expires + */ + expiresAt: string; + }; + DiscordChannelConfig: { + /** @enum {string} */ + channelType: "discord"; + /** @description Discord webhook URL */ + webhookUrl: string; + /** @description Optional Discord role ID to mention in notifications */ + mentionRoleId?: string | null; + }; + /** @description DNS check-type-specific details */ + Dns: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + check_type: "dns"; + /** @description Target hostname */ + hostname?: string | null; + /** @description Requested DNS record types */ + requestedTypes?: (string | null)[] | null; + /** @description Resolver used for lookup */ + usedResolver?: string | null; + /** @description Resolved DNS records keyed by record type */ + records?: { + [key: string]: ({ + [key: string]: Record | null; + } | null)[] | null; + } | null; + /** @description DNS resolution attempts */ + attempts?: ({ + [key: string]: Record | null; + } | null)[] | null; + /** @description Kind of DNS failure, if any */ + failureKind?: string | null; + }; + DnsExpectedCnameAssertion: { + /** @enum {string} */ + type: "dns_expected_cname"; + /** @description Expected CNAME target the resolution must include */ + value: string; + }; + DnsExpectedIpsAssertion: { + /** @enum {string} */ + type: "dns_expected_ips"; + /** @description Allowed IP addresses; at least one resolved address must match */ + ips: string[]; + }; + DnsMaxAnswersAssertion: { + /** @enum {string} */ + type: "dns_max_answers"; + /** @description DNS record type whose answer count is checked */ + recordType: string; + /** + * Format: int32 + * @description Maximum number of answers allowed for that record type + */ + max: number; + }; + DnsMinAnswersAssertion: { + /** @enum {string} */ + type: "dns_min_answers"; + /** @description DNS record type whose answer count is checked */ + recordType: string; + /** + * Format: int32 + * @description Minimum number of answers required for that record type + */ + min: number; + }; + DnsMonitorConfig: { + /** @description Domain name to resolve */ + hostname: string; + /** @description DNS record types to query: A, AAAA, CNAME, MX, NS, TXT, SRV, SOA, CAA, PTR */ + recordTypes?: ("A" | "AAAA" | "CNAME" | "MX" | "NS" | "TXT" | "SRV" | "SOA" | "CAA" | "PTR" | null)[] | null; + /** @description Custom nameservers to query (uses system defaults if omitted) */ + nameservers?: (string | null)[] | null; + /** + * Format: int32 + * @description Per-query timeout in milliseconds + */ + timeoutMs?: number | null; + /** + * Format: int32 + * @description Total timeout for all queries in milliseconds + */ + totalTimeoutMs?: number | null; + }; + DnsRecordContainsAssertion: { + /** @enum {string} */ + type: "dns_record_contains"; + /** @description DNS record type to assert on (A, AAAA, CNAME, MX, TXT) */ + recordType: string; + /** @description Substring that must appear in a matching record value */ + substring: string; + }; + DnsRecordEqualsAssertion: { + /** @enum {string} */ + type: "dns_record_equals"; + /** @description DNS record type to assert on (A, AAAA, CNAME, MX, TXT) */ + recordType: string; + /** @description Expected DNS record value for an exact match */ + value: string; + }; + DnsResolvesAssertion: { + /** @enum {string} */ + type: "dns_resolves"; + }; + DnsResponseTimeAssertion: { + /** @enum {string} */ + type: "dns_response_time"; + /** + * Format: int32 + * @description Maximum allowed DNS resolution time in milliseconds + */ + maxMs: number; + }; + DnsResponseTimeWarnAssertion: { + /** @enum {string} */ + type: "dns_response_time_warn"; + /** + * Format: int32 + * @description DNS resolution time in milliseconds that triggers a warning only + */ + warnMs: number; + }; + DnsTtlHighAssertion: { + /** @enum {string} */ + type: "dns_ttl_high"; + /** + * Format: int32 + * @description Maximum TTL in seconds before a high-TTL warning is raised + */ + maxTtl: number; + }; + DnsTtlLowAssertion: { + /** @enum {string} */ + type: "dns_ttl_low"; + /** + * Format: int32 + * @description Minimum acceptable TTL in seconds before a warning is raised + */ + minTtl: number; + }; + DnsTxtContainsAssertion: { + /** @enum {string} */ + type: "dns_txt_contains"; + /** @description Substring that must appear in at least one TXT record */ + substring: string; + }; + EmailChannelConfig: { + /** @enum {string} */ + channelType: "email"; + /** @description Email addresses to send notifications to */ + recipients: string[]; + }; + /** @description A single resolved entitlement for the organization */ + EntitlementDto: { + /** @description Entitlement key */ + key: string; + /** + * Format: int64 + * @description Effective limit value (overrides applied) + */ + value: number; + /** + * Format: int64 + * @description Plan-tier default value before overrides + */ + defaultValue: number; + /** @description Whether this entitlement has an org-level override */ + overridden: boolean; + }; + /** @description Environment with variable substitutions for monitor configs */ + EnvironmentDto: { + /** + * Format: uuid + * @description Unique environment identifier + */ + id: string; + /** + * Format: int32 + * @description Organization this environment belongs to + */ + orgId: number; + /** @description Human-readable environment name */ + name: string; + /** @description URL-safe identifier */ + slug: string; + /** @description Key-value variable pairs available for interpolation */ + variables: { + [key: string]: string; + }; + /** + * Format: date-time + * @description Timestamp when the environment was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the environment was last updated + */ + updatedAt: string; + /** + * Format: int32 + * @description Number of monitors using this environment + */ + monitorCount: number; + /** @description Whether this is the default environment for new monitors */ + isDefault: boolean; + }; + /** + * @description Uniform error envelope returned for every non-2xx response + * @example { + * "status": 404, + * "code": "NOT_FOUND", + * "message": "Monitor not found", + * "timestamp": 1737302400000, + * "requestId": "5b6f7a8c-1234-4d5e-9f0a-1b2c3d4e5f6a" + * } + */ + ErrorResponse: { + /** + * Format: int32 + * @description HTTP status code (mirrors the response status line) + * @example 404 + */ + status: number; + /** + * @description Coarse machine-readable error category (e.g. NOT_FOUND, RATE_LIMITED); stable per status + * @example NOT_FOUND + */ + code: string; + /** + * @description Human-readable error message; safe to surface to end users + * @example Monitor not found + */ + message: string; + /** + * Format: int64 + * @description Server time when the error was produced (epoch milliseconds) + * @example 1737302400000 + */ + timestamp: number; + /** + * @description Opaque per-request id; same value as the X-Request-Id response header. Use in support tickets. + * @example 5b6f7a8c-1234-4d5e-9f0a-1b2c3d4e5f6a + */ + requestId?: string | null; + }; + /** @description Escalation chain defining which channels to notify; null preserves current */ + EscalationChain: { + /** @description Ordered escalation steps, evaluated in sequence */ + steps: components["schemas"]["EscalationStep"][]; + /** @description Action when the incident resolves */ + onResolve?: string | null; + /** @description Action when a resolved incident reopens */ + onReopen?: string | null; + }; + /** @description Ordered escalation steps, evaluated in sequence */ + EscalationStep: { + /** + * Format: int32 + * @description Minutes to wait before executing this step (0 = immediate) + */ + delayMinutes: number; + /** @description Alert channel IDs to notify in this step */ + channelIds: string[]; + /** @description Whether an acknowledgment is required before escalating */ + requireAck?: boolean | null; + /** + * Format: int32 + * @description Repeat notification interval in seconds until acknowledged + */ + repeatIntervalSeconds?: number | null; + }; + /** @description Details about a single monitor that failed the bulk action */ + FailureDetail: { + /** + * Format: uuid + * @description Monitor ID that failed + */ + monitorId: string; + /** @description Human-readable reason for the failure */ + reason: string; + }; + /** @description Global status summary across all subscribed vendor services */ + GlobalStatusSummaryDto: { + /** + * Format: int32 + * @description Total number of services in the catalog + */ + totalServices: number; + /** + * Format: int32 + * @description Number of services currently fully operational + */ + operationalCount: number; + /** + * Format: int32 + * @description Number of services with degraded status + */ + degradedCount: number; + /** + * Format: int32 + * @description Number of services with partial outage + */ + partialOutageCount: number; + /** + * Format: int32 + * @description Number of services with major outage + */ + majorOutageCount: number; + /** + * Format: int32 + * @description Number of services currently under maintenance + */ + maintenanceCount: number; + /** + * Format: int32 + * @description Number of services with unknown or null status + */ + unknownCount: number; + /** + * Format: int64 + * @description Total number of active incidents across all services + */ + activeIncidentCount: number; + /** @description Services that are not fully operational */ + servicesWithIssues: components["schemas"]["ServiceCatalogDto"][]; + }; + /** @description Component ordering within a single group */ + GroupComponentOrder: { + /** + * Format: uuid + * @description Group these components belong to + */ + groupId: string; + /** @description Ordered component IDs with their within-group display order */ + positions: components["schemas"]["ComponentPosition"][]; + }; + HeaderAuthConfig: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + type: "header"; + /** @description Custom HTTP header name for the secret value */ + headerName: string; + /** + * Format: uuid + * @description Vault secret ID for the header value + */ + vaultSecretId?: string | null; + }; + HeaderValueAssertion: { + /** @enum {string} */ + type: "header_value"; + /** @description HTTP header name to assert on */ + headerName: string; + /** @description Expected value to compare against */ + expected: string; + /** + * @description Comparison operator (equals, contains, less_than, greater_than, etc.) + * @enum {string} + */ + operator: "equals" | "contains" | "less_than" | "greater_than" | "matches" | "range"; + }; + HeartbeatIntervalDriftAssertion: { + /** @enum {string} */ + type: "heartbeat_interval_drift"; + /** + * Format: int32 + * @description Max percent drift from expected ping interval before warning (non-fatal) + */ + maxDeviationPercent: number; + }; + HeartbeatMaxIntervalAssertion: { + /** @enum {string} */ + type: "heartbeat_max_interval"; + /** + * Format: int32 + * @description Maximum allowed gap in seconds between consecutive heartbeat pings + */ + maxSeconds: number; + }; + HeartbeatMonitorConfig: { + /** + * Format: int32 + * @description Expected heartbeat interval in seconds + */ + expectedInterval: number; + /** + * Format: int32 + * @description Grace period in seconds before marking as down + */ + gracePeriod: number; + }; + HeartbeatPayloadContainsAssertion: { + /** @enum {string} */ + type: "heartbeat_payload_contains"; + /** @description JSONPath expression into the heartbeat ping JSON payload */ + path: string; + /** @description Expected value to compare against at that path */ + value: string; + }; + /** @description Acknowledgement that a heartbeat ping was accepted */ + HeartbeatPingResponse: { + /** + * @description Always true on a 2xx response + * @example true + */ + ok: boolean; + }; + HeartbeatReceivedAssertion: { + /** @enum {string} */ + type: "heartbeat_received"; + }; + /** @description HTTP check-type-specific details */ + Http: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + check_type: "http"; + timing?: components["schemas"]["TimingPhasesDto"] | null; + /** @description Whether the response body was truncated before storage */ + bodyTruncated?: boolean | null; + }; + HttpMonitorConfig: { + /** @description Target URL to send requests to */ + url: string; + /** + * @description HTTP method: GET, POST, PUT, PATCH, DELETE, or HEAD + * @enum {string} + */ + method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD"; + /** @description Additional HTTP headers to include in requests */ + customHeaders?: { + [key: string]: string | null; + } | null; + /** @description Request body content for POST/PUT/PATCH methods */ + requestBody?: string | null; + /** @description Content-Type header value for the request body */ + contentType?: string | null; + /** @description Whether to verify TLS certificates (default: true) */ + verifyTls?: boolean | null; + }; + /** @description ICMP (ping) check-type-specific details */ + Icmp: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + check_type: "icmp"; + /** + * @description Target host + * @example 1.1.1.1 + */ + host: string; + /** + * Format: int32 + * @description Number of ICMP packets sent + */ + packetsSent?: number | null; + /** + * Format: int32 + * @description Number of ICMP packets received + */ + packetsReceived?: number | null; + /** + * Format: double + * @description Packet loss percentage + * @example 0 + */ + packetLoss?: number | null; + /** + * Format: double + * @description Average round-trip time in ms + */ + avgRttMs?: number | null; + /** + * Format: double + * @description Minimum round-trip time in ms + */ + minRttMs?: number | null; + /** + * Format: double + * @description Maximum round-trip time in ms + */ + maxRttMs?: number | null; + /** + * Format: double + * @description Jitter in ms + */ + jitterMs?: number | null; + }; + IcmpMonitorConfig: { + /** @description Target hostname or IP address to ping */ + host: string; + /** + * Format: int32 + * @description Number of ICMP packets to send + */ + packetCount?: number | null; + /** + * Format: int32 + * @description Ping timeout in milliseconds + */ + timeoutMs?: number | null; + }; + IcmpPacketLossAssertion: { + /** @enum {string} */ + type: "icmp_packet_loss"; + /** + * Format: double + * @description Maximum allowed packet loss percentage before the check fails (0–100) + */ + maxPercent: number; + }; + IcmpReachableAssertion: { + /** @enum {string} */ + type: "icmp_reachable"; + }; + IcmpResponseTimeAssertion: { + /** @enum {string} */ + type: "icmp_response_time"; + /** + * Format: int32 + * @description Maximum average ICMP round-trip time in milliseconds + */ + maxMs: number; + }; + IcmpResponseTimeWarnAssertion: { + /** @enum {string} */ + type: "icmp_response_time_warn"; + /** + * Format: int32 + * @description ICMP round-trip time in milliseconds that triggers a warning only + */ + warnMs: number; + }; + IncidentDetailDto: { + incident: components["schemas"]["IncidentDto"]; + updates: components["schemas"]["IncidentUpdateDto"][]; + statusPageIncidents?: components["schemas"]["LinkedStatusPageIncidentDto"][] | null; + }; + /** @description Incident triggered by a monitor check failure or manual creation */ + IncidentDto: { + /** + * Format: uuid + * @description Unique incident identifier + */ + id: string; + /** + * Format: uuid + * @description Monitor that triggered the incident; null for service or manual incidents + */ + monitorId?: string | null; + /** + * Format: int32 + * @description Organization this incident belongs to + */ + organizationId: number; + /** + * @description Incident origin: MONITOR, SERVICE, or MANUAL + * @enum {string} + */ + source: "AUTOMATIC" | "MANUAL" | "MONITORS" | "STATUS_DATA" | "RESOURCE_GROUP"; + /** + * @description Current lifecycle status (OPEN, RESOLVED, etc.) + * @enum {string} + */ + status: "WATCHING" | "TRIGGERED" | "CONFIRMED" | "RESOLVED"; + /** + * @description Severity level: DOWN, DEGRADED, or MAINTENANCE + * @enum {string} + */ + severity: "DOWN" | "DEGRADED" | "MAINTENANCE"; + /** @description Short summary of the incident; null for auto-generated incidents */ + title?: string | null; + /** @description Human-readable description of the trigger rule that fired */ + triggeredByRule?: string | null; + /** @description Probe regions that observed the failure */ + affectedRegions: string[]; + /** + * Format: int32 + * @description Number of times this incident has been reopened + */ + reopenCount: number; + /** + * Format: int32 + * @description User who created the incident (manual incidents only) + */ + createdByUserId?: number | null; + /** @description Whether this incident is visible on the status page */ + statusPageVisible: boolean; + /** + * Format: uuid + * @description Linked vendor service incident ID; null for monitor incidents + */ + serviceIncidentId?: string | null; + /** + * Format: uuid + * @description Linked service catalog ID; null for monitor incidents + */ + serviceId?: string | null; + /** @description External reference ID (e.g. PagerDuty incident ID) */ + externalRef?: string | null; + /** @description Service components affected by this incident */ + affectedComponents?: string[] | null; + /** @description Short URL linking to the incident details */ + shortlink?: string | null; + /** + * @description How the incident was resolved (AUTO_RECOVERED, MANUAL, etc.) + * @enum {string|null} + */ + resolutionReason?: "MANUAL" | "AUTO_RECOVERED" | "AUTO_RESOLVED" | null; + /** + * Format: date-time + * @description Timestamp when the incident was detected or created + */ + startedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the incident was confirmed (multi-region confirmation) + */ + confirmedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the incident was resolved + */ + resolvedAt?: string | null; + /** + * Format: date-time + * @description Cooldown window end; new incidents suppressed until this time + */ + cooldownUntil?: string | null; + /** + * Format: date-time + * @description Timestamp when the incident record was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the incident was last updated + */ + updatedAt: string; + /** @description Name of the associated monitor; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null. */ + monitorName?: string | null; + /** @description Name of the associated service; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null. */ + serviceName?: string | null; + /** @description Slug of the associated service; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null. */ + serviceSlug?: string | null; + /** @description Type of the associated monitor; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null. */ + monitorType?: string | null; + /** + * Format: uuid + * @description Resource group that owns this incident; null when not group-managed + */ + resourceGroupId?: string | null; + /** @description Name of the resource group; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null. */ + resourceGroupName?: string | null; + /** + * Format: uuid + * @description Scheduler-minted check execution ID whose result confirmed this incident; joins to check_results, rule_evaluations, and incident_state_transitions. Omitted from JSON (undefined to SDKs) when null, treat missing as null. + */ + triggeringCheckId?: string | null; + /** @description Hex SHA-256 of the canonical policy snapshot that fired; combined with triggeredByRuleIndex points to the exact TriggerRule. Omitted from JSON when null, treat missing as null. */ + triggeredByRuleSnapshotHashHex?: string | null; + /** + * Format: int32 + * @description Index of the fired rule inside the policy's trigger_rules array. Omitted from JSON when null, treat missing as null. + */ + triggeredByRuleIndex?: number | null; + /** @description Detection engine semver that evaluated the rule. Omitted from JSON when null, treat missing as null. */ + engineVersion?: string | null; + }; + IncidentFilterParams: { + /** + * @description Filter by incident lifecycle status; null returns every status + * @enum {string|null} + */ + status?: "WATCHING" | "TRIGGERED" | "CONFIRMED" | "RESOLVED" | null; + /** + * @description Filter by severity; null returns every severity + * @enum {string|null} + */ + severity?: "DOWN" | "DEGRADED" | "MAINTENANCE" | null; + /** + * @description Filter by where the incident originated (auto, manual, third-party) + * @enum {string|null} + */ + source?: "AUTOMATIC" | "MANUAL" | "MONITORS" | "STATUS_DATA" | "RESOURCE_GROUP" | null; + /** + * Format: uuid + * @description Only return incidents tied to this monitor ID + */ + monitorId?: string | null; + /** + * Format: uuid + * @description Only return incidents tied to this service ID (third-party services) + */ + serviceId?: string | null; + /** + * Format: uuid + * @description Only return incidents whose monitor belongs to this resource group + */ + resourceGroupId?: string | null; + /** + * Format: uuid + * @description Only return incidents whose monitor carries this tag + */ + tagId?: string | null; + /** + * Format: uuid + * @description Only return incidents whose monitor lives in this environment + */ + environmentId?: string | null; + /** + * Format: date-time + * @description Earliest startedAt to include (inclusive, ISO 8601) + */ + startedFrom?: string | null; + /** + * Format: date-time + * @description Latest startedAt to include (inclusive, ISO 8601) + */ + startedTo?: string | null; + /** + * Format: int32 + * @description Zero-based page index (default: 0) + * @example 0 + */ + page: number; + /** + * Format: int32 + * @description Number of incidents per page (1–200, default: 10) + * @example 10 + */ + size: number; + }; + /** @description Incident detection, confirmation, and recovery policy for a monitor */ + IncidentPolicyDto: { + /** + * Format: uuid + * @description Unique incident policy identifier + */ + id: string; + /** + * Format: uuid + * @description Monitor this policy is attached to + */ + monitorId: string; + /** @description Array of trigger rules defining when an incident should be raised */ + triggerRules: components["schemas"]["TriggerRule"][]; + confirmation: components["schemas"]["ConfirmationPolicy"]; + recovery: components["schemas"]["RecoveryPolicy"]; + /** + * Format: date-time + * @description Timestamp when the policy was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the policy was last updated + */ + updatedAt: string; + /** + * Format: int32 + * @description Number of regions configured on the monitor (only set in internal API responses) + */ + monitorRegionCount?: number | null; + /** + * Format: int32 + * @description Monitor check frequency in seconds (only set in internal API responses) + */ + checkFrequencySeconds?: number | null; + }; + /** @description Lightweight reference to an incident overlapping a given uptime day */ + IncidentRef: { + /** + * Format: uuid + * @description Internal incident ID — UUID for status-page incidents, service incident UUID for catalog + */ + id: string; + /** @description Incident title at the time of the overlap */ + title: string; + /** @description Incident impact level (e.g. minor, major, critical for catalog; NONE/MINOR/MAJOR/CRITICAL for status pages) */ + impact: string; + }; + /** @description Incident summary counters */ + IncidentsSummaryDto: { + /** Format: int64 */ + active: number; + /** Format: int64 */ + resolvedToday: number; + /** Format: double */ + mttr30d?: number | null; + }; + /** @description State-machine transitions this check caused (may be empty if nothing fired) */ + IncidentStateTransitionDto: { + /** + * Format: uuid + * @description Forensic row UUID + */ + id: string; + /** + * Format: date-time + * @description When the state transition occurred + */ + occurredAt: string; + /** + * Format: uuid + * @description Monitor this transition pertains to + */ + monitorId: string; + /** + * Format: uuid + * @description Incident this transition belongs to; null for pre-incident (auto-cleared) transitions + */ + incidentId?: string | null; + /** @description Previous status (WATCHING | TRIGGERED | CONFIRMED | RESOLVED) */ + fromStatus: string; + /** @description New status (WATCHING | TRIGGERED | CONFIRMED | RESOLVED) */ + toStatus: string; + /** @description Why the transition fired (trigger | confirm | resolve | auto_clear | reopen) */ + reason: string; + /** @description rule_evaluation ids that caused this transition (may be empty for timeout-driven edges) */ + triggeringEvaluationIds: string[]; + /** @description Regions whose evaluations contributed to this transition */ + affectedRegions: string[]; + /** @description Hex-encoded hash of the policy snapshot that governed this transition */ + policySnapshotHashHex: string; + /** @description Detection engine version that emitted this transition */ + engineVersion: string; + /** + * Format: uuid + * @description Scheduler-minted check execution ID (V92) of the triggering result + */ + checkId: string; + details: components["schemas"]["StateTransitionDetails"]; + }; + IncidentTimelineDto: { + /** @description State-machine transitions in chronological order */ + transitions: components["schemas"]["IncidentStateTransitionDto"][]; + /** @description Rule evaluations that caused any of the transitions above. Correlate via evaluation.triggeringTransitionId == transition.id */ + triggeringEvaluations: components["schemas"]["RuleEvaluationDto"][]; + policySnapshot?: components["schemas"]["PolicySnapshotDto"] | null; + }; + IncidentUpdateDto: { + /** Format: uuid */ + id: string; + /** Format: uuid */ + incidentId: string; + /** @enum {string|null} */ + oldStatus?: "WATCHING" | "TRIGGERED" | "CONFIRMED" | "RESOLVED" | null; + /** @enum {string|null} */ + newStatus?: "WATCHING" | "TRIGGERED" | "CONFIRMED" | "RESOLVED" | null; + body?: string | null; + /** @enum {string|null} */ + createdBy?: "SYSTEM" | "USER" | null; + notifySubscribers: boolean; + /** Format: date-time */ + createdAt: string; + }; + IntegrationConfigSchemaDto: { + connectionFields: components["schemas"]["IntegrationFieldDto"][]; + channelFields: components["schemas"]["IntegrationFieldDto"][]; + }; + IntegrationDto: { + type: string; + name: string; + description: string; + logoUrl: string; + authType: string; + /** @enum {string} */ + tierAvailability: "FREE" | "STARTER" | "PRO" | "TEAM" | "BUSINESS" | "ENTERPRISE"; + lifecycle: string; + setupGuideUrl: string; + configSchema: components["schemas"]["IntegrationConfigSchemaDto"]; + }; + IntegrationFieldDto: { + key: string; + label: string; + type: string; + required: boolean; + sensitive: boolean; + placeholder?: string | null; + helpText?: string | null; + options?: string[] | null; + default?: string | null; + }; + /** @description Organization invite sent to an email address */ + InviteDto: { + /** + * Format: int32 + * @description Unique invite identifier + */ + inviteId: number; + /** @description Email address the invite was sent to */ + email: string; + /** + * @description Role that will be assigned to the invitee on acceptance + * @enum {string} + */ + roleOffered: "OWNER" | "ADMIN" | "MEMBER"; + /** + * Format: date-time + * @description Timestamp when the invite expires + */ + expiresAt: string; + /** + * Format: date-time + * @description Timestamp when the invite was accepted; null if not yet used + */ + consumedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the invite was revoked; null if active + */ + revokedAt?: string | null; + }; + JsonPathAssertion: { + /** @enum {string} */ + type: "json_path"; + /** @description JSONPath expression to extract a value from the response body */ + path: string; + /** @description Expected value to compare against */ + expected: string; + /** + * @description Comparison operator (equals, contains, less_than, greater_than, etc.) + * @enum {string} + */ + operator: "equals" | "contains" | "less_than" | "greater_than" | "matches" | "range"; + }; + /** @description API key metadata */ + KeyInfo: { + /** + * Format: int32 + * @description Key ID + */ + id: number; + /** @description Human-readable key name */ + name: string; + /** + * Format: date-time + * @description When the key was created + */ + createdAt: string; + /** + * Format: date-time + * @description When the key expires (null = never) + */ + expiresAt?: string | null; + /** + * Format: date-time + * @description Last time the key was used + */ + lastUsedAt?: string | null; + }; + LinkedStatusPageIncidentDto: { + /** Format: uuid */ + id: string; + /** Format: uuid */ + statusPageId: string; + statusPageName: string; + statusPageSlug: string; + title: string; + /** @enum {string} */ + status: "INVESTIGATING" | "IDENTIFIED" | "MONITORING" | "RESOLVED"; + /** @enum {string} */ + impact: "NONE" | "MINOR" | "MAJOR" | "CRITICAL"; + scheduled: boolean; + /** Format: date-time */ + publishedAt?: string | null; + }; + /** @description A component affected by a scheduled maintenance window */ + MaintenanceComponentRef: { + /** + * Format: uuid + * @description Component identifier + */ + id: string; + /** @description Component name */ + name: string; + /** @description Component status at the time of the maintenance update */ + status: string; + }; + /** @description A status update within a scheduled maintenance lifecycle */ + MaintenanceUpdateDto: { + /** + * Format: uuid + * @description Unique update identifier + */ + id: string; + /** @description Status at the time of this update */ + status: string; + /** @description Update message from the vendor */ + body?: string | null; + /** + * Format: date-time + * @description Timestamp when this update was posted + */ + displayAt?: string | null; + }; + /** @description Scheduled maintenance window for a monitor */ + MaintenanceWindowDto: { + /** + * Format: uuid + * @description Unique maintenance window identifier + */ + id: string; + /** + * Format: uuid + * @description Monitor this window applies to; null for org-wide windows + */ + monitorId?: string | null; + /** + * Format: int32 + * @description Organization this maintenance window belongs to + */ + organizationId: number; + /** + * Format: date-time + * @description Scheduled start of the maintenance window + */ + startsAt: string; + /** + * Format: date-time + * @description Scheduled end of the maintenance window + */ + endsAt: string; + /** @description iCal RRULE for recurring windows; null for one-time */ + repeatRule?: string | null; + /** @description Human-readable reason for the maintenance */ + reason?: string | null; + /** @description Whether alerts are suppressed during this window */ + suppressAlerts: boolean; + /** + * Format: date-time + * @description Timestamp when the window was created + */ + createdAt: string; + }; + /** @description Match rules to evaluate (all must pass; omit or empty for catch-all) */ + MatchRule: { + /** + * @description Rule type used to evaluate incidents and status events + * @enum {string} + */ + type: "severity_gte" | "monitor_id_in" | "region_in" | "incident_status" | "monitor_type_in" | "service_id_in" | "resource_group_id_in" | "component_name_in" | "monitor_tag_in"; + /** @description Comparison value for single-value rules like severity_gte */ + value?: string | null; + /** @description Monitor UUIDs to match for monitor_id_in rules */ + monitorIds?: string[] | null; + /** @description Region codes to match for region_in rules */ + regions?: string[] | null; + /** @description Values list for multi-value rules like monitor_type_in */ + values?: string[] | null; + }; + McpConnectsAssertion: { + /** @enum {string} */ + type: "mcp_connects"; + }; + McpHasCapabilityAssertion: { + /** @enum {string} */ + type: "mcp_has_capability"; + /** @description Capability name the server must advertise, e.g. tools or resources */ + capability: string; + }; + McpMinToolsAssertion: { + /** @enum {string} */ + type: "mcp_min_tools"; + /** + * Format: int32 + * @description Minimum number of tools the server must expose + */ + min: number; + }; + McpProtocolVersionAssertion: { + /** @enum {string} */ + type: "mcp_protocol_version"; + /** @description Expected MCP protocol version string from the server handshake */ + version: string; + }; + McpResponseTimeAssertion: { + /** @enum {string} */ + type: "mcp_response_time"; + /** + * Format: int32 + * @description Maximum allowed MCP check duration in milliseconds + */ + maxMs: number; + }; + McpResponseTimeWarnAssertion: { + /** @enum {string} */ + type: "mcp_response_time_warn"; + /** + * Format: int32 + * @description MCP check duration in milliseconds that triggers a warning only + */ + warnMs: number; + }; + /** @description MCP server check-type-specific details */ + McpServer: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + check_type: "mcp_server"; + /** @description MCP server URL */ + url?: string | null; + /** @description MCP protocol version */ + protocolVersion?: string | null; + /** @description MCP server info (name, version, etc.) */ + serverInfo?: { + [key: string]: Record | null; + } | null; + /** + * Format: int32 + * @description Number of tools exposed + */ + toolCount?: number | null; + /** + * Format: int32 + * @description Number of resources exposed + */ + resourceCount?: number | null; + /** + * Format: int32 + * @description Number of prompts exposed + */ + promptCount?: number | null; + }; + McpServerMonitorConfig: { + /** @description Command to execute to start the MCP server */ + command: string; + /** @description Command-line arguments for the MCP server process */ + args?: (string | null)[] | null; + /** @description Environment variables to pass to the MCP server process */ + env?: { + [key: string]: string | null; + } | null; + }; + McpToolAvailableAssertion: { + /** @enum {string} */ + type: "mcp_tool_available"; + /** @description MCP tool name that must appear in the server's tool list */ + toolName: string; + }; + McpToolCountChangedAssertion: { + /** @enum {string} */ + type: "mcp_tool_count_changed"; + /** + * Format: int32 + * @description Expected tool count; warns when the live count differs + */ + expectedCount: number; + }; + /** @description Organization member with role and status */ + MemberDto: { + /** + * Format: int32 + * @description User identifier of the member + */ + userId: number; + /** @description Member email address */ + email: string; + /** @description Member display name; null if not set */ + name?: string | null; + /** + * @description Member role within this organization (OWNER, ADMIN, MEMBER) + * @enum {string} + */ + orgRole: "OWNER" | "ADMIN" | "MEMBER"; + /** + * @description Membership status (ACTIVE, PENDING, SUSPENDED) + * @enum {string} + */ + status: "INVITED" | "ACTIVE" | "SUSPENDED" | "LEFT" | "REMOVED" | "DECLINED"; + /** + * Format: date-time + * @description Timestamp when the member was added to the organization + */ + createdAt: string; + }; + /** @description Role transition recorded when an organization member's role changes. */ + MemberRoleChangedMetadata: { + /** + * @description discriminator enum property added by openapi-typescript + * @enum {string} + */ + kind: "member_role_changed"; + /** + * @description Role the member held before the change + * @enum {string} + */ + oldRole: "OWNER" | "ADMIN" | "MEMBER"; + /** + * @description Role the member holds after the change + * @enum {string} + */ + newRole: "OWNER" | "ADMIN" | "MEMBER"; + }; + MonitorAssertionDto: { + /** Format: uuid */ + id: string; + /** Format: uuid */ + monitorId: string; + /** @enum {string} */ + assertionType: "status_code" | "response_time" | "body_contains" | "json_path" | "header_value" | "regex_body" | "dns_resolves" | "dns_response_time" | "dns_expected_ips" | "dns_expected_cname" | "dns_record_contains" | "dns_record_equals" | "dns_txt_contains" | "dns_min_answers" | "dns_max_answers" | "dns_response_time_warn" | "dns_ttl_low" | "dns_ttl_high" | "mcp_connects" | "mcp_response_time" | "mcp_has_capability" | "mcp_tool_available" | "mcp_min_tools" | "mcp_protocol_version" | "mcp_response_time_warn" | "mcp_tool_count_changed" | "ssl_expiry" | "response_size" | "redirect_count" | "redirect_target" | "response_time_warn" | "tcp_connects" | "tcp_response_time" | "tcp_response_time_warn" | "icmp_reachable" | "icmp_response_time" | "icmp_response_time_warn" | "icmp_packet_loss" | "heartbeat_received" | "heartbeat_max_interval" | "heartbeat_interval_drift" | "heartbeat_payload_contains"; + config: components["schemas"]["BodyContainsAssertion"] | components["schemas"]["DnsExpectedCnameAssertion"] | components["schemas"]["DnsExpectedIpsAssertion"] | components["schemas"]["DnsMaxAnswersAssertion"] | components["schemas"]["DnsMinAnswersAssertion"] | components["schemas"]["DnsRecordContainsAssertion"] | components["schemas"]["DnsRecordEqualsAssertion"] | components["schemas"]["DnsResolvesAssertion"] | components["schemas"]["DnsResponseTimeAssertion"] | components["schemas"]["DnsResponseTimeWarnAssertion"] | components["schemas"]["DnsTtlHighAssertion"] | components["schemas"]["DnsTtlLowAssertion"] | components["schemas"]["DnsTxtContainsAssertion"] | components["schemas"]["HeaderValueAssertion"] | components["schemas"]["HeartbeatIntervalDriftAssertion"] | components["schemas"]["HeartbeatMaxIntervalAssertion"] | components["schemas"]["HeartbeatPayloadContainsAssertion"] | components["schemas"]["HeartbeatReceivedAssertion"] | components["schemas"]["IcmpPacketLossAssertion"] | components["schemas"]["IcmpReachableAssertion"] | components["schemas"]["IcmpResponseTimeAssertion"] | components["schemas"]["IcmpResponseTimeWarnAssertion"] | components["schemas"]["JsonPathAssertion"] | components["schemas"]["McpConnectsAssertion"] | components["schemas"]["McpHasCapabilityAssertion"] | components["schemas"]["McpMinToolsAssertion"] | components["schemas"]["McpProtocolVersionAssertion"] | components["schemas"]["McpResponseTimeAssertion"] | components["schemas"]["McpResponseTimeWarnAssertion"] | components["schemas"]["McpToolAvailableAssertion"] | components["schemas"]["McpToolCountChangedAssertion"] | components["schemas"]["RedirectCountAssertion"] | components["schemas"]["RedirectTargetAssertion"] | components["schemas"]["RegexBodyAssertion"] | components["schemas"]["ResponseSizeAssertion"] | components["schemas"]["ResponseTimeAssertion"] | components["schemas"]["ResponseTimeWarnAssertion"] | components["schemas"]["SslExpiryAssertion"] | components["schemas"]["StatusCodeAssertion"] | components["schemas"]["TcpConnectsAssertion"] | components["schemas"]["TcpResponseTimeAssertion"] | components["schemas"]["TcpResponseTimeWarnAssertion"]; + /** @enum {string} */ + severity: "fail" | "warn"; + }; + /** @description New authentication configuration (full replacement) */ + MonitorAuthConfig: components["schemas"]["BearerAuthConfig"] | components["schemas"]["BasicAuthConfig"] | components["schemas"]["HeaderAuthConfig"] | components["schemas"]["ApiKeyAuthConfig"]; + MonitorAuthDto: { + /** Format: uuid */ + id: string; + /** Format: uuid */ + monitorId: string; + /** @enum {string} */ + authType: "bearer" | "basic" | "header" | "api_key"; + config: components["schemas"]["ApiKeyAuthConfig"] | components["schemas"]["BasicAuthConfig"] | components["schemas"]["BearerAuthConfig"] | components["schemas"]["HeaderAuthConfig"]; + }; + /** @description Full monitor representation */ + MonitorDto: { + /** + * Format: uuid + * @description Unique monitor identifier + */ + id: string; + /** + * Format: int32 + * @description Organization this monitor belongs to + */ + organizationId: number; + /** @description Human-readable name for this monitor */ + name: string; + /** @enum {string} */ + type: "HTTP" | "DNS" | "MCP_SERVER" | "TCP" | "ICMP" | "HEARTBEAT"; + config: components["schemas"]["DnsMonitorConfig"] | components["schemas"]["HeartbeatMonitorConfig"] | components["schemas"]["HttpMonitorConfig"] | components["schemas"]["IcmpMonitorConfig"] | components["schemas"]["McpServerMonitorConfig"] | components["schemas"]["TcpMonitorConfig"]; + /** + * Format: int32 + * @description Check frequency in seconds (30–86400) + */ + frequencySeconds: number; + /** @description Whether the monitor is active */ + enabled: boolean; + /** @description Probe regions where checks are executed */ + regions: string[]; + /** + * @description Source that created/owns this monitor: DASHBOARD, CLI, TERRAFORM, MCP, or API + * @enum {string} + */ + managedBy: "DASHBOARD" | "CLI" | "TERRAFORM" | "MCP" | "API"; + /** + * Format: date-time + * @description Timestamp when the monitor was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the monitor was last updated + */ + updatedAt: string; + /** @description Assertions evaluated against each check result; null on list responses */ + assertions?: components["schemas"]["MonitorAssertionDto"][] | null; + /** @description Tags applied to this monitor */ + tags?: components["schemas"]["TagDto"][] | null; + /** @description Heartbeat ping URL; populated for HEARTBEAT monitors only */ + pingUrl?: string | null; + environment?: components["schemas"]["Summary"] | null; + auth?: Omit | null; + incidentPolicy?: components["schemas"]["IncidentPolicyDto"] | null; + /** @description Alert channel IDs linked to this monitor; populated on single-monitor responses */ + alertChannelIds?: string[] | null; + }; + /** @description Monitors that reference this secret; null on create/update responses */ + MonitorReference: { + /** + * Format: uuid + * @description Monitor identifier + */ + id: string; + /** @description Monitor name */ + name: string; + }; + /** @description Dashboard summary counters for monitors */ + MonitorsSummaryDto: { + /** + * Format: int64 + * @description Total number of monitors in the organization + */ + total: number; + /** + * Format: int64 + * @description Number of monitors currently passing + */ + up: number; + /** + * Format: int64 + * @description Number of monitors currently failing (DOWN severity) + */ + down: number; + /** + * Format: int64 + * @description Number of monitors with degraded status + */ + degraded: number; + /** + * Format: int64 + * @description Number of disabled monitors + */ + paused: number; + /** + * Format: double + * @description Average uptime percentage across all monitors over last 24h + */ + avgUptime24h?: number | null; + /** + * Format: double + * @description Average uptime percentage across all monitors over last 30 days + */ + avgUptime30d?: number | null; + }; + MonitorTestRequest: { + /** + * @description Monitor protocol type to test + * @enum {string} + */ + type: "HTTP" | "DNS" | "MCP_SERVER" | "TCP" | "ICMP" | "HEARTBEAT"; + config: components["schemas"]["DnsMonitorConfig"] | components["schemas"]["HeartbeatMonitorConfig"] | components["schemas"]["HttpMonitorConfig"] | components["schemas"]["IcmpMonitorConfig"] | components["schemas"]["McpServerMonitorConfig"] | components["schemas"]["TcpMonitorConfig"]; + /** @description Optional assertions to evaluate against the test result */ + assertions?: components["schemas"]["CreateAssertionRequest"][] | null; + }; + MonitorTestResultDto: { + passed: boolean; + error?: string | null; + /** Format: int32 */ + statusCode?: number | null; + /** Format: int64 */ + responseTimeMs?: number | null; + responseHeaders?: { + [key: string]: (string | null)[] | null; + } | null; + bodyPreview?: string | null; + /** Format: int64 */ + responseSizeBytes?: number | null; + /** Format: int32 */ + redirectCount?: number | null; + finalUrl?: string | null; + assertionResults: components["schemas"]["AssertionTestResultDto"][]; + warnings?: string[] | null; + }; + /** @description A point-in-time version snapshot of a monitor configuration */ + MonitorVersionDto: { + /** + * Format: uuid + * @description Unique version record identifier + */ + id: string; + /** + * Format: uuid + * @description Monitor this version belongs to + */ + monitorId: string; + /** + * Format: int32 + * @description Monotonically increasing version number + */ + version: number; + snapshot: components["schemas"]["MonitorDto"]; + /** + * Format: int32 + * @description User ID who made the change; null for automated changes + */ + changedById?: number | null; + /** + * @description Change source (DASHBOARD, CLI, API) + * @enum {string} + */ + changedVia: "API" | "DASHBOARD" | "CLI" | "TERRAFORM"; + /** @description Human-readable description of what changed */ + changeSummary?: string | null; + /** + * Format: date-time + * @description Timestamp when this version was recorded + */ + createdAt: string; + }; + /** @description Inline tag creation — creates the tag if it does not already exist */ + NewTagRequest: { + /** @description Tag name */ + name: string; + /** @description Hex color code (defaults to #6B7280 if omitted) */ + color?: string | null; + }; + /** @description Dispatch state for a single (incident, notification policy) pair, with delivery history */ + NotificationDispatchDto: { + /** + * Format: uuid + * @description Unique dispatch record identifier + */ + id: string; + /** + * Format: uuid + * @description Incident this dispatch is for + */ + incidentId: string; + /** + * Format: uuid + * @description Notification policy that matched this incident + */ + policyId: string; + /** @description Human-readable name of the matched policy (null if policy has been deleted) */ + policyName?: string | null; + /** + * @description Current dispatch state + * @enum {string} + */ + status: "PENDING" | "DISPATCHING" | "DELIVERED" | "ESCALATING" | "ACKNOWLEDGED" | "COMPLETED"; + /** + * @description Why the dispatch reached COMPLETED: EXHAUSTED (all steps ran, no ack), RESOLVED (incident resolved), NO_STEPS (policy had no steps). Null for non-terminal states. + * @enum {string|null} + */ + completionReason?: "EXHAUSTED" | "RESOLVED" | "NO_STEPS" | null; + /** + * Format: int32 + * @description 1-based index of the currently active escalation step + */ + currentStep: number; + /** + * Format: int32 + * @description Total number of escalation steps in the policy (null if policy has been deleted) + */ + totalSteps?: number | null; + /** + * Format: date-time + * @description Timestamp when this dispatch was acknowledged (null if not acknowledged) + */ + acknowledgedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the next escalation step will fire (null if not scheduled) + */ + nextEscalationAt?: string | null; + /** + * Format: date-time + * @description Timestamp of the most recent notification delivery + */ + lastNotifiedAt?: string | null; + /** @description Delivery records for all channels associated with this dispatch */ + deliveries: components["schemas"]["AlertDeliveryDto"][]; + /** + * Format: date-time + * @description Timestamp when the dispatch was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the dispatch was last updated + */ + updatedAt: string; + }; + /** @description In-app notification for the current user */ + NotificationDto: { + /** + * Format: int64 + * @description Unique notification identifier + */ + id: number; + /** @description Notification category (e.g. incident, monitor, team) */ + type: string; + /** @description Short notification title */ + title: string; + /** @description Full notification body; null for title-only notifications */ + body?: string | null; + /** @description Type of the resource this notification is about */ + resourceType?: string | null; + /** @description ID of the resource this notification is about */ + resourceId?: string | null; + /** @description Whether the notification has been read */ + read: boolean; + /** + * Format: date-time + * @description Timestamp when the notification was created + */ + createdAt: string; + }; + /** @description Org-level notification policy with match rules and escalation chain */ + NotificationPolicyDto: { + /** + * Format: uuid + * @description Unique notification policy identifier + */ + id: string; + /** + * Format: int32 + * @description Organization this policy belongs to + */ + organizationId: number; + /** @description Human-readable name for this policy */ + name: string; + /** @description Match rules (all must pass; empty = catch-all) */ + matchRules: components["schemas"]["MatchRule"][]; + escalation: components["schemas"]["EscalationChain"]; + /** @description Whether this policy is active */ + enabled: boolean; + /** + * Format: int32 + * @description Evaluation order; higher value = evaluated first + */ + priority: number; + /** + * Format: date-time + * @description Timestamp when the policy was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the policy was last updated + */ + updatedAt: string; + }; + OpsGenieChannelConfig: { + /** @enum {string} */ + channelType: "opsgenie"; + /** @description OpsGenie API key for alert creation */ + apiKey: string; + /** @description OpsGenie API region: us or eu */ + region?: string | null; + }; + /** @description Organization account details */ + OrganizationDto: { + /** + * Format: int32 + * @description Unique organization identifier + */ + id: number; + /** @description Organization name */ + name: string; + /** @description Billing and contact email */ + email: string | null; + /** @description Team size range (e.g. 1-10, 11-50) */ + size?: string | null; + /** @description Industry vertical (e.g. SaaS, Fintech) */ + industry?: string | null; + /** @description Organization website URL */ + websiteUrl?: string | null; + }; + /** @description Organization the key belongs to */ + OrgInfo: { + /** + * Format: int32 + * @description Organization ID + */ + id: number; + /** @description Organization name */ + name: string; + }; + Pageable: { + /** Format: int32 */ + page: number; + /** Format: int32 */ + size: number; + sort: string[]; + }; + PagerDutyChannelConfig: { + /** @enum {string} */ + channelType: "pagerduty"; + /** @description PagerDuty Events API v2 routing (integration) key */ + routingKey: string; + /** @description Override PagerDuty severity mapping */ + severityOverride?: string | null; + }; + /** @description A top-level page section (either a group or an ungrouped component) */ + PageSection: { + /** + * Format: uuid + * @description Group ID when this section is a group + */ + groupId?: string | null; + /** + * Format: uuid + * @description Component ID when this section is an ungrouped component + */ + componentId?: string | null; + /** + * Format: int32 + * @description Position on the page (0-based) + */ + pageOrder: number; + }; + /** @description Billing plan and entitlement state */ + PlanInfo: { + /** + * @description Resolved plan tier + * @enum {string} + */ + tier: "FREE" | "STARTER" | "PRO" | "TEAM" | "BUSINESS" | "ENTERPRISE"; + /** @description Subscription status (null if no subscription) */ + subscriptionStatus?: string | null; + /** @description Whether the org is on a trial */ + trialActive: boolean; + /** + * Format: date-time + * @description Trial expiry (null if not trialing) + */ + trialExpiresAt?: string | null; + /** @description Entitlement limits keyed by entitlement name */ + entitlements: { + [key: string]: components["schemas"]["EntitlementDto"]; + }; + /** @description Current usage counters keyed by entitlement name */ + usage: { + [key: string]: number; + }; + }; + /** @description Policy snapshot used during this check (all evaluations of a single check are against one policy) */ + PolicySnapshotDto: { + /** @description Hex-encoded SHA-256 of the canonical policy JSON */ + hashHex: string; + /** @description Canonical policy document (snake_case, sorted keys) */ + policy: { + [key: string]: Record; + }; + /** @description Detection engine version that observed this policy */ + engineVersion: string; + /** + * Format: date-time + * @description First time the detection engine evaluated against this policy bytes + */ + firstSeenAt: string; + /** + * Format: date-time + * @description Most recent time the engine evaluated against this policy bytes + */ + lastSeenAt: string; + } | null; + /** @description Aggregated poll metrics for a time bucket */ + PollChartBucketDto: { + /** + * Format: date-time + * @description Start of the time bucket (ISO 8601) + */ + bucket: string; + /** + * Format: double + * @description Uptime percentage for this bucket; null when no data + * @example 100 + */ + uptimePercent?: number | null; + /** + * Format: double + * @description Average response time in milliseconds for this bucket + * @example 245.3 + */ + avgResponseTimeMs?: number | null; + /** + * Format: int64 + * @description Total polls in this bucket + * @example 60 + */ + totalPolls: number; + }; + PublishStatusPageIncidentRequest: { + /** @description Customer-facing title; null keeps draft value */ + title?: string | null; + /** + * @description Impact level; null keeps draft value + * @enum {string|null} + */ + impact?: "NONE" | "MINOR" | "MAJOR" | "CRITICAL" | null; + /** + * @description Incident status; null keeps draft value (must be an active status) + * @enum {string|null} + */ + status?: "INVESTIGATING" | "IDENTIFIED" | "MONITORING" | "RESOLVED" | null; + /** @description Initial update body; null keeps draft value */ + body?: string | null; + /** @description Affected components; null keeps draft value */ + affectedComponents?: components["schemas"]["AffectedComponent"][] | null; + /** @description Whether to notify subscribers (default: true) */ + notifySubscribers?: boolean | null; + }; + /** @description Rate-limit quota for the current sliding window */ + RateLimitInfo: { + /** + * Format: int64 + * @description Maximum requests allowed per window + */ + requestsPerMinute: number; + /** + * Format: int64 + * @description Requests remaining in the current window + */ + remaining: number; + /** + * Format: int64 + * @description Sliding window size in milliseconds + */ + windowMs: number; + }; + /** @description Auto-recovery settings */ + RecoveryPolicy: { + /** + * Format: int32 + * @description Consecutive passing checks required to auto-resolve the incident + */ + consecutiveSuccesses: number; + /** + * Format: int32 + * @description Minimum regions that must be passing before recovery can complete + */ + minRegionsPassing: number; + /** + * Format: int32 + * @description Minutes after resolve before a new incident may open on the same monitor + */ + cooldownMinutes: number; + }; + RedirectCountAssertion: { + /** @enum {string} */ + type: "redirect_count"; + /** + * Format: int32 + * @description Maximum number of HTTP redirects allowed before the check fails + */ + maxCount: number; + }; + RedirectTargetAssertion: { + /** @enum {string} */ + type: "redirect_target"; + /** @description Expected final URL after following redirects */ + expected: string; + /** + * @description Comparison operator (equals, contains, less_than, greater_than, etc.) + * @enum {string} + */ + operator: "equals" | "contains" | "less_than" | "greater_than" | "matches" | "range"; + }; + RegexBodyAssertion: { + /** @enum {string} */ + type: "regex_body"; + /** @description Regular expression the response body must match */ + pattern: string; + }; + /** @description Latest check result for a single region */ + RegionStatusDto: { + /** + * @description Region identifier + * @example us-east + */ + region: string; + /** + * @description Whether the last check in this region passed + * @example true + */ + passed: boolean; + /** + * Format: int32 + * @description Response time in milliseconds for the last check + * @example 95 + */ + responseTimeMs?: number | null; + /** + * Format: date-time + * @description Timestamp of the last check in this region (ISO 8601) + */ + timestamp: string; + /** @description Severity hint: 'down' for hard failures, 'degraded' for warn-only failures, null when passing */ + severityHint?: string | null; + }; + /** @description Request body for removing tags from a monitor */ + RemoveMonitorTagsRequest: { + /** @description IDs of the tags to detach from the monitor */ + tagIds: string[]; + }; + /** @description Batch component reorder request */ + ReorderComponentsRequest: { + /** @description Ordered list of component IDs with their new positions */ + positions: components["schemas"]["ComponentPosition"][]; + }; + /** @description Reorder page-level layout: groups and ungrouped components share one ordering */ + ReorderPageLayoutRequest: { + /** @description Top-level sections in their new order */ + sections: components["schemas"]["PageSection"][]; + /** @description Within-group component ordering; only needed for groups whose internal order changed */ + groupOrders?: components["schemas"]["GroupComponentOrder"][] | null; + }; + ResolveIncidentRequest: { + /** @description Optional resolution message or post-mortem notes */ + body?: string | null; + }; + /** @description Resource group with health summary and optional member details */ + ResourceGroupDto: { + /** + * Format: uuid + * @description Unique resource group identifier + */ + id: string; + /** + * Format: int32 + * @description Organization this group belongs to + */ + organizationId: number; + /** @description Human-readable group name */ + name: string; + /** @description URL-safe group identifier */ + slug: string; + /** @description Optional group description */ + description?: string | null; + /** + * Format: uuid + * @description Notification policy applied to this group + */ + alertPolicyId?: string | null; + /** + * Format: int32 + * @description Default check frequency in seconds for member monitors + */ + defaultFrequency?: number | null; + /** @description Default regions for member monitors */ + defaultRegions?: string[] | null; + defaultRetryStrategy?: components["schemas"]["RetryStrategy"] | null; + /** @description Default alert channel IDs for member monitors */ + defaultAlertChannels?: string[] | null; + /** + * Format: uuid + * @description Default environment ID for member monitors + */ + defaultEnvironmentId?: string | null; + /** + * @description Health threshold type: COUNT or PERCENTAGE + * @enum {string|null} + */ + healthThresholdType?: "COUNT" | "PERCENTAGE" | null; + /** @description Health threshold value */ + healthThresholdValue?: number | null; + /** @description When true, member-level incidents skip notification dispatch; only group alerts fire */ + suppressMemberAlerts: boolean; + /** + * Format: int32 + * @description Seconds to wait after health threshold breach before creating group incident + */ + confirmationDelaySeconds?: number | null; + /** + * Format: int32 + * @description Cooldown minutes after group incident resolves before a new one can open + */ + recoveryCooldownMinutes?: number | null; + health: components["schemas"]["ResourceGroupHealthDto"]; + /** @description Member list with individual statuses; populated on detail GET only */ + members?: components["schemas"]["ResourceGroupMemberDto"][] | null; + /** + * Format: date-time + * @description Timestamp when the group was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the group was last updated + */ + updatedAt: string; + }; + /** @description Aggregated health summary for a resource group */ + ResourceGroupHealthDto: { + /** + * @description Worst-of health status across all members + * @enum {string} + */ + status: "operational" | "maintenance" | "degraded" | "down"; + /** + * Format: int32 + * @description Total number of members in the group + */ + totalMembers: number; + /** + * Format: int32 + * @description Number of members currently in operational status + */ + operationalCount: number; + /** + * Format: int32 + * @description Number of members with an active incident or non-operational status + */ + activeIncidents: number; + /** + * @description Computed group health status based on threshold: 'healthy', 'degraded', or 'down'. Null when no health threshold is configured. + * @enum {string|null} + */ + thresholdStatus?: "healthy" | "degraded" | "down" | null; + /** + * Format: int32 + * @description Number of failing members at time of last evaluation + */ + failingCount?: number | null; + }; + /** @description A single member of a resource group with its computed health status */ + ResourceGroupMemberDto: { + /** + * Format: uuid + * @description Unique group member record identifier + */ + id: string; + /** + * Format: uuid + * @description Resource group this member belongs to + */ + groupId: string; + /** @description Type of member: 'monitor' or 'service' */ + memberType: string; + /** + * Format: uuid + * @description Monitor ID; set when memberType is 'monitor' + */ + monitorId?: string | null; + /** + * Format: uuid + * @description Service ID; set when memberType is 'service' + */ + serviceId?: string | null; + /** @description Display name of the referenced monitor or service */ + name?: string | null; + /** @description Slug identifier for the service (services only); used for icons and uptime API calls */ + slug?: string | null; + /** + * Format: uuid + * @description Subscription ID for the service (services only); used to link to the dependency detail page + */ + subscriptionId?: string | null; + /** + * @description Computed health status for this member + * @enum {string} + */ + status: "operational" | "maintenance" | "degraded" | "down"; + /** @description Effective check frequency label showing the group default when the monitor inherits it; null for services or when no group default is configured */ + effectiveFrequency?: string | null; + /** + * Format: date-time + * @description Timestamp when the member was added to the group + */ + createdAt: string; + /** + * Format: double + * @description 24h uptime percentage; populated when includeMetrics=true + */ + uptime24h?: number | null; + /** @description Uptime tick values (0-100) for last-24h mini chart; populated when includeMetrics=true */ + chartData?: number[] | null; + /** + * Format: double + * @description Average latency in ms (monitors only); populated when includeMetrics=true + */ + avgLatencyMs?: number | null; + /** + * Format: double + * @description P95 latency in ms (monitors only); populated when includeMetrics=true + */ + p95LatencyMs?: number | null; + /** + * Format: date-time + * @description Timestamp of the most recent health check; populated when includeMetrics=true + */ + lastCheckedAt?: string | null; + /** @description Monitor type (HTTP, DNS, TCP, ICMP, HEARTBEAT, MCP); monitors only */ + monitorType?: string | null; + /** @description Environment name; monitors only */ + environmentName?: string | null; + }; + ResponseSizeAssertion: { + /** @enum {string} */ + type: "response_size"; + /** + * Format: int32 + * @description Maximum response body size in bytes before the check fails + */ + maxBytes: number; + }; + ResponseTimeAssertion: { + /** @enum {string} */ + type: "response_time"; + /** + * Format: int32 + * @description Maximum allowed response time in milliseconds before the check fails + */ + thresholdMs: number; + }; + ResponseTimeWarnAssertion: { + /** @enum {string} */ + type: "response_time_warn"; + /** + * Format: int32 + * @description HTTP response time in milliseconds that triggers a warning only + */ + warnMs: number; + }; + /** @description Dashboard summary: current status, per-region latest results, and chart data */ + ResultSummaryDto: { + /** + * @description Derived current status across all regions + * @enum {string} + */ + currentStatus: "up" | "degraded" | "down" | "unknown"; + /** @description Latest check result per region */ + latestPerRegion: components["schemas"]["RegionStatusDto"][]; + /** @description Time-bucketed chart data for the requested window */ + chartData: components["schemas"]["ChartBucketDto"][]; + /** + * Format: double + * @description Uptime percentage over the last 24 hours; null when no data + * @example 99.95 + */ + uptime24h?: number | null; + /** + * Format: double + * @description Uptime percentage for the selected chart window; null when no data + * @example 99.8 + */ + uptimeWindow?: number | null; + }; + /** @description Default retry strategy for member monitors; null clears */ + RetryStrategy: { + /** @description Retry strategy kind, e.g. fixed interval between attempts */ + type: string; + /** + * Format: int32 + * @description Maximum number of retries after a failed check + */ + maxRetries: number; + /** + * Format: int32 + * @description Delay between retry attempts in seconds + */ + interval: number; + }; + /** @description All rule evaluations that ran for this check */ + RuleEvaluationDto: { + /** + * Format: uuid + * @description Forensic row UUID + */ + id: string; + /** + * Format: date-time + * @description When the evaluation ran + */ + occurredAt: string; + /** + * Format: uuid + * @description Monitor that produced the input check result + */ + monitorId: string; + /** @description Probe region of the input check result */ + region: string; + /** @description Hex-encoded hash of the policy snapshot this rule came from */ + policySnapshotHashHex: string; + /** + * Format: int32 + * @description Index into the policy's triggerRules array (0-based) + */ + ruleIndex: number; + /** @description Rule type (e.g. consecutive_failures, failures_in_window) */ + ruleType: string; + /** @description Rule scope (per_region | multi_region) */ + ruleScope: string; + /** @description check_results IDs that were inputs to this evaluation (newest first) */ + inputResultIds: string[]; + /** @description Whether the rule fired on this evaluation */ + outputMatched: boolean; + /** @description Structured details (e.g. failure counts, response-time aggregates) */ + evaluationDetails: { + [key: string]: Record; + }; + /** @description Detection engine version that ran this evaluation */ + engineVersion: string; + /** + * Format: uuid + * @description Scheduler-minted check execution ID (V92) — the causal chain identifier + */ + checkId: string; + /** + * Format: uuid + * @description If this evaluation caused a state transition, points to that transition's id + */ + triggeringTransitionId?: string | null; + }; + /** @description A scheduled maintenance window from a vendor status page */ + ScheduledMaintenanceDto: { + /** + * Format: uuid + * @description Unique maintenance record identifier + */ + id: string; + /** @description Vendor-assigned maintenance identifier */ + externalId: string; + /** @description Maintenance title as reported by the vendor */ + title: string; + /** @description Current maintenance status (scheduled, in_progress, completed) */ + status: string; + /** @description Reported impact level */ + impact?: string | null; + /** @description Vendor-provided short URL to the maintenance page */ + shortlink?: string | null; + /** + * Format: date-time + * @description Timestamp when the maintenance is scheduled to begin + */ + scheduledFor?: string | null; + /** + * Format: date-time + * @description Timestamp when the maintenance is scheduled to end + */ + scheduledUntil?: string | null; + /** + * Format: date-time + * @description Timestamp when the maintenance actually started + */ + startedAt?: string | null; + /** + * Format: date-time + * @description Timestamp when the maintenance was completed + */ + completedAt?: string | null; + /** @description Components affected by this maintenance */ + affectedComponents: components["schemas"]["MaintenanceComponentRef"][]; + /** @description Status updates posted during the maintenance lifecycle */ + updates: components["schemas"]["MaintenanceUpdateDto"][]; + }; + /** @description Secret with change-detection hash; plaintext value is never returned */ + SecretDto: { + /** + * Format: uuid + * @description Unique secret identifier + */ + id: string; + /** @description Secret key name, unique within the workspace */ + key: string; + /** + * Format: int32 + * @description DEK version at the time of last encryption + */ + dekVersion: number; + /** @description SHA-256 hex digest of the current plaintext; use for change detection */ + valueHash: string; + /** + * Format: date-time + * @description Timestamp when the secret was created + */ + createdAt: string; + /** + * Format: date-time + * @description Timestamp when the secret was last updated + */ + updatedAt: string; + /** @description Monitors that reference this secret; null on create/update responses */ + usedByMonitors?: components["schemas"]["MonitorReference"][] | null; + }; + /** @description Admin-editable SEO metadata for pSEO pages */ + SeoMetadataDto: { + /** @description Short description for meta tags (max 160 chars) */ + shortDescription?: string | null; + /** @description Full description for the service page */ + description?: string | null; + /** @description Long-form about text for the About section on pSEO pages */ + about?: string | null; + }; + /** @description Related services */ + ServiceCatalogDto: { + /** Format: uuid */ + id: string; + slug: string; + name: string; + category?: string | null; + officialStatusUrl?: string | null; + developerContext?: string | null; + logoUrl?: string | null; + adapterType: string; + /** Format: int32 */ + pollingIntervalSeconds: number; + enabled: boolean; + published: boolean; + overallStatus?: string | null; + /** Format: date-time */ + createdAt: string; + /** Format: date-time */ + updatedAt: string; + /** Format: int64 */ + componentCount: number; + /** Format: int64 */ + activeIncidentCount: number; + dataCompleteness: string; + /** + * Format: double + * @description Aggregated 30-day uptime percentage across all components + */ + uptime30d?: number | null; + }; + /** @description A first-class service component with lifecycle and uptime data */ + ServiceComponentDto: { + /** Format: uuid */ + id: string; + externalId: string; + name: string; + status: string; + description?: string | null; + /** Format: uuid */ + groupId?: string | null; + /** Format: int32 */ + position?: number | null; + showcase: boolean; + onlyShowIfDegraded: boolean; + /** Format: date-time */ + startDate?: string | null; + /** Format: date-time */ + vendorCreatedAt?: string | null; + lifecycleStatus: string; + /** + * @description Data classification: full, status_only, or metric_only + * @example full + */ + dataType: string; + /** @description Whether uptime data is available for this component */ + hasUptime: boolean; + /** @description Geographic region for regional components (AWS, GCP, Azure) */ + region?: string | null; + /** @description Display name of the parent group */ + groupName?: string | null; + /** @description Group-only: render an aggregated uptime bar above this group's children */ + displayAggregatedUptime: boolean; + /** + * Format: int32 + * @description Group-only count of visible leaf children; null for leaves + */ + childCount?: number | null; + uptime?: components["schemas"]["ComponentUptimeSummaryDto"] | null; + /** Format: date-time */ + statusChangedAt?: string | null; + /** Format: date-time */ + firstSeenAt: string; + /** Format: date-time */ + lastSeenAt: string; + isGroup: boolean; + }; + /** @description One-day rollup for a public service status page: aggregated uptime, per-component impact, and incidents that overlapped the day. Powers the click/hover-to-expand panel under each uptime bar. */ + ServiceDayDetailDto: { + /** + * Format: date + * @description UTC calendar day this rollup covers + */ + date: string; + /** + * Format: double + * @description Average uptime % across leaf components with uptime data; null if no data + */ + overallUptimePercentage?: number | null; + /** + * Format: int64 + * @description Sum of partial outage seconds across all leaf components + */ + totalPartialOutageSeconds: number; + /** + * Format: int64 + * @description Sum of major outage seconds across all leaf components + */ + totalMajorOutageSeconds: number; + /** + * Format: int64 + * @description Sum of degraded performance seconds across all leaf components + */ + totalDegradedSeconds: number; + /** @description Per-component impact rows for the day (only components with uptime data) */ + components: components["schemas"]["ComponentImpact"][]; + /** @description Incidents that were active at any point during this day (started before day end, resolved after day start) */ + incidents: components["schemas"]["DayIncident"][]; + }; + ServiceDetailDto: { + /** Format: uuid */ + id: string; + slug: string; + name: string; + category?: string | null; + officialStatusUrl?: string | null; + developerContext?: string | null; + logoUrl?: string | null; + adapterType: string; + /** Format: int32 */ + pollingIntervalSeconds: number; + enabled: boolean; + /** Format: date-time */ + createdAt: string; + /** Format: date-time */ + updatedAt: string; + currentStatus?: components["schemas"]["ServiceStatusDto"] | null; + recentIncidents: components["schemas"]["ServiceIncidentDto"][]; + components: components["schemas"]["ServiceComponentDto"][]; + componentsSummary?: components["schemas"]["ComponentsSummaryDto"] | null; + uptime?: components["schemas"]["ComponentUptimeSummaryDto"] | null; + activeMaintenances: components["schemas"]["ScheduledMaintenanceDto"][]; + dataCompleteness: string; + seoMetadata?: components["schemas"]["SeoMetadataDto"] | null; + relatedServices?: components["schemas"]["ServiceCatalogDto"][] | null; + }; + ServiceIncidentDetailDto: { + /** Format: uuid */ + id: string; + title: string; + status: string; + impact?: string | null; + /** Format: date-time */ + startedAt?: string | null; + /** Format: date-time */ + resolvedAt?: string | null; + /** Format: date-time */ + detectedAt?: string | null; + shortlink?: string | null; + affectedComponents?: string[] | null; + updates: components["schemas"]["ServiceIncidentUpdateDto"][]; + }; + ServiceIncidentDto: { + /** Format: uuid */ + id: string; + /** Format: uuid */ + serviceId: string; + serviceSlug?: string | null; + serviceName?: string | null; + externalId?: string | null; + title: string; + status: string; + impact?: string | null; + /** Format: date-time */ + startedAt?: string | null; + /** Format: date-time */ + resolvedAt?: string | null; + /** Format: date-time */ + updatedAt?: string | null; + shortlink?: string | null; + /** Format: date-time */ + detectedAt?: string | null; + /** Format: date-time */ + vendorCreatedAt?: string | null; + }; + ServiceIncidentUpdateDto: { + status: string; + body?: string | null; + /** Format: date-time */ + displayAt?: string | null; + }; + ServiceLiveStatusDto: { + /** @description Current overall status of the service, e.g. operational, degraded_performance */ + overallStatus?: string | null; + /** @description Current status of each active component */ + componentStatuses: components["schemas"]["ComponentStatusDto"][]; + /** + * Format: int32 + * @description Number of currently unresolved incidents + */ + activeIncidentCount: number; + /** @description ISO 8601 timestamp of the last status poll */ + lastPolledAt?: string | null; + }; + /** @description A single poll result from the status poller */ + ServicePollResultDto: { + /** + * Format: uuid + * @description Service ID + */ + serviceId: string; + /** + * Format: date-time + * @description Timestamp when the poll was executed (ISO 8601) + */ + timestamp: string; + /** + * @description Overall status of the service at time of poll + * @example operational + */ + overallStatus?: string | null; + /** + * Format: int32 + * @description Response time of the poll in milliseconds + * @example 245 + */ + responseTimeMs?: number | null; + /** + * Format: int32 + * @description HTTP status code from the upstream status page + * @example 200 + */ + httpStatusCode?: number | null; + /** + * @description Whether the poll succeeded + * @example true + */ + passed: boolean; + /** @description Reason for failure when passed=false */ + failureReason?: string | null; + /** + * Format: int32 + * @description Number of components reported by the service + * @example 12 + */ + componentCount: number; + /** + * Format: int32 + * @description Number of degraded or non-operational components + * @example 1 + */ + degradedCount: number; + }; + /** @description Aggregated poll metrics and chart data for a service */ + ServicePollSummaryDto: { + /** + * Format: double + * @description Uptime percentage over the requested window; null when no data + * @example 99.95 + */ + uptimePercentage?: number | null; + /** + * Format: int64 + * @description Total number of polls executed + * @example 4320 + */ + totalPolls: number; + /** + * Format: int64 + * @description Number of polls that succeeded + * @example 4318 + */ + passedPolls: number; + /** + * Format: double + * @description Average response time in milliseconds; null when no data + * @example 312.5 + */ + avgResponseTimeMs?: number | null; + /** + * Format: double + * @description 95th-percentile response time in milliseconds; null when no data + * @example 580 + */ + p95ResponseTimeMs?: number | null; + /** + * @description Time window used for the summary + * @example 30d + */ + window: string; + /** @description Time-bucketed chart data for response time and uptime */ + chartData: components["schemas"]["PollChartBucketDto"][]; + }; + ServiceStatusDto: { + overallStatus: string; + /** Format: date-time */ + lastPolledAt?: string | null; + }; + /** @description Optional body for subscribing to a specific component of a service */ + ServiceSubscribeRequest: { + /** + * Format: uuid + * @description ID of the component to subscribe to. Omit or null for whole-service subscription. + */ + componentId?: string | null; + /** @description Alert sensitivity level. Defaults to INCIDENTS_ONLY when not provided. */ + alertSensitivity?: string | null; + }; + /** @description An org-level service subscription with current status information */ + ServiceSubscriptionDto: { + /** + * Format: uuid + * @description Unique subscription identifier + */ + subscriptionId: string; + /** + * Format: uuid + * @description Service identifier + */ + serviceId: string; + slug: string; + name: string; + category?: string | null; + officialStatusUrl?: string | null; + adapterType: string; + /** Format: int32 */ + pollingIntervalSeconds: number; + enabled: boolean; + /** @description Logo URL from the service catalog */ + logoUrl?: string | null; + /** @description Current overall status; null when the service has never been polled */ + overallStatus?: string | null; + /** + * Format: uuid + * @description Subscribed component id; null for whole-service subscription + */ + componentId?: string | null; + component?: components["schemas"]["ServiceComponentDto"] | null; + /** + * @description Alert sensitivity: ALL (synthetic + real incidents), INCIDENTS_ONLY (real vendor incidents, default), MAJOR_ONLY (real + DOWN severity) + * @enum {string} + */ + alertSensitivity: "ALL" | "INCIDENTS_ONLY" | "MAJOR_ONLY"; + /** + * Format: date-time + * @description When the organization subscribed to this service + */ + subscribedAt: string; + }; + /** @description Uptime response with per-bucket breakdown and overall percentage for the period */ + ServiceUptimeResponse: { + /** + * Format: double + * @description Overall uptime percentage across the entire period; null when no polling data exists + * @example 99.95 + */ + overallUptimePct?: number | null; + /** + * @description Requested period + * @example 7d + */ + period: string; + /** + * @description Requested granularity + * @example hourly + */ + granularity: string; + /** @description Per-bucket breakdown ordered by time ascending */ + buckets: components["schemas"]["UptimeBucketDto"][]; + /** + * @description Data source: vendor_reported, incident_derived, or poll_derived + * @example vendor_reported + */ + source?: string | null; + }; + /** @description Replace the alert channels linked to a monitor */ + SetAlertChannelsRequest: { + /** @description IDs of alert channels to link (replaces current list) */ + channelIds: string[]; + }; + SetMonitorAuthRequest: { + config: components["schemas"]["ApiKeyAuthConfig"] | components["schemas"]["BasicAuthConfig"] | components["schemas"]["BearerAuthConfig"] | components["schemas"]["HeaderAuthConfig"]; + }; + SingleValueResponseAlertChannelDto: { + data: components["schemas"]["AlertChannelDto"]; + }; + SingleValueResponseAlertDeliveryDto: { + data: components["schemas"]["AlertDeliveryDto"]; + }; + SingleValueResponseApiKeyCreateResponse: { + data: components["schemas"]["ApiKeyCreateResponse"]; + }; + SingleValueResponseApiKeyDto: { + data: components["schemas"]["ApiKeyDto"]; + }; + SingleValueResponseAuthMeResponse: { + data: components["schemas"]["AuthMeResponse"]; + }; + SingleValueResponseBatchComponentUptimeDto: { + data: components["schemas"]["BatchComponentUptimeDto"]; + }; + SingleValueResponseBulkMonitorActionResult: { + data: components["schemas"]["BulkMonitorActionResult"]; + }; + SingleValueResponseCheckTraceDto: { + data: components["schemas"]["CheckTraceDto"]; + }; + SingleValueResponseDashboardOverviewDto: { + data: components["schemas"]["DashboardOverviewDto"]; + }; + SingleValueResponseDekRotationResultDto: { + data: components["schemas"]["DekRotationResultDto"]; + }; + SingleValueResponseDeployLockDto: { + data: components["schemas"]["DeployLockDto"]; + }; + SingleValueResponseEnvironmentDto: { + data: components["schemas"]["EnvironmentDto"]; + }; + SingleValueResponseGlobalStatusSummaryDto: { + data: components["schemas"]["GlobalStatusSummaryDto"]; + }; + SingleValueResponseIncidentDetailDto: { + data: components["schemas"]["IncidentDetailDto"]; + }; + SingleValueResponseIncidentPolicyDto: { + data: components["schemas"]["IncidentPolicyDto"]; + }; + SingleValueResponseIncidentTimelineDto: { + data: components["schemas"]["IncidentTimelineDto"]; + }; + SingleValueResponseInviteDto: { + data: components["schemas"]["InviteDto"]; + }; + SingleValueResponseListUUID: { + data: string[]; + }; + SingleValueResponseLong: { + /** Format: int64 */ + data: number; + }; + SingleValueResponseMaintenanceWindowDto: { + data: components["schemas"]["MaintenanceWindowDto"]; + }; + SingleValueResponseMonitorAssertionDto: { + data: components["schemas"]["MonitorAssertionDto"]; + }; + SingleValueResponseMonitorAuthDto: { + data: components["schemas"]["MonitorAuthDto"]; + }; + SingleValueResponseMonitorDto: { + data: components["schemas"]["MonitorDto"]; + }; + SingleValueResponseMonitorTestResultDto: { + data: components["schemas"]["MonitorTestResultDto"]; + }; + SingleValueResponseMonitorVersionDto: { + data: components["schemas"]["MonitorVersionDto"]; + }; + SingleValueResponseNotificationDispatchDto: { + data: components["schemas"]["NotificationDispatchDto"]; + }; + SingleValueResponseNotificationPolicyDto: { + data: components["schemas"]["NotificationPolicyDto"]; + }; + SingleValueResponseOrganizationDto: { + data: components["schemas"]["OrganizationDto"]; + }; + SingleValueResponsePolicySnapshotDto: { + data: components["schemas"]["PolicySnapshotDto"]; + }; + SingleValueResponseResourceGroupDto: { + data: components["schemas"]["ResourceGroupDto"]; + }; + SingleValueResponseResourceGroupHealthDto: { + data: components["schemas"]["ResourceGroupHealthDto"]; + }; + SingleValueResponseResourceGroupMemberDto: { + data: components["schemas"]["ResourceGroupMemberDto"]; + }; + SingleValueResponseResultSummaryDto: { + data: components["schemas"]["ResultSummaryDto"]; + }; + SingleValueResponseSecretDto: { + data: components["schemas"]["SecretDto"]; + }; + SingleValueResponseServiceDayDetailDto: { + data: components["schemas"]["ServiceDayDetailDto"]; + }; + SingleValueResponseServiceDetailDto: { + data: components["schemas"]["ServiceDetailDto"]; + }; + SingleValueResponseServiceIncidentDetailDto: { + data: components["schemas"]["ServiceIncidentDetailDto"]; + }; + SingleValueResponseServiceLiveStatusDto: { + data: components["schemas"]["ServiceLiveStatusDto"]; + }; + SingleValueResponseServicePollSummaryDto: { + data: components["schemas"]["ServicePollSummaryDto"]; + }; + SingleValueResponseServiceSubscriptionDto: { + data: components["schemas"]["ServiceSubscriptionDto"]; + }; + SingleValueResponseServiceUptimeResponse: { + data: components["schemas"]["ServiceUptimeResponse"]; + }; + SingleValueResponseStatusPageComponentDto: { + data: components["schemas"]["StatusPageComponentDto"]; + }; + SingleValueResponseStatusPageComponentGroupDto: { + data: components["schemas"]["StatusPageComponentGroupDto"]; + }; + SingleValueResponseStatusPageCustomDomainDto: { + data: components["schemas"]["StatusPageCustomDomainDto"]; + }; + SingleValueResponseStatusPageDto: { + data: components["schemas"]["StatusPageDto"]; + }; + SingleValueResponseStatusPageIncidentDto: { + data: components["schemas"]["StatusPageIncidentDto"]; + }; + SingleValueResponseStatusPageSubscriberDto: { + data: components["schemas"]["StatusPageSubscriberDto"]; + }; + SingleValueResponseString: { + data: string; + }; + SingleValueResponseTagDto: { + data: components["schemas"]["TagDto"]; + }; + SingleValueResponseTestChannelResult: { + data: components["schemas"]["TestChannelResult"]; + }; + SingleValueResponseTestMatchResult: { + data: components["schemas"]["TestMatchResult"]; + }; + SingleValueResponseUptimeDto: { + data: components["schemas"]["UptimeDto"]; + }; + SingleValueResponseWebhookEndpointDto: { + data: components["schemas"]["WebhookEndpointDto"]; + }; + SingleValueResponseWebhookSigningSecretDto: { + data: components["schemas"]["WebhookSigningSecretDto"]; + }; + SingleValueResponseWebhookTestResult: { + data: components["schemas"]["WebhookTestResult"]; + }; + SingleValueResponseWorkspaceDto: { + data: components["schemas"]["WorkspaceDto"]; + }; + SlackChannelConfig: { + /** @enum {string} */ + channelType: "slack"; + /** @description Slack incoming webhook URL */ + webhookUrl: string; + /** @description Optional mention text included in notifications, e.g. @channel */ + mentionText?: string | null; + }; + SslExpiryAssertion: { + /** @enum {string} */ + type: "ssl_expiry"; + /** + * Format: int32 + * @description Minimum days before TLS certificate expiry; fails or warns below this threshold + */ + minDaysRemaining: number; + }; + /** @description Typed metadata about this transition (currently: actor source) */ + StateTransitionDetails: { + /** + * @description Actor that produced this transition (pipeline | public-api) + * @enum {string} + */ + source: "pipeline" | "public-api"; + }; + StatusCodeAssertion: { + /** @enum {string} */ + type: "status_code"; + /** @description Expected status code, range pattern, or wildcard such as 2xx */ + expected: string; + /** + * @description Comparison operator (equals, contains, less_than, greater_than, etc.) + * @enum {string} + */ + operator: "equals" | "contains" | "less_than" | "greater_than" | "matches" | "range"; + }; + /** @description Updated branding configuration; null preserves current */ + StatusPageBranding: { + /** @description URL for the logo image displayed in the header */ + logoUrl?: string | null; + /** @description URL for the browser tab favicon */ + faviconUrl?: string | null; + /** @description Primary brand color as hex, e.g. #4F46E5; drives accent/links/buttons */ + brandColor?: string | null; + /** @description Page body background color as hex, e.g. #FAFAFA */ + pageBackground?: string | null; + /** @description Card/surface background color as hex, e.g. #FFFFFF */ + cardBackground?: string | null; + /** @description Primary text color as hex, e.g. #09090B */ + textColor?: string | null; + /** @description Card border color as hex, e.g. #E4E4E7 */ + borderColor?: string | null; + /** @description Header layout style (reserved for future use) */ + headerStyle?: string | null; + /** @description Color theme: light or dark (default: light) */ + theme?: string | null; + /** @description URL where visitors can report a problem */ + reportUrl?: string | null; + /** + * @description Whether to hide the 'Powered by DevHelm' footer badge (default: false) + * @default false + */ + hidePoweredBy: boolean; + /** @description Custom CSS injected via