@devhelm/sdk 0.3.0 → 0.5.0

package/dist/generated/api.d.ts

@@ -376,6 +376,103 @@ export interface paths {
         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;
@@ -1866,6 +1963,23 @@ export interface paths {
         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;
@@ -2604,16 +2718,15 @@ export interface components {
             resourceId?: string | null;
             /** @description Human-readable name of the affected resource */
             resourceName?: string | null;
-            /** @description Additional context about the action */
-            metadata?: {
-                [key: string]: Record<string, never> | null;
-            } | null;
+            metadata?: Omit<components["schemas"]["AuditMetadata"], "kind"> | 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"];
@@ -2810,6 +2923,18 @@ export interface components {
              */
             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 */
@@ -2886,7 +3011,7 @@ export interface components {
         ComponentUptimeDayDto: {
             /**
              * Format: date-time
-             * @description Date of the daily bucket (ISO 8601)
+             * @description Start-of-day timestamp for this bucket (UTC midnight, ISO 8601)
              */
             date: string;
             /**
@@ -2906,13 +3031,11 @@ export interface components {
             degradedSeconds: number;
             /**
              * Format: double
-             * @description Computed uptime percentage for the day
+             * @description Computed uptime percentage using the weighted formula (degraded does not lower it)
              */
             uptimePercentage: number;
-            /** @description Incident event references for this day as raw JSON */
-            eventsJson?: string | null;
-            /** @description Data source: vendor_reported or incident_derived */
-            source: string;
+            /** @description Incidents that overlapped this day, in display order */
+            incidents?: components["schemas"]["IncidentRef"][] | null;
         };
         /** @description Inline uptime percentages for 24h, 7d, 30d */
         ComponentUptimeSummaryDto: {
@@ -3881,10 +4004,7 @@ export interface components {
              * @enum {string}
              */
             check_type: "http";
-            /** @description Request phase timing breakdown */
-            timing?: {
-                [key: string]: Record<string, never> | null;
-            } | null;
+            timing?: components["schemas"]["TimingPhasesDto"] | null;
             /** @description Whether the response body was truncated before storage */
             bodyTruncated?: boolean | null;
         };
@@ -4122,6 +4242,20 @@ export interface components {
             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: {
             /**
@@ -4224,16 +4358,16 @@ export interface components {
              */
             checkFrequencySeconds?: number | null;
         };
-        /** @description Lightweight reference to an incident overlapping this day */
+        /** @description Lightweight reference to an incident overlapping a given uptime day */
         IncidentRef: {
             /**
              * Format: uuid
-             * @description Status page incident ID
+             * @description Internal incident ID — UUID for status-page incidents, service incident UUID for catalog
              */
             id: string;
-            /** @description Incident title */
+            /** @description Incident title at the time of the overlap */
             title: string;
-            /** @description Incident impact level */
+            /** @description Incident impact level (e.g. minor, major, critical for catalog; NONE/MINOR/MAJOR/CRITICAL for status pages) */
             impact: string;
         };
         /** @description Incident summary counters */
@@ -4245,6 +4379,56 @@ export interface components {
             /** 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;
@@ -4582,6 +4766,24 @@ export interface components {
              */
             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;
@@ -4998,6 +5200,27 @@ export interface components {
                 [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<string, never>;
+            };
+            /** @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: {
             /**
@@ -5395,6 +5618,57 @@ export interface components {
              */
             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<string, never>;
+            };
+            /** @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: {
             /**
@@ -5869,6 +6143,9 @@ export interface components {
         SingleValueResponseBulkMonitorActionResult: {
             data: components["schemas"]["BulkMonitorActionResult"];
         };
+        SingleValueResponseCheckTraceDto: {
+            data: components["schemas"]["CheckTraceDto"];
+        };
         SingleValueResponseDashboardOverviewDto: {
             data: components["schemas"]["DashboardOverviewDto"];
         };
@@ -5890,6 +6167,9 @@ export interface components {
         SingleValueResponseIncidentPolicyDto: {
             data: components["schemas"]["IncidentPolicyDto"];
         };
+        SingleValueResponseIncidentTimelineDto: {
+            data: components["schemas"]["IncidentTimelineDto"];
+        };
         SingleValueResponseInviteDto: {
             data: components["schemas"]["InviteDto"];
         };
@@ -5927,6 +6207,9 @@ export interface components {
         SingleValueResponseOrganizationDto: {
             data: components["schemas"]["OrganizationDto"];
         };
+        SingleValueResponsePolicySnapshotDto: {
+            data: components["schemas"]["PolicySnapshotDto"];
+        };
         SingleValueResponseResourceGroupDto: {
             data: components["schemas"]["ResourceGroupDto"];
         };
@@ -6025,6 +6308,14 @@ export interface components {
              */
             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";
@@ -6116,31 +6407,6 @@ export interface components {
             /** Format: date-time */
             updatedAt: string;
         };
-        /** @description Daily uptime data for a status page component */
-        StatusPageComponentUptimeDayDto: {
-            /**
-             * Format: date-time
-             * @description Start-of-day timestamp for this bucket (UTC midnight)
-             */
-            date: string;
-            /**
-             * Format: int32
-             * @description Seconds of partial outage on this day
-             */
-            partialOutageSeconds: number;
-            /**
-             * Format: int32
-             * @description Seconds of major outage on this day
-             */
-            majorOutageSeconds: number;
-            /**
-             * Format: double
-             * @description Computed uptime percentage using weighted formula
-             */
-            uptimePercentage: number;
-            /** @description Incidents that overlapped this day */
-            incidents?: components["schemas"]["IncidentRef"][] | null;
-        };
         StatusPageCustomDomainDto: {
             /** Format: uuid */
             id: string;
@@ -6154,6 +6420,10 @@ export interface components {
             /** Format: date-time */
             verifiedAt?: string | null;
             verificationError?: string | null;
+            cfCustomHostnameId?: string | null;
+            cfSslStatus?: string | null;
+            /** Format: date-time */
+            sslActiveAt?: string | null;
             /** Format: date-time */
             createdAt: string;
             /** Format: date-time */
@@ -6339,6 +6609,15 @@ export interface components {
             /** Format: int32 */
             totalPages?: number | null;
         };
+        TableValueResultIncidentStateTransitionDto: {
+            data: components["schemas"]["IncidentStateTransitionDto"][];
+            hasNext: boolean;
+            hasPrev: boolean;
+            /** Format: int64 */
+            totalElements?: number | null;
+            /** Format: int32 */
+            totalPages?: number | null;
+        };
         TableValueResultIntegrationDto: {
             data: components["schemas"]["IntegrationDto"][];
             hasNext: boolean;
@@ -6429,6 +6708,15 @@ export interface components {
             /** Format: int32 */
             totalPages?: number | null;
         };
+        TableValueResultRuleEvaluationDto: {
+            data: components["schemas"]["RuleEvaluationDto"][];
+            hasNext: boolean;
+            hasPrev: boolean;
+            /** Format: int64 */
+            totalElements?: number | null;
+            /** Format: int32 */
+            totalPages?: number | null;
+        };
         TableValueResultScheduledMaintenanceDto: {
             data: components["schemas"]["ScheduledMaintenanceDto"][];
             hasNext: boolean;
@@ -6492,15 +6780,6 @@ export interface components {
             /** Format: int32 */
             totalPages?: number | null;
         };
-        TableValueResultStatusPageComponentUptimeDayDto: {
-            data: components["schemas"]["StatusPageComponentUptimeDayDto"][];
-            hasNext: boolean;
-            hasPrev: boolean;
-            /** Format: int64 */
-            totalElements?: number | null;
-            /** Format: int32 */
-            totalPages?: number | null;
-        };
         TableValueResultStatusPageCustomDomainDto: {
             data: components["schemas"]["StatusPageCustomDomainDto"][];
             hasNext: boolean;
@@ -6710,6 +6989,45 @@ export interface components {
             /** @description Event type to simulate (e.g. monitor.created); null uses a default */
             eventType?: string | null;
         };
+        /** @description Per-phase HTTP request timing breakdown (milliseconds) */
+        TimingPhasesDto: {
+            /**
+             * Format: int32
+             * @description DNS resolution time in milliseconds
+             * @example 12
+             */
+            dns_ms?: number | null;
+            /**
+             * Format: int32
+             * @description TCP connect time in milliseconds
+             * @example 18
+             */
+            tcp_ms?: number | null;
+            /**
+             * Format: int32
+             * @description TLS handshake time in milliseconds (null for plain HTTP)
+             * @example 34
+             */
+            tls_ms?: number | null;
+            /**
+             * Format: int32
+             * @description Time to first response byte in milliseconds
+             * @example 42
+             */
+            ttfb_ms?: number | null;
+            /**
+             * Format: int32
+             * @description Response body download time in milliseconds
+             * @example 8
+             */
+            download_ms?: number | null;
+            /**
+             * Format: int32
+             * @description Total wall-clock request time in milliseconds
+             * @example 114
+             */
+            total_ms?: number | null;
+        };
         /** @description TLS/SSL certificate details for HTTPS targets */
         TlsInfoDto: {
             /**
@@ -8782,15 +9100,479 @@ export interface operations {
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["TableValueResultAuditEventDto"];
+                };
+            };
+            /** @description Bad request — the payload failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized — missing or invalid credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Forbidden — the actor lacks permission for this resource */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not found — the requested resource does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Conflict — the request collides with current resource state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Internal server error — see the message field for details */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bad gateway — an upstream provider returned an error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Service unavailable — try again shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    me_1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["SingleValueResponseAuthMeResponse"];
+                };
+            };
+            /** @description Bad request — the payload failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized — missing or invalid credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Forbidden — the actor lacks permission for this resource */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not found — the requested resource does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Conflict — the request collides with current resource state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Internal server error — see the message field for details */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bad gateway — an upstream provider returned an error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Service unavailable — try again shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    listCategories: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["TableValueResultCategoryDto"];
+                };
+            };
+            /** @description Bad request — the payload failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized — missing or invalid credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Forbidden — the actor lacks permission for this resource */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not found — the requested resource does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Conflict — the request collides with current resource state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Internal server error — see the message field for details */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bad gateway — an upstream provider returned an error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Service unavailable — try again shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    overview: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["SingleValueResponseDashboardOverviewDto"];
+                };
+            };
+            /** @description Bad request — the payload failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized — missing or invalid credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Forbidden — the actor lacks permission for this resource */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not found — the requested resource does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Conflict — the request collides with current resource state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Internal server error — see the message field for details */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bad gateway — an upstream provider returned an error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Service unavailable — try again shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    current: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["SingleValueResponseDeployLockDto"];
+                };
+            };
+            /** @description Bad request — the payload failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized — missing or invalid credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Forbidden — the actor lacks permission for this resource */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not found — the requested resource does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Conflict — the request collides with current resource state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Internal server error — see the message field for details */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bad gateway — an upstream provider returned an error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Service unavailable — try again shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    acquire: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AcquireDeployLockRequest"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["TableValueResultAuditEventDto"];
+                    "*/*": components["schemas"]["SingleValueResponseDeployLockDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -8867,23 +9649,23 @@ export interface operations {
             };
         };
     };
-    me_1: {
+    release: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                lockId: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description No Content */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "*/*": components["schemas"]["SingleValueResponseAuthMeResponse"];
-                };
+                content?: never;
             };
             /** @description Bad request — the payload failed validation */
             400: {
@@ -8959,7 +9741,7 @@ export interface operations {
             };
         };
     };
-    listCategories: {
+    forceRelease: {
         parameters: {
             query?: never;
             header?: never;
@@ -8968,14 +9750,12 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description OK */
-            200: {
+            /** @description No Content */
+            204: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content: {
-                    "*/*": components["schemas"]["TableValueResultCategoryDto"];
-                };
+                content?: never;
             };
             /** @description Bad request — the payload failed validation */
             400: {
@@ -9051,7 +9831,7 @@ export interface operations {
             };
         };
     };
-    overview: {
+    list_12: {
         parameters: {
             query?: never;
             header?: never;
@@ -9066,7 +9846,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["SingleValueResponseDashboardOverviewDto"];
+                    "*/*": components["schemas"]["TableValueResultEnvironmentDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9143,22 +9923,26 @@ export interface operations {
             };
         };
     };
-    current: {
+    create_13: {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateEnvironmentRequest"];
+            };
+        };
         responses: {
-            /** @description OK */
-            200: {
+            /** @description Created */
+            201: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["SingleValueResponseDeployLockDto"];
+                    "*/*": components["schemas"]["SingleValueResponseEnvironmentDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9235,26 +10019,24 @@ export interface operations {
             };
         };
     };
-    acquire: {
+    get_7: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["AcquireDeployLockRequest"];
+            path: {
+                slug: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
-            /** @description Created */
-            201: {
+            /** @description OK */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["SingleValueResponseDeployLockDto"];
+                    "*/*": components["schemas"]["SingleValueResponseEnvironmentDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9331,23 +10113,29 @@ export interface operations {
             };
         };
     };
-    release: {
+    update_13: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                lockId: string;
+                slug: string;
             };
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["UpdateEnvironmentRequest"];
+            };
+        };
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description OK */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "*/*": components["schemas"]["SingleValueResponseEnvironmentDto"];
+                };
             };
             /** @description Bad request — the payload failed validation */
             400: {
@@ -9423,11 +10211,13 @@ export interface operations {
             };
         };
     };
-    forceRelease: {
+    delete_9: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                slug: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
@@ -9513,11 +10303,13 @@ export interface operations {
             };
         };
     };
