_generated.py

# generated by datamodel-codegen:
#   filename:  .openapi-preprocessed.json

from __future__ import annotations
from typing import Annotated, Any, Literal
from pydantic import ConfigDict, AwareDatetime, BaseModel, EmailStr, Field, RootModel
from enum import StrEnum
from uuid import UUID
from datetime import date as date_aliased


class AcquireDeployLockRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    locked_by: Annotated[
        str,
        Field(
            alias="lockedBy",
            description="Identity of the lock requester (e.g. hostname, CI job ID)",
            min_length=1,
        ),
    ]
    ttl_minutes: Annotated[
        int | None,
        Field(
            alias="ttlMinutes",
            description="Lock TTL in minutes (default: 30, max: 60)",
            examples=[30],
        ),
    ] = None


class AddCustomDomainRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    hostname: Annotated[
        str,
        Field(
            description="Custom hostname, e.g. status.acme.com",
            max_length=255,
            min_length=0,
            pattern="^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$",
        ),
    ]


class NewStatus(StrEnum):
    watching = "WATCHING"
    triggered = "TRIGGERED"
    confirmed = "CONFIRMED"
    resolved = "RESOLVED"


class AddIncidentUpdateRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    body: Annotated[
        str | None, Field(description="Update message or post-mortem notes")
    ] = None
    new_status: Annotated[
        NewStatus | None,
        Field(
            alias="newStatus",
            description="Updated incident status; null to keep current status",
        ),
    ] = None
    notify_subscribers: Annotated[
        bool,
        Field(
            alias="notifySubscribers",
            description="Whether to notify subscribers of this update",
        ),
    ]


class AddResourceGroupMemberRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    member_type: Annotated[
        str,
        Field(
            alias="memberType",
            description="Type of member: 'monitor' or 'service'",
            min_length=1,
            pattern="monitor|service",
        ),
    ]
    member_id: Annotated[
        UUID, Field(alias="memberId", description="ID of the monitor or service to add")
    ]


class AdminAddSubscriberRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    email: Annotated[
        EmailStr,
        Field(
            description="Email address to add as a confirmed subscriber", min_length=1
        ),
    ]


class Status(StrEnum):
    operational = "OPERATIONAL"
    degraded_performance = "DEGRADED_PERFORMANCE"
    partial_outage = "PARTIAL_OUTAGE"
    major_outage = "MAJOR_OUTAGE"
    under_maintenance = "UNDER_MAINTENANCE"


class AffectedComponent(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    component_id: Annotated[
        UUID, Field(alias="componentId", description="Status page component ID")
    ]
    status: Annotated[
        Status, Field(description="Component status during this incident")
    ]


class AlertChannelDisplayConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    recipients: Annotated[
        list[str] | None, Field(description="Email recipients list (email channels)")
    ] = None
    region: Annotated[
        str | None, Field(description="OpsGenie API region: us or eu")
    ] = None
    severity_override: Annotated[
        str | None,
        Field(
            alias="severityOverride",
            description="PagerDuty severity override (critical, error, warning, info)",
        ),
    ] = None
    mention_role_id: Annotated[
        str | None,
        Field(
            alias="mentionRoleId",
            description="Discord role ID to mention in notifications",
        ),
    ] = None
    custom_headers: Annotated[
        dict[str, str] | None,
        Field(
            alias="customHeaders",
            description="Custom HTTP headers for webhook requests",
        ),
    ] = None


class AlertChannelDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique alert channel identifier")]
    name: Annotated[str, Field(description="Human-readable channel name")]
    channel_type: Annotated[
        str,
        Field(
            alias="channelType",
            description="Channel integration type (e.g. SLACK, PAGERDUTY, EMAIL)",
        ),
    ]
    display_config: Annotated[
        AlertChannelDisplayConfig | None, Field(alias="displayConfig")
    ] = None
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the channel was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt", description="Timestamp when the channel was last updated"
        ),
    ]
    config_hash: Annotated[
        str | None,
        Field(
            alias="configHash",
            description="SHA-256 hash of the channel config; use for change detection",
        ),
    ] = None
    managed_by: Annotated[
        str | None,
        Field(
            alias="managedBy",
            description="Source that created/owns this channel: DASHBOARD, CLI, TERRAFORM, MCP, or API. Null on channels created before this attribution column existed.",
        ),
    ] = None
    last_delivery_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="lastDeliveryAt",
            description="Timestamp of the most recent delivery attempt",
        ),
    ] = None
    last_delivery_status: Annotated[
        str | None,
        Field(
            alias="lastDeliveryStatus",
            description="Outcome of the most recent delivery (SUCCESS, FAILED, etc.)",
        ),
    ] = None


class AlertDeliveryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    incident_id: Annotated[
        UUID,
        Field(alias="incidentId", description="Incident that triggered this delivery"),
    ]
    dispatch_id: Annotated[
        UUID | None,
        Field(
            alias="dispatchId",
            description="Notification dispatch that created this delivery",
        ),
    ] = None
    channel_id: Annotated[
        UUID, Field(alias="channelId", description="Alert channel ID")
    ]
    channel: Annotated[str, Field(description="Human-readable channel name")]
    channel_type: Annotated[
        str,
        Field(
            alias="channelType",
            description="Alert channel type (e.g. slack, email, webhook)",
        ),
    ]
    status: Annotated[str, Field(description="Current delivery status")]
    event_type: Annotated[
        str,
        Field(
            alias="eventType",
            description="Incident lifecycle event that triggered this delivery",
        ),
    ]
    step_number: Annotated[
        int,
        Field(
            alias="stepNumber",
            description="1-based escalation step this delivery belongs to",
        ),
    ]
    fire_count: Annotated[
        int,
        Field(
            alias="fireCount",
            description="Fire sequence within the step: 1 = initial, 2+ = repeat re-fires",
        ),
    ]
    attempt_count: Annotated[
        int, Field(alias="attemptCount", description="Number of delivery attempts made")
    ]
    last_attempt_at: Annotated[
        AwareDatetime | None,
        Field(alias="lastAttemptAt", description="When the last attempt was made"),
    ] = None
    next_retry_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="nextRetryAt",
            description="When the next retry is scheduled (null if not retrying)",
        ),
    ] = None
    delivered_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="deliveredAt",
            description="Timestamp when the delivery was confirmed (null if not yet delivered)",
        ),
    ] = None
    error_message: Annotated[
        str | None,
        Field(
            alias="errorMessage",
            description="Error message from the last failed attempt",
        ),
    ] = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]


class ApiKeyAuthConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["api_key"] = "api_key"
    header_name: Annotated[
        str,
        Field(
            alias="headerName",
            description="HTTP header name that carries the API key",
            min_length=1,
            pattern="^[A-Za-z0-9\\-_]+$",
        ),
    ]
    vault_secret_id: Annotated[
        UUID | None,
        Field(
            alias="vaultSecretId", description="Vault secret ID for the API key value"
        ),
    ] = None


class ApiKeyCreateResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Unique API key identifier")]
    name: Annotated[
        str, Field(description="Human-readable name for this API key", min_length=1)
    ]
    key: Annotated[
        str,
        Field(
            description="Full API key value in dh_live_* format; store this now",
            min_length=1,
        ),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the key was created"),
    ]
    expires_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="expiresAt",
            description="Timestamp when the key expires; null if no expiration",
        ),
    ] = None


class ApiKeyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Unique API key identifier")]
    name: Annotated[
        str, Field(description="Human-readable name for this API key", min_length=1)
    ]
    key: Annotated[
        str, Field(description="Full API key value in dh_live_* format", min_length=1)
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the key was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(alias="updatedAt", description="Timestamp when the key was last updated"),
    ]
    last_used_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="lastUsedAt",
            description="Timestamp of the most recent API call; null if never used",
        ),
    ] = None
    revoked_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="revokedAt",
            description="Timestamp when the key was revoked; null if active",
        ),
    ] = None
    expires_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="expiresAt",
            description="Timestamp when the key expires; null if no expiration",
        ),
    ] = None


class AssertionResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[str, Field(description="Assertion type", examples=["status_code"])]
    passed: Annotated[bool, Field(description="Whether the assertion passed")]
    severity: Annotated[str, Field(description="Assertion severity")]
    message: Annotated[
        str | None, Field(description="Human-readable result message")
    ] = None
    expected: Annotated[
        str | None, Field(description="Expected value", examples=["200"])
    ] = None
    actual: Annotated[
        str | None, Field(description="Actual value observed", examples=["503"])
    ] = None


class AssertionTestResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    assertion_type: Annotated[
        str, Field(alias="assertionType", description="Assertion type evaluated")
    ]
    passed: Annotated[bool, Field(description="Whether the assertion passed")]
    severity: Annotated[str, Field(description="Assertion severity: FAIL or WARN")]
    message: Annotated[str, Field(description="Human-readable result description")]
    expected: Annotated[str | None, Field(description="Expected value")] = None
    actual: Annotated[
        str | None, Field(description="Actual value observed during the test")
    ] = None


class BasicAuthConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["basic"] = "basic"
    vault_secret_id: Annotated[
        UUID | None,
        Field(
            alias="vaultSecretId",
            description="Vault secret ID holding Basic auth username and password",
        ),
    ] = None


class BearerAuthConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["bearer"] = "bearer"
    vault_secret_id: Annotated[
        UUID | None,
        Field(
            alias="vaultSecretId",
            description="Vault secret ID holding the bearer token value",
        ),
    ] = None


class BodyContainsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["body_contains"] = "body_contains"
    substring: Annotated[
        str,
        Field(
            description="Substring that must appear in the response body", min_length=1
        ),
    ]


class Action(StrEnum):
    pause = "PAUSE"
    resume = "RESUME"
    delete = "DELETE"
    add_tag = "ADD_TAG"
    remove_tag = "REMOVE_TAG"


class CategoryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    category: Annotated[
        str, Field(description="Category name (e.g. CI/CD, Cloud, Payments)")
    ]
    service_count: Annotated[
        int,
        Field(alias="serviceCount", description="Number of services in this category"),
    ]


class OrgRole(StrEnum):
    owner = "OWNER"
    admin = "ADMIN"
    member = "MEMBER"


class ChangeRoleRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    org_role: Annotated[
        OrgRole, Field(alias="orgRole", description="New role to assign")
    ]


class Status1(StrEnum):
    invited = "INVITED"
    active = "ACTIVE"
    suspended = "SUSPENDED"
    left = "LEFT"
    removed = "REMOVED"
    declined = "DECLINED"


class ChangeStatusRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status: Annotated[
        Status1, Field(description="New membership status (ACTIVE or SUSPENDED)")
    ]


class ChartBucketDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    bucket: Annotated[
        AwareDatetime,
        Field(
            description="Start of the time bucket (ISO 8601)",
            examples=["2026-03-12T10:00:00Z"],
        ),
    ]
    uptime_percent: Annotated[
        float | None,
        Field(
            alias="uptimePercent",
            description="Uptime percentage for this bucket; null when no data",
            examples=[100],
        ),
    ] = None
    avg_latency_ms: Annotated[
        float | None,
        Field(
            alias="avgLatencyMs",
            description="Weighted average latency in milliseconds for this bucket",
            examples=[120.3],
        ),
    ] = None
    p95_latency_ms: Annotated[
        float | None,
        Field(
            alias="p95LatencyMs",
            description="95th percentile latency in milliseconds (max across regions)",
            examples=[250],
        ),
    ] = None
    p99_latency_ms: Annotated[
        float | None,
        Field(
            alias="p99LatencyMs",
            description="99th percentile latency in milliseconds (max across regions)",
            examples=[480],
        ),
    ] = None


class ComponentImpact(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    component_id: Annotated[
        UUID, Field(alias="componentId", description="Status page component UUID")
    ]
    component_name: Annotated[
        str, Field(alias="componentName", description="Component display name")
    ]
    group_name: Annotated[
        str | None,
        Field(
            alias="groupName",
            description="Parent group display name when the component belongs to a group",
        ),
    ] = None
    uptime_percentage: Annotated[
        float,
        Field(
            alias="uptimePercentage",
            description="Computed uptime % for this component on this day",
        ),
    ]
    partial_outage_seconds: Annotated[
        int,
        Field(
            alias="partialOutageSeconds",
            description="Seconds of partial outage observed on this day",
        ),
    ]
    major_outage_seconds: Annotated[
        int,
        Field(
            alias="majorOutageSeconds",
            description="Seconds of major outage observed on this day",
        ),
    ]


class ComponentPosition(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    component_id: Annotated[
        UUID, Field(alias="componentId", description="Component ID")
    ]
    display_order: Annotated[
        int, Field(alias="displayOrder", description="New display order (0-based)")
    ]
    group_id: Annotated[
        UUID | None,
        Field(alias="groupId", description="Target group ID, null for ungrouped"),
    ] = None


class ComponentsSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    total_count: Annotated[
        int,
        Field(
            alias="totalCount",
            description="Total active components for this service across all groups",
        ),
    ]
    included_count: Annotated[
        int,
        Field(
            alias="includedCount",
            description="Number of components actually returned in the inline ``components`` list",
        ),
    ]
    group_component_counts: Annotated[
        dict[str, int],
        Field(
            alias="groupComponentCounts",
            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',
        ),
    ]


class ComponentStatusDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[str, Field(description="Component UUID")]
    name: Annotated[str, Field(description="Human-readable component name")]
    status: Annotated[
        str,
        Field(
            description="Current component status, e.g. operational, degraded_performance"
        ),
    ]


class ComponentUptimeSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    day: Annotated[
        float | None,
        Field(description="Uptime percentage over the last 24 hours", examples=[99.95]),
    ] = None
    week: Annotated[
        float | None,
        Field(description="Uptime percentage over the last 7 days", examples=[99.98]),
    ] = None
    month: Annotated[
        float | None,
        Field(description="Uptime percentage over the last 30 days", examples=[99.92]),
    ] = None
    source: Annotated[
        str,
        Field(
            description="Data source: vendor_reported or incident_derived",
            examples=["vendor_reported"],
        ),
    ]


class ConfirmationPolicy(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[
        Literal["multi_region"],
        Field(description="How incident confirmation is coordinated across regions"),
    ] = "multi_region"
    min_regions_failing: Annotated[
        int,
        Field(
            alias="minRegionsFailing",
            description="Minimum failing regions required to confirm an incident",
        ),
    ]
    max_wait_seconds: Annotated[
        int,
        Field(
            alias="maxWaitSeconds",
            description="Maximum seconds to wait for enough regions to fail after first trigger",
        ),
    ]


class ManagedBy(StrEnum):
    dashboard = "DASHBOARD"
    cli = "CLI"
    terraform = "TERRAFORM"
    mcp = "MCP"
    api = "API"


class CreateApiKeyRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name to identify this API key",
            max_length=200,
            min_length=0,
        ),
    ]
    expires_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="expiresAt",
            description="Optional expiration timestamp in ISO 8601 format",
        ),
    ] = None


class Severity(StrEnum):
    fail = "fail"
    warn = "warn"


class CreateEnvironmentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable environment name", max_length=100, min_length=0
        ),
    ]
    slug: Annotated[
        str,
        Field(
            description="URL-safe identifier (lowercase alphanumeric, hyphens, underscores)",
            max_length=100,
            min_length=0,
            pattern="^[a-z0-9][a-z0-9_-]*$",
        ),
    ]
    variables: Annotated[
        dict[str, str] | None,
        Field(description="Initial key-value variable pairs for this environment"),
    ] = None
    is_default: Annotated[
        bool | None,
        Field(
            alias="isDefault",
            description="Whether this is the default environment for new monitors (default: false)",
        ),
    ] = None


class RoleOffered(StrEnum):
    owner = "OWNER"
    admin = "ADMIN"
    member = "MEMBER"


class CreateInviteRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    email: Annotated[
        EmailStr, Field(description="Email address to invite", min_length=1)
    ]
    role_offered: Annotated[
        RoleOffered,
        Field(alias="roleOffered", description="Role to assign on acceptance"),
    ]


class CreateMaintenanceWindowRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Monitor to attach this maintenance window to; null for org-wide",
        ),
    ] = None
    starts_at: Annotated[
        AwareDatetime,
        Field(
            alias="startsAt",
            description="Scheduled start of the maintenance window (ISO 8601)",
        ),
    ]
    ends_at: Annotated[
        AwareDatetime,
        Field(
            alias="endsAt",
            description="Scheduled end of the maintenance window (ISO 8601)",
        ),
    ]
    repeat_rule: Annotated[
        str | None,
        Field(
            alias="repeatRule",
            description="Reserved: iCal RRULE for recurring windows (stored but not yet honored)",
            max_length=100,
            min_length=0,
        ),
    ] = None
    reason: Annotated[
        str | None,
        Field(
            description="Human-readable reason for the maintenance (max 500 chars)",
            max_length=500,
            min_length=0,
        ),
    ] = None
    suppress_alerts: Annotated[
        bool | None,
        Field(
            alias="suppressAlerts",
            description="Whether to suppress alerts during this window (default: true)",
        ),
    ] = None


class Severity1(StrEnum):
    down = "DOWN"
    degraded = "DEGRADED"
    maintenance = "MAINTENANCE"


class CreateManualIncidentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    title: Annotated[
        str, Field(description="Short summary of the incident", min_length=1)
    ]
    severity: Annotated[
        Severity1,
        Field(description="Incident severity: DOWN, DEGRADED, or MAINTENANCE"),
    ]
    monitor_id: Annotated[
        UUID | None,
        Field(alias="monitorId", description="Monitor to associate with this incident"),
    ] = None
    body: Annotated[
        str | None,
        Field(description="Detailed description or context for the incident"),
    ] = None


class Type(StrEnum):
    http = "HTTP"
    dns = "DNS"
    mcp_server = "MCP_SERVER"
    tcp = "TCP"
    icmp = "ICMP"
    heartbeat = "HEARTBEAT"


class HealthThresholdType(StrEnum):
    count = "COUNT"  # type: ignore[assignment]
    percentage = "PERCENTAGE"


class CreateSecretRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    key: Annotated[
        str,
        Field(
            description="Unique secret key within the workspace (max 255 chars)",
            max_length=255,
            min_length=0,
        ),
    ]
    value: Annotated[
        str,
        Field(
            description="Secret value, stored encrypted (max 32KB)",
            max_length=32768,
            min_length=0,
        ),
    ]


class CreateStatusPageComponentGroupRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str, Field(description="Group display name", max_length=255, min_length=0)
    ]
    description: Annotated[
        str | None,
        Field(description="Optional group description", max_length=500, min_length=0),
    ] = None
    display_order: Annotated[
        int | None,
        Field(alias="displayOrder", description="Position in the group list"),
    ] = None
    default_open: Annotated[
        bool | None,
        Field(
            alias="defaultOpen",
            description="Initial expand/collapse state when a visitor first loads the page; renderer may auto-expand on active incidents (default: true)",
        ),
    ] = None


class Type1(StrEnum):
    monitor = "MONITOR"
    group = "GROUP"
    static = "STATIC"


class CreateStatusPageComponentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str, Field(description="Component display name", max_length=255, min_length=0)
    ]
    description: Annotated[
        str | None,
        Field(
            description="Optional description shown on expand",
            max_length=500,
            min_length=0,
        ),
    ] = None
    type: Annotated[
        Type1, Field(description="Component type: MONITOR, GROUP, or STATIC")
    ]
    monitor_id: Annotated[
        UUID | None,
        Field(alias="monitorId", description="Monitor ID (required when type=MONITOR)"),
    ] = None
    resource_group_id: Annotated[
        UUID | None,
        Field(
            alias="resourceGroupId",
            description="Resource group ID (required when type=GROUP)",
        ),
    ] = None
    group_id: Annotated[
        UUID | None,
        Field(alias="groupId", description="Component group ID for visual grouping"),
    ] = None
    show_uptime: Annotated[
        bool | None,
        Field(
            alias="showUptime",
            description="Whether to show the uptime bar (default: true)",
        ),
    ] = None
    display_order: Annotated[
        int | None,
        Field(alias="displayOrder", description="Position in the component list"),
    ] = None
    exclude_from_overall: Annotated[
        bool | None,
        Field(
            alias="excludeFromOverall",
            description="Exclude from overall status calculation (default: false, use true for third-party deps)",
        ),
    ] = None
    start_date: Annotated[
        date_aliased | None,
        Field(
            alias="startDate",
            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",
        ),
    ] = None


class Status2(StrEnum):
    investigating = "INVESTIGATING"
    identified = "IDENTIFIED"
    monitoring = "MONITORING"
    resolved = "RESOLVED"


class Impact(StrEnum):
    none = "NONE"
    minor = "MINOR"
    major = "MAJOR"
    critical = "CRITICAL"


class CreateStatusPageIncidentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    title: Annotated[
        str,
        Field(
            description="Customer-facing incident title", max_length=500, min_length=0
        ),
    ]
    status: Annotated[
        Status2 | None, Field(description="Initial status (default: INVESTIGATING)")
    ] = None
    impact: Annotated[
        Impact, Field(description="Impact level: NONE, MINOR, MAJOR, or CRITICAL")
    ]
    body: Annotated[
        str, Field(description="Initial update body in markdown", min_length=1)
    ]
    affected_components: Annotated[
        list[AffectedComponent] | None,
        Field(
            alias="affectedComponents",
            description="Component IDs affected by this incident",
        ),
    ] = None
    scheduled: Annotated[
        bool | None,
        Field(description="Whether this is a scheduled maintenance (default: false)"),
    ] = None
    scheduled_for: Annotated[
        AwareDatetime | None,
        Field(
            alias="scheduledFor",
            description="Maintenance start time (required when scheduled=true)",
        ),
    ] = None
    scheduled_until: Annotated[
        AwareDatetime | None,
        Field(alias="scheduledUntil", description="Maintenance end time"),
    ] = None
    auto_resolve: Annotated[
        bool | None,
        Field(
            alias="autoResolve",
            description="Auto-resolve at scheduledUntil (default: false)",
        ),
    ] = None
    notify_subscribers: Annotated[
        bool | None,
        Field(
            alias="notifySubscribers",
            description="Whether to email confirmed subscribers about this incident (default: true)",
        ),
    ] = None


class CreateStatusPageIncidentUpdateRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status: Annotated[
        Status2, Field(description="Incident status at this point in the timeline")
    ]
    body: Annotated[str, Field(description="Update body in markdown", min_length=1)]
    notify_subscribers: Annotated[
        bool | None,
        Field(
            alias="notifySubscribers",
            description="Whether to email confirmed subscribers about this update (default: true)",
        ),
    ] = None
    affected_components: Annotated[
        list[AffectedComponent] | None,
        Field(
            alias="affectedComponents",
            description="Updated affected components; null preserves current",
        ),
    ] = None


class Visibility(StrEnum):
    public = "PUBLIC"
    password = "PASSWORD"
    ip_restricted = "IP_RESTRICTED"


class IncidentMode(StrEnum):
    manual = "MANUAL"
    review = "REVIEW"
    automatic = "AUTOMATIC"


class CreateTagRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Tag name, unique within the org", max_length=100, min_length=0
        ),
    ]
    color: Annotated[
        str | None,
        Field(
            description="Hex color code (defaults to #6B7280 if omitted)",
            pattern="^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$",
        ),
    ] = None


class SubscribedEvent(StrEnum):
    monitor_created = "monitor.created"
    monitor_updated = "monitor.updated"
    monitor_deleted = "monitor.deleted"
    incident_created = "incident.created"
    incident_resolved = "incident.resolved"
    incident_reopened = "incident.reopened"
    service_status_changed = "service.status_changed"
    service_component_changed = "service.component_changed"
    service_incident_created = "service.incident_created"
    service_incident_updated = "service.incident_updated"
    service_incident_resolved = "service.incident_resolved"


class CreateWebhookEndpointRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    url: Annotated[
        str,
        Field(
            description="HTTPS endpoint that receives webhook event payloads",
            max_length=2048,
            min_length=0,
        ),
    ]
    description: Annotated[
        str | None,
        Field(
            description="Optional human-readable description",
            max_length=255,
            min_length=0,
        ),
    ] = None
    subscribed_events: Annotated[
        list[SubscribedEvent],
        Field(
            alias="subscribedEvents", description="Event types to deliver", min_length=1
        ),
    ]


class CreateWorkspaceRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[str, Field(description="Workspace name", min_length=1)]


class DayIncident(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Status page incident UUID")]
    title: Annotated[str, Field(description="Incident title")]
    status: Annotated[
        Status2,
        Field(
            description="Lifecycle status (investigating, identified, monitoring, resolved, …)"
        ),
    ]
    impact: Annotated[
        Impact, Field(description="Severity bucket (none, minor, major, critical)")
    ]
    scheduled: Annotated[
        bool,
        Field(
            description="True for scheduled maintenances; false for unplanned incidents"
        ),
    ]
    started_at: Annotated[
        AwareDatetime | None,
        Field(alias="startedAt", description="Incident start timestamp"),
    ] = None
    resolved_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="resolvedAt",
            description="Incident resolved timestamp; null while still active",
        ),
    ] = None
    affected_component_names: Annotated[
        list[str],
        Field(
            alias="affectedComponentNames",
            description="Display names of components affected by this incident (deduplicated)",
        ),
    ]


class DekRotationResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    previous_dek_version: Annotated[
        int,
        Field(alias="previousDekVersion", description="DEK version before rotation"),
    ]
    new_dek_version: Annotated[
        int, Field(alias="newDekVersion", description="DEK version after rotation")
    ]
    secrets_re_encrypted: Annotated[
        int,
        Field(
            alias="secretsReEncrypted",
            description="Number of secrets re-encrypted with the new DEK",
        ),
    ]
    channels_re_encrypted: Annotated[
        int,
        Field(
            alias="channelsReEncrypted",
            description="Number of alert channels re-encrypted with the new DEK",
        ),
    ]
    rotated_at: Annotated[
        AwareDatetime,
        Field(
            alias="rotatedAt", description="Timestamp when the rotation was performed"
        ),
    ]


class DeleteChannelResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    affected_policies: Annotated[
        int,
        Field(
            alias="affectedPolicies",
            description="Number of notification policies whose escalation steps were modified",
        ),
    ]
    disabled_policies: Annotated[
        int,
        Field(
            alias="disabledPolicies",
            description="Number of notification policies disabled because they had no remaining channels",
        ),
    ]


class DeliveryAttemptDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    delivery_id: Annotated[UUID, Field(alias="deliveryId")]
    attempt_number: Annotated[
        int, Field(alias="attemptNumber", description="1-based attempt number")
    ]
    status: Annotated[
        str, Field(description="Outcome: SUCCESS, FAILED, TIMEOUT, ERROR")
    ]
    response_status_code: Annotated[
        int | None,
        Field(
            alias="responseStatusCode",
            description="HTTP response status code from the external service",
        ),
    ] = None
    request_payload: Annotated[
        str | None,
        Field(
            alias="requestPayload",
            description="JSON payload sent to the external service",
        ),
    ] = None
    response_body: Annotated[
        str | None,
        Field(
            alias="responseBody",
            description="Response body from the external service (truncated)",
        ),
    ] = None
    error_message: Annotated[
        str | None,
        Field(alias="errorMessage", description="Error message if the attempt failed"),
    ] = None
    response_time_ms: Annotated[
        int | None,
        Field(alias="responseTimeMs", description="Round-trip time in milliseconds"),
    ] = None
    external_id: Annotated[
        str | None,
        Field(
            alias="externalId",
            description="External identifier (e.g. PagerDuty dedup_key, SES MessageId, webhook delivery UUID)",
        ),
    ] = None
    request_headers: Annotated[
        dict[str, str] | None,
        Field(
            alias="requestHeaders",
            description="HTTP request headers sent to the external service",
        ),
    ] = None
    attempted_at: Annotated[AwareDatetime, Field(alias="attemptedAt")]


class DeployLockDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique lock identifier")]
    locked_by: Annotated[
        str,
        Field(
            alias="lockedBy",
            description="Identity of the lock holder (e.g. CLI session ID, username)",
            min_length=1,
        ),
    ]
    locked_at: Annotated[
        AwareDatetime,
        Field(alias="lockedAt", description="Timestamp when the lock was acquired"),
    ]
    expires_at: Annotated[
        AwareDatetime,
        Field(
            alias="expiresAt",
            description="Timestamp when the lock automatically expires",
        ),
    ]


class DiscordChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["discord"], Field(alias="channelType")] = "discord"
    webhook_url: Annotated[
        str, Field(alias="webhookUrl", description="Discord webhook URL", min_length=1)
    ]
    mention_role_id: Annotated[
        str | None,
        Field(
            alias="mentionRoleId",
            description="Optional Discord role ID to mention in notifications",
        ),
    ] = None


class Dns(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    check_type: Literal["dns"] = "dns"
    hostname: Annotated[str | None, Field(description="Target hostname")] = None
    requested_types: Annotated[
        list[str] | None,
        Field(alias="requestedTypes", description="Requested DNS record types"),
    ] = None
    used_resolver: Annotated[
        str | None, Field(alias="usedResolver", description="Resolver used for lookup")
    ] = None
    records: Annotated[
        dict[str, list[dict[str, dict[str, Any]]]] | None,
        Field(description="Resolved DNS records keyed by record type"),
    ] = None
    attempts: Annotated[
        list[dict[str, dict[str, Any]]] | None,
        Field(description="DNS resolution attempts"),
    ] = None
    failure_kind: Annotated[
        str | None,
        Field(alias="failureKind", description="Kind of DNS failure, if any"),
    ] = None


class DnsExpectedCnameAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_expected_cname"] = "dns_expected_cname"
    value: Annotated[
        str,
        Field(
            description="Expected CNAME target the resolution must include",
            min_length=1,
        ),
    ]


class DnsExpectedIpsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_expected_ips"] = "dns_expected_ips"
    ips: Annotated[
        list[str],
        Field(
            description="Allowed IP addresses; at least one resolved address must match",
            min_length=1,
        ),
    ]


class DnsMaxAnswersAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_max_answers"] = "dns_max_answers"
    record_type: Annotated[
        str,
        Field(
            alias="recordType",
            description="DNS record type whose answer count is checked",
            min_length=1,
        ),
    ]
    max: Annotated[
        int, Field(description="Maximum number of answers allowed for that record type")
    ]


class DnsMinAnswersAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_min_answers"] = "dns_min_answers"
    record_type: Annotated[
        str,
        Field(
            alias="recordType",
            description="DNS record type whose answer count is checked",
            min_length=1,
        ),
    ]
    min: Annotated[
        int,
        Field(description="Minimum number of answers required for that record type"),
    ]


class RecordType(StrEnum):
    a = "A"
    aaaa = "AAAA"
    cname = "CNAME"
    mx = "MX"
    ns = "NS"
    txt = "TXT"
    srv = "SRV"
    soa = "SOA"
    caa = "CAA"
    ptr = "PTR"


class DnsMonitorConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    hostname: Annotated[str, Field(description="Domain name to resolve", min_length=1)]
    record_types: Annotated[
        list[RecordType] | None,
        Field(
            alias="recordTypes",
            description="DNS record types to query: A, AAAA, CNAME, MX, NS, TXT, SRV, SOA, CAA, PTR",
        ),
    ] = None
    nameservers: Annotated[
        list[str] | None,
        Field(
            description="Custom nameservers to query (uses system defaults if omitted)"
        ),
    ] = None
    timeout_ms: Annotated[
        int | None,
        Field(alias="timeoutMs", description="Per-query timeout in milliseconds"),
    ] = None
    total_timeout_ms: Annotated[
        int | None,
        Field(
            alias="totalTimeoutMs",
            description="Total timeout for all queries in milliseconds",
        ),
    ] = None


class DnsRecordContainsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_record_contains"] = "dns_record_contains"
    record_type: Annotated[
        str,
        Field(
            alias="recordType",
            description="DNS record type to assert on (A, AAAA, CNAME, MX, TXT)",
            min_length=1,
        ),
    ]
    substring: Annotated[
        str,
        Field(
            description="Substring that must appear in a matching record value",
            min_length=1,
        ),
    ]


class DnsRecordEqualsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_record_equals"] = "dns_record_equals"
    record_type: Annotated[
        str,
        Field(
            alias="recordType",
            description="DNS record type to assert on (A, AAAA, CNAME, MX, TXT)",
            min_length=1,
        ),
    ]
    value: Annotated[
        str,
        Field(description="Expected DNS record value for an exact match", min_length=1),
    ]


class DnsResolvesAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_resolves"] = "dns_resolves"


class DnsResponseTimeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_response_time"] = "dns_response_time"
    max_ms: Annotated[
        int,
        Field(
            alias="maxMs",
            description="Maximum allowed DNS resolution time in milliseconds",
        ),
    ]


class DnsResponseTimeWarnAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_response_time_warn"] = "dns_response_time_warn"
    warn_ms: Annotated[
        int,
        Field(
            alias="warnMs",
            description="DNS resolution time in milliseconds that triggers a warning only",
        ),
    ]


class DnsTtlHighAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_ttl_high"] = "dns_ttl_high"
    max_ttl: Annotated[
        int,
        Field(
            alias="maxTtl",
            description="Maximum TTL in seconds before a high-TTL warning is raised",
        ),
    ]


class DnsTtlLowAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_ttl_low"] = "dns_ttl_low"
    min_ttl: Annotated[
        int,
        Field(
            alias="minTtl",
            description="Minimum acceptable TTL in seconds before a warning is raised",
        ),
    ]


class DnsTxtContainsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["dns_txt_contains"] = "dns_txt_contains"
    substring: Annotated[
        str,
        Field(
            description="Substring that must appear in at least one TXT record",
            min_length=1,
        ),
    ]


class EmailChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["email"], Field(alias="channelType")] = "email"
    recipients: Annotated[
        list[EmailStr],
        Field(description="Email addresses to send notifications to", min_length=1),
    ]


class EntitlementDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    key: Annotated[str, Field(description="Entitlement key")]
    value: Annotated[
        int, Field(description="Effective limit value (overrides applied)")
    ]
    default_value: Annotated[
        int,
        Field(
            alias="defaultValue", description="Plan-tier default value before overrides"
        ),
    ]
    overridden: Annotated[
        bool, Field(description="Whether this entitlement has an org-level override")
    ]


class EnvironmentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique environment identifier")]
    org_id: Annotated[
        int,
        Field(alias="orgId", description="Organization this environment belongs to"),
    ]
    name: Annotated[
        str, Field(description="Human-readable environment name", min_length=1)
    ]
    slug: Annotated[str, Field(description="URL-safe identifier", min_length=1)]
    variables: Annotated[
        dict[str, str],
        Field(description="Key-value variable pairs available for interpolation"),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt", description="Timestamp when the environment was created"
        ),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt",
            description="Timestamp when the environment was last updated",
        ),
    ]
    monitor_count: Annotated[
        int,
        Field(
            alias="monitorCount",
            description="Number of monitors using this environment",
        ),
    ]
    is_default: Annotated[
        bool,
        Field(
            alias="isDefault",
            description="Whether this is the default environment for new monitors",
        ),
    ]


class ErrorEntry(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    code: Annotated[
        str,
        Field(
            description="Stable machine-readable code; see ValidationErrorCode for the registry",
            examples=["MONITOR_HEARTBEAT_GRACE_EXCEEDS_INTERVAL"],
            min_length=1,
        ),
    ]
    field: Annotated[
        str | None,
        Field(
            description="JSON-pointer-like path to the offending field, or null for request-wide errors",
            examples=["config.gracePeriod"],
        ),
    ] = None
    message: Annotated[
        str,
        Field(
            description="Human-readable message; safe to surface to end users",
            min_length=1,
        ),
    ]


class ErrorResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status: Annotated[
        int,
        Field(
            description="HTTP status code (mirrors the response status line)",
            examples=[404],
        ),
    ]
    code: Annotated[
        str,
        Field(
            description="Coarse machine-readable error category (e.g. NOT_FOUND, RATE_LIMITED); stable per status",
            examples=["NOT_FOUND"],
        ),
    ]
    message: Annotated[
        str,
        Field(
            description="Human-readable error message; safe to surface to end users",
            examples=["Monitor not found"],
        ),
    ]
    timestamp: Annotated[
        int,
        Field(
            description="Server time when the error was produced (epoch milliseconds)",
            examples=[1737302400000],
        ),
    ]
    request_id: Annotated[
        str | None,
        Field(
            alias="requestId",
            description="Opaque per-request id; same value as the X-Request-Id response header. Use in support tickets.",
            examples=["5b6f7a8c-1234-4d5e-9f0a-1b2c3d4e5f6a"],
        ),
    ] = None
    errors: Annotated[
        list[ErrorEntry] | None,
        Field(
            description="Structured per-field rejections; populated for validation errors, null otherwise"
        ),
    ] = None


class EscalationStep(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    delay_minutes: Annotated[
        int,
        Field(
            alias="delayMinutes",
            description="Minutes to wait before executing this step (0 = immediate)",
            ge=0,
        ),
    ]
    channel_ids: Annotated[
        list[UUID],
        Field(
            alias="channelIds",
            description="Alert channel IDs to notify in this step",
            min_length=1,
        ),
    ]
    require_ack: Annotated[
        bool | None,
        Field(
            alias="requireAck",
            description="Whether an acknowledgment is required before escalating",
        ),
    ] = None
    repeat_interval_seconds: Annotated[
        int | None,
        Field(
            alias="repeatIntervalSeconds",
            description="Repeat notification interval in seconds until acknowledged",
            ge=1,
        ),
    ] = None


class FailureDetail(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    monitor_id: Annotated[
        UUID, Field(alias="monitorId", description="Monitor ID that failed")
    ]
    reason: Annotated[str, Field(description="Human-readable reason for the failure")]


class GroupComponentOrder(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    group_id: Annotated[
        UUID, Field(alias="groupId", description="Group these components belong to")
    ]
    positions: Annotated[
        list[ComponentPosition],
        Field(
            description="Ordered component IDs with their within-group display order",
            min_length=1,
        ),
    ]


class HeaderAuthConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["header"] = "header"
    header_name: Annotated[
        str,
        Field(
            alias="headerName",
            description="Custom HTTP header name for the secret value",
            min_length=1,
            pattern="^[A-Za-z0-9\\-_]+$",
        ),
    ]
    vault_secret_id: Annotated[
        UUID | None,
        Field(
            alias="vaultSecretId", description="Vault secret ID for the header value"
        ),
    ] = None


class Operator(StrEnum):
    equals = "equals"
    contains = "contains"
    less_than = "less_than"
    greater_than = "greater_than"
    matches = "matches"
    range = "range"


class HeaderValueAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["header_value"] = "header_value"
    header_name: Annotated[
        str,
        Field(
            alias="headerName",
            description="HTTP header name to assert on",
            min_length=1,
        ),
    ]
    expected: Annotated[
        str, Field(description="Expected value to compare against", min_length=1)
    ]
    operator: Annotated[
        Operator,
        Field(
            description="Comparison operator (equals, contains, less_than, greater_than, etc.)"
        ),
    ]


class HeartbeatIntervalDriftAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["heartbeat_interval_drift"] = "heartbeat_interval_drift"
    max_deviation_percent: Annotated[
        int,
        Field(
            alias="maxDeviationPercent",
            description="Max percent drift from expected ping interval before warning (non-fatal)",
            ge=1,
            le=100,
        ),
    ]


class HeartbeatMaxIntervalAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["heartbeat_max_interval"] = "heartbeat_max_interval"
    max_seconds: Annotated[
        int,
        Field(
            alias="maxSeconds",
            description="Maximum allowed gap in seconds between consecutive heartbeat pings",
            ge=1,
        ),
    ]


class HeartbeatMonitorConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    expected_interval: Annotated[
        int,
        Field(
            alias="expectedInterval",
            description="Expected heartbeat interval in seconds",
            ge=1,
            le=86400,
        ),
    ]
    grace_period: Annotated[
        int,
        Field(
            alias="gracePeriod",
            description="Grace period in seconds before marking as down",
            ge=1,
        ),
    ]


class HeartbeatPayloadContainsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["heartbeat_payload_contains"] = "heartbeat_payload_contains"
    path: Annotated[
        str,
        Field(
            description="JSONPath expression into the heartbeat ping JSON payload",
            min_length=1,
        ),
    ]
    value: Annotated[
        str, Field(description="Expected value to compare against at that path")
    ]


class HeartbeatPingResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    ok: Annotated[
        bool, Field(description="Always true on a 2xx response", examples=[True])
    ]


class HeartbeatReceivedAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["heartbeat_received"] = "heartbeat_received"


class Method(StrEnum):
    get = "GET"
    post = "POST"
    put = "PUT"
    patch = "PATCH"
    delete = "DELETE"
    head = "HEAD"


class HttpMonitorConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    url: Annotated[
        str, Field(description="Target URL to send requests to", min_length=1)
    ]
    method: Annotated[
        Method, Field(description="HTTP method: GET, POST, PUT, PATCH, DELETE, or HEAD")
    ]
    custom_headers: Annotated[
        dict[str, str] | None,
        Field(
            alias="customHeaders",
            description="Additional HTTP headers to include in requests",
        ),
    ] = None
    request_body: Annotated[
        str | None,
        Field(
            alias="requestBody",
            description="Request body content for POST/PUT/PATCH methods",
        ),
    ] = None
    content_type: Annotated[
        str | None,
        Field(
            alias="contentType",
            description="Content-Type header value for the request body",
        ),
    ] = None
    verify_tls: Annotated[
        bool | None,
        Field(
            alias="verifyTls",
            description="Whether to verify TLS certificates (default: true)",
        ),
    ] = None


class Icmp(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    check_type: Literal["icmp"] = "icmp"
    host: Annotated[str, Field(description="Target host", examples=["1.1.1.1"])]
    packets_sent: Annotated[
        int | None,
        Field(alias="packetsSent", description="Number of ICMP packets sent"),
    ] = None
    packets_received: Annotated[
        int | None,
        Field(alias="packetsReceived", description="Number of ICMP packets received"),
    ] = None
    packet_loss: Annotated[
        float | None,
        Field(alias="packetLoss", description="Packet loss percentage", examples=[0]),
    ] = None
    avg_rtt_ms: Annotated[
        float | None,
        Field(alias="avgRttMs", description="Average round-trip time in ms"),
    ] = None
    min_rtt_ms: Annotated[
        float | None,
        Field(alias="minRttMs", description="Minimum round-trip time in ms"),
    ] = None
    max_rtt_ms: Annotated[
        float | None,
        Field(alias="maxRttMs", description="Maximum round-trip time in ms"),
    ] = None
    jitter_ms: Annotated[
        float | None, Field(alias="jitterMs", description="Jitter in ms")
    ] = None


class IcmpMonitorConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    host: Annotated[
        str, Field(description="Target hostname or IP address to ping", min_length=1)
    ]
    packet_count: Annotated[
        int | None,
        Field(
            alias="packetCount",
            description="Number of ICMP packets to send",
            ge=1,
            le=20,
        ),
    ] = None
    timeout_ms: Annotated[
        int | None, Field(alias="timeoutMs", description="Ping timeout in milliseconds")
    ] = None


class IcmpPacketLossAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["icmp_packet_loss"] = "icmp_packet_loss"
    max_percent: Annotated[
        float,
        Field(
            alias="maxPercent",
            description="Maximum allowed packet loss percentage before the check fails (0–100)",
            ge=0.0,
            le=100.0,
        ),
    ]


class IcmpReachableAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["icmp_reachable"] = "icmp_reachable"


class IcmpResponseTimeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["icmp_response_time"] = "icmp_response_time"
    max_ms: Annotated[
        int,
        Field(
            alias="maxMs",
            description="Maximum average ICMP round-trip time in milliseconds",
        ),
    ]


class IcmpResponseTimeWarnAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["icmp_response_time_warn"] = "icmp_response_time_warn"
    warn_ms: Annotated[
        int,
        Field(
            alias="warnMs",
            description="ICMP round-trip time in milliseconds that triggers a warning only",
        ),
    ]


class IncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique incident identifier")]
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Monitor that triggered the incident; null for service or manual incidents",
        ),
    ] = None
    organization_id: Annotated[
        int,
        Field(
            alias="organizationId", description="Organization this incident belongs to"
        ),
    ]
    source: Annotated[
        str, Field(description="Incident origin: MONITOR, SERVICE, or MANUAL")
    ]
    status: Annotated[
        str, Field(description="Current lifecycle status (OPEN, RESOLVED, etc.)")
    ]
    severity: Annotated[
        str, Field(description="Severity level: DOWN, DEGRADED, or MAINTENANCE")
    ]
    title: Annotated[
        str | None,
        Field(
            description="Short summary of the incident; null for auto-generated incidents"
        ),
    ] = None
    triggered_by_rule: Annotated[
        str | None,
        Field(
            alias="triggeredByRule",
            description="Human-readable description of the trigger rule that fired",
        ),
    ] = None
    affected_regions: Annotated[
        list[str],
        Field(
            alias="affectedRegions",
            description="Probe regions that observed the failure",
        ),
    ]
    reopen_count: Annotated[
        int,
        Field(
            alias="reopenCount",
            description="Number of times this incident has been reopened",
        ),
    ]
    created_by_user_id: Annotated[
        int | None,
        Field(
            alias="createdByUserId",
            description="User who created the incident (manual incidents only)",
        ),
    ] = None
    status_page_visible: Annotated[
        bool,
        Field(
            alias="statusPageVisible",
            description="Whether this incident is visible on the status page",
        ),
    ]
    service_incident_id: Annotated[
        UUID | None,
        Field(
            alias="serviceIncidentId",
            description="Linked vendor service incident ID; null for monitor incidents",
        ),
    ] = None
    service_id: Annotated[
        UUID | None,
        Field(
            alias="serviceId",
            description="Linked service catalog ID; null for monitor incidents",
        ),
    ] = None
    external_ref: Annotated[
        str | None,
        Field(
            alias="externalRef",
            description="External reference ID (e.g. PagerDuty incident ID)",
        ),
    ] = None
    affected_components: Annotated[
        list[str] | None,
        Field(
            alias="affectedComponents",
            description="Service components affected by this incident",
        ),
    ] = None
    shortlink: Annotated[
        str | None, Field(description="Short URL linking to the incident details")
    ] = None
    resolution_reason: Annotated[
        str | None,
        Field(
            alias="resolutionReason",
            description="How the incident was resolved (AUTO_RECOVERED, MANUAL, etc.)",
        ),
    ] = None
    started_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="startedAt",
            description="Timestamp when the incident was detected or created",
        ),
    ] = None
    confirmed_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="confirmedAt",
            description="Timestamp when the incident was confirmed (multi-region confirmation)",
        ),
    ] = None
    resolved_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="resolvedAt", description="Timestamp when the incident was resolved"
        ),
    ] = None
    cooldown_until: Annotated[
        AwareDatetime | None,
        Field(
            alias="cooldownUntil",
            description="Cooldown window end; new incidents suppressed until this time",
        ),
    ] = None
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt",
            description="Timestamp when the incident record was created",
        ),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt",
            description="Timestamp when the incident was last updated",
        ),
    ]
    monitor_name: Annotated[
        str | None,
        Field(
            alias="monitorName",
            description="Name of the associated monitor; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null.",
        ),
    ] = None
    service_name: Annotated[
        str | None,
        Field(
            alias="serviceName",
            description="Name of the associated service; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null.",
        ),
    ] = None
    service_slug: Annotated[
        str | None,
        Field(
            alias="serviceSlug",
            description="Slug of the associated service; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null.",
        ),
    ] = None
    monitor_type: Annotated[
        str | None,
        Field(
            alias="monitorType",
            description="Type of the associated monitor; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null.",
        ),
    ] = None
    resource_group_id: Annotated[
        UUID | None,
        Field(
            alias="resourceGroupId",
            description="Resource group that owns this incident; null when not group-managed",
        ),
    ] = None
    resource_group_name: Annotated[
        str | None,
        Field(
            alias="resourceGroupName",
            description="Name of the resource group; populated on list responses. Omitted from JSON (undefined to SDKs) on detail responses, treat missing as null.",
        ),
    ] = None
    triggering_check_id: Annotated[
        UUID | None,
        Field(
            alias="triggeringCheckId",
            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.",
        ),
    ] = None
    triggered_by_rule_snapshot_hash_hex: Annotated[
        str | None,
        Field(
            alias="triggeredByRuleSnapshotHashHex",
            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.",
        ),
    ] = None
    triggered_by_rule_index: Annotated[
        int | None,
        Field(
            alias="triggeredByRuleIndex",
            description="Index of the fired rule inside the policy's trigger_rules array. Omitted from JSON when null, treat missing as null.",
        ),
    ] = None
    engine_version: Annotated[
        str | None,
        Field(
            alias="engineVersion",
            description="Detection engine semver that evaluated the rule. Omitted from JSON when null, treat missing as null.",
        ),
    ] = None