-    list_12: {
+    getTimeline: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                id: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
@@ -9528,7 +10320,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["TableValueResultEnvironmentDto"];
+                    "*/*": components["schemas"]["SingleValueResponseIncidentTimelineDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9605,26 +10397,31 @@ export interface operations {
             };
         };
     };
-    create_13: {
+    listMonitorRuleEvaluations: {
         parameters: {
-            query?: never;
+            query: {
+                ruleType?: string;
+                region?: string;
+                onlyMatched?: boolean;
+                from?: string;
+                to?: string;
+                pageable: components["schemas"]["Pageable"];
+            };
             header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CreateEnvironmentRequest"];
+            path: {
+                id: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
-            /** @description Created */
-            201: {
+            /** @description OK */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["SingleValueResponseEnvironmentDto"];
+                    "*/*": components["schemas"]["TableValueResultRuleEvaluationDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9701,12 +10498,16 @@ export interface operations {
             };
         };
     };
-    get_7: {
+    listMonitorTransitions: {
         parameters: {
-            query?: never;
+            query: {
+                from?: string;
+                to?: string;
+                pageable: components["schemas"]["Pageable"];
+            };
             header?: never;
             path: {
-                slug: string;
+                id: string;
             };
             cookie?: never;
         };
@@ -9718,7 +10519,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["SingleValueResponseEnvironmentDto"];
+                    "*/*": components["schemas"]["TableValueResultIncidentStateTransitionDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9795,20 +10596,16 @@ export interface operations {
             };
         };
     };
-    update_13: {
+    getPolicySnapshot: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                slug: string;
+                hashHex: string;
             };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["UpdateEnvironmentRequest"];
-            };
-        };
+        requestBody?: never;
         responses: {
             /** @description OK */
             200: {
@@ -9816,7 +10613,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["SingleValueResponseEnvironmentDto"];
+                    "*/*": components["schemas"]["SingleValueResponsePolicySnapshotDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -9893,23 +10690,25 @@ export interface operations {
             };
         };
     };
-    delete_9: {
+    getTrace: {
         parameters: {
             query?: never;
             header?: never;
             path: {
-                slug: string;
+                checkId: string;
             };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description No Content */
-            204: {
+            /** @description OK */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "*/*": components["schemas"]["SingleValueResponseCheckTraceDto"];
+                };
             };
             /** @description Bad request — the payload failed validation */
             400: {
@@ -20150,7 +20949,7 @@ export interface operations {
                     [name: string]: unknown;
                 };
                 content: {
-                    "*/*": components["schemas"]["TableValueResultStatusPageComponentUptimeDayDto"];
+                    "*/*": components["schemas"]["TableValueResultComponentUptimeDayDto"];
                 };
             };
             /** @description Bad request — the payload failed validation */
@@ -20608,6 +21407,101 @@ export interface operations {
             };
         };
     };
+    setPrimaryDomain: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                domainId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "*/*": components["schemas"]["SingleValueResponseStatusPageCustomDomainDto"];
+                };
+            };
+            /** @description Bad request — the payload failed validation */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Unauthorized — missing or invalid credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Forbidden — the actor lacks permission for this resource */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Not found — the requested resource does not exist */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Conflict — the request collides with current resource state */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Internal server error — see the message field for details */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Bad gateway — an upstream provider returned an error */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description Service unavailable — try again shortly */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     verifyDomain: {
         parameters: {
             query?: never;