class Status5(StrEnum):
    watching = "WATCHING"
    triggered = "TRIGGERED"
    confirmed = "CONFIRMED"
    resolved = "RESOLVED"


class Source(StrEnum):
    automatic = "AUTOMATIC"
    manual = "MANUAL"
    monitors = "MONITORS"
    status_data = "STATUS_DATA"
    resource_group = "RESOURCE_GROUP"


class IncidentFilterParams(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status: Annotated[
        Status5 | None,
        Field(
            description="Filter by incident lifecycle status; null returns every status"
        ),
    ] = None
    severity: Annotated[
        Severity1 | None,
        Field(description="Filter by severity; null returns every severity"),
    ] = None
    source: Annotated[
        Source | None,
        Field(
            description="Filter by where the incident originated (auto, manual, third-party)"
        ),
    ] = None
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Only return incidents tied to this monitor ID",
        ),
    ] = None
    service_id: Annotated[
        UUID | None,
        Field(
            alias="serviceId",
            description="Only return incidents tied to this service ID (third-party services)",
        ),
    ] = None
    resource_group_id: Annotated[
        UUID | None,
        Field(
            alias="resourceGroupId",
            description="Only return incidents whose monitor belongs to this resource group",
        ),
    ] = None
    tag_id: Annotated[
        UUID | None,
        Field(
            alias="tagId",
            description="Only return incidents whose monitor carries this tag",
        ),
    ] = None
    environment_id: Annotated[
        UUID | None,
        Field(
            alias="environmentId",
            description="Only return incidents whose monitor lives in this environment",
        ),
    ] = None
    started_from: Annotated[
        AwareDatetime | None,
        Field(
            alias="startedFrom",
            description="Earliest startedAt to include (inclusive, ISO 8601)",
        ),
    ] = None
    started_to: Annotated[
        AwareDatetime | None,
        Field(
            alias="startedTo",
            description="Latest startedAt to include (inclusive, ISO 8601)",
        ),
    ] = None
    page: Annotated[
        int, Field(description="Zero-based page index (default: 0)", examples=[0], ge=0)
    ]
    size: Annotated[
        int,
        Field(
            description="Number of incidents per page (1–200, default: 10)",
            examples=[10],
            ge=1,
            le=200,
        ),
    ]


class IncidentRef(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[
        UUID,
        Field(
            description="Internal incident ID — UUID for status-page incidents, service incident UUID for catalog"
        ),
    ]
    title: Annotated[
        str, Field(description="Incident title at the time of the overlap")
    ]
    impact: Annotated[
        str,
        Field(
            description="Incident impact level (e.g. minor, major, critical for catalog; NONE/MINOR/MAJOR/CRITICAL for status pages)"
        ),
    ]


class IncidentsSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    active: int
    resolved_today: Annotated[int, Field(alias="resolvedToday")]
    mttr30d: float | None = None


class IncidentUpdateDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    incident_id: Annotated[UUID, Field(alias="incidentId")]
    old_status: Annotated[str | None, Field(alias="oldStatus")] = None
    new_status: Annotated[str | None, Field(alias="newStatus")] = None
    body: str | None = None
    created_by: Annotated[str | None, Field(alias="createdBy")] = None
    notify_subscribers: Annotated[bool, Field(alias="notifySubscribers")]
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]


class IntegrationFieldDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    key: str
    label: str
    type: str
    required: bool
    sensitive: bool
    placeholder: str | None = None
    help_text: Annotated[str | None, Field(alias="helpText")] = None
    options: list[str] | None = None
    default: str | None = None


class InviteDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    invite_id: Annotated[
        int, Field(alias="inviteId", description="Unique invite identifier")
    ]
    email: Annotated[str, Field(description="Email address the invite was sent to")]
    role_offered: Annotated[
        str,
        Field(
            alias="roleOffered",
            description="Role that will be assigned to the invitee on acceptance",
        ),
    ]
    expires_at: Annotated[
        AwareDatetime,
        Field(alias="expiresAt", description="Timestamp when the invite expires"),
    ]
    consumed_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="consumedAt",
            description="Timestamp when the invite was accepted; null if not yet used",
        ),
    ] = None
    revoked_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="revokedAt",
            description="Timestamp when the invite was revoked; null if active",
        ),
    ] = None


class JsonPathAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["json_path"] = "json_path"
    path: Annotated[
        str,
        Field(
            description="JSONPath expression to extract a value from the response body",
            min_length=1,
        ),
    ]
    expected: Annotated[
        str, Field(description="Expected value to compare against", min_length=1)
    ]
    operator: Annotated[
        Operator,
        Field(
            description="Comparison operator (equals, contains, less_than, greater_than, etc.)"
        ),
    ]


class KeyInfo(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Key ID")]
    name: Annotated[str, Field(description="Human-readable key name")]
    created_at: Annotated[
        AwareDatetime, Field(alias="createdAt", description="When the key was created")
    ]
    expires_at: Annotated[
        AwareDatetime | None,
        Field(alias="expiresAt", description="When the key expires (null = never)"),
    ] = None
    last_used_at: Annotated[
        AwareDatetime | None,
        Field(alias="lastUsedAt", description="Last time the key was used"),
    ] = None


class LinkedStatusPageIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    status_page_id: Annotated[UUID, Field(alias="statusPageId")]
    status_page_name: Annotated[str, Field(alias="statusPageName")]
    status_page_slug: Annotated[str, Field(alias="statusPageSlug")]
    title: str
    status: str
    impact: str
    scheduled: bool
    published_at: Annotated[AwareDatetime | None, Field(alias="publishedAt")] = None


class MaintenanceComponentRef(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Component identifier")]
    name: Annotated[str, Field(description="Component name")]
    status: Annotated[
        str, Field(description="Component status at the time of the maintenance update")
    ]


class MaintenanceUpdateDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique update identifier")]
    status: Annotated[str, Field(description="Status at the time of this update")]
    body: Annotated[str | None, Field(description="Update message from the vendor")] = (
        None
    )
    display_at: Annotated[
        AwareDatetime | None,
        Field(alias="displayAt", description="Timestamp when this update was posted"),
    ] = None


class MaintenanceWindowDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique maintenance window identifier")]
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Monitor this window applies to; null for org-wide windows",
        ),
    ] = None
    organization_id: Annotated[
        int,
        Field(
            alias="organizationId",
            description="Organization this maintenance window belongs to",
        ),
    ]
    starts_at: Annotated[
        AwareDatetime,
        Field(
            alias="startsAt", description="Scheduled start of the maintenance window"
        ),
    ]
    ends_at: Annotated[
        AwareDatetime,
        Field(alias="endsAt", description="Scheduled end of the maintenance window"),
    ]
    repeat_rule: Annotated[
        str | None,
        Field(
            alias="repeatRule",
            description="Reserved: iCal RRULE for recurring windows (stored but not yet honored)",
        ),
    ] = None
    reason: Annotated[
        str | None, Field(description="Human-readable reason for the maintenance")
    ] = None
    suppress_alerts: Annotated[
        bool,
        Field(
            alias="suppressAlerts",
            description="Whether alerts are suppressed during this window",
        ),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the window was created"),
    ]


class Type2(StrEnum):
    severity_gte = "severity_gte"
    monitor_id_in = "monitor_id_in"
    region_in = "region_in"
    incident_status = "incident_status"
    monitor_type_in = "monitor_type_in"
    service_id_in = "service_id_in"
    resource_group_id_in = "resource_group_id_in"
    component_name_in = "component_name_in"
    monitor_tag_in = "monitor_tag_in"


class MatchRule(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[
        Type2,
        Field(description="Rule type used to evaluate incidents and status events"),
    ]
    value: Annotated[
        str | None,
        Field(description="Comparison value for single-value rules like severity_gte"),
    ] = None
    monitor_ids: Annotated[
        list[UUID] | None,
        Field(
            alias="monitorIds",
            description="Monitor UUIDs to match for monitor_id_in rules",
        ),
    ] = None
    regions: Annotated[
        list[str] | None, Field(description="Region codes to match for region_in rules")
    ] = None
    values: Annotated[
        list[str] | None,
        Field(description="Values list for multi-value rules like monitor_type_in"),
    ] = None


class McpConnectsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_connects"] = "mcp_connects"


class McpHasCapabilityAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_has_capability"] = "mcp_has_capability"
    capability: Annotated[
        str,
        Field(
            description="Capability name the server must advertise, e.g. tools or resources",
            min_length=1,
        ),
    ]


class McpMinToolsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_min_tools"] = "mcp_min_tools"
    min: Annotated[
        int, Field(description="Minimum number of tools the server must expose")
    ]


class McpProtocolVersionAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_protocol_version"] = "mcp_protocol_version"
    version: Annotated[
        str,
        Field(
            description="Expected MCP protocol version string from the server handshake",
            min_length=1,
        ),
    ]


class McpResponseTimeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_response_time"] = "mcp_response_time"
    max_ms: Annotated[
        int,
        Field(
            alias="maxMs",
            description="Maximum allowed MCP check duration in milliseconds",
        ),
    ]


class McpResponseTimeWarnAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_response_time_warn"] = "mcp_response_time_warn"
    warn_ms: Annotated[
        int,
        Field(
            alias="warnMs",
            description="MCP check duration in milliseconds that triggers a warning only",
        ),
    ]


class McpServer(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    check_type: Literal["mcp_server"] = "mcp_server"
    url: Annotated[str | None, Field(description="MCP server URL")] = None
    protocol_version: Annotated[
        str | None, Field(alias="protocolVersion", description="MCP protocol version")
    ] = None
    server_info: Annotated[
        dict[str, dict[str, Any]] | None,
        Field(alias="serverInfo", description="MCP server info (name, version, etc.)"),
    ] = None
    tool_count: Annotated[
        int | None, Field(alias="toolCount", description="Number of tools exposed")
    ] = None
    resource_count: Annotated[
        int | None,
        Field(alias="resourceCount", description="Number of resources exposed"),
    ] = None
    prompt_count: Annotated[
        int | None, Field(alias="promptCount", description="Number of prompts exposed")
    ] = None


class McpServerMonitorConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    command: Annotated[
        str,
        Field(description="Command to execute to start the MCP server", min_length=1),
    ]
    args: Annotated[
        list[str] | None,
        Field(description="Command-line arguments for the MCP server process"),
    ] = None
    env: Annotated[
        dict[str, str] | None,
        Field(description="Environment variables to pass to the MCP server process"),
    ] = None


class McpToolAvailableAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_tool_available"] = "mcp_tool_available"
    tool_name: Annotated[
        str,
        Field(
            alias="toolName",
            description="MCP tool name that must appear in the server's tool list",
            min_length=1,
        ),
    ]


class McpToolCountChangedAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["mcp_tool_count_changed"] = "mcp_tool_count_changed"
    expected_count: Annotated[
        int,
        Field(
            alias="expectedCount",
            description="Expected tool count; warns when the live count differs",
        ),
    ]


class MemberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    user_id: Annotated[
        int, Field(alias="userId", description="User identifier of the member")
    ]
    email: Annotated[str, Field(description="Member email address")]
    name: Annotated[
        str | None, Field(description="Member display name; null if not set")
    ] = None
    org_role: Annotated[
        str,
        Field(
            alias="orgRole",
            description="Member role within this organization (OWNER, ADMIN, MEMBER)",
        ),
    ]
    status: Annotated[
        str, Field(description="Membership status (ACTIVE, PENDING, SUSPENDED)")
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt",
            description="Timestamp when the member was added to the organization",
        ),
    ]


class OldRole(StrEnum):
    owner = "OWNER"
    admin = "ADMIN"
    member = "MEMBER"


class NewRole(StrEnum):
    owner = "OWNER"
    admin = "ADMIN"
    member = "MEMBER"


class MemberRoleChangedMetadata(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    kind: Literal["member_role_changed"] = "member_role_changed"
    old_role: Annotated[
        OldRole,
        Field(alias="oldRole", description="Role the member held before the change"),
    ]
    new_role: Annotated[
        NewRole,
        Field(alias="newRole", description="Role the member holds after the change"),
    ]


class MonitorAuthConfig(
    RootModel[BearerAuthConfig | BasicAuthConfig | HeaderAuthConfig | ApiKeyAuthConfig]
):
    root: Annotated[
        BearerAuthConfig | BasicAuthConfig | HeaderAuthConfig | ApiKeyAuthConfig,
        Field(
            description="New authentication configuration (full replacement)",
            discriminator="type",
        ),
    ]


class MonitorAuthDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    monitor_id: Annotated[UUID, Field(alias="monitorId")]
    auth_type: Annotated[str, Field(alias="authType")]
    config: ApiKeyAuthConfig | BasicAuthConfig | BearerAuthConfig | HeaderAuthConfig


class MonitorReference(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Monitor identifier")]
    name: Annotated[str, Field(description="Monitor name")]


class MonitorsSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    total: Annotated[
        int, Field(description="Total number of monitors in the organization")
    ]
    up: Annotated[int, Field(description="Number of monitors currently passing")]
    down: Annotated[
        int, Field(description="Number of monitors currently failing (DOWN severity)")
    ]
    degraded: Annotated[
        int, Field(description="Number of monitors with degraded status")
    ]
    paused: Annotated[int, Field(description="Number of disabled monitors")]
    avg_uptime24h: Annotated[
        float | None,
        Field(
            alias="avgUptime24h",
            description="Average uptime percentage across all monitors over last 24h",
        ),
    ] = None
    avg_uptime30d: Annotated[
        float | None,
        Field(
            alias="avgUptime30d",
            description="Average uptime percentage across all monitors over last 30 days",
        ),
    ] = None


class Type3(StrEnum):
    http = "HTTP"
    dns = "DNS"
    mcp_server = "MCP_SERVER"
    tcp = "TCP"
    icmp = "ICMP"
    heartbeat = "HEARTBEAT"


class MonitorTestResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    passed: bool
    error: str | None = None
    status_code: Annotated[int | None, Field(alias="statusCode")] = None
    response_time_ms: Annotated[int | None, Field(alias="responseTimeMs")] = None
    response_headers: Annotated[
        dict[str, list[str]] | None, Field(alias="responseHeaders")
    ] = None
    body_preview: Annotated[str | None, Field(alias="bodyPreview")] = None
    response_size_bytes: Annotated[int | None, Field(alias="responseSizeBytes")] = None
    redirect_count: Annotated[int | None, Field(alias="redirectCount")] = None
    final_url: Annotated[str | None, Field(alias="finalUrl")] = None
    assertion_results: Annotated[
        list[AssertionTestResultDto], Field(alias="assertionResults")
    ]
    warnings: list[str] | None = None


class NewTagRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[str, Field(description="Tag name", max_length=100, min_length=0)]
    color: Annotated[
        str | None,
        Field(
            description="Hex color code (defaults to #6B7280 if omitted)",
            pattern="^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$",
        ),
    ] = None


class NotificationDispatchDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique dispatch record identifier")]
    incident_id: Annotated[
        UUID, Field(alias="incidentId", description="Incident this dispatch is for")
    ]
    policy_id: Annotated[
        UUID,
        Field(
            alias="policyId",
            description="Notification policy that matched this incident",
        ),
    ]
    policy_name: Annotated[
        str | None,
        Field(
            alias="policyName",
            description="Human-readable name of the matched policy (null if policy has been deleted)",
        ),
    ] = None
    status: Annotated[str, Field(description="Current dispatch state")]
    completion_reason: Annotated[
        str | None,
        Field(
            alias="completionReason",
            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.",
        ),
    ] = None
    current_step: Annotated[
        int,
        Field(
            alias="currentStep",
            description="1-based index of the currently active escalation step",
        ),
    ]
    total_steps: Annotated[
        int | None,
        Field(
            alias="totalSteps",
            description="Total number of escalation steps in the policy (null if policy has been deleted)",
        ),
    ] = None
    acknowledged_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="acknowledgedAt",
            description="Timestamp when this dispatch was acknowledged (null if not acknowledged)",
        ),
    ] = None
    next_escalation_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="nextEscalationAt",
            description="Timestamp when the next escalation step will fire (null if not scheduled)",
        ),
    ] = None
    last_notified_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="lastNotifiedAt",
            description="Timestamp of the most recent notification delivery",
        ),
    ] = None
    deliveries: Annotated[
        list[AlertDeliveryDto],
        Field(
            description="Delivery records for all channels associated with this dispatch"
        ),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the dispatch was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt",
            description="Timestamp when the dispatch was last updated",
        ),
    ]


class NotificationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Unique notification identifier")]
    type: Annotated[
        str, Field(description="Notification category (e.g. incident, monitor, team)")
    ]
    title: Annotated[str, Field(description="Short notification title")]
    body: Annotated[
        str | None,
        Field(description="Full notification body; null for title-only notifications"),
    ] = None
    resource_type: Annotated[
        str | None,
        Field(
            alias="resourceType",
            description="Type of the resource this notification is about",
        ),
    ] = None
    resource_id: Annotated[
        str | None,
        Field(
            alias="resourceId",
            description="ID of the resource this notification is about",
        ),
    ] = None
    read: Annotated[bool, Field(description="Whether the notification has been read")]
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt", description="Timestamp when the notification was created"
        ),
    ]


class OpsGenieChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["opsgenie"], Field(alias="channelType")] = (
        "opsgenie"
    )
    api_key: Annotated[
        str,
        Field(
            alias="apiKey",
            description="OpsGenie API key for alert creation",
            min_length=1,
        ),
    ]
    region: Annotated[
        str | None, Field(description="OpsGenie API region: us or eu")
    ] = None


class OrganizationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Unique organization identifier")]
    name: Annotated[str, Field(description="Organization name")]
    email: Annotated[str, Field(description="Billing and contact email")]
    size: Annotated[
        str | None, Field(description="Team size range (e.g. 1-10, 11-50)")
    ] = None
    industry: Annotated[
        str | None, Field(description="Industry vertical (e.g. SaaS, Fintech)")
    ] = None
    website_url: Annotated[
        str | None, Field(alias="websiteUrl", description="Organization website URL")
    ] = None


class OrgInfo(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Organization ID")]
    name: Annotated[str, Field(description="Organization name")]


class Pageable(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    page: Annotated[int, Field(ge=0)]
    size: Annotated[int, Field(ge=1)]
    sort: list[str]


class PagerDutyChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["pagerduty"], Field(alias="channelType")] = (
        "pagerduty"
    )
    routing_key: Annotated[
        str,
        Field(
            alias="routingKey",
            description="PagerDuty Events API v2 routing (integration) key",
            min_length=1,
        ),
    ]
    severity_override: Annotated[
        str | None,
        Field(
            alias="severityOverride", description="Override PagerDuty severity mapping"
        ),
    ] = None


class PageSection(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    group_id: Annotated[
        UUID | None,
        Field(alias="groupId", description="Group ID when this section is a group"),
    ] = None
    component_id: Annotated[
        UUID | None,
        Field(
            alias="componentId",
            description="Component ID when this section is an ungrouped component",
        ),
    ] = None
    page_order: Annotated[
        int, Field(alias="pageOrder", description="Position on the page (0-based)")
    ]


class Tier(StrEnum):
    free = "FREE"
    starter = "STARTER"
    pro = "PRO"
    team = "TEAM"
    business = "BUSINESS"
    enterprise = "ENTERPRISE"


class PlanInfo(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    tier: Annotated[Tier, Field(description="Resolved plan tier")]
    subscription_status: Annotated[
        str | None,
        Field(
            alias="subscriptionStatus",
            description="Subscription status (null if no subscription)",
        ),
    ] = None
    trial_active: Annotated[
        bool, Field(alias="trialActive", description="Whether the org is on a trial")
    ]
    trial_expires_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="trialExpiresAt", description="Trial expiry (null if not trialing)"
        ),
    ] = None
    entitlements: Annotated[
        dict[str, EntitlementDto],
        Field(description="Entitlement limits keyed by entitlement name"),
    ]
    usage: Annotated[
        dict[str, int],
        Field(description="Current usage counters keyed by entitlement name"),
    ]


class PolicySnapshotDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    hash_hex: Annotated[
        str,
        Field(
            alias="hashHex",
            description="Hex-encoded SHA-256 of the canonical policy JSON",
            min_length=1,
        ),
    ]
    policy: Annotated[
        dict[str, dict[str, Any]],
        Field(description="Canonical policy document (snake_case, sorted keys)"),
    ]
    engine_version: Annotated[
        str,
        Field(
            alias="engineVersion",
            description="Detection engine version that observed this policy",
            min_length=1,
        ),
    ]
    first_seen_at: Annotated[
        AwareDatetime,
        Field(
            alias="firstSeenAt",
            description="First time the detection engine evaluated against this policy bytes",
        ),
    ]
    last_seen_at: Annotated[
        AwareDatetime,
        Field(
            alias="lastSeenAt",
            description="Most recent time the engine evaluated against this policy bytes",
        ),
    ]


class PollChartBucketDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    bucket: Annotated[
        AwareDatetime, Field(description="Start of the time bucket (ISO 8601)")
    ]
    uptime_percent: Annotated[
        float | None,
        Field(
            alias="uptimePercent",
            description="Uptime percentage for this bucket; null when no data",
            examples=[100],
        ),
    ] = None
    avg_response_time_ms: Annotated[
        float | None,
        Field(
            alias="avgResponseTimeMs",
            description="Average response time in milliseconds for this bucket",
            examples=[245.3],
        ),
    ] = None
    total_polls: Annotated[
        int,
        Field(
            alias="totalPolls", description="Total polls in this bucket", examples=[60]
        ),
    ]


class Status6(StrEnum):
    investigating = "INVESTIGATING"
    identified = "IDENTIFIED"
    monitoring = "MONITORING"
    resolved = "RESOLVED"


class PublishStatusPageIncidentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    title: Annotated[
        str | None,
        Field(
            description="Customer-facing title; null keeps draft value",
            max_length=500,
            min_length=0,
        ),
    ] = None
    impact: Annotated[
        Impact | None, Field(description="Impact level; null keeps draft value")
    ] = None
    status: Annotated[
        Status6 | None,
        Field(
            description="Incident status; null keeps draft value (must be an active status)"
        ),
    ] = None
    body: Annotated[
        str | None, Field(description="Initial update body; null keeps draft value")
    ] = None
    affected_components: Annotated[
        list[AffectedComponent] | None,
        Field(
            alias="affectedComponents",
            description="Affected components; null keeps draft value",
        ),
    ] = None
    notify_subscribers: Annotated[
        bool | None,
        Field(
            alias="notifySubscribers",
            description="Whether to notify subscribers (default: true)",
        ),
    ] = None


class RateLimitInfo(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    requests_per_minute: Annotated[
        int,
        Field(
            alias="requestsPerMinute", description="Maximum requests allowed per window"
        ),
    ]
    remaining: Annotated[
        int, Field(description="Requests remaining in the current window")
    ]
    window_ms: Annotated[
        int, Field(alias="windowMs", description="Sliding window size in milliseconds")
    ]


class RecoveryPolicy(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    consecutive_successes: Annotated[
        int,
        Field(
            alias="consecutiveSuccesses",
            description="Consecutive passing checks required to auto-resolve the incident",
        ),
    ]
    min_regions_passing: Annotated[
        int,
        Field(
            alias="minRegionsPassing",
            description="Minimum regions that must be passing before recovery can complete",
        ),
    ]
    cooldown_minutes: Annotated[
        int,
        Field(
            alias="cooldownMinutes",
            description="Minutes after resolve before a new incident may open on the same monitor",
        ),
    ]


class RedirectCountAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["redirect_count"] = "redirect_count"
    max_count: Annotated[
        int,
        Field(
            alias="maxCount",
            description="Maximum number of HTTP redirects allowed before the check fails",
        ),
    ]


class RedirectTargetAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["redirect_target"] = "redirect_target"
    expected: Annotated[
        str,
        Field(description="Expected final URL after following redirects", min_length=1),
    ]
    operator: Annotated[
        Operator,
        Field(
            description="Comparison operator (equals, contains, less_than, greater_than, etc.)"
        ),
    ]


class RegexBodyAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["regex_body"] = "regex_body"
    pattern: Annotated[
        str,
        Field(
            description="Regular expression the response body must match", min_length=1
        ),
    ]


class RegionStatusDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    region: Annotated[str, Field(description="Region identifier", examples=["us-east"])]
    passed: Annotated[
        bool,
        Field(
            description="Whether the last check in this region passed", examples=[True]
        ),
    ]
    response_time_ms: Annotated[
        int | None,
        Field(
            alias="responseTimeMs",
            description="Response time in milliseconds for the last check",
            examples=[95],
        ),
    ] = None
    timestamp: Annotated[
        AwareDatetime,
        Field(description="Timestamp of the last check in this region (ISO 8601)"),
    ]
    severity_hint: Annotated[
        str | None,
        Field(
            alias="severityHint",
            description="Severity hint: 'down' for hard failures, 'degraded' for warn-only failures, null when passing",
        ),
    ] = None


class RemoveMonitorTagsRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    tag_ids: Annotated[
        list[UUID],
        Field(
            alias="tagIds",
            description="IDs of the tags to detach from the monitor",
            min_length=1,
        ),
    ]


class ReorderComponentsRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    positions: Annotated[
        list[ComponentPosition],
        Field(
            description="Ordered list of component IDs with their new positions",
            min_length=1,
        ),
    ]


class ReorderPageLayoutRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    sections: Annotated[
        list[PageSection],
        Field(description="Top-level sections in their new order", min_length=1),
    ]
    group_orders: Annotated[
        list[GroupComponentOrder] | None,
        Field(
            alias="groupOrders",
            description="Within-group component ordering; only needed for groups whose internal order changed",
        ),
    ] = None


class ResolveIncidentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    body: Annotated[
        str | None,
        Field(description="Optional resolution message or post-mortem notes"),
    ] = None


class ResourceGroupHealthDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status: Annotated[
        str, Field(description="Worst-of health status across all members")
    ]
    total_members: Annotated[
        int,
        Field(alias="totalMembers", description="Total number of members in the group"),
    ]
    operational_count: Annotated[
        int,
        Field(
            alias="operationalCount",
            description="Number of members currently in operational status",
        ),
    ]
    active_incidents: Annotated[
        int,
        Field(
            alias="activeIncidents",
            description="Number of members with an active incident or non-operational status",
        ),
    ]
    threshold_status: Annotated[
        str | None,
        Field(
            alias="thresholdStatus",
            description="Computed group health status based on threshold: 'healthy', 'degraded', or 'down'. Null when no health threshold is configured.",
        ),
    ] = None
    failing_count: Annotated[
        int | None,
        Field(
            alias="failingCount",
            description="Number of failing members at time of last evaluation",
        ),
    ] = None


class ResourceGroupMemberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique group member record identifier")]
    group_id: Annotated[
        UUID,
        Field(alias="groupId", description="Resource group this member belongs to"),
    ]
    member_type: Annotated[
        str,
        Field(alias="memberType", description="Type of member: 'monitor' or 'service'"),
    ]
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Monitor ID; set when memberType is 'monitor'",
        ),
    ] = None
    service_id: Annotated[
        UUID | None,
        Field(
            alias="serviceId",
            description="Service ID; set when memberType is 'service'",
        ),
    ] = None
    name: Annotated[
        str | None,
        Field(description="Display name of the referenced monitor or service"),
    ] = None
    slug: Annotated[
        str | None,
        Field(
            description="Slug identifier for the service (services only); used for icons and uptime API calls"
        ),
    ] = None
    subscription_id: Annotated[
        UUID | None,
        Field(
            alias="subscriptionId",
            description="Subscription ID for the service (services only); used to link to the dependency detail page",
        ),
    ] = None
    status: Annotated[str, Field(description="Computed health status for this member")]
    effective_frequency: Annotated[
        str | None,
        Field(
            alias="effectiveFrequency",
            description="Effective check frequency label showing the group default when the monitor inherits it; null for services or when no group default is configured",
        ),
    ] = None
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt",
            description="Timestamp when the member was added to the group",
        ),
    ]
    uptime24h: Annotated[
        float | None,
        Field(description="24h uptime percentage; populated when includeMetrics=true"),
    ] = None
    chart_data: Annotated[
        list[float] | None,
        Field(
            alias="chartData",
            description="Uptime tick values (0-100) for last-24h mini chart; populated when includeMetrics=true",
        ),
    ] = None
    avg_latency_ms: Annotated[
        float | None,
        Field(
            alias="avgLatencyMs",
            description="Average latency in ms (monitors only); populated when includeMetrics=true",
        ),
    ] = None
    p95_latency_ms: Annotated[
        float | None,
        Field(
            alias="p95LatencyMs",
            description="P95 latency in ms (monitors only); populated when includeMetrics=true",
        ),
    ] = None
    last_checked_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="lastCheckedAt",
            description="Timestamp of the most recent health check; populated when includeMetrics=true",
        ),
    ] = None
    monitor_type: Annotated[
        str | None,
        Field(
            alias="monitorType",
            description="Monitor type (HTTP, DNS, TCP, ICMP, HEARTBEAT, MCP); monitors only",
        ),
    ] = None
    environment_name: Annotated[
        str | None,
        Field(alias="environmentName", description="Environment name; monitors only"),
    ] = None


class ResponseSizeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["response_size"] = "response_size"
    max_bytes: Annotated[
        int,
        Field(
            alias="maxBytes",
            description="Maximum response body size in bytes before the check fails",
        ),
    ]


class ResponseTimeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["response_time"] = "response_time"
    threshold_ms: Annotated[
        int,
        Field(
            alias="thresholdMs",
            description="Maximum allowed response time in milliseconds before the check fails",
        ),
    ]


class ResponseTimeWarnAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["response_time_warn"] = "response_time_warn"
    warn_ms: Annotated[
        int,
        Field(
            alias="warnMs",
            description="HTTP response time in milliseconds that triggers a warning only",
        ),
    ]


class ResultSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    current_status: Annotated[
        str,
        Field(
            alias="currentStatus",
            description="Derived current status across all regions",
        ),
    ]
    latest_per_region: Annotated[
        list[RegionStatusDto],
        Field(alias="latestPerRegion", description="Latest check result per region"),
    ]
    chart_data: Annotated[
        list[ChartBucketDto],
        Field(
            alias="chartData",
            description="Time-bucketed chart data for the requested window",
        ),
    ]
    uptime24h: Annotated[
        float | None,
        Field(
            description="Uptime percentage over the last 24 hours; null when no data",
            examples=[99.95],
        ),
    ] = None
    uptime_window: Annotated[
        float | None,
        Field(
            alias="uptimeWindow",
            description="Uptime percentage for the selected chart window; null when no data",
            examples=[99.8],
        ),
    ] = None


class RetryStrategy(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[
        str,
        Field(description="Retry strategy kind, e.g. fixed interval between attempts"),
    ]
    max_retries: Annotated[
        int,
        Field(
            alias="maxRetries",
            description="Maximum number of retries after a failed check",
        ),
    ]
    interval: Annotated[
        int, Field(description="Delay between retry attempts in seconds")
    ]


class RuleEvaluationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Forensic row UUID")]
    occurred_at: Annotated[
        AwareDatetime, Field(alias="occurredAt", description="When the evaluation ran")
    ]
    monitor_id: Annotated[
        UUID,
        Field(
            alias="monitorId",
            description="Monitor that produced the input check result",
        ),
    ]
    region: Annotated[
        str, Field(description="Probe region of the input check result", min_length=1)
    ]
    policy_snapshot_hash_hex: Annotated[
        str,
        Field(
            alias="policySnapshotHashHex",
            description="Hex-encoded hash of the policy snapshot this rule came from",
            min_length=1,
        ),
    ]
    rule_index: Annotated[
        int,
        Field(
            alias="ruleIndex",
            description="Index into the policy's triggerRules array (0-based)",
        ),
    ]
    rule_type: Annotated[
        str,
        Field(
            alias="ruleType",
            description="Rule type (e.g. consecutive_failures, failures_in_window)",
            min_length=1,
        ),
    ]
    rule_scope: Annotated[
        str,
        Field(
            alias="ruleScope",
            description="Rule scope (per_region | multi_region)",
            min_length=1,
        ),
    ]
    input_result_ids: Annotated[
        list[UUID],
        Field(
            alias="inputResultIds",
            description="check_results IDs that were inputs to this evaluation (newest first)",
            min_length=1,
        ),
    ]
    output_matched: Annotated[
        bool,
        Field(
            alias="outputMatched",
            description="Whether the rule fired on this evaluation",
        ),
    ]
    evaluation_details: Annotated[
        dict[str, dict[str, Any]],
        Field(
            alias="evaluationDetails",
            description="Structured details (e.g. failure counts, response-time aggregates)",
        ),
    ]
    engine_version: Annotated[
        str,
        Field(
            alias="engineVersion",
            description="Detection engine version that ran this evaluation",
            min_length=1,
        ),
    ]
    check_id: Annotated[
        UUID,
        Field(
            alias="checkId",
            description="Scheduler-minted check execution ID (V92) — the causal chain identifier",
        ),
    ]
    triggering_transition_id: Annotated[
        UUID | None,
        Field(
            alias="triggeringTransitionId",
            description="If this evaluation caused a state transition, points to that transition's id",
        ),
    ] = None


class ScheduledMaintenanceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique maintenance record identifier")]
    external_id: Annotated[
        str,
        Field(alias="externalId", description="Vendor-assigned maintenance identifier"),
    ]
    title: Annotated[
        str, Field(description="Maintenance title as reported by the vendor")
    ]
    status: Annotated[
        str,
        Field(
            description="Current maintenance status (scheduled, in_progress, completed)"
        ),
    ]
    impact: Annotated[str | None, Field(description="Reported impact level")] = None
    shortlink: Annotated[
        str | None,
        Field(description="Vendor-provided short URL to the maintenance page"),
    ] = None
    scheduled_for: Annotated[
        AwareDatetime | None,
        Field(
            alias="scheduledFor",
            description="Timestamp when the maintenance is scheduled to begin",
        ),
    ] = None
    scheduled_until: Annotated[
        AwareDatetime | None,
        Field(
            alias="scheduledUntil",
            description="Timestamp when the maintenance is scheduled to end",
        ),
    ] = None
    started_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="startedAt",
            description="Timestamp when the maintenance actually started",
        ),
    ] = None
    completed_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="completedAt",
            description="Timestamp when the maintenance was completed",
        ),
    ] = None
    affected_components: Annotated[
        list[MaintenanceComponentRef],
        Field(
            alias="affectedComponents",
            description="Components affected by this maintenance",
        ),
    ]
    updates: Annotated[
        list[MaintenanceUpdateDto],
        Field(description="Status updates posted during the maintenance lifecycle"),
    ]


class SecretDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique secret identifier")]
    key: Annotated[
        str, Field(description="Secret key name, unique within the workspace")
    ]
    dek_version: Annotated[
        int,
        Field(
            alias="dekVersion", description="DEK version at the time of last encryption"
        ),
    ]
    value_hash: Annotated[
        str,
        Field(
            alias="valueHash",
            description="SHA-256 hex digest of the current plaintext; use for change detection",
        ),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the secret was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt", description="Timestamp when the secret was last updated"
        ),
    ]
    used_by_monitors: Annotated[
        list[MonitorReference] | None,
        Field(
            alias="usedByMonitors",
            description="Monitors that reference this secret; null on create/update responses",
        ),
    ] = None


class SeoMetadataDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    short_description: Annotated[
        str | None,
        Field(
            alias="shortDescription",
            description="Short description for meta tags (max 160 chars)",
        ),
    ] = None
    description: Annotated[
        str | None, Field(description="Full description for the service page")
    ] = None
    about: Annotated[
        str | None,
        Field(description="Long-form about text for the About section on pSEO pages"),
    ] = None


class ServiceCatalogDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    slug: str
    name: str
    category: str | None = None
    official_status_url: Annotated[str | None, Field(alias="officialStatusUrl")] = None
    developer_context: Annotated[str | None, Field(alias="developerContext")] = None
    logo_url: Annotated[str | None, Field(alias="logoUrl")] = None
    adapter_type: Annotated[str, Field(alias="adapterType")]
    polling_interval_seconds: Annotated[int, Field(alias="pollingIntervalSeconds")]
    enabled: bool
    published: bool
    overall_status: Annotated[str | None, Field(alias="overallStatus")] = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]
    component_count: Annotated[int, Field(alias="componentCount")]
    active_incident_count: Annotated[int, Field(alias="activeIncidentCount")]
    data_completeness: Annotated[str, Field(alias="dataCompleteness")]
    uptime30d: Annotated[
        float | None,
        Field(description="Aggregated 30-day uptime percentage across all components"),
    ] = None


class ServiceComponentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    external_id: Annotated[str, Field(alias="externalId")]
    name: str
    status: str
    description: str | None = None
    group_id: Annotated[UUID | None, Field(alias="groupId")] = None
    position: int | None = None
    showcase: bool
    only_show_if_degraded: Annotated[bool, Field(alias="onlyShowIfDegraded")]
    start_date: Annotated[AwareDatetime | None, Field(alias="startDate")] = None
    vendor_created_at: Annotated[
        AwareDatetime | None, Field(alias="vendorCreatedAt")
    ] = None
    lifecycle_status: Annotated[str, Field(alias="lifecycleStatus")]
    data_type: Annotated[
        str,
        Field(
            alias="dataType",
            description="Data classification: full, status_only, or metric_only",
            examples=["full"],
        ),
    ]
    has_uptime: Annotated[
        bool,
        Field(
            alias="hasUptime",
            description="Whether uptime data is available for this component",
        ),
    ]
    region: Annotated[
        str | None,
        Field(
            description="Geographic region for regional components (AWS, GCP, Azure)"
        ),
    ] = None
    group_name: Annotated[
        str | None,
        Field(alias="groupName", description="Display name of the parent group"),
    ] = None
    display_aggregated_uptime: Annotated[
        bool,
        Field(
            alias="displayAggregatedUptime",
            description="Group-only: render an aggregated uptime bar above this group's children",
        ),
    ]
    child_count: Annotated[
        int | None,
        Field(
            alias="childCount",
            description="Group-only count of visible leaf children; null for leaves",
        ),
    ] = None
    uptime: ComponentUptimeSummaryDto | None = None
    status_changed_at: Annotated[
        AwareDatetime | None, Field(alias="statusChangedAt")
    ] = None
    first_seen_at: Annotated[AwareDatetime, Field(alias="firstSeenAt")]
    last_seen_at: Annotated[AwareDatetime, Field(alias="lastSeenAt")]
    is_group: Annotated[bool, Field(alias="isGroup")]


class ServiceDayDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    date: Annotated[
        date_aliased, Field(description="UTC calendar day this rollup covers")
    ]
    overall_uptime_percentage: Annotated[
        float | None,
        Field(
            alias="overallUptimePercentage",
            description="Average uptime % across leaf components with uptime data; null if no data",
        ),
    ] = None
    total_partial_outage_seconds: Annotated[
        int,
        Field(
            alias="totalPartialOutageSeconds",
            description="Sum of partial outage seconds across all leaf components",
        ),
    ]
    total_major_outage_seconds: Annotated[
        int,
        Field(
            alias="totalMajorOutageSeconds",
            description="Sum of major outage seconds across all leaf components",
        ),
    ]
    total_degraded_seconds: Annotated[
        int,
        Field(
            alias="totalDegradedSeconds",
            description="Sum of degraded performance seconds across all leaf components",
        ),
    ]
    components: Annotated[
        list[ComponentImpact],
        Field(
            description="Per-component impact rows for the day (only components with uptime data)"
        ),
    ]
    incidents: Annotated[
        list[DayIncident],
        Field(
            description="Incidents that were active at any point during this day (started before day end, resolved after day start)"
        ),
    ]


class ServiceIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    service_id: Annotated[UUID, Field(alias="serviceId")]
    service_slug: Annotated[str | None, Field(alias="serviceSlug")] = None
    service_name: Annotated[str | None, Field(alias="serviceName")] = None
    external_id: Annotated[str | None, Field(alias="externalId")] = None
    title: str
    status: str
    impact: str | None = None
    started_at: Annotated[AwareDatetime | None, Field(alias="startedAt")] = None
    resolved_at: Annotated[AwareDatetime | None, Field(alias="resolvedAt")] = None
    updated_at: Annotated[AwareDatetime | None, Field(alias="updatedAt")] = None
    shortlink: str | None = None
    detected_at: Annotated[AwareDatetime | None, Field(alias="detectedAt")] = None
    vendor_created_at: Annotated[
        AwareDatetime | None, Field(alias="vendorCreatedAt")
    ] = None


class ServiceIncidentUpdateDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status: str
    body: str | None = None
    display_at: Annotated[AwareDatetime | None, Field(alias="displayAt")] = None


class ServiceLiveStatusDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    overall_status: Annotated[
        str | None,
        Field(
            alias="overallStatus",
            description="Current overall status of the service, e.g. operational, degraded_performance",
        ),
    ] = None
    component_statuses: Annotated[
        list[ComponentStatusDto],
        Field(
            alias="componentStatuses",
            description="Current status of each active component",
        ),
    ]
    active_incident_count: Annotated[
        int,
        Field(
            alias="activeIncidentCount",
            description="Number of currently unresolved incidents",
        ),
    ]
    last_polled_at: Annotated[
        str | None,
        Field(
            alias="lastPolledAt",
            description="ISO 8601 timestamp of the last status poll",
        ),
    ] = None


class ServicePollResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    service_id: Annotated[UUID, Field(alias="serviceId", description="Service ID")]
    timestamp: Annotated[
        AwareDatetime,
        Field(description="Timestamp when the poll was executed (ISO 8601)"),
    ]
    overall_status: Annotated[
        str | None,
        Field(
            alias="overallStatus",
            description="Overall status of the service at time of poll",
            examples=["operational"],
        ),
    ] = None
    response_time_ms: Annotated[
        int | None,
        Field(
            alias="responseTimeMs",
            description="Response time of the poll in milliseconds",
            examples=[245],
        ),
    ] = None
    http_status_code: Annotated[
        int | None,
        Field(
            alias="httpStatusCode",
            description="HTTP status code from the upstream status page",
            examples=[200],
        ),
    ] = None
    passed: Annotated[
        bool, Field(description="Whether the poll succeeded", examples=[True])
    ]
    failure_reason: Annotated[
        str | None,
        Field(
            alias="failureReason", description="Reason for failure when passed=false"
        ),
    ] = None
    component_count: Annotated[
        int,
        Field(
            alias="componentCount",
            description="Number of components reported by the service",
            examples=[12],
        ),
    ]
    degraded_count: Annotated[
        int,
        Field(
            alias="degradedCount",
            description="Number of degraded or non-operational components",
            examples=[1],
        ),
    ]


class ServicePollSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    uptime_percentage: Annotated[
        float | None,
        Field(
            alias="uptimePercentage",
            description="Uptime percentage over the requested window; null when no data",
            examples=[99.95],
        ),
    ] = None
    total_polls: Annotated[
        int,
        Field(
            alias="totalPolls",
            description="Total number of polls executed",
            examples=[4320],
        ),
    ]
    passed_polls: Annotated[
        int,
        Field(
            alias="passedPolls",
            description="Number of polls that succeeded",
            examples=[4318],
        ),
    ]
    avg_response_time_ms: Annotated[
        float | None,
        Field(
            alias="avgResponseTimeMs",
            description="Average response time in milliseconds; null when no data",
            examples=[312.5],
        ),
    ] = None
    p95_response_time_ms: Annotated[
        float | None,
        Field(
            alias="p95ResponseTimeMs",
            description="95th-percentile response time in milliseconds; null when no data",
            examples=[580],
        ),
    ] = None
    window: Annotated[
        str, Field(description="Time window used for the summary", examples=["30d"])
    ]
    chart_data: Annotated[
        list[PollChartBucketDto],
        Field(
            alias="chartData",
            description="Time-bucketed chart data for response time and uptime",
        ),
    ]


class ServiceStatusDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    overall_status: Annotated[str, Field(alias="overallStatus")]
    last_polled_at: Annotated[AwareDatetime | None, Field(alias="lastPolledAt")] = None


class ServiceSubscribeRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    component_id: Annotated[
        UUID | None,
        Field(
            alias="componentId",
            description="ID of the component to subscribe to. Omit or null for whole-service subscription.",
        ),
    ] = None
    alert_sensitivity: Annotated[
        str | None,
        Field(
            alias="alertSensitivity",
            description="Alert sensitivity: ALL (any status change), INCIDENTS_ONLY (real vendor incidents, page on every one), MAJOR_ONLY (only DOWN-level incidents), AWARENESS (track silently — show on dashboard, never send alerts). Defaults to AWARENESS when not provided — silent tracking is the friendliest first-run choice; switch to one of the paging modes to opt in to alert-channel fan-out.",
            pattern="ALL|AWARENESS|INCIDENTS_ONLY|MAJOR_ONLY",
        ),
    ] = None


class ServiceSubscriptionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    subscription_id: Annotated[
        UUID,
        Field(alias="subscriptionId", description="Unique subscription identifier"),
    ]
    service_id: Annotated[
        UUID, Field(alias="serviceId", description="Service identifier")
    ]
    slug: Annotated[str, Field(min_length=1)]
    name: Annotated[str, Field(min_length=1)]
    category: str | None = None
    official_status_url: Annotated[str | None, Field(alias="officialStatusUrl")] = None
    adapter_type: Annotated[str, Field(alias="adapterType", min_length=1)]
    polling_interval_seconds: Annotated[int, Field(alias="pollingIntervalSeconds")]
    enabled: bool
    logo_url: Annotated[
        str | None,
        Field(alias="logoUrl", description="Logo URL from the service catalog"),
    ] = None
    overall_status: Annotated[
        str | None,
        Field(
            alias="overallStatus",
            description="Current overall status; null when the service has never been polled",
        ),
    ] = None
    component_id: Annotated[
        UUID | None,
        Field(
            alias="componentId",
            description="Subscribed component id; null for whole-service subscription",
        ),
    ] = None
    component: ServiceComponentDto | None = None
    alert_sensitivity: Annotated[
        str,
        Field(
            alias="alertSensitivity",
            description="Alert sensitivity: ALL (synthetic + real incidents, paged), INCIDENTS_ONLY (real vendor incidents, paged), MAJOR_ONLY (real + DOWN severity, paged), AWARENESS (real vendor incidents tracked silently — visible on dashboard, never paged; default for new subscriptions)",
            min_length=1,
        ),
    ]
    subscribed_at: Annotated[
        AwareDatetime,
        Field(
            alias="subscribedAt",
            description="When the organization subscribed to this service",
        ),
    ]


class SetAlertChannelsRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_ids: Annotated[
        list[UUID],
        Field(
            alias="channelIds",
            description="IDs of alert channels to link (replaces current list)",
        ),
    ]


class SetMonitorAuthRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    config: ApiKeyAuthConfig | BasicAuthConfig | BearerAuthConfig | HeaderAuthConfig


class SingleValueResponseAlertChannelDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: AlertChannelDto


class SingleValueResponseAlertDeliveryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: AlertDeliveryDto


class SingleValueResponseApiKeyCreateResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ApiKeyCreateResponse


class SingleValueResponseApiKeyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ApiKeyDto


class SingleValueResponseDekRotationResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: DekRotationResultDto


class SingleValueResponseDeployLockDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: DeployLockDto


class SingleValueResponseEnvironmentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: EnvironmentDto


class SingleValueResponseInviteDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: InviteDto


class SingleValueResponseListUUID(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[UUID]


class SingleValueResponseLong(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: int


class SingleValueResponseMaintenanceWindowDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: MaintenanceWindowDto


class SingleValueResponseMonitorAuthDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: MonitorAuthDto


class SingleValueResponseMonitorTestResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: MonitorTestResultDto


class SingleValueResponseNotificationDispatchDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: NotificationDispatchDto


class SingleValueResponseOrganizationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: OrganizationDto


class SingleValueResponsePolicySnapshotDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: PolicySnapshotDto


class SingleValueResponseResourceGroupHealthDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ResourceGroupHealthDto


class SingleValueResponseResourceGroupMemberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ResourceGroupMemberDto


class SingleValueResponseResultSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ResultSummaryDto


class SingleValueResponseSecretDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: SecretDto


class SingleValueResponseServiceDayDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServiceDayDetailDto


class SingleValueResponseServiceLiveStatusDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServiceLiveStatusDto


class SingleValueResponseServicePollSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServicePollSummaryDto


class SingleValueResponseServiceSubscriptionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServiceSubscriptionDto


class SingleValueResponseString(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: str


class SlackChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["slack"], Field(alias="channelType")] = "slack"
    webhook_url: Annotated[
        str,
        Field(
            alias="webhookUrl", description="Slack incoming webhook URL", min_length=1
        ),
    ]
    mention_text: Annotated[
        str | None,
        Field(
            alias="mentionText",
            description="Optional mention text included in notifications, e.g. @channel",
        ),
    ] = None


class SslExpiryAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["ssl_expiry"] = "ssl_expiry"
    min_days_remaining: Annotated[
        int,
        Field(
            alias="minDaysRemaining",
            description="Minimum days before TLS certificate expiry; fails or warns below this threshold",
        ),
    ]


class Source1(StrEnum):
    pipeline = "pipeline"
    public_api = "public-api"


class StateTransitionDetails(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    source: Annotated[
        Source1,
        Field(
            description="Actor that produced this transition (pipeline | public-api)"
        ),
    ]


class StatusCodeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["status_code"] = "status_code"
    expected: Annotated[
        str,
        Field(
            description="Expected status code, range pattern, or wildcard such as 2xx",
            min_length=1,
        ),
    ]
    operator: Annotated[
        Operator,
        Field(
            description="Comparison operator (equals, contains, less_than, greater_than, etc.)"
        ),
    ]


class StatusPageBranding(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    logo_url: Annotated[
        str | None,
        Field(
            alias="logoUrl",
            description="URL for the logo image displayed in the header",
            max_length=2048,
            min_length=0,
            pattern="^https?://.*",
        ),
    ] = None
    favicon_url: Annotated[
        str | None,
        Field(
            alias="faviconUrl",
            description="URL for the browser tab favicon",
            max_length=2048,
            min_length=0,
            pattern="^https?://.*",
        ),
    ] = None
    brand_color: Annotated[
        str | None,
        Field(
            alias="brandColor",
            description="Primary brand color as hex, e.g. #4F46E5; drives accent/links/buttons",
            max_length=30,
            min_length=0,
            pattern="^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
        ),
    ] = None
    page_background: Annotated[
        str | None,
        Field(
            alias="pageBackground",
            description="Page body background color as hex, e.g. #FAFAFA",
            max_length=30,
            min_length=0,
            pattern="^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
        ),
    ] = None
    card_background: Annotated[
        str | None,
        Field(
            alias="cardBackground",
            description="Card/surface background color as hex, e.g. #FFFFFF",
            max_length=30,
            min_length=0,
            pattern="^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
        ),
    ] = None
    text_color: Annotated[
        str | None,
        Field(
            alias="textColor",
            description="Primary text color as hex, e.g. #09090B",
            max_length=30,
            min_length=0,
            pattern="^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
        ),
    ] = None
    border_color: Annotated[
        str | None,
        Field(
            alias="borderColor",
            description="Card border color as hex, e.g. #E4E4E7",
            max_length=30,
            min_length=0,
            pattern="^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$",
        ),
    ] = None
    header_style: Annotated[
        str | None,
        Field(
            alias="headerStyle",
            description="Header layout style (reserved for future use)",
            max_length=50,
            min_length=0,
        ),
    ] = None
    theme: Annotated[
        str | None,
        Field(
            description="Color theme: light or dark (default: light)",
            max_length=50,
            min_length=0,
        ),
    ] = None
    report_url: Annotated[
        str | None,
        Field(
            alias="reportUrl",
            description="URL where visitors can report a problem",
            max_length=2048,
            min_length=0,
            pattern="^https?://.*",
        ),
    ] = None
    hide_powered_by: Annotated[
        bool | None,
        Field(
            alias="hidePoweredBy",
            description="Whether to hide the 'Powered by DevHelm' footer badge (default: false)",
        ),
    ] = False
    custom_css: Annotated[
        str | None,
        Field(
            alias="customCss",
            description="Custom CSS injected via <style> on the public page — grants full style control",
            max_length=50000,
            min_length=0,
        ),
    ] = None
    custom_head_html: Annotated[
        str | None,
        Field(
            alias="customHeadHtml",
            description="Custom HTML injected into <head> on the public page — grants full script control (analytics, pixels)",
            max_length=50000,
            min_length=0,
        ),
    ] = None


class StatusPageComponentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    status_page_id: Annotated[UUID, Field(alias="statusPageId")]
    group_id: Annotated[UUID | None, Field(alias="groupId")] = None
    name: Annotated[str, Field(min_length=1)]
    description: str | None = None
    type: str
    monitor_id: Annotated[UUID | None, Field(alias="monitorId")] = None
    resource_group_id: Annotated[UUID | None, Field(alias="resourceGroupId")] = None
    current_status: Annotated[str, Field(alias="currentStatus")]
    show_uptime: Annotated[bool, Field(alias="showUptime")]
    display_order: Annotated[int, Field(alias="displayOrder")]
    page_order: Annotated[int, Field(alias="pageOrder")]
    exclude_from_overall: Annotated[bool, Field(alias="excludeFromOverall")]
    start_date: Annotated[AwareDatetime | None, Field(alias="startDate")] = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]


class StatusPageComponentGroupDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    status_page_id: Annotated[UUID, Field(alias="statusPageId")]
    name: str
    description: str | None = None
    display_order: Annotated[int, Field(alias="displayOrder")]
    page_order: Annotated[int, Field(alias="pageOrder")]
    default_open: Annotated[bool, Field(alias="defaultOpen")]
    components: list[StatusPageComponentDto] | None = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]


class StatusPageCustomDomainDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    hostname: str
    status: str
    verification_method: Annotated[str, Field(alias="verificationMethod")]
    verification_token: Annotated[str, Field(alias="verificationToken")]
    verification_cname_target: Annotated[str, Field(alias="verificationCnameTarget")]
    verified_at: Annotated[AwareDatetime | None, Field(alias="verifiedAt")] = None
    verification_error: Annotated[str | None, Field(alias="verificationError")] = None
    cf_custom_hostname_id: Annotated[str | None, Field(alias="cfCustomHostnameId")] = (
        None
    )
    cf_ssl_status: Annotated[str | None, Field(alias="cfSslStatus")] = None
    ssl_active_at: Annotated[AwareDatetime | None, Field(alias="sslActiveAt")] = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]
    primary: bool


class StatusPageDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    organization_id: Annotated[int, Field(alias="organizationId")]
    workspace_id: Annotated[int, Field(alias="workspaceId")]
    name: Annotated[str, Field(min_length=1)]
    slug: Annotated[str, Field(min_length=1)]
    description: str | None = None
    branding: StatusPageBranding
    visibility: str
    enabled: bool
    incident_mode: Annotated[str, Field(alias="incidentMode")]
    component_count: Annotated[int | None, Field(alias="componentCount")] = None
    subscriber_count: Annotated[int | None, Field(alias="subscriberCount")] = None
    overall_status: Annotated[str | None, Field(alias="overallStatus")] = None
    managed_by: Annotated[
        str | None,
        Field(
            alias="managedBy",
            description="Source that created/owns this status page: DASHBOARD, CLI, TERRAFORM, MCP, or API. Null on pages created before this attribution column existed.",
        ),
    ] = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]


class StatusPageIncidentComponentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status_page_component_id: Annotated[UUID, Field(alias="statusPageComponentId")]
    component_status: Annotated[str, Field(alias="componentStatus")]
    component_name: Annotated[str, Field(alias="componentName")]


class StatusPageIncidentUpdateDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    status: str
    body: str
    created_by: Annotated[str | None, Field(alias="createdBy")] = None
    created_by_user_id: Annotated[int | None, Field(alias="createdByUserId")] = None
    notify_subscribers: Annotated[bool, Field(alias="notifySubscribers")]
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]


class StatusPageSubscriberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    email: str
    confirmed: bool
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]


class Summary(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    name: Annotated[str, Field(min_length=1)]
    slug: Annotated[str, Field(min_length=1)]


class TableValueResultAlertChannelDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[AlertChannelDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultAlertDeliveryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[AlertDeliveryDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultApiKeyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ApiKeyDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultCategoryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[CategoryDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultDeliveryAttemptDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[DeliveryAttemptDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultEnvironmentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[EnvironmentDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[IncidentDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultInviteDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[InviteDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultMaintenanceWindowDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[MaintenanceWindowDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultMemberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[MemberDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultNotificationDispatchDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[NotificationDispatchDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultNotificationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[NotificationDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultRuleEvaluationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[RuleEvaluationDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultScheduledMaintenanceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ScheduledMaintenanceDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultSecretDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[SecretDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultServiceComponentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ServiceComponentDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultServiceIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ServiceIncidentDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultServiceSubscriptionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ServiceSubscriptionDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultStatusPageComponentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[StatusPageComponentDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultStatusPageComponentGroupDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[StatusPageComponentGroupDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultStatusPageCustomDomainDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[StatusPageCustomDomainDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultStatusPageDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[StatusPageDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultStatusPageSubscriberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[StatusPageSubscriberDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TagDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique tag identifier")]
    organization_id: Annotated[
        int,
        Field(alias="organizationId", description="Organization this tag belongs to"),
    ]
    name: Annotated[
        str, Field(description="Tag name, unique within the org", min_length=1)
    ]
    color: Annotated[
        str,
        Field(description="Hex color code for display (e.g. #6B7280)", min_length=1),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the tag was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(alias="updatedAt", description="Timestamp when the tag was last updated"),
    ]


class Tcp(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    check_type: Literal["tcp"] = "tcp"
    host: Annotated[str, Field(description="Target host", examples=["db.example.com"])]
    port: Annotated[int, Field(description="Target port", examples=[5432])]
    connected: Annotated[
        bool, Field(description="Whether a TCP connection was established")
    ]


class TcpConnectsAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["tcp_connects"] = "tcp_connects"


class TcpMonitorConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    host: Annotated[
        str, Field(description="Target hostname or IP address", min_length=1)
    ]
    port: Annotated[int, Field(description="TCP port to connect to", ge=1, le=65535)]
    timeout_ms: Annotated[
        int | None,
        Field(alias="timeoutMs", description="Connection timeout in milliseconds"),
    ] = None


class TcpResponseTimeAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["tcp_response_time"] = "tcp_response_time"
    max_ms: Annotated[
        int,
        Field(
            alias="maxMs",
            description="Maximum TCP connect time in milliseconds before the check fails",
        ),
    ]


class TcpResponseTimeWarnAssertion(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Literal["tcp_response_time_warn"] = "tcp_response_time_warn"
    warn_ms: Annotated[
        int,
        Field(
            alias="warnMs",
            description="TCP connect time in milliseconds that triggers a warning only",
        ),
    ]


class TeamsChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["teams"], Field(alias="channelType")] = "teams"
    webhook_url: Annotated[
        str,
        Field(
            alias="webhookUrl",
            description="Microsoft Teams incoming webhook URL",
            min_length=1,
        ),
    ]


class TestChannelResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    success: bool
    message: str


class TestMatchResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    matched: Annotated[
        bool,
        Field(
            description="Whether the policy would match the supplied incident context"
        ),
    ]
    matched_rules: Annotated[
        list[str],
        Field(alias="matchedRules", description="Rules that passed evaluation"),
    ]
    unmatched_rules: Annotated[
        list[str],
        Field(alias="unmatchedRules", description="Rules that did not pass evaluation"),
    ]


class TestNotificationPolicyRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    severity: Annotated[
        str | None,
        Field(
            description="Incident severity to test against (e.g. DOWN, DEGRADED, MAINTENANCE)"
        ),
    ] = None
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Monitor UUID to test against (monitoring events)",
        ),
    ] = None
    regions: Annotated[
        list[str] | None,
        Field(
            description="Affected region identifiers to test against (monitoring events)"
        ),
    ] = None
    event_type: Annotated[
        str | None,
        Field(
            alias="eventType",
            description="Incident event type to test against — short form (e.g. created, resolved, reopened) or full form (e.g. incident.created)",
        ),
    ] = None
    monitor_type: Annotated[
        str | None,
        Field(
            alias="monitorType",
            description="Monitor check type to test against (e.g. HTTP, DNS, MCP_SERVER)",
        ),
    ] = None
    service_id: Annotated[
        UUID | None,
        Field(
            alias="serviceId",
            description="Service catalog UUID to test against (status data events)",
        ),
    ] = None
    component_name: Annotated[
        str | None,
        Field(
            alias="componentName",
            description='Component name to test against (status data events, e.g. "Actions")',
        ),
    ] = None
    resource_group_ids: Annotated[
        list[UUID] | None,
        Field(
            alias="resourceGroupIds",
            description="Resource group UUIDs the entity belongs to, for resource_group_id_in rules",
        ),
    ] = None


class TestWebhookEndpointRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    event_type: Annotated[
        str | None,
        Field(
            alias="eventType",
            description="Event type to simulate (e.g. monitor.created); null uses a default",
        ),
    ] = None


class TimingPhasesDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    dns_ms: Annotated[
        int | None,
        Field(description="DNS resolution time in milliseconds", examples=[12]),
    ] = None
    tcp_ms: Annotated[
        int | None, Field(description="TCP connect time in milliseconds", examples=[18])
    ] = None
    tls_ms: Annotated[
        int | None,
        Field(
            description="TLS handshake time in milliseconds (null for plain HTTP)",
            examples=[34],
        ),
    ] = None
    ttfb_ms: Annotated[
        int | None,
        Field(description="Time to first response byte in milliseconds", examples=[42]),
    ] = None
    download_ms: Annotated[
        int | None,
        Field(description="Response body download time in milliseconds", examples=[8]),
    ] = None
    total_ms: Annotated[
        int | None,
        Field(
            description="Total wall-clock request time in milliseconds", examples=[114]
        ),
    ] = None


class TlsInfoDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    subject_cn: Annotated[
        str | None,
        Field(
            alias="subjectCn",
            description="Certificate subject common name",
            examples=["*.example.com"],
        ),
    ] = None
    subject_san: Annotated[
        list[str] | None,
        Field(alias="subjectSan", description="Subject Alternative Names"),
    ] = None
    issuer_cn: Annotated[
        str | None,
        Field(alias="issuerCn", description="Issuer common name", examples=["R3"]),
    ] = None
    issuer_org: Annotated[
        str | None,
        Field(
            alias="issuerOrg",
            description="Issuer organisation",
            examples=["Let's Encrypt"],
        ),
    ] = None
    not_before: Annotated[
        str | None,
        Field(
            alias="notBefore", description="Certificate validity start (ISO 8601 UTC)"
        ),
    ] = None
    not_after: Annotated[
        str | None,
        Field(alias="notAfter", description="Certificate validity end (ISO 8601 UTC)"),
    ] = None
    serial_number: Annotated[
        str | None, Field(alias="serialNumber", description="Certificate serial number")
    ] = None
    tls_version: Annotated[
        str | None,
        Field(
            alias="tlsVersion", description="TLS protocol version", examples=["TLSv1.3"]
        ),
    ] = None
    cipher_suite: Annotated[
        str | None, Field(alias="cipherSuite", description="Negotiated cipher suite")
    ] = None
    chain_valid: Annotated[
        bool | None,
        Field(
            alias="chainValid",
            description="Whether the chain validated against the OS trust store",
        ),
    ] = None


class Type4(StrEnum):
    consecutive_failures = "consecutive_failures"
    failures_in_window = "failures_in_window"
    response_time = "response_time"


class Scope(StrEnum):
    per_region = "per_region"
    any_region = "any_region"


class Severity3(StrEnum):
    down = "down"
    degraded = "degraded"


class AggregationType(StrEnum):
    all_exceed = "all_exceed"
    average = "average"
    p95 = "p95"
    max = "max"


class TriggerRule(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[
        Type4,
        Field(
            description="Condition that opens or escalates an incident from check results"
        ),
    ]
    count: Annotated[
        int | None,
        Field(description="Failure count for consecutive or windowed failure rules"),
    ] = None
    window_minutes: Annotated[
        int | None,
        Field(
            alias="windowMinutes",
            description="Window length in minutes for failures-in-window rules",
        ),
    ] = None
    scope: Annotated[
        Scope,
        Field(description="Whether the rule applies per region or across regions"),
    ]
    threshold_ms: Annotated[
        int | None,
        Field(
            alias="thresholdMs",
            description="Response time threshold in milliseconds for response-time rules",
        ),
    ] = None
    severity: Annotated[
        Severity3, Field(description="Incident severity when this rule fires")
    ]
    aggregation_type: Annotated[
        AggregationType | None,
        Field(
            alias="aggregationType",
            description="How response times are aggregated for response-time rules",
        ),
    ] = None


class UpdateAlertSensitivityRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    alert_sensitivity: Annotated[
        str,
        Field(
            alias="alertSensitivity",
            description="Alert sensitivity: ALL (any status change), INCIDENTS_ONLY (real vendor incidents, page on every one), MAJOR_ONLY (only DOWN-level incidents), AWARENESS (track silently — show on dashboard, never send alerts; default for new subscriptions)",
            min_length=1,
            pattern="ALL|AWARENESS|INCIDENTS_ONLY|MAJOR_ONLY",
        ),
    ]


class UpdateApiKeyRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(description="New name for this API key", max_length=200, min_length=0),
    ]


class Severity4(StrEnum):
    fail = "fail"
    warn = "warn"


class UpdateAssertionRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    config: Annotated[
        BodyContainsAssertion
        | DnsExpectedCnameAssertion
        | DnsExpectedIpsAssertion
        | DnsMaxAnswersAssertion
        | DnsMinAnswersAssertion
        | DnsRecordContainsAssertion
        | DnsRecordEqualsAssertion
        | DnsResolvesAssertion
        | DnsResponseTimeAssertion
        | DnsResponseTimeWarnAssertion
        | DnsTtlHighAssertion
        | DnsTtlLowAssertion
        | DnsTxtContainsAssertion
        | HeaderValueAssertion
        | HeartbeatIntervalDriftAssertion
        | HeartbeatMaxIntervalAssertion
        | HeartbeatPayloadContainsAssertion
        | HeartbeatReceivedAssertion
        | IcmpPacketLossAssertion
        | IcmpReachableAssertion
        | IcmpResponseTimeAssertion
        | IcmpResponseTimeWarnAssertion
        | JsonPathAssertion
        | McpConnectsAssertion
        | McpHasCapabilityAssertion
        | McpMinToolsAssertion
        | McpProtocolVersionAssertion
        | McpResponseTimeAssertion
        | McpResponseTimeWarnAssertion
        | McpToolAvailableAssertion
        | McpToolCountChangedAssertion
        | RedirectCountAssertion
        | RedirectTargetAssertion
        | RegexBodyAssertion
        | ResponseSizeAssertion
        | ResponseTimeAssertion
        | ResponseTimeWarnAssertion
        | SslExpiryAssertion
        | StatusCodeAssertion
        | TcpConnectsAssertion
        | TcpResponseTimeAssertion
        | TcpResponseTimeWarnAssertion,
        Field(discriminator="type"),
    ]
    severity: Annotated[
        Severity4 | None, Field(description="New outcome severity: FAIL or WARN")
    ] = None


class UpdateEnvironmentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None,
        Field(
            description="New environment name; null preserves current",
            max_length=100,
            min_length=0,
        ),
    ] = None
    variables: Annotated[
        dict[str, str] | None,
        Field(description="Replace all variables; null preserves current"),
    ] = None
    is_default: Annotated[
        bool | None,
        Field(
            alias="isDefault",
            description="Whether this is the default environment; null preserves current",
        ),
    ] = None


class UpdateIncidentPolicyRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    trigger_rules: Annotated[
        list[TriggerRule],
        Field(
            alias="triggerRules",
            description="Array of trigger rules; at least one required",
            min_length=1,
        ),
    ]
    confirmation: ConfirmationPolicy
    recovery: RecoveryPolicy


class UpdateMaintenanceWindowRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    monitor_id: Annotated[
        UUID | None,
        Field(
            alias="monitorId",
            description="Monitor this window applies to; null switches the window to org-wide",
        ),
    ] = None
    starts_at: Annotated[
        AwareDatetime,
        Field(alias="startsAt", description="Updated start time (ISO 8601)"),
    ]
    ends_at: Annotated[
        AwareDatetime, Field(alias="endsAt", description="Updated end time (ISO 8601)")
    ]
    repeat_rule: Annotated[
        str | None,
        Field(
            alias="repeatRule",
            description="Reserved: iCal RRULE for recurring windows (stored but not yet honored); null clears it",
            max_length=100,
            min_length=0,
        ),
    ] = None
    reason: Annotated[
        str | None,
        Field(
            description="Updated reason (max 500 chars); null clears the existing reason",
            max_length=500,
            min_length=0,
        ),
    ] = None
    suppress_alerts: Annotated[
        bool | None,
        Field(
            alias="suppressAlerts",
            description="Whether to suppress alerts during this window; null defaults to true",
        ),
    ] = None


class UpdateMonitorAuthRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    config: ApiKeyAuthConfig | BasicAuthConfig | BearerAuthConfig | HeaderAuthConfig


class UpdateOrgDetailsRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="New organization name (max 200 chars)",
            max_length=200,
            min_length=0,
        ),
    ]
    email: Annotated[
        EmailStr,
        Field(description="New billing and contact email address", min_length=1),
    ]
    size: Annotated[
        str | None,
        Field(
            description="Team size range (e.g. 1-10, 11-50)",
            max_length=50,
            min_length=0,
        ),
    ] = None
    industry: Annotated[
        str | None,
        Field(
            description="Industry vertical (e.g. SaaS, Fintech)",
            max_length=100,
            min_length=0,
        ),
    ] = None
    website_url: Annotated[
        str | None,
        Field(
            alias="websiteUrl",
            description="Organization website URL (max 255 chars)",
            max_length=255,
            min_length=0,
        ),
    ] = None


class UpdateResourceGroupRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name for this group",
            max_length=255,
            min_length=0,
        ),
    ]
    description: Annotated[
        str | None,
        Field(description="Optional description; null clears the existing value"),
    ] = None
    alert_policy_id: Annotated[
        UUID | None,
        Field(
            alias="alertPolicyId",
            description="Optional notification policy to apply for this group; null clears the existing value",
        ),
    ] = None
    default_frequency: Annotated[
        int | None,
        Field(
            alias="defaultFrequency",
            description="Default check frequency in seconds for members (30–86400); null clears",
            ge=30,
            le=86400,
        ),
    ] = None
    default_regions: Annotated[
        list[str] | None,
        Field(
            alias="defaultRegions",
            description="Default regions for member monitors; null clears",
        ),
    ] = None
    default_retry_strategy: Annotated[
        RetryStrategy | None, Field(alias="defaultRetryStrategy")
    ] = None
    default_alert_channels: Annotated[
        list[UUID] | None,
        Field(
            alias="defaultAlertChannels",
            description="Default alert channel IDs for member monitors; null clears",
        ),
    ] = None
    default_environment_id: Annotated[
        UUID | None,
        Field(
            alias="defaultEnvironmentId",
            description="Default environment ID for member monitors; null clears",
        ),
    ] = None
    health_threshold_type: Annotated[
        HealthThresholdType | None,
        Field(
            alias="healthThresholdType",
            description="Health threshold type: COUNT or PERCENTAGE; null disables threshold",
        ),
    ] = None
    health_threshold_value: Annotated[
        float | None,
        Field(
            alias="healthThresholdValue",
            description="Health threshold value; null disables threshold",
            ge=0.0,
            le=100.0,
        ),
    ] = None
    suppress_member_alerts: Annotated[
        bool | None,
        Field(
            alias="suppressMemberAlerts",
            description="Suppress member-level alert notifications; null preserves current value",
        ),
    ] = None
    confirmation_delay_seconds: Annotated[
        int | None,
        Field(
            alias="confirmationDelaySeconds",
            description="Confirmation delay in seconds; null clears",
            ge=0,
            le=600,
        ),
    ] = None
    recovery_cooldown_minutes: Annotated[
        int | None,
        Field(
            alias="recoveryCooldownMinutes",
            description="Recovery cooldown in minutes; null clears",
            ge=0,
            le=60,
        ),
    ] = None
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="New attribution source: DASHBOARD, CLI, TERRAFORM, MCP, or API; null preserves current value.",
        ),
    ] = None


class UpdateSecretRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    value: Annotated[
        str,
        Field(
            description="New secret value, stored encrypted (max 32KB)",
            max_length=32768,
            min_length=0,
        ),
    ]


class UpdateStatusPageComponentGroupRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None,
        Field(
            description="New group name; null preserves current",
            max_length=255,
            min_length=0,
        ),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description="New description; null preserves current, empty string clears",
            max_length=500,
            min_length=0,
        ),
    ] = None
    display_order: Annotated[
        int | None,
        Field(
            alias="displayOrder",
            description="New position in the group list; null preserves current",
        ),
    ] = None
    default_open: Annotated[
        bool | None,
        Field(
            alias="defaultOpen",
            description="Initial expand/collapse state on first page load; null preserves current. Renderer may auto-expand on active incidents",
        ),
    ] = None


class UpdateStatusPageComponentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None,
        Field(
            description="New component name; null preserves current",
            max_length=255,
            min_length=0,
        ),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description="New description; null preserves current, empty string clears",
            max_length=500,
            min_length=0,
        ),
    ] = None
    group_id: Annotated[
        UUID | None,
        Field(
            alias="groupId",
            description="Move to a different group; null preserves current",
        ),
    ] = None
    remove_from_group: Annotated[
        bool | None,
        Field(
            alias="removeFromGroup",
            description="Remove the component from its group (default: false)",
        ),
    ] = None
    show_uptime: Annotated[
        bool | None,
        Field(
            alias="showUptime",
            description="Whether to show the uptime bar; null preserves current",
        ),
    ] = None
    display_order: Annotated[
        int | None,
        Field(
            alias="displayOrder",
            description="New position in the component list; null preserves current",
        ),
    ] = None
    exclude_from_overall: Annotated[
        bool | None,
        Field(
            alias="excludeFromOverall",
            description="Exclude from overall status calculation; null preserves current",
        ),
    ] = None
    start_date: Annotated[
        date_aliased | None,
        Field(
            alias="startDate",
            description="Date from which to start showing uptime; null preserves current. Bars never extend earlier than the underlying monitor's createdAt regardless of value",
        ),
    ] = None


class UpdateStatusPageIncidentRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    title: Annotated[
        str | None,
        Field(
            description="New title; null preserves current",
            max_length=500,
            min_length=0,
        ),
    ] = None
    status: Annotated[
        Status6 | None, Field(description="New status; null preserves current")
    ] = None
    impact: Annotated[
        Impact | None, Field(description="New impact level; null preserves current")
    ] = None
    affected_components: Annotated[
        list[AffectedComponent] | None,
        Field(
            alias="affectedComponents",
            description="Updated affected components; null preserves current",
        ),
    ] = None
    postmortem_body: Annotated[
        str | None,
        Field(
            alias="postmortemBody",
            description="Postmortem body in markdown; empty string clears",
        ),
    ] = None
    postmortem_url: Annotated[
        str | None,
        Field(
            alias="postmortemUrl",
            description="URL to an external postmortem document; empty string clears",
            max_length=2048,
            min_length=0,
            pattern="^https?://.*",
        ),
    ] = None


class UpdateStatusPageRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None,
        Field(
            description="New name; null preserves current", max_length=255, min_length=0
        ),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description="New description; null preserves current, empty string clears",
            max_length=500,
            min_length=0,
        ),
    ] = None
    branding: StatusPageBranding | None = None
    visibility: Annotated[
        Visibility | None, Field(description="Page visibility; null preserves current")
    ] = None
    enabled: Annotated[
        bool | None,
        Field(description="Whether the page is enabled; null preserves current"),
    ] = None
    incident_mode: Annotated[
        IncidentMode | None,
        Field(
            alias="incidentMode",
            description="Incident mode: MANUAL, REVIEW, or AUTOMATIC; null preserves current",
        ),
    ] = None
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="New attribution source: DASHBOARD, CLI, TERRAFORM, MCP, or API; null preserves current value.",
        ),
    ] = None


class UpdateTagRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None, Field(description="New tag name", max_length=100, min_length=0)
    ] = None
    color: Annotated[
        str | None,
        Field(
            description="New hex color code",
            pattern="^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$",
        ),
    ] = None


class UpdateWebhookEndpointRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    url: Annotated[
        str | None,
        Field(
            description="New webhook URL; null preserves current",
            max_length=2048,
            min_length=0,
        ),
    ] = None
    description: Annotated[
        str | None,
        Field(
            description="New description; null preserves current",
            max_length=255,
            min_length=0,
        ),
    ] = None
    subscribed_events: Annotated[
        list[SubscribedEvent] | None,
        Field(
            alias="subscribedEvents",
            description="Replace subscribed events; null preserves current",
        ),
    ] = None
    enabled: Annotated[
        bool | None,
        Field(description="Enable or disable delivery; null preserves current"),
    ] = None


class UpdateWorkspaceRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str, Field(description="New workspace name", max_length=200, min_length=0)
    ]


class UptimeBucketDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    timestamp: Annotated[
        AwareDatetime,
        Field(
            description="Start of the bucket interval (ISO 8601)",
            examples=["2024-01-01T00:00:00Z"],
        ),
    ]
    uptime_pct: Annotated[
        float | None,
        Field(
            alias="uptimePct",
            description="Uptime percentage for this bucket; null when no polls occurred",
            examples=[100],
        ),
    ] = None
    total_polls: Annotated[
        int,
        Field(
            alias="totalPolls",
            description="Total number of polls recorded in this bucket",
            examples=[12],
        ),
    ]


class UptimeDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    uptime_percentage: Annotated[
        float | None,
        Field(
            alias="uptimePercentage",
            description="Uptime percentage over the requested window; null when no data",
            examples=[99.95],
        ),
    ] = None
    total_checks: Annotated[
        int,
        Field(
            alias="totalChecks",
            description="Total number of checks executed",
            examples=[1440],
        ),
    ]
    passed_checks: Annotated[
        int,
        Field(
            alias="passedChecks",
            description="Number of checks that passed",
            examples=[1439],
        ),
    ]
    avg_latency_ms: Annotated[
        float | None,
        Field(
            alias="avgLatencyMs",
            description="Weighted average latency in milliseconds; null when no data",
            examples=[142.5],
        ),
    ] = None
    p95_latency_ms: Annotated[
        float | None,
        Field(
            alias="p95LatencyMs",
            description="95th-percentile latency in milliseconds (upper bound across regions); null when no data",
            examples=[312],
        ),
    ] = None


class WebhookChannelConfig(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    channel_type: Annotated[Literal["webhook"], Field(alias="channelType")] = "webhook"
    url: Annotated[
        str,
        Field(
            description="Webhook endpoint URL that receives alert payloads",
            min_length=1,
        ),
    ]
    signing_secret: Annotated[
        str | None,
        Field(
            alias="signingSecret",
            description="Optional HMAC signing secret for payload verification",
        ),
    ] = None
    custom_headers: Annotated[
        dict[str, str] | None,
        Field(
            alias="customHeaders",
            description="Additional HTTP headers to include in webhook requests",
        ),
    ] = None


class WebhookDeliveryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    endpoint_id: Annotated[UUID, Field(alias="endpointId")]
    event_id: Annotated[str, Field(alias="eventId")]
    event_type: Annotated[str, Field(alias="eventType")]
    status: str
    attempt_count: Annotated[int, Field(alias="attemptCount")]
    max_attempts: Annotated[int, Field(alias="maxAttempts")]
    response_status: Annotated[int | None, Field(alias="responseStatus")] = None
    response_latency_ms: Annotated[int | None, Field(alias="responseLatencyMs")] = None
    error_message: Annotated[str | None, Field(alias="errorMessage")] = None
    delivered_at: Annotated[AwareDatetime | None, Field(alias="deliveredAt")] = None
    failed_at: Annotated[AwareDatetime | None, Field(alias="failedAt")] = None
    next_retry_at: Annotated[AwareDatetime | None, Field(alias="nextRetryAt")] = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]


class WebhookEndpointDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique webhook endpoint identifier")]
    url: Annotated[
        str, Field(description="HTTPS endpoint URL that receives event payloads")
    ]
    description: Annotated[
        str | None, Field(description="Human-readable description of this endpoint")
    ] = None
    subscribed_events: Annotated[
        list[str],
        Field(
            alias="subscribedEvents",
            description="Event types this endpoint is subscribed to",
        ),
    ]
    enabled: Annotated[
        bool, Field(description="Whether delivery is enabled for this endpoint")
    ]
    consecutive_failures: Annotated[
        int,
        Field(
            alias="consecutiveFailures",
            description="Number of consecutive delivery failures",
        ),
    ]
    disabled_reason: Annotated[
        str | None,
        Field(
            alias="disabledReason", description="Reason the endpoint was auto-disabled"
        ),
    ] = None
    disabled_at: Annotated[
        AwareDatetime | None,
        Field(
            alias="disabledAt",
            description="Timestamp when the endpoint was auto-disabled",
        ),
    ] = None
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the endpoint was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt",
            description="Timestamp when the endpoint was last updated",
        ),
    ]


class WebhookEventCatalogEntry(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[
        str,
        Field(description='Dot-notation event type identifier, e.g. "monitor.created"'),
    ]
    surface: Annotated[
        str,
        Field(
            description='Product surface this event belongs to, e.g. "monitoring" or "status_data"'
        ),
    ]
    description: Annotated[
        str, Field(description="Human-readable description of when this event fires")
    ]


class WebhookEventCatalogResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: Annotated[
        list[WebhookEventCatalogEntry],
        Field(description="List of all available webhook event types"),
    ]


class WebhookSigningSecretDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    configured: bool
    masked_secret: Annotated[str | None, Field(alias="maskedSecret")] = None


class WebhookTestResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    success: bool
    status_code: Annotated[int | None, Field(alias="statusCode")] = None
    message: str
    duration_ms: Annotated[int | None, Field(alias="durationMs")] = None


class WorkspaceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Unique workspace identifier")]
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt", description="Timestamp when the workspace was created"
        ),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt",
            description="Timestamp when the workspace was last updated",
        ),
    ]
    name: Annotated[str, Field(description="Workspace name", min_length=1)]
    org_id: Annotated[
        int, Field(alias="orgId", description="Organization this workspace belongs to")
    ]


class AddMonitorTagsRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    tag_ids: Annotated[
        list[UUID] | None,
        Field(alias="tagIds", description="IDs of existing org tags to attach"),
    ] = None
    new_tags: Annotated[
        list[NewTagRequest] | None,
        Field(
            alias="newTags",
            description="New tags to create (if not already present) and attach",
        ),
    ] = None


class AuditMetadata(RootModel[MemberRoleChangedMetadata | None]):
    root: Annotated[
        MemberRoleChangedMetadata | None,
        Field(
            description="Typed metadata payload attached to an audit event; null for actions that carry no extra context.",
            discriminator="kind",
        ),
    ] = None


class AuthMeResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    key: KeyInfo
    organization: OrgInfo
    plan: PlanInfo
    rate_limits: Annotated[RateLimitInfo, Field(alias="rateLimits")]


class BulkMonitorActionRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    monitor_ids: Annotated[
        list[UUID],
        Field(
            alias="monitorIds",
            description="IDs of monitors to act on (max 200)",
            max_length=200,
            min_length=0,
        ),
    ]
    action: Annotated[
        Action,
        Field(description="Action to apply to every monitor in the bulk request"),
    ]
    tag_ids: Annotated[
        list[UUID] | None,
        Field(
            alias="tagIds",
            description="Tag IDs to attach or detach (required for ADD_TAG and REMOVE_TAG)",
        ),
    ] = None
    new_tags: Annotated[
        list[NewTagRequest] | None,
        Field(
            alias="newTags",
            description="New tags to create and attach (only for ADD_TAG)",
        ),
    ] = None


class BulkMonitorActionResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    succeeded: Annotated[
        list[UUID], Field(description="IDs of monitors on which the action succeeded")
    ]
    failed: Annotated[
        list[FailureDetail],
        Field(
            description="Monitors on which the action failed, with the reason for each failure"
        ),
    ]


class ComponentUptimeDayDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    date: Annotated[
        AwareDatetime,
        Field(
            description="Start-of-day timestamp for this bucket (UTC midnight, ISO 8601)"
        ),
    ]
    partial_outage_seconds: Annotated[
        int,
        Field(
            alias="partialOutageSeconds",
            description="Seconds of partial outage observed on this day",
        ),
    ]
    major_outage_seconds: Annotated[
        int,
        Field(
            alias="majorOutageSeconds",
            description="Seconds of major outage observed on this day",
        ),
    ]
    degraded_seconds: Annotated[
        int,
        Field(
            alias="degradedSeconds",
            description="Seconds the component spent in degraded performance on this day",
        ),
    ]
    uptime_percentage: Annotated[
        float,
        Field(
            alias="uptimePercentage",
            description="Computed uptime percentage using the weighted formula (degraded does not lower it)",
        ),
    ]
    incidents: Annotated[
        list[IncidentRef] | None,
        Field(description="Incidents that overlapped this day, in display order"),
    ] = None


class CreateAlertChannelRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name for this alert channel",
            max_length=255,
            min_length=0,
        ),
    ]
    config: Annotated[
        DiscordChannelConfig
        | EmailChannelConfig
        | OpsGenieChannelConfig
        | PagerDutyChannelConfig
        | SlackChannelConfig
        | TeamsChannelConfig
        | WebhookChannelConfig,
        Field(discriminator="channel_type"),
    ]
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="Source creating this channel: DASHBOARD, CLI, TERRAFORM, MCP, or API. Defaults to API when omitted.",
        ),
    ] = None


class CreateAssertionRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    config: Annotated[
        BodyContainsAssertion
        | DnsExpectedCnameAssertion
        | DnsExpectedIpsAssertion
        | DnsMaxAnswersAssertion
        | DnsMinAnswersAssertion
        | DnsRecordContainsAssertion
        | DnsRecordEqualsAssertion
        | DnsResolvesAssertion
        | DnsResponseTimeAssertion
        | DnsResponseTimeWarnAssertion
        | DnsTtlHighAssertion
        | DnsTtlLowAssertion
        | DnsTxtContainsAssertion
        | HeaderValueAssertion
        | HeartbeatIntervalDriftAssertion
        | HeartbeatMaxIntervalAssertion
        | HeartbeatPayloadContainsAssertion
        | HeartbeatReceivedAssertion
        | IcmpPacketLossAssertion
        | IcmpReachableAssertion
        | IcmpResponseTimeAssertion
        | IcmpResponseTimeWarnAssertion
        | JsonPathAssertion
        | McpConnectsAssertion
        | McpHasCapabilityAssertion
        | McpMinToolsAssertion
        | McpProtocolVersionAssertion
        | McpResponseTimeAssertion
        | McpResponseTimeWarnAssertion
        | McpToolAvailableAssertion
        | McpToolCountChangedAssertion
        | RedirectCountAssertion
        | RedirectTargetAssertion
        | RegexBodyAssertion
        | ResponseSizeAssertion
        | ResponseTimeAssertion
        | ResponseTimeWarnAssertion
        | SslExpiryAssertion
        | StatusCodeAssertion
        | TcpConnectsAssertion
        | TcpResponseTimeAssertion
        | TcpResponseTimeWarnAssertion,
        Field(discriminator="type"),
    ]
    severity: Annotated[
        Severity | None,
        Field(
            description="Outcome severity: FAIL (fails the check) or WARN (warns without failing, default: FAIL)"
        ),
    ] = None


class CreateMonitorRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name for this monitor",
            max_length=255,
            min_length=0,
        ),
    ]
    type: Annotated[Type, Field(description="Monitor protocol type")]
    config: (
        DnsMonitorConfig
        | HeartbeatMonitorConfig
        | HttpMonitorConfig
        | IcmpMonitorConfig
        | McpServerMonitorConfig
        | TcpMonitorConfig
    )
    frequency_seconds: Annotated[
        int | None,
        Field(
            alias="frequencySeconds",
            description="Check frequency in seconds (10–86400); null defaults to plan minimum (60s on most paid plans)",
            ge=10,
            le=86400,
        ),
    ] = None
    enabled: Annotated[
        bool | None, Field(description="Whether the monitor is active (default: true)")
    ] = None
    regions: Annotated[
        list[str] | None,
        Field(
            description="Probe regions to run checks from. Allowed values are deployment-dependent; production: us-east, us-west, eu-west, ap-south."
        ),
    ] = None
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="Source that created/owns this monitor: DASHBOARD, CLI, TERRAFORM, MCP, or API. Defaults to API when omitted; set to your surface so audit logs, drift detection, and analytics attribute correctly.",
        ),
    ] = None
    environment_id: Annotated[
        UUID | None,
        Field(
            alias="environmentId",
            description="Environment to associate with this monitor",
        ),
    ] = None
    assertions: Annotated[
        list[CreateAssertionRequest] | None,
        Field(description="Assertions to evaluate against each check result"),
    ] = None
    auth: MonitorAuthConfig | None = None
    incident_policy: Annotated[
        UpdateIncidentPolicyRequest | None, Field(alias="incidentPolicy")
    ] = None
    alert_channel_ids: Annotated[
        list[UUID] | None,
        Field(
            alias="alertChannelIds",
            description="Alert channels to notify when this monitor triggers",
        ),
    ] = None
    tags: AddMonitorTagsRequest | None = None


class CreateResourceGroupRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name for this group",
            max_length=255,
            min_length=0,
        ),
    ]
    description: Annotated[str | None, Field(description="Optional description")] = None
    alert_policy_id: Annotated[
        UUID | None,
        Field(
            alias="alertPolicyId",
            description="Optional notification policy to apply for this group",
        ),
    ] = None
    default_frequency: Annotated[
        int | None,
        Field(
            alias="defaultFrequency",
            description="Default check frequency in seconds applied to members (30–86400)",
            ge=30,
            le=86400,
        ),
    ] = None
    default_regions: Annotated[
        list[str] | None,
        Field(
            alias="defaultRegions",
            description="Default regions applied to member monitors",
        ),
    ] = None
    default_retry_strategy: Annotated[
        RetryStrategy | None, Field(alias="defaultRetryStrategy")
    ] = None
    default_alert_channels: Annotated[
        list[UUID] | None,
        Field(
            alias="defaultAlertChannels",
            description="Default alert channel IDs applied to member monitors",
        ),
    ] = None
    default_environment_id: Annotated[
        UUID | None,
        Field(
            alias="defaultEnvironmentId",
            description="Default environment ID applied to member monitors",
        ),
    ] = None
    health_threshold_type: Annotated[
        HealthThresholdType | None,
        Field(
            alias="healthThresholdType",
            description="Health threshold type: COUNT or PERCENTAGE",
        ),
    ] = None
    health_threshold_value: Annotated[
        float | None,
        Field(
            alias="healthThresholdValue",
            description="Health threshold value: count (0+) or percentage (0–100)",
            ge=0.0,
            le=100.0,
        ),
    ] = None
    suppress_member_alerts: Annotated[
        bool | None,
        Field(
            alias="suppressMemberAlerts",
            description="Suppress member-level alert notifications when group manages alerting",
        ),
    ] = None
    confirmation_delay_seconds: Annotated[
        int | None,
        Field(
            alias="confirmationDelaySeconds",
            description="Confirmation delay in seconds before group incident creation (0–600)",
            ge=0,
            le=600,
        ),
    ] = None
    recovery_cooldown_minutes: Annotated[
        int | None,
        Field(
            alias="recoveryCooldownMinutes",
            description="Recovery cooldown in minutes after group incident resolves (0–60)",
            ge=0,
            le=60,
        ),
    ] = None
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="Source creating this group: DASHBOARD, CLI, TERRAFORM, MCP, or API. Defaults to API when omitted.",
        ),
    ] = None


class CreateStatusPageRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name for this status page",
            max_length=255,
            min_length=0,
        ),
    ]
    slug: Annotated[
        str,
        Field(
            description="URL slug (lowercase, hyphens, globally unique)",
            max_length=63,
            min_length=3,
            pattern="^[a-z0-9][a-z0-9-]*[a-z0-9]$",
        ),
    ]
    description: Annotated[
        str | None,
        Field(
            description="Optional description shown below the page header",
            max_length=500,
            min_length=0,
        ),
    ] = None
    branding: StatusPageBranding | None = None
    visibility: Annotated[
        Visibility | None,
        Field(
            description="Page visibility: PUBLIC, PASSWORD, or IP_RESTRICTED (default: PUBLIC)"
        ),
    ] = None
    enabled: Annotated[
        bool | None, Field(description="Whether the page is enabled (default: true)")
    ] = None
    incident_mode: Annotated[
        IncidentMode | None,
        Field(
            alias="incidentMode",
            description="Incident mode: MANUAL, REVIEW, or AUTOMATIC (default: AUTOMATIC)",
        ),
    ] = None
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="Source creating this page: DASHBOARD, CLI, TERRAFORM, MCP, or API. Defaults to API when omitted.",
        ),
    ] = None


class CursorPageServiceCatalogDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: Annotated[list[ServiceCatalogDto], Field(description="Items on this page")]
    next_cursor: Annotated[
        str | None,
        Field(
            alias="nextCursor",
            description="Opaque cursor for the next page; null when there are no more results",
        ),
    ] = None
    has_more: Annotated[
        bool,
        Field(
            alias="hasMore", description="Whether more results exist beyond this page"
        ),
    ]


class CursorPageServicePollResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: Annotated[list[ServicePollResultDto], Field(description="Items on this page")]
    next_cursor: Annotated[
        str | None,
        Field(
            alias="nextCursor",
            description="Opaque cursor for the next page; null when there are no more results",
        ),
    ] = None
    has_more: Annotated[
        bool,
        Field(
            alias="hasMore", description="Whether more results exist beyond this page"
        ),
    ]


class DashboardOverviewDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    monitors: MonitorsSummaryDto
    incidents: IncidentsSummaryDto


class EscalationChain(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    steps: Annotated[
        list[EscalationStep],
        Field(
            description="Ordered escalation steps, evaluated in sequence", min_length=1
        ),
    ]
    on_resolve: Annotated[
        str | None,
        Field(alias="onResolve", description="Action when the incident resolves"),
    ] = None
    on_reopen: Annotated[
        str | None,
        Field(alias="onReopen", description="Action when a resolved incident reopens"),
    ] = None


class GlobalStatusSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    total_services: Annotated[
        int,
        Field(
            alias="totalServices", description="Total number of services in the catalog"
        ),
    ]
    operational_count: Annotated[
        int,
        Field(
            alias="operationalCount",
            description="Number of services currently fully operational",
        ),
    ]
    degraded_count: Annotated[
        int,
        Field(
            alias="degradedCount", description="Number of services with degraded status"
        ),
    ]
    partial_outage_count: Annotated[
        int,
        Field(
            alias="partialOutageCount",
            description="Number of services with partial outage",
        ),
    ]
    major_outage_count: Annotated[
        int,
        Field(
            alias="majorOutageCount", description="Number of services with major outage"
        ),
    ]
    maintenance_count: Annotated[
        int,
        Field(
            alias="maintenanceCount",
            description="Number of services currently under maintenance",
        ),
    ]
    unknown_count: Annotated[
        int,
        Field(
            alias="unknownCount",
            description="Number of services with unknown or null status",
        ),
    ]
    active_incident_count: Annotated[
        int,
        Field(
            alias="activeIncidentCount",
            description="Total number of active incidents across all services",
        ),
    ]
    services_with_issues: Annotated[
        list[ServiceCatalogDto],
        Field(
            alias="servicesWithIssues",
            description="Services that are not fully operational",
        ),
    ]


class Http(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    check_type: Literal["http"] = "http"
    timing: TimingPhasesDto | None = None
    body_truncated: Annotated[
        bool | None,
        Field(
            alias="bodyTruncated",
            description="Whether the response body was truncated before storage",
        ),
    ] = None


class IncidentDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    incident: IncidentDto
    updates: list[IncidentUpdateDto]
    status_page_incidents: Annotated[
        list[LinkedStatusPageIncidentDto] | None, Field(alias="statusPageIncidents")
    ] = None


class IncidentPolicyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique incident policy identifier")]
    monitor_id: Annotated[
        UUID, Field(alias="monitorId", description="Monitor this policy is attached to")
    ]
    trigger_rules: Annotated[
        list[TriggerRule],
        Field(
            alias="triggerRules",
            description="Array of trigger rules defining when an incident should be raised",
        ),
    ]
    confirmation: ConfirmationPolicy
    recovery: RecoveryPolicy
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the policy was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt", description="Timestamp when the policy was last updated"
        ),
    ]
    monitor_region_count: Annotated[
        int | None,
        Field(
            alias="monitorRegionCount",
            description="Number of regions configured on the monitor (only set in internal API responses)",
        ),
    ] = None
    check_frequency_seconds: Annotated[
        int | None,
        Field(
            alias="checkFrequencySeconds",
            description="Monitor check frequency in seconds (only set in internal API responses)",
        ),
    ] = None


class IncidentStateTransitionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Forensic row UUID")]
    occurred_at: Annotated[
        AwareDatetime,
        Field(alias="occurredAt", description="When the state transition occurred"),
    ]
    monitor_id: Annotated[
        UUID,
        Field(alias="monitorId", description="Monitor this transition pertains to"),
    ]
    incident_id: Annotated[
        UUID | None,
        Field(
            alias="incidentId",
            description="Incident this transition belongs to; null for pre-incident (auto-cleared) transitions",
        ),
    ] = None
    from_status: Annotated[
        str,
        Field(
            alias="fromStatus",
            description="Previous status (WATCHING | TRIGGERED | CONFIRMED | RESOLVED)",
            min_length=1,
        ),
    ]
    to_status: Annotated[
        str,
        Field(
            alias="toStatus",
            description="New status (WATCHING | TRIGGERED | CONFIRMED | RESOLVED)",
            min_length=1,
        ),
    ]
    reason: Annotated[
        str,
        Field(
            description="Why the transition fired (trigger | confirm | resolve | auto_clear | reopen)",
            min_length=1,
        ),
    ]
    triggering_evaluation_ids: Annotated[
        list[UUID],
        Field(
            alias="triggeringEvaluationIds",
            description="rule_evaluation ids that caused this transition (may be empty for timeout-driven edges)",
        ),
    ]
    affected_regions: Annotated[
        list[str],
        Field(
            alias="affectedRegions",
            description="Regions whose evaluations contributed to this transition",
        ),
    ]
    policy_snapshot_hash_hex: Annotated[
        str,
        Field(
            alias="policySnapshotHashHex",
            description="Hex-encoded hash of the policy snapshot that governed this transition",
            min_length=1,
        ),
    ]
    engine_version: Annotated[
        str,
        Field(
            alias="engineVersion",
            description="Detection engine version that emitted this transition",
            min_length=1,
        ),
    ]
    check_id: Annotated[
        UUID,
        Field(
            alias="checkId",
            description="Scheduler-minted check execution ID (V92) of the triggering result",
        ),
    ]
    details: StateTransitionDetails


class IncidentTimelineDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    transitions: Annotated[
        list[IncidentStateTransitionDto],
        Field(description="State-machine transitions in chronological order"),
    ]
    triggering_evaluations: Annotated[
        list[RuleEvaluationDto],
        Field(
            alias="triggeringEvaluations",
            description="Rule evaluations that caused any of the transitions above. Correlate via evaluation.triggeringTransitionId == transition.id",
        ),
    ]
    policy_snapshot: Annotated[
        PolicySnapshotDto | None, Field(alias="policySnapshot")
    ] = None


class IntegrationConfigSchemaDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    connection_fields: Annotated[
        list[IntegrationFieldDto], Field(alias="connectionFields")
    ]
    channel_fields: Annotated[list[IntegrationFieldDto], Field(alias="channelFields")]


class IntegrationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: str
    name: str
    description: str
    logo_url: Annotated[str, Field(alias="logoUrl")]
    auth_type: Annotated[str, Field(alias="authType")]
    tier_availability: Annotated[str, Field(alias="tierAvailability")]
    lifecycle: str
    setup_guide_url: Annotated[str, Field(alias="setupGuideUrl")]
    config_schema: Annotated[IntegrationConfigSchemaDto, Field(alias="configSchema")]


class MonitorAssertionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    monitor_id: Annotated[UUID, Field(alias="monitorId")]
    assertion_type: Annotated[str, Field(alias="assertionType")]
    config: Annotated[
        BodyContainsAssertion
        | DnsExpectedCnameAssertion
        | DnsExpectedIpsAssertion
        | DnsMaxAnswersAssertion
        | DnsMinAnswersAssertion
        | DnsRecordContainsAssertion
        | DnsRecordEqualsAssertion
        | DnsResolvesAssertion
        | DnsResponseTimeAssertion
        | DnsResponseTimeWarnAssertion
        | DnsTtlHighAssertion
        | DnsTtlLowAssertion
        | DnsTxtContainsAssertion
        | HeaderValueAssertion
        | HeartbeatIntervalDriftAssertion
        | HeartbeatMaxIntervalAssertion
        | HeartbeatPayloadContainsAssertion
        | HeartbeatReceivedAssertion
        | IcmpPacketLossAssertion
        | IcmpReachableAssertion
        | IcmpResponseTimeAssertion
        | IcmpResponseTimeWarnAssertion
        | JsonPathAssertion
        | McpConnectsAssertion
        | McpHasCapabilityAssertion
        | McpMinToolsAssertion
        | McpProtocolVersionAssertion
        | McpResponseTimeAssertion
        | McpResponseTimeWarnAssertion
        | McpToolAvailableAssertion
        | McpToolCountChangedAssertion
        | RedirectCountAssertion
        | RedirectTargetAssertion
        | RegexBodyAssertion
        | ResponseSizeAssertion
        | ResponseTimeAssertion
        | ResponseTimeWarnAssertion
        | SslExpiryAssertion
        | StatusCodeAssertion
        | TcpConnectsAssertion
        | TcpResponseTimeAssertion
        | TcpResponseTimeWarnAssertion,
        Field(discriminator="type"),
    ]
    severity: str


class MonitorDto(BaseModel):
    """Note: ``currentStatus`` was removed from this DTO. Inspect ``enabled`` and the incident-policy API to derive a live status for a monitor instead."""

    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique monitor identifier")]
    organization_id: Annotated[
        int,
        Field(
            alias="organizationId", description="Organization this monitor belongs to"
        ),
    ]
    name: Annotated[
        str, Field(description="Human-readable name for this monitor", min_length=1)
    ]
    type: str
    config: (
        DnsMonitorConfig
        | HeartbeatMonitorConfig
        | HttpMonitorConfig
        | IcmpMonitorConfig
        | McpServerMonitorConfig
        | TcpMonitorConfig
    )
    frequency_seconds: Annotated[
        int,
        Field(
            alias="frequencySeconds",
            description="Check frequency in seconds (30–86400)",
        ),
    ]
    enabled: Annotated[bool, Field(description="Whether the monitor is active")]
    regions: Annotated[
        list[str], Field(description="Probe regions where checks are executed")
    ]
    managed_by: Annotated[
        str,
        Field(
            alias="managedBy",
            description="Source that created/owns this monitor: DASHBOARD, CLI, TERRAFORM, MCP, or API",
        ),
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the monitor was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt", description="Timestamp when the monitor was last updated"
        ),
    ]
    assertions: Annotated[
        list[MonitorAssertionDto] | None,
        Field(
            description="Assertions evaluated against each check result; null on list responses"
        ),
    ] = None
    tags: Annotated[
        list[TagDto] | None, Field(description="Tags applied to this monitor")
    ] = None
    ping_url: Annotated[
        str | None,
        Field(
            alias="pingUrl",
            description="Heartbeat ping URL; populated for HEARTBEAT monitors only",
        ),
    ] = None
    environment: Summary | None = None
    auth: MonitorAuthConfig | None = None
    incident_policy: Annotated[
        IncidentPolicyDto | None, Field(alias="incidentPolicy")
    ] = None
    alert_channel_ids: Annotated[
        list[UUID] | None,
        Field(
            alias="alertChannelIds",
            description="Alert channel IDs linked to this monitor; populated on single-monitor responses",
        ),
    ] = None
    current_status: Annotated[
        str | None,
        Field(
            alias="currentStatus",
            description="Current operational state — UP, DOWN, DEGRADED, PAUSED, or UNKNOWN if no probe data yet",
        ),
    ] = None


class MonitorTestRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    type: Annotated[Type3, Field(description="Monitor protocol type to test")]
    config: (
        DnsMonitorConfig
        | HeartbeatMonitorConfig
        | HttpMonitorConfig
        | IcmpMonitorConfig
        | McpServerMonitorConfig
        | TcpMonitorConfig
    )
    assertions: Annotated[
        list[CreateAssertionRequest] | None,
        Field(description="Optional assertions to evaluate against the test result"),
    ] = None


class MonitorVersionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique version record identifier")]
    monitor_id: Annotated[
        UUID, Field(alias="monitorId", description="Monitor this version belongs to")
    ]
    version: Annotated[
        int, Field(description="Monotonically increasing version number")
    ]
    snapshot: MonitorDto
    changed_by_id: Annotated[
        int | None,
        Field(
            alias="changedById",
            description="User ID who made the change; null for automated changes",
        ),
    ] = None
    changed_via: Annotated[
        str,
        Field(alias="changedVia", description="Change source (DASHBOARD, CLI, API)"),
    ]
    change_summary: Annotated[
        str | None,
        Field(
            alias="changeSummary",
            description="Human-readable description of what changed",
        ),
    ] = None
    created_at: Annotated[
        AwareDatetime,
        Field(
            alias="createdAt", description="Timestamp when this version was recorded"
        ),
    ]


class NotificationPolicyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique notification policy identifier")]
    organization_id: Annotated[
        int,
        Field(
            alias="organizationId", description="Organization this policy belongs to"
        ),
    ]
    name: Annotated[
        str, Field(description="Human-readable name for this policy", min_length=1)
    ]
    match_rules: Annotated[
        list[MatchRule],
        Field(
            alias="matchRules",
            description="Match rules (all must pass; empty = catch-all)",
        ),
    ]
    escalation: EscalationChain
    enabled: Annotated[bool, Field(description="Whether this policy is active")]
    priority: Annotated[
        int, Field(description="Evaluation order; higher value = evaluated first")
    ]
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the policy was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt", description="Timestamp when the policy was last updated"
        ),
    ]


class ResourceGroupDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique resource group identifier")]
    organization_id: Annotated[
        int,
        Field(alias="organizationId", description="Organization this group belongs to"),
    ]
    name: Annotated[str, Field(description="Human-readable group name", min_length=1)]
    slug: Annotated[str, Field(description="URL-safe group identifier", min_length=1)]
    description: Annotated[
        str | None, Field(description="Optional group description")
    ] = None
    alert_policy_id: Annotated[
        UUID | None,
        Field(
            alias="alertPolicyId",
            description="Notification policy applied to this group",
        ),
    ] = None
    default_frequency: Annotated[
        int | None,
        Field(
            alias="defaultFrequency",
            description="Default check frequency in seconds for member monitors",
        ),
    ] = None
    default_regions: Annotated[
        list[str] | None,
        Field(
            alias="defaultRegions", description="Default regions for member monitors"
        ),
    ] = None
    default_retry_strategy: Annotated[
        RetryStrategy | None, Field(alias="defaultRetryStrategy")
    ] = None
    default_alert_channels: Annotated[
        list[UUID] | None,
        Field(
            alias="defaultAlertChannels",
            description="Default alert channel IDs for member monitors",
        ),
    ] = None
    default_environment_id: Annotated[
        UUID | None,
        Field(
            alias="defaultEnvironmentId",
            description="Default environment ID for member monitors",
        ),
    ] = None
    health_threshold_type: Annotated[
        str | None,
        Field(
            alias="healthThresholdType",
            description="Health threshold type: COUNT or PERCENTAGE",
        ),
    ] = None
    health_threshold_value: Annotated[
        float | None,
        Field(alias="healthThresholdValue", description="Health threshold value"),
    ] = None
    suppress_member_alerts: Annotated[
        bool,
        Field(
            alias="suppressMemberAlerts",
            description="When true, member-level incidents skip notification dispatch; only group alerts fire",
        ),
    ]
    confirmation_delay_seconds: Annotated[
        int | None,
        Field(
            alias="confirmationDelaySeconds",
            description="Seconds to wait after health threshold breach before creating group incident",
        ),
    ] = None
    recovery_cooldown_minutes: Annotated[
        int | None,
        Field(
            alias="recoveryCooldownMinutes",
            description="Cooldown minutes after group incident resolves before a new one can open",
        ),
    ] = None
    health: ResourceGroupHealthDto
    members: Annotated[
        list[ResourceGroupMemberDto] | None,
        Field(
            description="Member list with individual statuses; populated on detail GET only"
        ),
    ] = None
    managed_by: Annotated[
        str | None,
        Field(
            alias="managedBy",
            description="Source that created/owns this group: DASHBOARD, CLI, TERRAFORM, MCP, or API. Null on groups created before this attribution column existed.",
        ),
    ] = None
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the group was created"),
    ]
    updated_at: Annotated[
        AwareDatetime,
        Field(
            alias="updatedAt", description="Timestamp when the group was last updated"
        ),
    ]


class ServiceDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    slug: str
    name: str
    category: str | None = None
    official_status_url: Annotated[str | None, Field(alias="officialStatusUrl")] = None
    developer_context: Annotated[str | None, Field(alias="developerContext")] = None
    logo_url: Annotated[str | None, Field(alias="logoUrl")] = None
    adapter_type: Annotated[str, Field(alias="adapterType")]
    polling_interval_seconds: Annotated[int, Field(alias="pollingIntervalSeconds")]
    enabled: bool
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]
    current_status: Annotated[ServiceStatusDto | None, Field(alias="currentStatus")] = (
        None
    )
    recent_incidents: Annotated[
        list[ServiceIncidentDto], Field(alias="recentIncidents")
    ]
    components: list[ServiceComponentDto]
    components_summary: Annotated[
        ComponentsSummaryDto | None, Field(alias="componentsSummary")
    ] = None
    uptime: ComponentUptimeSummaryDto | None = None
    active_maintenances: Annotated[
        list[ScheduledMaintenanceDto], Field(alias="activeMaintenances")
    ]
    data_completeness: Annotated[str, Field(alias="dataCompleteness")]
    seo_metadata: Annotated[SeoMetadataDto | None, Field(alias="seoMetadata")] = None
    related_services: Annotated[
        list[ServiceCatalogDto] | None, Field(alias="relatedServices")
    ] = None


class ServiceIncidentDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    title: str
    status: str
    impact: str | None = None
    started_at: Annotated[AwareDatetime | None, Field(alias="startedAt")] = None
    resolved_at: Annotated[AwareDatetime | None, Field(alias="resolvedAt")] = None
    detected_at: Annotated[AwareDatetime | None, Field(alias="detectedAt")] = None
    shortlink: str | None = None
    affected_components: Annotated[
        list[str] | None, Field(alias="affectedComponents")
    ] = None
    updates: list[ServiceIncidentUpdateDto]


class ServiceUptimeResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    overall_uptime_pct: Annotated[
        float | None,
        Field(
            alias="overallUptimePct",
            description="Overall uptime percentage across the entire period; null when no polling data exists",
            examples=[99.95],
        ),
    ] = None
    period: Annotated[str, Field(description="Requested period", examples=["7d"])]
    granularity: Annotated[
        str, Field(description="Requested granularity", examples=["hourly"])
    ]
    buckets: Annotated[
        list[UptimeBucketDto],
        Field(description="Per-bucket breakdown ordered by time ascending"),
    ]
    source: Annotated[
        str | None,
        Field(
            description="Data source: vendor_reported, incident_derived, or poll_derived",
            examples=["vendor_reported"],
        ),
    ] = None


class SingleValueResponseAuthMeResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: AuthMeResponse


class SingleValueResponseBulkMonitorActionResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: BulkMonitorActionResult


class SingleValueResponseDashboardOverviewDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: DashboardOverviewDto


class SingleValueResponseGlobalStatusSummaryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: GlobalStatusSummaryDto


class SingleValueResponseIncidentDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: IncidentDetailDto


class SingleValueResponseIncidentPolicyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: IncidentPolicyDto


class SingleValueResponseIncidentTimelineDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: IncidentTimelineDto


class SingleValueResponseMonitorAssertionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: MonitorAssertionDto


class SingleValueResponseMonitorDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: MonitorDto


class SingleValueResponseMonitorVersionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: MonitorVersionDto


class SingleValueResponseNotificationPolicyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: NotificationPolicyDto


class SingleValueResponseResourceGroupDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ResourceGroupDto


class SingleValueResponseServiceDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServiceDetailDto


class SingleValueResponseServiceIncidentDetailDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServiceIncidentDetailDto


class SingleValueResponseServiceUptimeResponse(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: ServiceUptimeResponse


class SingleValueResponseStatusPageComponentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: StatusPageComponentDto


class SingleValueResponseStatusPageComponentGroupDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: StatusPageComponentGroupDto


class SingleValueResponseStatusPageCustomDomainDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: StatusPageCustomDomainDto


class SingleValueResponseStatusPageDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: StatusPageDto


class SingleValueResponseStatusPageSubscriberDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: StatusPageSubscriberDto


class SingleValueResponseTagDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: TagDto


class SingleValueResponseTestChannelResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: TestChannelResult


class SingleValueResponseTestMatchResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: TestMatchResult


class SingleValueResponseUptimeDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: UptimeDto


class SingleValueResponseWebhookEndpointDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: WebhookEndpointDto


class SingleValueResponseWebhookSigningSecretDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: WebhookSigningSecretDto


class SingleValueResponseWebhookTestResult(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: WebhookTestResult


class SingleValueResponseWorkspaceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: WorkspaceDto


class StatusPageIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: UUID
    status_page_id: Annotated[UUID, Field(alias="statusPageId")]
    title: Annotated[str, Field(min_length=1)]
    status: str
    impact: str
    scheduled: bool
    scheduled_for: Annotated[AwareDatetime | None, Field(alias="scheduledFor")] = None
    scheduled_until: Annotated[AwareDatetime | None, Field(alias="scheduledUntil")] = (
        None
    )
    auto_resolve: Annotated[bool, Field(alias="autoResolve")]
    incident_id: Annotated[UUID | None, Field(alias="incidentId")] = None
    started_at: Annotated[AwareDatetime, Field(alias="startedAt")]
    published_at: Annotated[AwareDatetime | None, Field(alias="publishedAt")] = None
    resolved_at: Annotated[AwareDatetime | None, Field(alias="resolvedAt")] = None
    created_by_user_id: Annotated[int | None, Field(alias="createdByUserId")] = None
    postmortem_body: Annotated[str | None, Field(alias="postmortemBody")] = None
    postmortem_url: Annotated[str | None, Field(alias="postmortemUrl")] = None
    affected_components: Annotated[
        list[StatusPageIncidentComponentDto] | None, Field(alias="affectedComponents")
    ] = None
    updates: list[StatusPageIncidentUpdateDto] | None = None
    created_at: Annotated[AwareDatetime, Field(alias="createdAt")]
    updated_at: Annotated[AwareDatetime, Field(alias="updatedAt")]


class TableValueResultComponentUptimeDayDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ComponentUptimeDayDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultIncidentStateTransitionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[IncidentStateTransitionDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultIntegrationDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[IntegrationDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultMonitorDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[MonitorDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultMonitorVersionDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[MonitorVersionDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultNotificationPolicyDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[NotificationPolicyDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultResourceGroupDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[ResourceGroupDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultStatusPageIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[StatusPageIncidentDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultTagDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[TagDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultWebhookDeliveryDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[WebhookDeliveryDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultWebhookEndpointDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[WebhookEndpointDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TableValueResultWorkspaceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[WorkspaceDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class TestAlertChannelRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    config: Annotated[
        DiscordChannelConfig
        | EmailChannelConfig
        | OpsGenieChannelConfig
        | PagerDutyChannelConfig
        | SlackChannelConfig
        | TeamsChannelConfig
        | WebhookChannelConfig,
        Field(discriminator="channel_type"),
    ]


class UpdateAlertChannelRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="New channel name (full replacement, not partial update)",
            max_length=255,
            min_length=0,
        ),
    ]
    config: Annotated[
        DiscordChannelConfig
        | EmailChannelConfig
        | OpsGenieChannelConfig
        | PagerDutyChannelConfig
        | SlackChannelConfig
        | TeamsChannelConfig
        | WebhookChannelConfig,
        Field(discriminator="channel_type"),
    ]
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="New attribution source: DASHBOARD, CLI, TERRAFORM, MCP, or API; null preserves current value.",
        ),
    ] = None


class UpdateMonitorRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None,
        Field(
            description="New monitor name; null preserves current",
            max_length=255,
            min_length=0,
        ),
    ] = None
    config: (
        DnsMonitorConfig
        | HeartbeatMonitorConfig
        | HttpMonitorConfig
        | IcmpMonitorConfig
        | McpServerMonitorConfig
        | TcpMonitorConfig
        | None
    ) = None
    frequency_seconds: Annotated[
        int | None,
        Field(
            alias="frequencySeconds",
            description="New check frequency in seconds (10–86400); null preserves current",
            ge=10,
            le=86400,
        ),
    ] = None
    enabled: Annotated[
        bool | None,
        Field(description="Enable or disable the monitor; null preserves current"),
    ] = None
    regions: Annotated[
        list[str] | None,
        Field(
            description="New probe regions; null preserves current. Allowed values are deployment-dependent."
        ),
    ] = None
    managed_by: Annotated[
        ManagedBy | None,
        Field(
            alias="managedBy",
            description="New ownership source: DASHBOARD, CLI, TERRAFORM, MCP, or API; null preserves current value",
        ),
    ] = None
    environment_id: Annotated[
        UUID | None,
        Field(
            alias="environmentId",
            description="New environment ID; null preserves current (use clearEnvironmentId to unset)",
        ),
    ] = None
    clear_environment_id: Annotated[
        bool | None,
        Field(
            alias="clearEnvironmentId",
            description="Set to true to remove the environment association",
        ),
    ] = None
    assertions: Annotated[
        list[CreateAssertionRequest] | None,
        Field(description="Replace all assertions; null preserves current"),
    ] = None
    auth: MonitorAuthConfig | None = None
    clear_auth: Annotated[
        bool | None,
        Field(alias="clearAuth", description="Set to true to remove authentication"),
    ] = None
    incident_policy: Annotated[
        UpdateIncidentPolicyRequest | None, Field(alias="incidentPolicy")
    ] = None
    alert_channel_ids: Annotated[
        list[UUID] | None,
        Field(
            alias="alertChannelIds",
            description="Replace alert channel list; null preserves current",
        ),
    ] = None
    tags: AddMonitorTagsRequest | None = None


class UpdateNotificationPolicyRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str | None,
        Field(
            description="Human-readable name for this policy; null preserves current",
            max_length=255,
            min_length=0,
        ),
    ] = None
    match_rules: Annotated[
        list[MatchRule] | None,
        Field(
            alias="matchRules",
            description="Match rules to evaluate (all must pass; omit or empty for catch-all)",
        ),
    ] = None
    escalation: EscalationChain | None = None
    enabled: Annotated[
        bool | None,
        Field(description="Whether this policy is enabled; null preserves current"),
    ] = None
    priority: Annotated[
        int | None,
        Field(
            description="Evaluation priority; higher value = evaluated first; null preserves current"
        ),
    ] = None


class AuditEventDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[int, Field(description="Unique audit event identifier")]
    actor_id: Annotated[
        int | None,
        Field(
            alias="actorId",
            description="User ID who performed the action; null for system actions",
        ),
    ] = None
    actor_email: Annotated[
        str | None,
        Field(
            alias="actorEmail",
            description="Email of the actor; null for system actions",
        ),
    ] = None
    action: Annotated[
        str,
        Field(description="Audit action type (e.g. monitor.created, api_key.revoked)"),
    ]
    resource_type: Annotated[
        str | None,
        Field(
            alias="resourceType",
            description="Type of resource affected (e.g. monitor, api_key)",
        ),
    ] = None
    resource_id: Annotated[
        str | None, Field(alias="resourceId", description="ID of the affected resource")
    ] = None
    resource_name: Annotated[
        str | None,
        Field(
            alias="resourceName",
            description="Human-readable name of the affected resource",
        ),
    ] = None
    metadata: AuditMetadata | None = None
    created_at: Annotated[
        AwareDatetime,
        Field(alias="createdAt", description="Timestamp when the action was performed"),
    ]


class BatchComponentUptimeDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    components: Annotated[
        dict[str, list[ComponentUptimeDayDto]],
        Field(
            description="Map of component ID → list of per-day uptime entries (oldest → newest)"
        ),
    ]


class CheckTraceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    check_id: Annotated[
        UUID,
        Field(
            alias="checkId", description="The check execution ID this trace is keyed by"
        ),
    ]
    evaluations: Annotated[
        list[RuleEvaluationDto],
        Field(description="All rule evaluations that ran for this check"),
    ]
    transitions: Annotated[
        list[IncidentStateTransitionDto],
        Field(
            description="State-machine transitions this check caused (may be empty if nothing fired)"
        ),
    ]
    policy_snapshot: Annotated[
        PolicySnapshotDto | None, Field(alias="policySnapshot")
    ] = None


class CheckTypeDetailsDto(RootModel[Http | Tcp | Icmp | Dns | McpServer]):
    root: Annotated[
        Http | Tcp | Icmp | Dns | McpServer,
        Field(
            description="Check-type-specific details — polymorphic by check_type discriminator",
            discriminator="check_type",
        ),
    ]


class CreateNotificationPolicyRequest(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    name: Annotated[
        str,
        Field(
            description="Human-readable name for this policy",
            max_length=255,
            min_length=0,
        ),
    ]
    match_rules: Annotated[
        list[MatchRule] | None,
        Field(
            alias="matchRules",
            description="Match rules to evaluate (all must pass; omit or empty for catch-all)",
        ),
    ] = None
    escalation: EscalationChain
    enabled: Annotated[
        bool | None, Field(description="Whether this policy is enabled (default true)")
    ] = True
    priority: Annotated[
        int | None,
        Field(
            description="Evaluation priority; higher value = evaluated first (default 0)"
        ),
    ] = 0


class SingleValueResponseBatchComponentUptimeDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: BatchComponentUptimeDto


class SingleValueResponseCheckTraceDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: CheckTraceDto


class SingleValueResponseStatusPageIncidentDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: StatusPageIncidentDto


class TableValueResultAuditEventDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: list[AuditEventDto]
    has_next: Annotated[bool, Field(alias="hasNext")]
    has_prev: Annotated[bool, Field(alias="hasPrev")]
    total_elements: Annotated[int | None, Field(alias="totalElements")] = None
    total_pages: Annotated[int | None, Field(alias="totalPages")] = None


class CheckResultDetailsDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    status_code: Annotated[
        int | None,
        Field(
            alias="statusCode",
            description="HTTP status code of the response",
            examples=[200],
        ),
    ] = None
    response_headers: Annotated[
        dict[str, list[str]] | None,
        Field(alias="responseHeaders", description="HTTP response headers"),
    ] = None
    response_body_snapshot: Annotated[
        str | None,
        Field(
            alias="responseBodySnapshot",
            description="Raw response body snapshot (may be HTML, XML, JSON, or plain text)",
        ),
    ] = None
    assertion_results: Annotated[
        list[AssertionResultDto] | None,
        Field(
            alias="assertionResults",
            description="Individual assertion evaluation results",
        ),
    ] = None
    tls_info: Annotated[TlsInfoDto | None, Field(alias="tlsInfo")] = None
    redirect_count: Annotated[
        int | None,
        Field(
            alias="redirectCount",
            description="Number of HTTP redirects followed",
            examples=[2],
        ),
    ] = None
    redirect_target: Annotated[
        str | None,
        Field(alias="redirectTarget", description="Final URL after redirects"),
    ] = None
    response_size_bytes: Annotated[
        int | None,
        Field(
            alias="responseSizeBytes",
            description="Response body size in bytes",
            examples=[4096],
        ),
    ] = None
    check_details: Annotated[
        CheckTypeDetailsDto | None, Field(alias="checkDetails")
    ] = None


class CheckResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    id: Annotated[UUID, Field(description="Unique identifier of the check result")]
    timestamp: Annotated[
        AwareDatetime,
        Field(description="Timestamp when the check was executed (ISO 8601)"),
    ]
    region: Annotated[
        str,
        Field(description="Region where the check was executed", examples=["us-east"]),
    ]
    response_time_ms: Annotated[
        int | None,
        Field(
            alias="responseTimeMs",
            description="Response time in milliseconds",
            examples=[123],
        ),
    ] = None
    passed: Annotated[
        bool, Field(description="Whether the check passed", examples=[True])
    ]
    failure_reason: Annotated[
        str | None,
        Field(
            alias="failureReason", description="Reason for failure when passed=false"
        ),
    ] = None
    severity_hint: Annotated[
        str | None,
        Field(
            alias="severityHint",
            description="Severity hint: 'down' for hard failures, 'degraded' for warn-only failures, null when passing",
        ),
    ] = None
    details: CheckResultDetailsDto | None = None
    check_id: Annotated[
        UUID | None,
        Field(
            alias="checkId",
            description="Unique execution trace ID for cross-service correlation",
        ),
    ] = None


class CursorPageCheckResultDto(BaseModel):
    model_config = ConfigDict(extra="forbid", populate_by_name=True)
    data: Annotated[list[CheckResultDto], Field(description="Items on this page")]
    next_cursor: Annotated[
        str | None,
        Field(
            alias="nextCursor",
            description="Opaque cursor for the next page; null when there are no more results",
        ),
    ] = None
    has_more: Annotated[
        bool,
        Field(
            alias="hasMore", description="Whether more results exist beyond this page"
        ),
    ]