uarp_sdk/generated/

models.rs

// Code generated by @uarp/codegen from spec/openapi.json. DO NOT EDIT.
//!
//! Data models for UARP — Universal Agent Runtime Platform (spec version 0.4.0).

#![allow(unused_imports, clippy::large_enum_variant)]

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use crate::multipart::FilePart;

/// a2a/agent-card.ts A2AAgentCard, built by buildAgentCard. `provider` is declared on the type
/// and never emitted.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCard {
    pub name: String,
    pub description: String,
    /// `{origin}/api/v1/a2a`.
    pub url: String,
    pub agent_id: String,
    pub version: String,
    pub schema_version: A2AAgentCardSchemaVersion,
    pub protocol_version: A2AAgentCardProtocolVersion,
    pub capabilities: A2AAgentCardCapabilities,
    pub skills: Vec<A2AAgentCardSkill>,
    pub authentication: A2AAgentCardAuthentication,
    pub default_input_modes: Vec<String>,
    pub default_output_modes: Vec<String>,
    pub mcp_resources: Vec<String>,
}

/// `A2AAgentCardAuthentication` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCardAuthentication {
    pub r#type: A2AAgentCardAuthenticationType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub header: Option<A2AAgentCardAuthenticationHeader>,
}

/// `A2AAgentCardAuthenticationHeader` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2AAgentCardAuthenticationHeader {
    #[default]
    #[serde(rename = "Authorization")]
    Authorization,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2AAgentCardAuthenticationHeader {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Authorization => "Authorization",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2AAgentCardAuthenticationHeader {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2AAgentCardAuthenticationHeader {
    fn from(value: &str) -> Self {
        match value {
            "Authorization" => Self::Authorization,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `A2AAgentCardAuthenticationType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2AAgentCardAuthenticationType {
    #[default]
    #[serde(rename = "none")]
    None,
    #[serde(rename = "apiKey")]
    APIKey,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2AAgentCardAuthenticationType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::None => "none",
            Self::APIKey => "apiKey",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2AAgentCardAuthenticationType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2AAgentCardAuthenticationType {
    fn from(value: &str) -> Self {
        match value {
            "none" => Self::None,
            "apiKey" => Self::APIKey,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `A2AAgentCardCapabilities` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCardCapabilities {
    pub streaming: bool,
    pub push_notifications: bool,
    pub state_transition_history: bool,
}

/// `A2AAgentCardProtocolVersion` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2AAgentCardProtocolVersion {
    #[default]
    #[serde(rename = "0.2")]
    V02,
    #[serde(rename = "0.3")]
    V03,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2AAgentCardProtocolVersion {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::V02 => "0.2",
            Self::V03 => "0.3",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2AAgentCardProtocolVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2AAgentCardProtocolVersion {
    fn from(value: &str) -> Self {
        match value {
            "0.2" => Self::V02,
            "0.3" => Self::V03,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `A2AAgentCardSchemaVersion` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2AAgentCardSchemaVersion {
    #[default]
    #[serde(rename = "1.0")]
    V10,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2AAgentCardSchemaVersion {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::V10 => "1.0",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2AAgentCardSchemaVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2AAgentCardSchemaVersion {
    fn from(value: &str) -> Self {
        match value {
            "1.0" => Self::V10,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `A2AAgentCardSkill` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCardSkill {
    pub id: String,
    pub name: String,
    pub description: String,
    pub tags: Vec<String>,
    pub examples: Vec<String>,
}

/// `A2ajsonRpcRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2ajsonRpcRequest {
    /// Always `2.0`.
    pub jsonrpc: String,
    pub method: A2ajsonRpcRequestMethod,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub params: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<serde_json::Value>,
}

/// `A2ajsonRpcRequestMethod` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2ajsonRpcRequestMethod {
    #[default]
    #[serde(rename = "tasks/send")]
    TasksSend,
    #[serde(rename = "tasks/sendSubscribe")]
    TasksSendSubscribe,
    #[serde(rename = "tasks/get")]
    TasksGet,
    #[serde(rename = "tasks/cancel")]
    TasksCancel,
    #[serde(rename = "tasks/pushNotification/set")]
    TasksPushNotificationSet,
    #[serde(rename = "tasks/pushNotification/get")]
    TasksPushNotificationGet,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2ajsonRpcRequestMethod {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::TasksSend => "tasks/send",
            Self::TasksSendSubscribe => "tasks/sendSubscribe",
            Self::TasksGet => "tasks/get",
            Self::TasksCancel => "tasks/cancel",
            Self::TasksPushNotificationSet => "tasks/pushNotification/set",
            Self::TasksPushNotificationGet => "tasks/pushNotification/get",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2ajsonRpcRequestMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2ajsonRpcRequestMethod {
    fn from(value: &str) -> Self {
        match value {
            "tasks/send" => Self::TasksSend,
            "tasks/sendSubscribe" => Self::TasksSendSubscribe,
            "tasks/get" => Self::TasksGet,
            "tasks/cancel" => Self::TasksCancel,
            "tasks/pushNotification/set" => Self::TasksPushNotificationSet,
            "tasks/pushNotification/get" => Self::TasksPushNotificationGet,
            other => Self::Other(other.to_string()),
        }
    }
}

/// a2a/agent-card.ts A2APart — `text`, `file` or `data` by `type`. The platform itself emits
/// one text or data part per message; file parts arrive from remote agents.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2APart {
    pub r#type: A2APartType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file: Option<A2APartFile>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `A2APartFile` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2APartFile {
    pub name: String,
    pub mime_type: String,
    /// Inline base64.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
}

/// `A2APartType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2APartType {
    #[default]
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "file")]
    File,
    #[serde(rename = "data")]
    Data,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2APartType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Text => "text",
            Self::File => "file",
            Self::Data => "data",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2APartType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2APartType {
    fn from(value: &str) -> Self {
        match value {
            "text" => Self::Text,
            "file" => Self::File,
            "data" => Self::Data,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `A2ATask` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2ATask {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    pub status: A2ATaskStatus,
    pub messages: Vec<A2ATaskMessage>,
    pub artifacts: Vec<A2ATaskArtifact>,
    pub metadata: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `A2ATaskArtifact` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2ATaskArtifact {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub parts: Vec<A2APart>,
    pub index: i64,
}

/// `A2ATaskMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2ATaskMessage {
    pub role: DrawingJournalEntryAuthorKind,
    pub parts: Vec<A2APart>,
}

/// `A2ATaskStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum A2ATaskStatus {
    #[default]
    #[serde(rename = "submitted")]
    Submitted,
    #[serde(rename = "working")]
    Working,
    #[serde(rename = "input-required")]
    InputRequired,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "canceled")]
    Canceled,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl A2ATaskStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Submitted => "submitted",
            Self::Working => "working",
            Self::InputRequired => "input-required",
            Self::Completed => "completed",
            Self::Canceled => "canceled",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for A2ATaskStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for A2ATaskStatus {
    fn from(value: &str) -> Self {
        match value {
            "submitted" => Self::Submitted,
            "working" => Self::Working,
            "input-required" => Self::InputRequired,
            "completed" => Self::Completed,
            "canceled" => Self::Canceled,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// After-action review, built once when the mission reaches a terminal status.
/// `failure_analysis` is present only when something failed.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Aar {
    pub aar_id: String,
    pub mission_id: String,
    pub tenant_id: String,
    pub created_at: String,
    pub outcome: MissionOutcome,
    pub phases: Vec<AarPhaseRecord>,
    pub objective_outcomes: Vec<AarObjectiveOutcome>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure_analysis: Option<AarFailureAnalysis>,
}

/// `AarFailureAnalysis` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AarFailureAnalysis {
    pub failed_objective_ids: Vec<String>,
    pub root_causes: Vec<AarRootCause>,
    pub lessons: Vec<AarLesson>,
}

/// A pattern seen in this mission and what to do about it next time.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AarLesson {
    pub pattern: String,
    pub recommendation: String,
}

/// `AarObjectiveOutcome` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AarObjectiveOutcome {
    pub objective_id: String,
    /// The objective's status when the mission ended.
    pub final_status: String,
    /// Retries spent on this objective before it settled — read from the objective record, so it
    /// agrees with `GET /missions/{missionId}/objectives`.
    pub strikes_used: i64,
    /// The objective record's `abort_reason`, copied. Absent when it has none.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub abort_reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub final_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub final_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_usd: Option<f64>,
    /// Whether the success criteria were checked and held.
    pub verified: bool,
}

/// `AarPhaseRecord` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AarPhaseRecord {
    pub phase: AarPhaseRecordPhase,
    pub started_at: String,
    pub completed_at: String,
    pub duration_ms: i64,
}

/// `AarPhaseRecordPhase` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AarPhaseRecordPhase {
    #[default]
    #[serde(rename = "recon")]
    Recon,
    #[serde(rename = "plan")]
    Plan,
    #[serde(rename = "authorize")]
    Authorize,
    #[serde(rename = "execute")]
    Execute,
    #[serde(rename = "verify")]
    Verify,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AarPhaseRecordPhase {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Recon => "recon",
            Self::Plan => "plan",
            Self::Authorize => "authorize",
            Self::Execute => "execute",
            Self::Verify => "verify",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AarPhaseRecordPhase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AarPhaseRecordPhase {
    fn from(value: &str) -> Self {
        match value {
            "recon" => Self::Recon,
            "plan" => Self::Plan,
            "authorize" => Self::Authorize,
            "execute" => Self::Execute,
            "verify" => Self::Verify,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AarRootCause` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AarRootCause {
    pub objective_id: String,
    /// Coarse and closed. Derived from the objective's `abort_reason`: `budget_exhausted` and
    /// `exhausted_strikes_\<n\>` → `max_duration_exceeded`; `dependency_failed` and
    /// `verifier_error` → `external_error`. Branch on `code` for the precise reason.
    pub category: AarRootCauseCategory,
    pub details: String,
    /// The objective's `abort_reason` verbatim (e.g. `budget_exhausted`, `verifier_error`). Absent
    /// when the objective recorded none.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
}

/// Coarse and closed. Derived from the objective's `abort_reason`: `budget_exhausted` and
/// `exhausted_strikes_\<n\>` → `max_duration_exceeded`; `dependency_failed` and
/// `verifier_error` → `external_error`. Branch on `code` for the precise reason.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AarRootCauseCategory {
    #[default]
    #[serde(rename = "llm_timeout")]
    LLMTimeout,
    #[serde(rename = "llm_idle")]
    LLMIdle,
    #[serde(rename = "llm_loop")]
    LLMLoop,
    #[serde(rename = "tool_error")]
    ToolError,
    #[serde(rename = "tool_truncation")]
    ToolTruncation,
    #[serde(rename = "verification_failed")]
    VerificationFailed,
    #[serde(rename = "authorization_denied")]
    AuthorizationDenied,
    #[serde(rename = "external_error")]
    ExternalError,
    #[serde(rename = "max_duration_exceeded")]
    MaxDurationExceeded,
    #[serde(rename = "unknown")]
    Unknown,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AarRootCauseCategory {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::LLMTimeout => "llm_timeout",
            Self::LLMIdle => "llm_idle",
            Self::LLMLoop => "llm_loop",
            Self::ToolError => "tool_error",
            Self::ToolTruncation => "tool_truncation",
            Self::VerificationFailed => "verification_failed",
            Self::AuthorizationDenied => "authorization_denied",
            Self::ExternalError => "external_error",
            Self::MaxDurationExceeded => "max_duration_exceeded",
            Self::Unknown => "unknown",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AarRootCauseCategory {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AarRootCauseCategory {
    fn from(value: &str) -> Self {
        match value {
            "llm_timeout" => Self::LLMTimeout,
            "llm_idle" => Self::LLMIdle,
            "llm_loop" => Self::LLMLoop,
            "tool_error" => Self::ToolError,
            "tool_truncation" => Self::ToolTruncation,
            "verification_failed" => Self::VerificationFailed,
            "authorization_denied" => Self::AuthorizationDenied,
            "external_error" => Self::ExternalError,
            "max_duration_exceeded" => Self::MaxDurationExceeded,
            "unknown" => Self::Unknown,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AbortMissionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AbortMissionRequest {
    /// Recorded on the mission; blank or missing is fine.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `AcceptInviteFromPickerRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AcceptInviteFromPickerRequest {
    /// The invite secret, echoed to the picker by `GET /api/v1/me/tenants`. Compared in constant
    /// time. Defence in depth rather than the primary gate — the email match is that — and it
    /// catches the class where the listing ever shows an invite not addressed to the caller.
    /// Invites created before secrets exist accept without one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub token: Option<String>,
    /// Display name for the new member. Omitted, the local part of the invited email is used.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `AcceptInviteFromPickerResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AcceptInviteFromPickerResponse {
    pub accepted: bool,
    pub tenant_id: String,
    pub user_id: String,
    pub role: String,
}

/// `AcceptInviteRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AcceptInviteRequest {
    /// Display name. Omitted, the local part of the invited email is used.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The invite secret from the email link's `?t=`, forwarded in the body.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub token: Option<String>,
}

/// `AcceptInviteResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AcceptInviteResponse {
    pub accepted: bool,
    pub user_id: String,
    pub tenant_id: String,
    pub role: String,
}

/// The JSON form of an account export. The same bundle the zip contains, as one document.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AccountExport {
    pub format: AccountExportFormat,
    pub exported_at: String,
    pub counts: AccountExportCounts,
    /// False when a size ceiling was hit; `omitted` then says what was left out. An export that
    /// quietly drops things is worse than one that admits it.
    pub complete: bool,
    pub omitted: Vec<String>,
    /// Path inside the bundle → its contents (`account.json`, `projects.md`, `memory.md`,
    /// `chats/…`).
    pub files: serde_json::Map<String, serde_json::Value>,
}

/// `AccountExportCounts` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AccountExportCounts {
    pub chats: i64,
    pub projects: i64,
    pub memories: i64,
}

/// `AccountExportFormat` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AccountExportFormat {
    #[default]
    #[serde(rename = "snaga.export.v1")]
    SnagaExportV1,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AccountExportFormat {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::SnagaExportV1 => "snaga.export.v1",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AccountExportFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AccountExportFormat {
    fn from(value: &str) -> Self {
        match value {
            "snaga.export.v1" => Self::SnagaExportV1,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ActivateSafeModeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ActivateSafeModeRequest {
    pub reason: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub activated_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline_hours: Option<f64>,
}

/// `ActivateSessionBranchResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ActivateSessionBranchResponse {
    pub session_id: String,
    pub active_branch: String,
}

/// `ActiveSession` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ActiveSession {
    pub key_id: String,
    pub name: String,
    pub prefix: String,
    pub scopes: Vec<String>,
    pub status: APIKeySummaryStatus,
    pub is_current: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_used_at: Option<String>,
}

/// `AddAndroidTestersRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddAndroidTestersRequest {
    pub emails: Vec<String>,
    /// Server default: `"admin"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
}

/// `AddAndroidTestersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddAndroidTestersResponse {
    pub added: Vec<String>,
    pub already: Vec<String>,
    pub invalid: Vec<String>,
}

/// `AddSquadGraphEdgeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddSquadGraphEdgeRequest {
    pub from: String,
    pub to: String,
    pub r#type: TeamGraphEdgeType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_id: Option<String>,
}

/// `AddSquadGraphNodeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddSquadGraphNodeRequest {
    pub agent_id: String,
    pub role: TeamGraphNodeRole,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spawned_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal_summary: Option<String>,
}

/// `AddTeamGraphEdgeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddTeamGraphEdgeRequest {
    pub from: String,
    pub to: String,
    pub r#type: TeamGraphEdgeType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_id: Option<String>,
}

/// `AddTeamGraphNodeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddTeamGraphNodeRequest {
    pub agent_id: String,
    pub role: TeamGraphNodeRole,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spawned_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal_summary: Option<String>,
}

/// `AdminAnalyticsEventsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAnalyticsEventsResponse {
    pub items: Vec<AdminAnalyticsEventsResponseItem>,
    pub count: i64,
}

/// `AdminAnalyticsEventsResponseItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAnalyticsEventsResponseItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub event_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ts: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visitor_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_type: Option<AdminAnalyticsEventsResponseItemDeviceType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub browser: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub os: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub referrer_host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub utm_source: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub utm_medium: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub utm_campaign: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ip_hash: Option<String>,
}

/// `AdminAnalyticsEventsResponseItemDeviceType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminAnalyticsEventsResponseItemDeviceType {
    #[default]
    #[serde(rename = "mobile")]
    Mobile,
    #[serde(rename = "tablet")]
    Tablet,
    #[serde(rename = "desktop")]
    Desktop,
    #[serde(rename = "bot")]
    Bot,
    #[serde(rename = "unknown")]
    Unknown,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminAnalyticsEventsResponseItemDeviceType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Mobile => "mobile",
            Self::Tablet => "tablet",
            Self::Desktop => "desktop",
            Self::Bot => "bot",
            Self::Unknown => "unknown",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminAnalyticsEventsResponseItemDeviceType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminAnalyticsEventsResponseItemDeviceType {
    fn from(value: &str) -> Self {
        match value {
            "mobile" => Self::Mobile,
            "tablet" => Self::Tablet,
            "desktop" => Self::Desktop,
            "bot" => Self::Bot,
            "unknown" => Self::Unknown,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AdminAnalyticsOverviewResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAnalyticsOverviewResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub range: Option<AdminAnalyticsOverviewResponseRange>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub totals: Option<AdminAnalyticsOverviewResponseTotals>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unique_visitors_30d: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signups_30d: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversion_rate: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeseries: Option<Vec<AnalyticsTimeseriesPoint>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_countries: Option<Vec<AnalyticsTopValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_devices: Option<Vec<AnalyticsTopValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_browsers: Option<Vec<AnalyticsTopValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_referrers: Option<Vec<AnalyticsTopValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_utm_sources: Option<Vec<AnalyticsTopValue>>,
}

/// `AdminAnalyticsOverviewResponseRange` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAnalyticsOverviewResponseRange {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub days: Option<i64>,
}

/// `AdminAnalyticsOverviewResponseTotals` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAnalyticsOverviewResponseTotals {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub landing_visit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page_view: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signup: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub login: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub app_open: Option<i64>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; types/security.ts
/// AdminAuditEntry — actor_* and ip_address conditional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAuditList {
    pub entries: Vec<AdminAuditListEntry>,
    pub total: i64,
}

/// `AdminAuditListEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminAuditListEntry {
    pub entry_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub actor_tenant_id: Option<String>,
    pub action: String,
    pub target_type: String,
    pub target_id: String,
    pub details: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ip_address: Option<String>,
    pub timestamp: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub actor_key_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub actor_user_id: Option<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `agent_memory` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigAgentMemoryConfig {
    pub agent_memory: AdminConfigAgentMemoryConfigAgentMemory,
}

/// `AdminConfigAgentMemoryConfigAgentMemory` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigAgentMemoryConfigAgentMemory {
    pub enabled: bool,
    pub use_shared_store: bool,
    pub default_max_entries: i64,
    pub default_retrieval_limit: i64,
    pub default_retrieval_strategy: String,
    pub decay_enabled: bool,
    pub decay_half_life_days: i64,
    pub decay_job_interval_ms: i64,
    pub extraction_max_tokens: i64,
    pub extraction_model: String,
    pub eviction_threshold: i64,
    pub embedding_dimensions: i64,
    pub embedding_provider: String,
    pub embedding_model: String,
    pub compression_model: String,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `auth` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigAuthConfig {
    pub auth: AdminConfigAuthConfigAuth,
}

/// `AdminConfigAuthConfigAuth` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigAuthConfigAuth {
    pub super_admin_email: String,
    pub otp_ttl_ms: i64,
    pub verification_ttl_ms: i64,
    pub jwks_cache_ttl_ms: i64,
    pub jwks_grace_ttl_ms: i64,
    pub api_key_cache_ttl_s: i64,
    pub api_key_rotation_grace_period_h: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `backpressure` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigBackpressureConfig {
    pub backpressure: AdminConfigBackpressureConfigBackpressure,
}

/// `AdminConfigBackpressureConfigBackpressure` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigBackpressureConfigBackpressure {
    pub sse_buffer_max: i64,
    pub sse_high_watermark: i64,
    pub sse_low_watermark: i64,
    pub tool_queue_max_depth: i64,
    pub tool_queue_high_watermark: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `code_interpreter` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigCodeInterpreterConfig {
    pub code_interpreter: AdminConfigCodeInterpreterConfigCodeInterpreter,
}

/// `AdminConfigCodeInterpreterConfigCodeInterpreter` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigCodeInterpreterConfigCodeInterpreter {
    pub isolation: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_memory_mb: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub container_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub python_container_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub python_sandbox_host_dir: Option<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `evaluation` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigEvaluationConfig {
    pub evaluation: AdminConfigEvaluationConfigEvaluation,
}

/// `AdminConfigEvaluationConfigEvaluation` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigEvaluationConfigEvaluation {
    pub enabled: bool,
    pub max_concurrent_eval_cases: i64,
    pub regression_threshold: f64,
    pub default_scorers: Vec<String>,
    pub max_cases_per_dataset: i64,
    pub eval_run_timeout_ms: i64,
    pub auto_rollback_enabled: bool,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `idempotency` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigIdempotencyConfig {
    pub idempotency: AdminConfigIdempotencyConfigIdempotency,
}

/// `AdminConfigIdempotencyConfigIdempotency` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigIdempotencyConfigIdempotency {
    pub enabled: bool,
    pub ttl_hours: i64,
    pub max_response_cache_bytes: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `llm_adapters` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLLMAdaptersConfig {
    pub llm_adapters: AdminConfigLLMAdaptersConfigLLMAdapters,
}

/// `AdminConfigLLMAdaptersConfigLLMAdapters` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLLMAdaptersConfigLLMAdapters {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_retries: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retry_base_delay_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retry_max_delay_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stream_empty_timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub circuit_breaker: Option<AdminConfigLLMAdaptersConfigLLMAdaptersCircuitBreaker>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_rate_limits: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `AdminConfigLLMAdaptersConfigLLMAdaptersCircuitBreaker` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLLMAdaptersConfigLLMAdaptersCircuitBreaker {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure_threshold: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reset_timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub half_open_max_requests: Option<i64>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `logging` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLoggingConfig {
    pub logging: AdminConfigLoggingConfigLogging,
}

/// `AdminConfigLoggingConfigLogging` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLoggingConfigLogging {
    pub pii_mode: String,
    pub log_agent_responses: bool,
    pub file_enabled: bool,
    pub file_max_size_mb: i64,
    pub file_retention_days: i64,
    pub file_level: String,
    pub file_separate_error: bool,
    pub activity_log_verbosity: String,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `long_running` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLongRunningConfig {
    pub long_running: AdminConfigLongRunningConfigLongRunning,
}

/// `AdminConfigLongRunningConfigLongRunning` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigLongRunningConfigLongRunning {
    pub enabled: bool,
    pub max_duration_ms: i64,
    pub checkpoint_interval_ms: i64,
    pub idle_timeout_ms: i64,
    pub continuation_token_ttl_days: i64,
    pub max_background_runs_per_tenant: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `mcp` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigMCPConfig {
    pub mcp: AdminConfigMCPConfigMCP,
}

/// `AdminConfigMCPConfigMCP` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigMCPConfigMCP {
    pub max_sessions_per_server: i64,
    pub max_total_stdio_sessions: i64,
    pub session_idle_timeout_ms: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `multimodal` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigMultimodalConfig {
    pub multimodal: AdminConfigMultimodalConfigMultimodal,
}

/// `AdminConfigMultimodalConfigMultimodal` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigMultimodalConfigMultimodal {
    pub enabled: bool,
    pub max_image_size_bytes: i64,
    pub max_audio_duration_s: i64,
    pub max_video_duration_s: i64,
    pub auto_resize_images: bool,
    pub supported_image_formats: Vec<String>,
    pub supported_audio_formats: Vec<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `persistence` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigPersistenceConfig {
    pub persistence: AdminConfigPersistenceConfigPersistence,
}

/// `AdminConfigPersistenceConfigPersistence` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigPersistenceConfigPersistence {
    pub snapshot_every_n_events: i64,
    pub checkpoint_after_tool_calls: bool,
    pub usage_shards: i64,
    pub auto_cap_kv_values: bool,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `retention` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigRetentionConfig {
    pub retention: AdminConfigRetentionConfigRetention,
}

/// `AdminConfigRetentionConfigRetention` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigRetentionConfigRetention {
    pub completed_run_ttl_days: i64,
    pub event_ttl_days: i64,
    pub archive_to_sqlite: bool,
    pub audit_log_ttl_days: i64,
    pub archive_job_interval_ms: i64,
    pub archive_batch_size: i64,
    pub feed_ttl_days: i64,
    pub artifact_ttl_days: i64,
    /// Notification retention in days. 0 (the default) means no expiry. Applies to rows written
    /// after the setting changes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notification_ttl_days: Option<i64>,
    pub checkpoint_ttl_hours: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `run_command` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigRunCommandConfig {
    pub run_command: AdminConfigRunCommandConfigRunCommand,
}

/// `AdminConfigRunCommandConfigRunCommand` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigRunCommandConfigRunCommand {
    pub enabled: bool,
    pub isolation: String,
    pub timeout_ms: i64,
    pub max_output_bytes: i64,
    pub allowed_commands: Vec<String>,
    pub deno_allow: Vec<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `policies` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigSecurityPoliciesConfig {
    pub policies: AdminConfigSecurityPoliciesConfigPolicies,
}

/// `AdminConfigSecurityPoliciesConfigPolicies` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigSecurityPoliciesConfigPolicies {
    pub cors_allowed_origins: Vec<String>,
    pub webhook_url_denylist: Vec<String>,
    pub file_upload_max_size_bytes: i64,
    pub file_upload_allowed_mime_types: Vec<String>,
    pub admin_provider_settings_require_super_admin: bool,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `server` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigServerConfig {
    pub server: AdminConfigServerConfigServer,
}

/// `AdminConfigServerConfigServer` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigServerConfigServer {
    pub trust_proxy: bool,
    pub max_body_bytes: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub graceful_shutdown_timeout_ms: Option<i64>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `sse` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigSSEConfig {
    pub sse: AdminConfigSSEConfigSSE,
}

/// `AdminConfigSSEConfigSSE` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigSSEConfigSSE {
    pub heartbeat_interval_ms: i64,
    pub watch_timeout_ms: i64,
    pub poll_interval_ms: i64,
    pub max_poll_interval_ms: i64,
    pub reconnect_hint_ms: i64,
    pub run_wait_timeout_sec: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `tool_security` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigToolSecurityConfig {
    pub tool_security: AdminConfigToolSecurityConfigToolSecurity,
}

/// `AdminConfigToolSecurityConfigToolSecurity` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigToolSecurityConfigToolSecurity {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub egress_allowlist_per_tenant: Option<Vec<String>>,
    pub default_tool_timeout_ms: i64,
    pub default_tool_max_payload_bytes: i64,
    pub default_tool_max_concurrency: i64,
    pub stdio_inherit_env: bool,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `webhooks` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigWebhooksConfig {
    pub webhooks: AdminConfigWebhooksConfigWebhooks,
}

/// `AdminConfigWebhooksConfigWebhooks` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigWebhooksConfigWebhooks {
    pub enabled: bool,
    pub max_subscriptions_per_tenant: i64,
    pub delivery_timeout_ms: i64,
    pub max_retry_attempts: i64,
    pub require_https: bool,
    pub max_payload_bytes: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `policy` is the effective
/// section — platform defaults under the stored override (admin-config.ts getEffectiveSection);
/// keys measured present are required unless the handler marks them optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigWebhooksPolicyConfig {
    pub policy: AdminConfigWebhooksPolicyConfigPolicy,
}

/// `AdminConfigWebhooksPolicyConfigPolicy` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigWebhooksPolicyConfigPolicy {
    pub ssrf_check_at_subscription: bool,
    pub stripe_signature_tolerance_sec: i64,
    pub delivery_max_retries: i64,
    pub delivery_backoff_base_ms: i64,
    pub delivery_max_window_hours: i64,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. `worker_pool` is the
/// effective section — platform defaults under the stored override (admin-config.ts
/// getEffectiveSection); keys measured present are required unless the handler marks them
/// optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigWorkerPoolConfig {
    pub worker_pool: AdminConfigWorkerPoolConfigWorkerPool,
}

/// `AdminConfigWorkerPoolConfigWorkerPool` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminConfigWorkerPoolConfigWorkerPool {
    pub max_workers: i64,
    pub default_mode: String,
    pub max_run_duration_ms: i64,
    pub reconciliation_interval_ms: i64,
    pub schedule_max_retries: i64,
    pub schedule_base_delay_ms: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_queue_size: Option<i64>,
}

/// `AdminDataExplorerRawKeysResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminDataExplorerRawKeysResponse {
    pub keys: Vec<AdminDataExplorerRawKeysResponseKey>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    pub total: i64,
}

/// `AdminDataExplorerRawKeysResponseKey` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminDataExplorerRawKeysResponseKey {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<Vec<serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value_preview: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<AdminDataExplorerRawKeysResponseKeyType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sensitive: Option<bool>,
}

/// `AdminDataExplorerRawKeysResponseKeyType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminDataExplorerRawKeysResponseKeyType {
    #[default]
    #[serde(rename = "null")]
    Null,
    #[serde(rename = "array")]
    Array,
    #[serde(rename = "string")]
    String,
    #[serde(rename = "number")]
    Number,
    #[serde(rename = "boolean")]
    Boolean,
    #[serde(rename = "object")]
    Object,
    #[serde(rename = "undefined")]
    Undefined,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminDataExplorerRawKeysResponseKeyType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Null => "null",
            Self::Array => "array",
            Self::String => "string",
            Self::Number => "number",
            Self::Boolean => "boolean",
            Self::Object => "object",
            Self::Undefined => "undefined",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminDataExplorerRawKeysResponseKeyType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminDataExplorerRawKeysResponseKeyType {
    fn from(value: &str) -> Self {
        match value {
            "null" => Self::Null,
            "array" => Self::Array,
            "string" => Self::String,
            "number" => Self::Number,
            "boolean" => Self::Boolean,
            "object" => Self::Object,
            "undefined" => Self::Undefined,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminFeatureFlagsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub flags: Option<Vec<FeatureFlag>>,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminFounderConfig {
    pub kv: FounderIdentity,
    pub env: FounderIdentity,
    pub effective: FounderIdentity,
}

/// `AdminGetLandingConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetLandingConfigResponse {
    pub landing: LandingConfigSection,
    pub source: AdminGetLandingConfigResponseSource,
    /// KV versionstamp; echo it as `expected_version` on PUT.
    #[serde(default)]
    pub version: Option<String>,
}

/// `AdminGetLandingConfigResponseSource` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminGetLandingConfigResponseSource {
    #[default]
    #[serde(rename = "kv")]
    Kv,
    #[serde(rename = "none")]
    None,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminGetLandingConfigResponseSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Kv => "kv",
            Self::None => "none",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminGetLandingConfigResponseSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminGetLandingConfigResponseSource {
    fn from(value: &str) -> Self {
        match value {
            "kv" => Self::Kv,
            "none" => Self::None,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AdminGetReconciliationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetReconciliationResponse {
    pub tenant_id: String,
    pub reconciliation: AdminGetReconciliationResponseReconciliation,
}

/// `AdminGetReconciliationResponseReconciliation` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetReconciliationResponseReconciliation {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub period: Option<String>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `AdminGetVoiceConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetVoiceConfigResponse {
    #[serde(default)]
    pub voice: Option<AdminGetVoiceConfigResponseVoiceVariant1>,
    pub source: AdminGetLandingConfigResponseSource,
}

/// `AdminGetVoiceConfigResponseVoiceVariant1` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetVoiceConfigResponseVoiceVariant1 {
    pub stt: AdminGetVoiceConfigResponseVoiceVariant1stt,
    pub tts: AdminGetVoiceConfigResponseVoiceVariant1tts,
}

/// `AdminGetVoiceConfigResponseVoiceVariant1stt` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetVoiceConfigResponseVoiceVariant1stt {
    pub provider: String,
    pub model: String,
}

/// `AdminGetVoiceConfigResponseVoiceVariant1tts` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetVoiceConfigResponseVoiceVariant1tts {
    pub provider: String,
    pub model: String,
    pub voice: String,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGuardrailsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrails: Option<Vec<GuardrailConfigItem>>,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminIntegrationsConfig {
    pub integrations: Vec<AdminIntegrationsConfigIntegration>,
}

/// `AdminIntegrationsConfigIntegration` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminIntegrationsConfigIntegration {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth_type: Option<AdminIntegrationsConfigIntegrationAuthType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub beta: Option<bool>,
    /// `kv` when an operator overrode the shipped default, `default` otherwise.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
}

/// `AdminIntegrationsConfigIntegrationAuthType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminIntegrationsConfigIntegrationAuthType {
    #[default]
    #[serde(rename = "oauth2")]
    Oauth2,
    #[serde(rename = "api_key")]
    APIKey,
    #[serde(rename = "none")]
    None,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminIntegrationsConfigIntegrationAuthType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Oauth2 => "oauth2",
            Self::APIKey => "api_key",
            Self::None => "none",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminIntegrationsConfigIntegrationAuthType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminIntegrationsConfigIntegrationAuthType {
    fn from(value: &str) -> Self {
        match value {
            "oauth2" => Self::Oauth2,
            "api_key" => Self::APIKey,
            "none" => Self::None,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AdminListToolsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminListToolsResponse {
    pub tools: Vec<AdminListToolsResponseTool>,
    pub count: i64,
}

/// `AdminListToolsResponseTool` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminListToolsResponseTool {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// JSON Schema for tool parameters.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parameters: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `AdminListWebhookDLQResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminListWebhookDLQResponse {
    pub entries: Vec<AdminListWebhookDLQResponseEntry>,
}

/// `AdminListWebhookDLQResponseEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminListWebhookDLQResponseEntry {
    /// Deprecated spelling of `event_id` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `event_id`.
    #[serde(rename = "eventId")]
    pub event_id: String,
    /// Deprecated spelling of `event_type` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `event_type`.
    #[serde(rename = "eventType")]
    pub event_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub payload: Option<serde_json::Map<String, serde_json::Value>>,
    /// Deprecated spelling of `error_message` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `error_message`.
    #[serde(rename = "errorMessage")]
    pub error_message: String,
    pub timestamp: String,
    /// Deprecated spelling of `tenant_id` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `tenant_id`.
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "event_id")]
    pub event_id_: String,
    #[serde(rename = "event_type")]
    pub event_type_: String,
    #[serde(rename = "error_message")]
    pub error_message_: String,
    #[serde(rename = "tenant_id", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id_: Option<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. The stored catalogue or,
/// with `source: seed`, the built-in registry; rows carry computed
/// `effective_pricing`/`effective_tier`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelCatalog {
    pub models: Vec<AdminModelCatalogModel>,
    pub source: AdminModelCatalogSource,
    pub count: i64,
    #[serde(default)]
    pub version: Option<String>,
}

/// `AdminModelCatalogModel` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelCatalogModel {
    pub id: String,
    pub provider: String,
    pub display_name: String,
    pub max_context_tokens: i64,
    pub max_output_tokens: i64,
    pub supports_streaming: bool,
    pub supports_tool_calls: bool,
    pub supports_json_mode: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_vision: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tier: Option<String>,
    /// Read-only, computed on read (admin-config.ts withEffectiveEconomics); absent from PUT and
    /// seed answers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effective_pricing: Option<AdminModelCatalogModelEffectivePricing>,
    /// Read-only, computed on read (admin-config.ts withEffectiveEconomics); absent from PUT and
    /// seed answers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effective_tier: Option<String>,
}

/// Read-only, computed on read (admin-config.ts withEffectiveEconomics); absent from PUT and
/// seed answers.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelCatalogModelEffectivePricing {
    pub input_per_million: f64,
    pub output_per_million: f64,
    pub cached_input_per_million: f64,
    pub source: String,
    pub layer: String,
    pub key: String,
    pub r#match: String,
    pub confidence: String,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; the built-in registry merged
/// with every configured provider's live model list — no `source`, no `version`, no computed
/// economics.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelCatalogSeed {
    pub models: Vec<AdminModelCatalogSeedModel>,
    pub count: i64,
}

/// `AdminModelCatalogSeedModel` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelCatalogSeedModel {
    pub id: String,
    pub provider: String,
    pub display_name: String,
    pub max_context_tokens: i64,
    pub max_output_tokens: i64,
    pub supports_streaming: bool,
    pub supports_tool_calls: bool,
    pub supports_json_mode: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_vision: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tier: Option<String>,
}

/// `AdminModelCatalogSource` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminModelCatalogSource {
    #[default]
    #[serde(rename = "kv")]
    Kv,
    #[serde(rename = "seed")]
    Seed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminModelCatalogSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Kv => "kv",
            Self::Seed => "seed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminModelCatalogSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminModelCatalogSource {
    fn from(value: &str) -> Self {
        match value {
            "kv" => Self::Kv,
            "seed" => Self::Seed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; billing/cost-estimator.ts
/// listAllPricing — a live in-memory view, `layer` says where each price comes from.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelPricingList {
    pub models: Vec<AdminModelPricingListModel>,
    pub count: i64,
    pub source: String,
}

/// `AdminModelPricingListModel` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminModelPricingListModel {
    pub model: String,
    pub layer: String,
    pub input_per_million: f64,
    pub output_per_million: f64,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminOAuthIdentityConfig {
    pub kv: OAuthIdentityConfig,
    pub env: OAuthIdentityConfig,
    pub effective: OAuthIdentityConfig,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPlatformURLSConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub urls: Option<AdminPlatformURLSConfigURLS>,
}

/// `AdminPlatformURLSConfigURLS` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPlatformURLSConfigURLS {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_base_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webhook_base_url: Option<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. The whole stored override
/// when one exists, else the config defaults; `source` says which (admin-config.ts
/// getEffectivePricing).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPricingConfig {
    pub pricing: AdminPricingConfigPricing,
    pub source: AdminPricingConfigSource,
}

/// `AdminPricingConfigPricing` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPricingConfigPricing {
    pub openai_compat_input: f64,
    pub openai_compat_output: f64,
    pub anthropic_input: i64,
    pub anthropic_output: f64,
    pub anthropic_thinking: f64,
}

/// `AdminPricingConfigSource` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminPricingConfigSource {
    #[default]
    #[serde(rename = "kv")]
    Kv,
    #[serde(rename = "config")]
    Config,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminPricingConfigSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Kv => "kv",
            Self::Config => "config",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminPricingConfigSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminPricingConfigSource {
    fn from(value: &str) -> Self {
        match value {
            "kv" => Self::Kv,
            "config" => Self::Config,
            other => Self::Other(other.to_string()),
        }
    }
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; admin.ts — a projection over
/// the custom provider, its settings and catalogue status; never the API key.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminProvider {
    pub id: String,
    pub name: String,
    pub canonical: String,
    pub default_endpoint: String,
    pub local: bool,
    pub enabled: bool,
    pub model_allowlist: Vec<String>,
    pub is_custom: bool,
    pub requires_api_key: bool,
    pub models_in_catalog: i64,
    pub catalog_model_ids: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_models_sync: Option<AdminProviderLastModelsSync>,
}

/// `AdminProviderLastModelsSync` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminProviderLastModelsSync {
    pub at: String,
    pub added: i64,
    pub live: i64,
}

/// admin.ts — the list projection of a custom provider (the single GET adds catalogue fields;
/// see AdminProvider).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminProviderSummary {
    pub id: String,
    pub name: String,
    pub canonical: String,
    pub default_endpoint: String,
    pub local: bool,
    pub enabled: bool,
    pub model_allowlist: Vec<String>,
    pub is_custom: bool,
    pub requires_api_key: bool,
}

/// `AdminPutLandingConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutLandingConfigResponse {
    pub landing: LandingConfigSection,
    pub source: AdminPutLandingConfigResponseSource,
    pub updated: bool,
    #[serde(default)]
    pub version: Option<String>,
}

/// `AdminPutLandingConfigResponseSource` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminPutLandingConfigResponseSource {
    #[default]
    #[serde(rename = "kv")]
    Kv,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminPutLandingConfigResponseSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Kv => "kv",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminPutLandingConfigResponseSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminPutLandingConfigResponseSource {
    fn from(value: &str) -> Self {
        match value {
            "kv" => Self::Kv,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AdminPutModelCatalogResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutModelCatalogResponse {
    pub models: Vec<AdminPutModelCatalogResponseModel>,
    pub source: AdminPutLandingConfigResponseSource,
    pub count: i64,
    #[serde(default)]
    pub version: Option<String>,
}

/// `AdminPutModelCatalogResponseModel` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutModelCatalogResponseModel {
    pub id: String,
    pub provider: String,
    pub display_name: String,
    pub max_context_tokens: i64,
    pub max_output_tokens: i64,
    pub supports_streaming: bool,
    pub supports_tool_calls: bool,
    pub supports_json_mode: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_vision: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tier: Option<String>,
}

/// `AdminPutVoiceConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutVoiceConfigResponse {
    pub voice: AdminPutVoiceConfigResponseVoice,
    pub updated: bool,
}

/// `AdminPutVoiceConfigResponseVoice` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutVoiceConfigResponseVoice {
    pub stt: AdminPutVoiceConfigResponseVoiceStt,
    pub tts: AdminPutVoiceConfigResponseVoiceTts,
}

/// `AdminPutVoiceConfigResponseVoiceStt` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutVoiceConfigResponseVoiceStt {
    pub provider: String,
    pub model: String,
}

/// `AdminPutVoiceConfigResponseVoiceTts` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutVoiceConfigResponseVoiceTts {
    pub provider: String,
    pub model: String,
    pub voice: String,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminRateLimitsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<EndpointRateLimit>>,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminRegistrationConfig {
    pub registration_open: bool,
    /// `free` when nothing is stored.
    pub default_signup_plan: String,
    /// Empty means no domain restriction.
    pub allowed_email_domains: Vec<String>,
    pub setup_status: AdminRegistrationConfigSetupStatus,
    /// Setup steps still outstanding. Non-empty means an attempt to open registration is refused,
    /// and this is the list it will name.
    pub missing_required: Vec<String>,
    /// How many tenants are waitlisted — ALL of them, counted by walking every KV page. It used to
    /// be `waitlist.length`, from a single unpaginated read, so past a thousand signups the number
    /// froze at exactly 1000 with nothing saying it had been cut (ADM-04). This is the number an
    /// admin uses to decide when to open registration, so it is the one that must be complete
    /// rather than the roster.
    pub waitlist_count: i64,
    /// True when `waitlist` holds fewer rows than `waitlist_count`. The roster is a display list
    /// and stays bounded at 1000; the count is not.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub waitlist_truncated: Option<bool>,
    /// Oldest first. Bounded at 1000 rows — check `waitlist_truncated` rather than taking
    /// `waitlist.length` as the total.
    pub waitlist: Vec<AdminRegistrationConfigWaitlistItem>,
}

/// `AdminRegistrationConfigSetupStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminRegistrationConfigSetupStatus {
    #[default]
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "live")]
    Live,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminRegistrationConfigSetupStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::InProgress => "in_progress",
            Self::Live => "live",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminRegistrationConfigSetupStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminRegistrationConfigSetupStatus {
    fn from(value: &str) -> Self {
        match value {
            "in_progress" => Self::InProgress,
            "live" => Self::Live,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AdminRegistrationConfigWaitlistItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminRegistrationConfigWaitlistItem {
    pub tenant_id: String,
    pub email: String,
    pub created_at: String,
}

/// `AdminReplayWebhookDLQResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminReplayWebhookDLQResponse {
    pub success: bool,
    /// Deprecated spelling of `event_id` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `event_id`.
    #[serde(rename = "eventId")]
    pub event_id: String,
    pub action: String,
    pub message: String,
    #[serde(rename = "event_id")]
    pub event_id_: String,
}

/// Hoisted from the typed GET (handler: admin-config.ts) so the PUT can name the same shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminSmtpConfig {
    /// What is stored. Empty strings and a `port` of 0 mean nothing has been saved for that field.
    pub kv: AdminSmtpConfigKv,
    /// What the environment supplies. `port` defaults to 465 when unset or unparseable.
    pub env: AdminSmtpConfigEnv,
    /// Which layer is in force, decided by the stored HOST alone: a saved host makes it `kv`,
    /// otherwise an environment host makes it `env`, otherwise `none`. Note the consequence —
    /// saving a user or a password WITHOUT a host leaves `source` at `env` and the stored fields
    /// inert.
    pub source: AdminSmtpConfigSource,
}

/// What the environment supplies. `port` defaults to 465 when unset or unparseable.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminSmtpConfigEnv {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_name: Option<String>,
    /// Whether a credential is stored. The password itself is never returned by any read.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_password: Option<bool>,
}

/// What is stored. Empty strings and a `port` of 0 mean nothing has been saved for that field.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminSmtpConfigKv {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_name: Option<String>,
    /// Whether a credential is stored. The password itself is never returned by any read.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_password: Option<bool>,
}

/// Which layer is in force, decided by the stored HOST alone: a saved host makes it `kv`,
/// otherwise an environment host makes it `env`, otherwise `none`. Note the consequence —
/// saving a user or a password WITHOUT a host leaves `source` at `env` and the stored fields
/// inert.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AdminSmtpConfigSource {
    #[default]
    #[serde(rename = "kv")]
    Kv,
    #[serde(rename = "env")]
    Env,
    #[serde(rename = "none")]
    None,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AdminSmtpConfigSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Kv => "kv",
            Self::Env => "env",
            Self::None => "none",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AdminSmtpConfigSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AdminSmtpConfigSource {
    fn from(value: &str) -> Self {
        match value {
            "kv" => Self::Kv,
            "env" => Self::Env,
            "none" => Self::None,
            other => Self::Other(other.to_string()),
        }
    }
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z. Secrets are redacted to
/// their last four characters or empty (admin-config.ts getEffectiveStripeAdminConfig).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminStripeConfig {
    pub stripe: AdminStripeConfigStripe,
    pub has_secret_key: bool,
    pub has_webhook_secret: bool,
}

/// `AdminStripeConfigStripe` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminStripeConfigStripe {
    pub enabled: bool,
    pub mode: String,
    pub secret_key: String,
    pub webhook_secret: String,
    pub publishable_key: String,
    pub price_id_starter: String,
    pub price_id_pro: String,
    pub price_id_enterprise: String,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; provider/model → voice ids;
/// `defaults` is always empty, `effective` equals `override` (admin-config.ts
/// handleGetVoicePresets).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminVoicePresets {
    pub defaults: serde_json::Map<String, serde_json::Value>,
    pub r#override: HashMap<String, Vec<String>>,
    pub effective: HashMap<String, Vec<String>>,
}

/// `Agent` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Agent {
    /// SPECs installed on this agent, with version pin and granted permissions.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub specs: Option<Vec<AgentSpec>>,
    /// Tools this agent may call without a human-in-the-loop prompt.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_approve_tools: Option<Vec<String>>,
    /// Command hierarchy (MVP: opcon only).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command_relationships: Option<AgentCommandRelationships>,
    /// Security clearance and compartment access.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub access_control: Option<AgentAccessControl>,
    /// Free-form caller-supplied metadata; `ui` is the one key with a shared, documented shape.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<AgentMetadata>,
    pub agent_id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    pub model: AgentModelConfig,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompts: Option<AgentPrompts>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mcp: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub policies: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effort_policy: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrails: Option<serde_json::Map<String, serde_json::Value>>,
    /// Tool names requiring human approval before execution
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approval_required_tools: Option<Vec<String>>,
    /// Built-in tool names enabled for this agent
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub built_in_tools: Option<Vec<String>>,
    /// Image generation configuration
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image_generation: Option<serde_json::Map<String, serde_json::Value>>,
    /// Deprecated in `packages/types/agent.ts:296`; kept for pre-migration records. Use
    /// `knowledge_base_ids`. Documenting only the singular is why a client reading this schema
    /// could link one base to an agent that supports several.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_id: Option<String>,
    /// Every knowledge base linked to the agent. `search_kb` searches all of them by default.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_ids: Option<Vec<String>>,
    /// Who can reach the agent. The publication screen is built on this field — but `public` alone
    /// does not open the agent to the world: the anonymous routes (`GET /public/agents/{agentId}`,
    /// public sessions) answer only when `visibility` is `public` AND `public_config.enabled` is
    /// true AND `status` is `active` (public.ts loadPublicAgent). A client that shows "anyone with
    /// the link can reach this agent" on `visibility` alone shows it a step too early. Measured
    /// 2026-09-10 on a real tenant: the one agent with both switches answered 200 without a key,
    /// every other `public` one 404.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<AgentUpdateVisibility>,
    /// Governance state, distinct from a run's status.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<AgentStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_changed_at: Option<String>,
    /// Why the agent is in this status, as a sentence. One field with six writers — a person, an
    /// operator, four governance paths and a plan downgrade — so its language is whichever the
    /// writer used, and every reader sees that one. Branch on `status_reason_code`; render this.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_reason: Option<String>,
    /// Who wrote `status_reason`. `manual` means the sentence is the caller's own and should be
    /// rendered as-is; the other five are the platform's English, and a client may say them in the
    /// reader's language using `status_reason_details` for the identifier. Added 2026-09-21.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_reason_code: Option<AgentStatusReasonCode>,
    /// The identifier the platform's sentence quotes: `case_id`, `proposal_id`, `rule_id`. Absent
    /// for `manual`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_reason_details: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub autonomy: Option<AgentAutonomy>,
    /// Per-tool trust, overriding the agent's default approval policy.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_overrides: Option<Vec<AgentToolOverride>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_config: Option<AgentPublicConfig>,
    /// Present only on `GET /agents/{id}`, and only for a bridge agent. Computed at read time from
    /// the machines currently registered, never stored on the record.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge: Option<AgentBridgeState>,
    /// Fallback model configuration
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_model: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_mode: Option<AgentExecutionMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_reuse: Option<bool>,
    /// Cron schedule configuration
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schedule: Option<serde_json::Map<String, serde_json::Value>>,
    /// Agent-to-Agent protocol configuration
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub a2a: Option<serde_json::Map<String, serde_json::Value>>,
    /// EU AI Act risk classification
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub risk_classification: Option<serde_json::Map<String, serde_json::Value>>,
    /// Workspace this agent belongs to
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context_strategy: Option<AgentContextStrategy>,
    /// Number of recent MESSAGES to keep — not a token budget, and read only when
    /// `context_strategy` is `sliding_window`. Default 20. Under any other strategy it is ignored
    /// entirely.
    ///
    /// Said explicitly because the name reads like a token ceiling and was used as one: the Head
    /// Agent tier template set it to 65536/131072/262144 as if it capped context, and a client
    /// posted those values believing they sized the window. The window is the model's — see
    /// `model.capabilities.max_context_tokens` — and what bounds history per call is
    /// `resource_limits.max_tokens_per_run` together with the platform's history-budget ratio.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context_window_size: Option<i64>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// Security clearance and compartment access.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAccessControl {
    /// 0=public, 1=internal, 2=restricted, 3=confidential, 4=secret.
    pub clearance: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compartments: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub caveats: Option<Vec<String>>,
}

/// `AgentAnalyticsRow` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAnalyticsRow {
    pub agent_id: String,
    pub tenant_id: String,
    pub name: String,
    pub execution_mode: AgentExecutionMode,
    pub status: String,
    /// Bridge agents only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge_status: Option<AgentSummaryBridgeStatus>,
    /// Bridge agents only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub machine_count: Option<i64>,
    pub runs: i64,
    pub cost_usd: f64,
    pub tokens: i64,
}

/// Output of summariseAgents (analytics.ts) — same shape for /admin/analytics/agents and
/// /analytics/agents (tenant-scoped).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAnalyticsSummary {
    pub range: AgentAnalyticsSummaryRange,
    pub total: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub by_execution_mode: Option<AgentAnalyticsSummaryByExecutionMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge: Option<AgentAnalyticsSummaryBridge>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs_total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_total_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens_total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_by_runs: Option<Vec<AgentSummary>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_by_cost: Option<Vec<AgentSummary>>,
    pub agents: Vec<AgentSummary>,
}

/// `AgentAnalyticsSummaryBridge` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAnalyticsSummaryBridge {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub online: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stale: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub offline: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub machines_total: Option<i64>,
}

/// `AgentAnalyticsSummaryByExecutionMode` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAnalyticsSummaryByExecutionMode {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cloud: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge: Option<i64>,
}

/// `AgentAnalyticsSummaryRange` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAnalyticsSummaryRange {
    pub days: i64,
}

/// `AgentAutonomy` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentAutonomy {
    pub level: AgentAutonomyLevel,
}

/// `AgentAutonomyLevel` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentAutonomyLevel {
    #[default]
    #[serde(rename = "manual")]
    Manual,
    #[serde(rename = "approve_risky")]
    ApproveRisky,
    #[serde(rename = "full_auto")]
    FullAuto,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentAutonomyLevel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Manual => "manual",
            Self::ApproveRisky => "approve_risky",
            Self::FullAuto => "full_auto",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentAutonomyLevel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentAutonomyLevel {
    fn from(value: &str) -> Self {
        match value {
            "manual" => Self::Manual,
            "approve_risky" => Self::ApproveRisky,
            "full_auto" => Self::FullAuto,
            other => Self::Other(other.to_string()),
        }
    }
}

/// A message pinned under an agent. Keyed by `message_id`; the platform keeps the text the
/// client sent, it does not look the message up.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentBookmark {
    pub message_id: String,
    pub agent_id: String,
    pub tenant_id: String,
    pub kind: AgentBookmarkKind,
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    pub created_at: String,
}

/// `AgentBookmarkKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentBookmarkKind {
    #[default]
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentBookmarkKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::User => "user",
            Self::Assistant => "assistant",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentBookmarkKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentBookmarkKind {
    fn from(value: &str) -> Self {
        match value {
            "user" => Self::User,
            "assistant" => Self::Assistant,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentBridgeState` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentBridgeState {
    pub online_machines: i64,
    pub total_machines: i64,
    pub platforms: Vec<String>,
    pub working_directories: Vec<String>,
    pub machine_names: Vec<String>,
    pub latest_heartbeat: String,
    pub installed_specs: Vec<BridgeInstalledSpec>,
}

/// What GET /agents/{agentId}/capabilities serves. Measured 2026-09-10 on the e2e-canon tenant;
/// `tools\[\]` and `kb_ids\[\]` were empty there, so their element shape is not asserted.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentCapabilities {
    pub agent_id: String,
    pub skills: Vec<AgentCapabilitiesSkill>,
    pub constraints: AgentCapabilitiesConstraints,
    pub tools: Vec<String>,
    pub kb_ids: Vec<String>,
    pub updated_at: String,
}

/// `AgentCapabilitiesConstraints` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentCapabilitiesConstraints {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_context_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit_rpm: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supported_languages: Option<Vec<String>>,
}

/// `AgentCapabilitiesSkill` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentCapabilitiesSkill {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_types: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_types: Option<Vec<String>>,
}

/// Command hierarchy (MVP: opcon only).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentCommandRelationships {
    /// Agent ID holding operational control.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub opcon: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub coordinates_with: Option<Vec<String>>,
}

/// `AgentContextStrategy` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentContextStrategy {
    #[default]
    #[serde(rename = "compaction")]
    Compaction,
    #[serde(rename = "summarize")]
    Summarize,
    #[serde(rename = "truncate")]
    Truncate,
    #[serde(rename = "sliding_window")]
    SlidingWindow,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentContextStrategy {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Compaction => "compaction",
            Self::Summarize => "summarize",
            Self::Truncate => "truncate",
            Self::SlidingWindow => "sliding_window",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentContextStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentContextStrategy {
    fn from(value: &str) -> Self {
        match value {
            "compaction" => Self::Compaction,
            "summarize" => Self::Summarize,
            "truncate" => Self::Truncate,
            "sliding_window" => Self::SlidingWindow,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentExecutionMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentExecutionMode {
    #[default]
    #[serde(rename = "async")]
    Async,
    #[serde(rename = "worker")]
    Worker,
    #[serde(rename = "bridge")]
    Bridge,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentExecutionMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Async => "async",
            Self::Worker => "worker",
            Self::Bridge => "bridge",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentExecutionMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentExecutionMode {
    fn from(value: &str) -> Self {
        match value {
            "async" => Self::Async,
            "worker" => Self::Worker,
            "bridge" => Self::Bridge,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Agent-scoped integration (connection) instance
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentIntegration {
    pub id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub connector_id: String,
    pub name: String,
    pub status: IntegrationStatus,
    /// Redacted config (no secrets)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `AgentLineage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentLineage {
    pub agent_id: String,
    /// Full chain from root to this agent.
    pub chain: Vec<String>,
    pub depth: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_id: Option<String>,
    pub spawned_by: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spawned_at: Option<String>,
}

/// One message between two agents.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentMessage {
    pub message_id: String,
    pub thread_id: String,
    pub from_agent_id: String,
    pub to_agent_id: String,
    pub message: String,
    pub created_at: String,
    /// Integrity signature, when the message carries one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    /// Communications precedence; absent means routine.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub precedence: Option<AgentMessagePrecedence>,
}

/// Communications precedence; absent means routine.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentMessagePrecedence {
    #[default]
    #[serde(rename = "flash")]
    Flash,
    #[serde(rename = "immediate")]
    Immediate,
    #[serde(rename = "priority")]
    Priority,
    #[serde(rename = "routine")]
    Routine,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentMessagePrecedence {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Flash => "flash",
            Self::Immediate => "immediate",
            Self::Priority => "priority",
            Self::Routine => "routine",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentMessagePrecedence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentMessagePrecedence {
    fn from(value: &str) -> Self {
        match value {
            "flash" => Self::Flash,
            "immediate" => Self::Immediate,
            "priority" => Self::Priority,
            "routine" => Self::Routine,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Free-form caller-supplied metadata; `ui` is the one key with a shared, documented shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentMetadata {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ui: Option<AgentMetadataUi>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// The `metadata.ui` record three clients and the platform share. PATCH merges it one level,
/// and `avatar` one level deeper: a client that sends `{protocol, variant}` keeps the stored
/// `hue`, one that sends `{hue}` keeps `protocol` and `variant` (agent-genome.ts
/// mergeAgentMetadata; owner 2026-09-10).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentMetadataUi {
    /// Identity: which drawing protocol, which variant, and the hue (degrees). Merged field by
    /// field on PATCH.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub avatar: Option<AgentMetadataUiAvatar>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub drop_genome: Option<DropGenome>,
    /// Provenance of the FIRST server-written genome — set only by the platform (ensureAgentGenome
    /// / the create path), never by a client, and left untouched by client PATCHes of
    /// `drop_genome`. Absent when the genome was client-authored or predates the field.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub drop_genome_source: Option<AgentMetadataUiDropGenomeSource>,
}

/// Identity: which drawing protocol, which variant, and the hue (degrees). Merged field by
/// field on PATCH.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentMetadataUiAvatar {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hue: Option<f64>,
}

/// Provenance of the FIRST server-written genome — set only by the platform (ensureAgentGenome
/// / the create path), never by a client, and left untouched by client PATCHes of
/// `drop_genome`. Absent when the genome was client-authored or predates the field.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentMetadataUiDropGenomeSource {
    #[default]
    #[serde(rename = "llm")]
    LLM,
    #[serde(rename = "fallback")]
    Fallback,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentMetadataUiDropGenomeSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::LLM => "llm",
            Self::Fallback => "fallback",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentMetadataUiDropGenomeSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentMetadataUiDropGenomeSource {
    fn from(value: &str) -> Self {
        match value {
            "llm" => Self::LLM,
            "fallback" => Self::Fallback,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Model capabilities. Deliberately carries no provider or model identifier — see the model
/// lockdown.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentModelConfig {
    /// Feature flags the client may branch on (e.g. `vision`, `tool_calls`, `streaming`). Absent
    /// when the platform has published none.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Accepted and IGNORED. The platform default is applied on create and preserved on update, so
/// sending this changes nothing. Kept so existing clients do not start failing validation.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentModelConfigInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_ref: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api_key_ref: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `AgentPrompts` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentPrompts {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub developer: Option<String>,
}

/// `AgentPublicConfig` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentPublicConfig {
    /// One of the three switches that make the agent reachable without a key (public.ts
    /// loadPublicAgent): `visibility` must be `public`, this must be true, and `status` must be
    /// `active` (or absent). Any one of them alone does nothing visible.
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system_prompt: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub greeting: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_messages_per_session: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_sessions: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit_sessions_per_ip: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit_messages_per_min: Option<i64>,
    /// Messages per UTC day per visitor identity (a hash of IP + anonymous visitor id). Enforced
    /// ONLY for the featured landing agent — the one `GET /admin/config/landing` names as
    /// `public_agent_id`; every other public agent keeps its per-session caps and ignores this.
    /// Over the cap the server answers 429 with `code: "DAILY_LIMIT"`. Unset means the platform
    /// default of 15.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub daily_message_limit: Option<i64>,
}

/// The stored schedule configuration (AgentScheduleConfig in @uarp/scheduler).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentScheduleConfig {
    pub cron: String,
    pub enabled: bool,
    /// IANA zone; `UTC` when not given.
    pub timezone: String,
    pub input: serde_json::Map<String, serde_json::Value>,
    pub max_concurrent_scheduled: i64,
    pub on_failure: AgentScheduleConfigOnFailure,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub autonomous_mode: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reflection_prompt: Option<String>,
}

/// `AgentScheduleConfigOnFailure` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentScheduleConfigOnFailure {
    #[default]
    #[serde(rename = "retry_next")]
    RetryNext,
    #[serde(rename = "pause_schedule")]
    PauseSchedule,
    #[serde(rename = "notify")]
    Notify,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentScheduleConfigOnFailure {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::RetryNext => "retry_next",
            Self::PauseSchedule => "pause_schedule",
            Self::Notify => "notify",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentScheduleConfigOnFailure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentScheduleConfigOnFailure {
    fn from(value: &str) -> Self {
        match value {
            "retry_next" => Self::RetryNext,
            "pause_schedule" => Self::PauseSchedule,
            "notify" => Self::Notify,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentScorer` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentScorer {
    pub scorer_id: String,
    pub agent_id: String,
    pub tenant_id: String,
    pub name: String,
    pub config: AgentScorerConfig,
    pub created_at: String,
}

/// `AgentScorerConfig` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentScorerConfig {
    pub r#type: AgentScorerConfigType,
    pub url: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `AgentScorerConfigType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentScorerConfigType {
    #[default]
    #[serde(rename = "webhook")]
    Webhook,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentScorerConfigType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Webhook => "webhook",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentScorerConfigType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentScorerConfigType {
    fn from(value: &str) -> Self {
        match value {
            "webhook" => Self::Webhook,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentSpec {
    pub spec_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    /// Soft-disable. false keeps the install history but skips injection.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permissions_granted: Option<Vec<AgentSpecPermissionsGrantedItem>>,
}

/// `AgentSpecPermissionsGrantedItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentSpecPermissionsGrantedItem {
    pub cap: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    pub granted_by: AgentSpecPermissionsGrantedItemGrantedBy,
    pub granted_at: String,
}

/// `AgentSpecPermissionsGrantedItemGrantedBy` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentSpecPermissionsGrantedItemGrantedBy {
    #[default]
    #[serde(rename = "wizard")]
    Wizard,
    #[serde(rename = "admin")]
    Admin,
    #[serde(rename = "bootstrap")]
    Bootstrap,
    #[serde(rename = "migrated")]
    Migrated,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentSpecPermissionsGrantedItemGrantedBy {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Wizard => "wizard",
            Self::Admin => "admin",
            Self::Bootstrap => "bootstrap",
            Self::Migrated => "migrated",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentSpecPermissionsGrantedItemGrantedBy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentSpecPermissionsGrantedItemGrantedBy {
    fn from(value: &str) -> Self {
        match value {
            "wizard" => Self::Wizard,
            "admin" => Self::Admin,
            "bootstrap" => Self::Bootstrap,
            "migrated" => Self::Migrated,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Governance state, distinct from a run's status.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "suspended")]
    Suspended,
    #[serde(rename = "terminated")]
    Terminated,
    #[serde(rename = "deposed")]
    Deposed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Suspended => "suspended",
            Self::Terminated => "terminated",
            Self::Deposed => "deposed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "suspended" => Self::Suspended,
            "terminated" => Self::Terminated,
            "deposed" => Self::Deposed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Who wrote `status_reason`. `manual` means the sentence is the caller's own and should be
/// rendered as-is; the other five are the platform's English, and a client may say them in the
/// reader's language using `status_reason_details` for the identifier. Added 2026-09-21.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentStatusReasonCode {
    #[default]
    #[serde(rename = "manual")]
    Manual,
    #[serde(rename = "proposal_passed")]
    ProposalPassed,
    #[serde(rename = "arbiter_ruling")]
    ArbiterRuling,
    #[serde(rename = "arbiter_penalty")]
    ArbiterPenalty,
    #[serde(rename = "constitutional_penalty")]
    ConstitutionalPenalty,
    #[serde(rename = "plan_downgrade")]
    PlanDowngrade,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentStatusReasonCode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Manual => "manual",
            Self::ProposalPassed => "proposal_passed",
            Self::ArbiterRuling => "arbiter_ruling",
            Self::ArbiterPenalty => "arbiter_penalty",
            Self::ConstitutionalPenalty => "constitutional_penalty",
            Self::PlanDowngrade => "plan_downgrade",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentStatusReasonCode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentStatusReasonCode {
    fn from(value: &str) -> Self {
        match value {
            "manual" => Self::Manual,
            "proposal_passed" => Self::ProposalPassed,
            "arbiter_ruling" => Self::ArbiterRuling,
            "arbiter_penalty" => Self::ArbiterPenalty,
            "constitutional_penalty" => Self::ConstitutionalPenalty,
            "plan_downgrade" => Self::PlanDowngrade,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentSummary {
    pub agent_id: String,
    pub tenant_id: String,
    pub name: String,
    pub execution_mode: AgentSummaryExecutionMode,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge_status: Option<AgentSummaryBridgeStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub machine_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens: Option<i64>,
}

/// `AgentSummaryBridgeStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentSummaryBridgeStatus {
    #[default]
    #[serde(rename = "online")]
    Online,
    #[serde(rename = "stale")]
    Stale,
    #[serde(rename = "offline")]
    Offline,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentSummaryBridgeStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Online => "online",
            Self::Stale => "stale",
            Self::Offline => "offline",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentSummaryBridgeStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentSummaryBridgeStatus {
    fn from(value: &str) -> Self {
        match value {
            "online" => Self::Online,
            "stale" => Self::Stale,
            "offline" => Self::Offline,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentSummaryExecutionMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentSummaryExecutionMode {
    #[default]
    #[serde(rename = "async")]
    Async,
    #[serde(rename = "worker")]
    Worker,
    #[serde(rename = "bridge")]
    Bridge,
    #[serde(rename = "cloud")]
    Cloud,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentSummaryExecutionMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Async => "async",
            Self::Worker => "worker",
            Self::Bridge => "bridge",
            Self::Cloud => "cloud",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentSummaryExecutionMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentSummaryExecutionMode {
    fn from(value: &str) -> Self {
        match value {
            "async" => Self::Async,
            "worker" => Self::Worker,
            "bridge" => Self::Bridge,
            "cloud" => Self::Cloud,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentToolOverride` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentToolOverride {
    pub tool_name: String,
    pub trust_level: AgentToolOverrideTrustLevel,
}

/// `AgentToolOverrideTrustLevel` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentToolOverrideTrustLevel {
    #[default]
    #[serde(rename = "always_allow")]
    AlwaysAllow,
    #[serde(rename = "ask_first")]
    AskFirst,
    #[serde(rename = "never_allow")]
    NeverAllow,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentToolOverrideTrustLevel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::AlwaysAllow => "always_allow",
            Self::AskFirst => "ask_first",
            Self::NeverAllow => "never_allow",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentToolOverrideTrustLevel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentToolOverrideTrustLevel {
    fn from(value: &str) -> Self {
        match value {
            "always_allow" => Self::AlwaysAllow,
            "ask_first" => Self::AskFirst,
            "never_allow" => Self::NeverAllow,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentToolOverrideUpdate` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentToolOverrideUpdate {
    pub tool_name: String,
    pub trust_level: AgentToolOverrideTrustLevel,
}

/// Body for `PUT /api/v1/agents/{agentId}`. Every field optional — an omitted field means NO
/// CHANGE, not 'clear it'. `model` and `fallback_model` are accepted and ignored (see the model
/// lockdown).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// `prompts.system` is accepted and IGNORED: the per-agent system prompt is managed by the Head
    /// Agent (system prompt lockdown, 2026-08-04). A new agent stores a neutral default; an update
    /// keeps the stored prompt. `prompts.developer` is stored. For the prompt a public chat uses,
    /// set `public_config.system_prompt`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompts: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<AgentModelConfigInput>,
    /// Sending this field REPLACES the stored list; it is not merged. A PATCH carrying one id
    /// leaves the agent with exactly that one — read the current value and send the full set. The
    /// incoming list is normalised and persisted whole; the previous list is consulted only to keep
    /// permission-grant timestamps stable for SPECs that were already installed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub specs: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    /// Sending this field REPLACES the stored list; it is not merged. A PATCH carrying one id
    /// leaves the agent with exactly that one — read the current value and send the full set. 
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approval_required_tools: Option<Vec<String>>,
    /// Sending this field REPLACES the stored list; it is not merged. A PATCH carrying one id
    /// leaves the agent with exactly that one — read the current value and send the full set. 
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_approve_tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_id: Option<String>,
    /// Sending this field REPLACES the stored list; it is not merged. A PATCH carrying one id
    /// leaves the agent with exactly that one — read the current value and send the full set. Note
    /// the legacy singular `knowledge_base_id` is UNIONED with this array within the same request —
    /// the server-side helper is named `mergeKbIds` for that reason, and merges the two REQUEST
    /// fields, never the request with what is stored.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<AgentUpdateVisibility>,
    /// Partial: the handler merges it one level over the stored `public_config` (agents.ts, `{
    /// ...existing.public_config, ...body.public_config }`), so `{ public_config: { enabled: true }
    /// }` flips the switch and keeps the greeting, limits and allowed tools. Sending `enabled`
    /// alone does not make the agent reachable — see `Agent.visibility`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_config: Option<AgentUpdatePublicConfig>,
}

/// Partial: the handler merges it one level over the stored `public_config` (agents.ts, `{
/// ...existing.public_config, ...body.public_config }`), so `{ public_config: { enabled: true }
/// }` flips the switch and keeps the greeting, limits and allowed tools. Sending `enabled`
/// alone does not make the agent reachable — see `Agent.visibility`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentUpdatePublicConfig {
    /// One of the three switches that make the agent reachable without a key (public.ts
    /// loadPublicAgent): `visibility` must be `public`, this must be true, and `status` must be
    /// `active` (or absent). Any one of them alone does nothing visible.
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system_prompt: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub greeting: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_messages_per_session: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_sessions: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit_sessions_per_ip: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit_messages_per_min: Option<i64>,
    /// Messages per UTC day per visitor identity (a hash of IP + anonymous visitor id). Enforced
    /// ONLY for the featured landing agent — the one `GET /admin/config/landing` names as
    /// `public_agent_id`; every other public agent keeps its per-session caps and ignores this.
    /// Over the cap the server answers 429 with `code: "DAILY_LIMIT"`. Unset means the platform
    /// default of 15.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub daily_message_limit: Option<i64>,
}

/// `AgentUpdateVisibility` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AgentUpdateVisibility {
    #[default]
    #[serde(rename = "private")]
    Private,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "public")]
    Public,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AgentUpdateVisibility {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Private => "private",
            Self::Team => "team",
            Self::Public => "public",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AgentUpdateVisibility {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AgentUpdateVisibility {
    fn from(value: &str) -> Self {
        match value {
            "private" => Self::Private,
            "team" => Self::Team,
            "public" => Self::Public,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AgentVersion` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AgentVersion {
    pub version_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub version: i64,
    /// Free text when a client sent one with POST /agents/{agentId}/versions. The SERVER writes
    /// these fixed values of its own on the versions it mints — known values a client may match on,
    /// and therefore part of the contract (a test keeps this list equal to the literals in the
    /// code): `Initial version`, `Initial version (auto-created)`, `Initial version (created by
    /// agent factory)`, `Auto-versioned before update`, `Auto-versioned after update`,
    /// `Auto-versioned after update (retry)`, `Updated by agent factory`, `Head Agent orchestration
    /// kernel installed (agent-factory + discovery)`, `Head Agent orchestration kernel back-filled
    /// (agent-factory + discovery)`, `Head Agent promoted`, `Head Agent system prompt synced to
    /// canonical`, `Head Agent system prompt restored from backup`, `Tier SPECs synced`, `Model
    /// provider healed to the platform default`, `Core memory enabled`, `Tool trust override
    /// updated`, `Platform agent provisioned`, `Platform agent config migrated on boot`, `Rollback
    /// to version N` (N = the version rolled back to), `Self-improvement: N changes based on N
    /// analysis` (the self-improvement loop: the first N is a count, the second is one of errors,
    /// ratings or feedback — words, not a number). A reason code beside the prose is the owner's
    /// decision (DEC 11).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub changelog: Option<String>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_by: Option<String>,
    /// The full agent configuration as it stood at this version. Shape follows `Agent`; not pinned
    /// here so the two cannot drift.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `AiSystemCard` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AiSystemCard {
    pub system_name: String,
    pub provider: String,
    pub version: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub risk_classification: Option<RiskClassification>,
    pub intended_purpose: String,
    pub technical_specifications: AiSystemCardTechnicalSpecifications,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub training_data_summary: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub performance_metrics: Option<serde_json::Map<String, serde_json::Value>>,
    pub limitations: Vec<String>,
    pub guardrails_summary: Vec<String>,
    pub human_oversight_measures: Vec<String>,
    pub generated_at: String,
}

/// `AiSystemCardTechnicalSpecifications` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AiSystemCardTechnicalSpecifications {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_ref: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_context_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub built_in_tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrails_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrail_ids: Option<Vec<String>>,
}

/// Keys as served by GET /governance/ambassador/ambassadors and …/{id} (measured 2026-09-10).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Ambassador {
    pub ambassador_id: String,
    pub tenant_id: String,
    pub name: String,
    pub role: AmbassadorRole,
    pub permissions: AmbassadorPermissions,
    pub created_at: String,
}

/// `AmbassadorPermissions` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AmbassadorPermissions {
    pub can_veto: bool,
    pub can_audit: bool,
    pub can_propose: bool,
}

/// `AmbassadorRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AmbassadorRequest {
    pub request_id: String,
    pub tenant_id: String,
    pub from_agent_id: String,
    pub r#type: AmbassadorRequestType,
    pub subject: String,
    pub body: String,
    pub status: AmbassadorRequestStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: Option<String>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolved_at: Option<String>,
}

/// `AmbassadorRequestStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AmbassadorRequestStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "acknowledged")]
    Acknowledged,
    #[serde(rename = "resolved")]
    Resolved,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AmbassadorRequestStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Acknowledged => "acknowledged",
            Self::Resolved => "resolved",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AmbassadorRequestStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AmbassadorRequestStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "acknowledged" => Self::Acknowledged,
            "resolved" => Self::Resolved,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AmbassadorRequestType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AmbassadorRequestType {
    #[default]
    #[serde(rename = "clarification")]
    Clarification,
    #[serde(rename = "approval")]
    Approval,
    #[serde(rename = "escalation")]
    Escalation,
    #[serde(rename = "report")]
    Report,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AmbassadorRequestType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Clarification => "clarification",
            Self::Approval => "approval",
            Self::Escalation => "escalation",
            Self::Report => "report",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AmbassadorRequestType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AmbassadorRequestType {
    fn from(value: &str) -> Self {
        match value {
            "clarification" => Self::Clarification,
            "approval" => Self::Approval,
            "escalation" => Self::Escalation,
            "report" => Self::Report,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AmbassadorRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum AmbassadorRole {
    #[default]
    #[serde(rename = "founder")]
    Founder,
    #[serde(rename = "ambassador")]
    Ambassador,
    #[serde(rename = "observer")]
    Observer,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl AmbassadorRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Founder => "founder",
            Self::Ambassador => "ambassador",
            Self::Observer => "observer",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for AmbassadorRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for AmbassadorRole {
    fn from(value: &str) -> Self {
        match value {
            "founder" => Self::Founder,
            "ambassador" => Self::Ambassador,
            "observer" => Self::Observer,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AmbassadorVetoRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AmbassadorVetoRequest {
    pub target_type: String,
    pub target_id: String,
    pub reason: String,
}

/// `AmendConstitutionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AmendConstitutionRequest {
    pub rule_id: String,
    pub action: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rule: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
}

/// `AnalyticsTimeseriesPoint` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AnalyticsTimeseriesPoint {
    pub date: String,
    pub landing_visit: i64,
    pub page_view: i64,
    pub otp_requested: i64,
    pub signup: i64,
    pub login: i64,
    pub app_open: i64,
    pub activated: i64,
    pub checkout_started: i64,
    pub subscribed: i64,
}

/// `AnalyticsTopValue` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AnalyticsTopValue {
    pub value: String,
    pub count: i64,
}

/// `AndroidTester` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidTester {
    pub email: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    /// Truncated hash of the first submitting address. The raw IP is never stored.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_ip_hash: Option<String>,
    pub created_at: String,
    pub emails_sent: i64,
    /// `last_email_at` under the name the admin table renders; null rather than absent so a column
    /// can bind to it.
    #[serde(default)]
    pub emailed_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub send_failures: Option<i64>,
}

/// `AndroidTesterSignupResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AndroidTesterSignupResult {
    pub ok: bool,
    pub already_registered: bool,
    /// Whether a letter went out on THIS request. False when no testing URL is configured, when
    /// SMTP refused, when the address is inside its 24-hour resend cooldown, or when the
    /// platform-wide hourly send ceiling is reached. The address is recorded in every one of those
    /// cases — a "here is your link" letter without a link is worse than silence — so a client must
    /// NOT read `emailed: false` as "testing has not opened yet".
    pub emailed: bool,
}

/// `APIKeyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct APIKeyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prefix: Option<String>,
    /// Shown once. Save immediately.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub raw_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub warning: Option<String>,
}

/// An API key as listed. The secret is shown once, at creation, and never here.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct APIKeySummary {
    pub key_id: String,
    pub name: String,
    pub prefix: String,
    /// What the key IS: `session` was minted by an OTP/OAuth sign-in and carries a user_id;
    /// `api_key` was created deliberately from Settings or the CLI.
    pub kind: APIKeySummaryKind,
    pub scopes: Vec<String>,
    pub status: APIKeySummaryStatus,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_used_at: Option<String>,
}

/// What the key IS: `session` was minted by an OTP/OAuth sign-in and carries a user_id;
/// `api_key` was created deliberately from Settings or the CLI.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum APIKeySummaryKind {
    #[default]
    #[serde(rename = "session")]
    Session,
    #[serde(rename = "api_key")]
    APIKey,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl APIKeySummaryKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Session => "session",
            Self::APIKey => "api_key",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for APIKeySummaryKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for APIKeySummaryKind {
    fn from(value: &str) -> Self {
        match value {
            "session" => Self::Session,
            "api_key" => Self::APIKey,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `APIKeySummaryStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum APIKeySummaryStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "revoked")]
    Revoked,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl APIKeySummaryStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Revoked => "revoked",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for APIKeySummaryStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for APIKeySummaryStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "revoked" => Self::Revoked,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `AppendDrawingOpsRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AppendDrawingOpsRequest {
    pub ops: Vec<AppendDrawingOpsRequestOp>,
}

/// `AppendDrawingOpsRequestOp` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AppendDrawingOpsRequestOp {
    pub client_op_id: String,
    pub op: DrawingOp,
}

/// `AppendDrawingOpsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AppendDrawingOpsResponse {
    pub items: Vec<AppendDrawingOpsResponseItem>,
    /// The drawing's head after the batch.
    pub seq: i64,
}

/// `AppendDrawingOpsResponseItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AppendDrawingOpsResponseItem {
    pub client_op_id: String,
    pub seq: i64,
}

/// `AppleNativeAuthRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AppleNativeAuthRequest {
    /// Apple-signed JWT from `ASAuthorizationAppleIDCredential.identityToken`.
    pub identity_token: String,
    /// Apple's stable `userIdentifier` (informational only — server reads `sub` from the JWT).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    /// User profile name from Apple. Apple supplies this only on first sign-in; iOS should cache it
    /// locally and resend if the user record needs to be bootstrapped.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Device name (e.g. `iPhone 15 Pro`) surfaced on the minted api_key for `/me/sessions`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_label: Option<String>,
}

/// `AppleNativeAuthResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AppleNativeAuthResponse {
    pub api_key: String,
    pub email: String,
}

/// `ApplyProgramRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ApplyProgramRequest {
    pub session_id: String,
    pub start_date: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// `ApplyProgramResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ApplyProgramResponse {
    pub applied: bool,
    pub program_id: String,
    pub todos: Vec<Todo>,
}

/// `ApproveRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ApproveRunResponse {
    pub approved: bool,
    pub run_id: String,
}

/// `ArbiterCase` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ArbiterCase {
    pub case_id: String,
    pub tenant_id: String,
    pub filed_by: String,
    pub against_agent_id: String,
    pub rule_ids: Vec<String>,
    pub description: String,
    pub evidence: serde_json::Map<String, serde_json::Value>,
    pub status: ArbiterCaseStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_arbiter_id: Option<String>,
    pub created_at: String,
    pub deadline: String,
    pub updated_at: String,
}

/// `ArbiterCaseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ArbiterCaseStatus {
    #[default]
    #[serde(rename = "open")]
    Open,
    #[serde(rename = "under_review")]
    UnderReview,
    #[serde(rename = "ruled")]
    Ruled,
    #[serde(rename = "appealed")]
    Appealed,
    #[serde(rename = "closed")]
    Closed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ArbiterCaseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Open => "open",
            Self::UnderReview => "under_review",
            Self::Ruled => "ruled",
            Self::Appealed => "appealed",
            Self::Closed => "closed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ArbiterCaseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ArbiterCaseStatus {
    fn from(value: &str) -> Self {
        match value {
            "open" => Self::Open,
            "under_review" => Self::UnderReview,
            "ruled" => Self::Ruled,
            "appealed" => Self::Appealed,
            "closed" => Self::Closed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ArbiterRegistry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ArbiterRegistry {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arbiter_agent_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_appeals: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub panel_size: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ruling_deadline_hours: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `Artifact` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Artifact {
    pub artifact_id: String,
    pub run_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub name: String,
    pub mime_type: String,
    pub size_bytes: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub storage_ref: Option<String>,
    pub created_at: String,
}

/// `AssignWorkspaceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AssignWorkspaceRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub company_id: Option<String>,
}

/// One audit-log row as served by GET /runs/{runId}/audit-log and GET
/// /sessions/{sessionId}/audit-log. Keys measured 2026-09-10 on the e2e-canon tenant (runs and
/// sessions alike).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AuditLogEntry {
    pub entry_id: String,
    pub action: String,
    pub actor_tenant_id: String,
    pub target_type: String,
    pub target_id: String,
    pub details: serde_json::Map<String, serde_json::Value>,
    pub ip_address: String,
    pub timestamp: String,
}

/// `AuthProvider` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AuthProvider {
    pub email: String,
    pub id: String,
    pub linked: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub linked_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sub: Option<String>,
}

/// Body for POST /api/v1/auth/verify-code. No request_id; code is bound to email only.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AuthVerifyCodeRequest {
    /// Same email used in request-code
    pub email: String,
    /// OTP from email (6 digits); spaces are stripped server-side
    pub code: String,
}

/// Success response: API key to use as Bearer token
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AuthVerifyCodeResponse {
    /// uarp_\<prefix\>_\<secret\>; store and use as Authorization: Bearer \<api_key\>
    pub api_key: String,
}

/// `Ballot` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Ballot {
    pub proposal_id: String,
    pub agent_id: String,
    pub vote: BallotVote,
    pub weight: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    pub cast_at: String,
}

/// `BallotVote` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BallotVote {
    #[default]
    #[serde(rename = "approve")]
    Approve,
    #[serde(rename = "reject")]
    Reject,
    #[serde(rename = "abstain")]
    Abstain,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BallotVote {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Approve => "approve",
            Self::Reject => "reject",
            Self::Abstain => "abstain",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BallotVote {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BallotVote {
    fn from(value: &str) -> Self {
        match value {
            "approve" => Self::Approve,
            "reject" => Self::Reject,
            "abstain" => Self::Abstain,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BlogConfig` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BlogConfig {
    pub enabled: bool,
    pub title: String,
    pub description: String,
    #[serde(default)]
    pub agent_id: Option<String>,
    /// Derived, never sent by a client: set from the caller's tenant when `agent_id` is assigned,
    /// so the cron can run the author without a request context.
    #[serde(default)]
    pub agent_tenant_id: Option<String>,
    pub frequency: BlogConfigFrequency,
    pub schedule_hour: i64,
    pub schedule_weekday: i64,
    pub topic_prompt: String,
    pub conditions: String,
    pub auto_publish: bool,
    /// Drives scheduling. Null until the first successful generation.
    #[serde(default)]
    pub last_generated_at: Option<String>,
}

/// `BlogConfigFrequency` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BlogConfigFrequency {
    #[default]
    #[serde(rename = "manual")]
    Manual,
    #[serde(rename = "hourly")]
    Hourly,
    #[serde(rename = "daily")]
    Daily,
    #[serde(rename = "weekly")]
    Weekly,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BlogConfigFrequency {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Manual => "manual",
            Self::Hourly => "hourly",
            Self::Daily => "daily",
            Self::Weekly => "weekly",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BlogConfigFrequency {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BlogConfigFrequency {
    fn from(value: &str) -> Self {
        match value {
            "manual" => Self::Manual,
            "hourly" => Self::Hourly,
            "daily" => Self::Daily,
            "weekly" => Self::Weekly,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BlogPost` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BlogPost {
    pub id: String,
    /// Derived from the title and unique. Re-minted whenever the title changes.
    pub slug: String,
    pub title: String,
    pub body: String,
    pub tags: Vec<String>,
    pub status: BlogPostStatus,
    /// Who last shaped it, not who started it — an edit to the title or body of an agent-written
    /// post re-stamps this to `manual`.
    pub source: BlogPostSource,
    #[serde(default)]
    pub agent_id: Option<String>,
    #[serde(default)]
    pub run_id: Option<String>,
    pub created_at: String,
    pub updated_at: String,
    /// Null while a draft. Stamped on transition to published and cleared on a return to draft, so
    /// a republished post carries a new timestamp rather than its original.
    #[serde(default)]
    pub published_at: Option<String>,
}

/// Who last shaped it, not who started it — an edit to the title or body of an agent-written
/// post re-stamps this to `manual`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BlogPostSource {
    #[default]
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "manual")]
    Manual,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BlogPostSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Agent => "agent",
            Self::Manual => "manual",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BlogPostSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BlogPostSource {
    fn from(value: &str) -> Self {
        match value {
            "agent" => Self::Agent,
            "manual" => Self::Manual,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BlogPostStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BlogPostStatus {
    #[default]
    #[serde(rename = "draft")]
    Draft,
    #[serde(rename = "published")]
    Published,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BlogPostStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Draft => "draft",
            Self::Published => "published",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BlogPostStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BlogPostStatus {
    fn from(value: &str) -> Self {
        match value {
            "draft" => Self::Draft,
            "published" => Self::Published,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BootstrapRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BootstrapRequest {
    /// Server default: `"Admin Tenant"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_name: Option<String>,
    /// Server default: `"admin"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_slug: Option<String>,
}

/// `BootstrapResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BootstrapResponse {
    pub message: String,
    pub tenant: BootstrapResponseTenant,
    pub api_key: BootstrapResponseAPIKey,
}

/// `BootstrapResponseAPIKey` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BootstrapResponseAPIKey {
    pub key_id: String,
    pub prefix: String,
    pub raw_key: String,
    pub scopes: Vec<String>,
    pub warning: String,
}

/// `BootstrapResponseTenant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BootstrapResponseTenant {
    pub tenant_id: String,
    pub name: String,
    pub slug: String,
    pub plan: String,
}

/// `BridgeAgentSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeAgentSummary {
    pub agent_id: String,
    pub machine_id: String,
    pub machine_name: String,
    pub capabilities: Vec<String>,
    pub working_directory: String,
    pub status: String,
    pub last_heartbeat: String,
}

/// `BridgeConnection` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeConnection {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub machine_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub machine_name: Option<String>,
    pub capabilities: Vec<String>,
    pub working_directory: String,
    pub version: String,
    pub last_heartbeat: String,
    pub status: AgentSummaryBridgeStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub registered_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub os: Option<String>,
}

/// `BridgeDelegateRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeDelegateRequest {
    /// The bridge agent to hand the task to.
    pub agent_id: String,
    /// The task itself. Required: the handler answers 400 when either this or agent_id is missing.
    /// This block used to omit it entirely while requiring `context`, which the handler never
    /// checks — so a body written from the document was refused for a field it was told to send,
    /// and accepted without the one that is actually needed. Measured 2026-09-18.
    pub message: String,
    /// Optional.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority: Option<String>,
    /// Optional. Rendered into the message ahead of it when present.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `BridgeDelegateResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeDelegateResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_id: Option<String>,
}

/// `BridgeDeregisterRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeDeregisterRequest {
    pub machine_id: String,
}

/// `BridgeDeregisterResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeDeregisterResponse {
    pub status: BridgeDeregisterResponseStatus,
}

/// `BridgeDeregisterResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BridgeDeregisterResponseStatus {
    #[default]
    #[serde(rename = "offline")]
    Offline,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BridgeDeregisterResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Offline => "offline",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BridgeDeregisterResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BridgeDeregisterResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "offline" => Self::Offline,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BridgeHeartbeatRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeHeartbeatRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub machine_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `BridgeHeartbeatResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeHeartbeatResponse {
    pub ok: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
}

/// `BridgeInstalledSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeInstalledSpec {
    /// `@scope/name`.
    pub spec_id: String,
    /// Resolved exactly, never a range.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    /// Tool names the SPEC registered into the local runtime.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<String>>,
    pub status: BridgeInstalledSpecStatus,
    /// Failure detail when `status` is `failed` — artifact 404, SHA mismatch, capability conflict.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reported_at: Option<String>,
}

/// `BridgeInstalledSpecStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BridgeInstalledSpecStatus {
    #[default]
    #[serde(rename = "installed")]
    Installed,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BridgeInstalledSpecStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Installed => "installed",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BridgeInstalledSpecStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BridgeInstalledSpecStatus {
    fn from(value: &str) -> Self {
        match value {
            "installed" => Self::Installed,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BridgePendingTask` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgePendingTask {
    pub task_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    pub input: BridgePendingTaskInput,
    pub queued_at: String,
    pub expires_at: String,
    pub source: BridgePendingTaskSource,
}

/// `BridgePendingTaskInput` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgePendingTaskInput {
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_history: Option<Vec<BridgePendingTaskInputConversationHistoryItem>>,
    /// Attachment ids the user added to this message. Fetch each with GET /files/{fileId}/content
    /// (scope files:read). Absent when the message had no attachment.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<String>>,
    /// The attachments, in the same order as `files`, with what a client needs BEFORE it spends a
    /// fetch: a 40 MB video and a 2 KB note are not the same decision, and an error that cannot
    /// name the file leaves the model answering about a document it never opened. This is the
    /// SUBSET of `files` whose artifact record still exists when the task is enqueued — a run
    /// dispatched from a schedule was written earlier and the file may have been deleted since. An
    /// id present in `files` with no entry here means the file is gone, not that its metadata was
    /// omitted; fetching it will 404, which is how the client reports the attachment as not
    /// delivered.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attachments: Option<Vec<BridgePendingTaskInputAttachment>>,
}

/// `BridgePendingTaskInputAttachment` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgePendingTaskInputAttachment {
    pub file_id: String,
    pub filename: String,
    pub mime_type: String,
    pub size_bytes: i64,
}

/// `BridgePendingTaskInputConversationHistoryItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgePendingTaskInputConversationHistoryItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
}

/// `BridgePendingTaskSource` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgePendingTaskSource {
    pub r#type: BridgePendingTaskSourceType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
}

/// `BridgePendingTaskSourceType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BridgePendingTaskSourceType {
    #[default]
    #[serde(rename = "head_agent")]
    HeadAgent,
    #[serde(rename = "user")]
    User,
    #[serde(rename = "team")]
    Team,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BridgePendingTaskSourceType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::HeadAgent => "head_agent",
            Self::User => "user",
            Self::Team => "team",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BridgePendingTaskSourceType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BridgePendingTaskSourceType {
    fn from(value: &str) -> Self {
        match value {
            "head_agent" => Self::HeadAgent,
            "user" => Self::User,
            "team" => Self::Team,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BridgePollResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgePollResponse {
    pub tasks: Vec<BridgePendingTask>,
}

/// `BridgeRegisterRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeRegisterRequest {
    pub machine_id: String,
    pub capabilities: Vec<String>,
    pub working_directory: String,
    pub version: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub machine_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub os: Option<String>,
}

/// `BridgeRegisterResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeRegisterResponse {
    pub agent_id: String,
    /// Always `online`.
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub registered: Option<bool>,
}

/// `BridgeStatusResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeStatusResponse {
    pub connections: Vec<BridgeConnection>,
}

/// A progress frame from the Snaga bridge (BridgeTaskEvent in @uarp/types); `type` decides
/// which optional fields are present.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeTaskEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub event_id: Option<String>,
    pub r#type: BridgeTaskEventType,
    pub timestamp: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approval_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_args_preview: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_call_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_result_preview: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<BridgeTaskEventMetrics>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub working_directory: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hostname: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub platform: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
}

/// `BridgeTaskEventMetrics` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BridgeTaskEventMetrics {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files_modified: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commands_executed: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_time_ms: Option<i64>,
}

/// `BridgeTaskEventType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BridgeTaskEventType {
    #[default]
    #[serde(rename = "status")]
    Status,
    #[serde(rename = "tool_call")]
    ToolCall,
    #[serde(rename = "tool_result")]
    ToolResult,
    #[serde(rename = "content")]
    Content,
    #[serde(rename = "thinking")]
    Thinking,
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "metrics")]
    Metrics,
    #[serde(rename = "approval_request")]
    ApprovalRequest,
    #[serde(rename = "error")]
    Error,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "capability_report")]
    CapabilityReport,
    #[serde(rename = "escalation")]
    Escalation,
    #[serde(rename = "approval_denied")]
    ApprovalDenied,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BridgeTaskEventType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Status => "status",
            Self::ToolCall => "tool_call",
            Self::ToolResult => "tool_result",
            Self::Content => "content",
            Self::Thinking => "thinking",
            Self::Text => "text",
            Self::Metrics => "metrics",
            Self::ApprovalRequest => "approval_request",
            Self::Error => "error",
            Self::Completed => "completed",
            Self::CapabilityReport => "capability_report",
            Self::Escalation => "escalation",
            Self::ApprovalDenied => "approval_denied",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BridgeTaskEventType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BridgeTaskEventType {
    fn from(value: &str) -> Self {
        match value {
            "status" => Self::Status,
            "tool_call" => Self::ToolCall,
            "tool_result" => Self::ToolResult,
            "content" => Self::Content,
            "thinking" => Self::Thinking,
            "text" => Self::Text,
            "metrics" => Self::Metrics,
            "approval_request" => Self::ApprovalRequest,
            "error" => Self::Error,
            "completed" => Self::Completed,
            "capability_report" => Self::CapabilityReport,
            "escalation" => Self::Escalation,
            "approval_denied" => Self::ApprovalDenied,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BulkDeleteNotificationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BulkDeleteNotificationsResponse {
    pub deleted: i64,
    pub scope: BulkDeleteNotificationsScope,
}

/// `BulkDeleteNotificationsScope` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum BulkDeleteNotificationsScope {
    #[default]
    #[serde(rename = "read")]
    Read,
    #[serde(rename = "all")]
    All,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl BulkDeleteNotificationsScope {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Read => "read",
            Self::All => "all",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for BulkDeleteNotificationsScope {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for BulkDeleteNotificationsScope {
    fn from(value: &str) -> Self {
        match value {
            "read" => Self::Read,
            "all" => Self::All,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `BulkDeleteSessionsRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BulkDeleteSessionsRequest {
    pub session_ids: Vec<String>,
}

/// `BulkDeleteSessionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BulkDeleteSessionsResponse {
    pub deleted: i64,
    pub failed: Vec<String>,
}

/// `CancelA2ATaskResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CancelA2ATaskResponse {
    pub cancelled: bool,
    pub task_id: String,
}

/// `CancelPublicSessionRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CancelPublicSessionRunResponse {
    pub cancelled: bool,
    pub run_id: String,
}

/// `CancelRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CancelRunResponse {
    pub cancelled: bool,
    pub run_id: String,
}

/// `CancelSquadRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CancelSquadRunResponse {
    pub cancelled: bool,
    pub team_run_id: String,
    /// Child runs actually stopped. Zero is normal for a run whose children had already finished.
    /// Deprecated spelling of `cancelled_count` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `cancelled_count`.
    #[serde(rename = "cancelledCount")]
    pub cancelled_count: i64,
    /// False when no orchestration loop was in flight in this process — the run had already
    /// settled, or it belongs to another replica.
    pub orchestrator_stopped: bool,
    /// Child runs actually stopped. Zero is normal for a run whose children had already finished.
    #[serde(rename = "cancelled_count")]
    pub cancelled_count_: i64,
}

/// `CancelTeamRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CancelTeamRunResponse {
    pub cancelled: bool,
    pub team_run_id: String,
    /// Child runs actually stopped. Zero is normal for a run whose children had already finished.
    /// Deprecated spelling of `cancelled_count` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `cancelled_count`.
    #[serde(rename = "cancelledCount")]
    pub cancelled_count: i64,
    /// False when no orchestration loop was in flight in this process — the run had already
    /// settled, or it belongs to another replica.
    pub orchestrator_stopped: bool,
    /// Child runs actually stopped. Zero is normal for a run whose children had already finished.
    #[serde(rename = "cancelled_count")]
    pub cancelled_count_: i64,
}

/// visual-builder.ts CanvasEdge.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CanvasEdge {
    pub id: String,
    pub source: String,
    pub target: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
}

/// visual-builder.ts CanvasNode.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CanvasNode {
    pub id: String,
    pub r#type: CanvasNodeType,
    pub label: String,
    pub position: CanvasNodePosition,
    pub config: serde_json::Map<String, serde_json::Value>,
}

/// `CanvasNodePosition` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CanvasNodePosition {
    pub x: f64,
    pub y: f64,
}

/// `CanvasNodeType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CanvasNodeType {
    #[default]
    #[serde(rename = "llm")]
    LLM,
    #[serde(rename = "tool")]
    Tool,
    #[serde(rename = "guardrail")]
    Guardrail,
    #[serde(rename = "memory")]
    Memory,
    #[serde(rename = "condition")]
    Condition,
    #[serde(rename = "input")]
    Input,
    #[serde(rename = "output")]
    Output,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CanvasNodeType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::LLM => "llm",
            Self::Tool => "tool",
            Self::Guardrail => "guardrail",
            Self::Memory => "memory",
            Self::Condition => "condition",
            Self::Input => "input",
            Self::Output => "output",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CanvasNodeType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CanvasNodeType {
    fn from(value: &str) -> Self {
        match value {
            "llm" => Self::LLM,
            "tool" => Self::Tool,
            "guardrail" => Self::Guardrail,
            "memory" => Self::Memory,
            "condition" => Self::Condition,
            "input" => Self::Input,
            "output" => Self::Output,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CanvasWorkflowStep` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CanvasWorkflowStep {
    /// The agent this step runs. An entry without it is silently discarded.
    pub agent_id: String,
    /// Display name for the step; falls back to the agent's own name.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    /// Per-step instruction. Carried through the SCHEDULE too — dropping it there made every
    /// scheduled run fall back to the bare label while the manual run honoured it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompt: Option<String>,
}

/// `CastBallotRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CastBallotRequest {
    pub agent_id: String,
    pub vote: String,
    /// Voting weight; 0 \< w ≤ 1 (the same cap the cast_vote tool applies; 100 was accepted until
    /// 2026-09-16).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub weight: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<String>,
    /// Optional cryptographic ballot signature.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
}

/// `ChatCompletionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequest {
    /// Agent ID or 'agent/\<agent_id\>'
    pub model: String,
    pub messages: Vec<ChatCompletionRequestMessage>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
    /// Values below 1 are clamped, not refused.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i64>,
    /// Server default: `false`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stream: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<ChatCompletionRequestTool>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<serde_json::Value>,
}

/// `ChatCompletionRequestMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestMessage {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<ChatCompletionRequestMessageRole>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
}

/// `ChatCompletionRequestMessageRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ChatCompletionRequestMessageRole {
    #[default]
    #[serde(rename = "system")]
    System,
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    #[serde(rename = "tool")]
    Tool,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ChatCompletionRequestMessageRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::System => "system",
            Self::User => "user",
            Self::Assistant => "assistant",
            Self::Tool => "tool",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ChatCompletionRequestMessageRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ChatCompletionRequestMessageRole {
    fn from(value: &str) -> Self {
        match value {
            "system" => Self::System,
            "user" => Self::User,
            "assistant" => Self::Assistant,
            "tool" => Self::Tool,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ChatCompletionRequestTool` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestTool {
    pub r#type: OpenAiToolCallType,
    pub function: ChatCompletionRequestToolFunction,
}

/// `ChatCompletionRequestToolFunction` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestToolFunction {
    pub name: String,
    pub description: String,
    /// JSON Schema Draft 2020-12 for tool parameters
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parameters: Option<serde_json::Map<String, serde_json::Value>>,
}

/// types/llm.ts ChatMessage — the model-facing message a checkpoint stores.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatMessage {
    pub role: ChatMessageRole,
    pub content: serde_json::Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_call_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<ChatMessageToolCall>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning_content: Option<String>,
}

/// `ChatMessageContentVariant2item` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatMessageContentVariant2item {
    pub r#type: ChatMessageContentVariant2itemType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub media: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `ChatMessageContentVariant2itemType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ChatMessageContentVariant2itemType {
    #[default]
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "image")]
    Image,
    #[serde(rename = "audio")]
    Audio,
    #[serde(rename = "video")]
    Video,
    #[serde(rename = "file")]
    File,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ChatMessageContentVariant2itemType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Text => "text",
            Self::Image => "image",
            Self::Audio => "audio",
            Self::Video => "video",
            Self::File => "file",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ChatMessageContentVariant2itemType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ChatMessageContentVariant2itemType {
    fn from(value: &str) -> Self {
        match value {
            "text" => Self::Text,
            "image" => Self::Image,
            "audio" => Self::Audio,
            "video" => Self::Video,
            "file" => Self::File,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ChatMessageRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ChatMessageRole {
    #[default]
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "tool")]
    Tool,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ChatMessageRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::User => "user",
            Self::Assistant => "assistant",
            Self::System => "system",
            Self::Tool => "tool",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ChatMessageRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ChatMessageRole {
    fn from(value: &str) -> Self {
        match value {
            "user" => Self::User,
            "assistant" => Self::Assistant,
            "system" => Self::System,
            "tool" => Self::Tool,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ChatMessageToolCall` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ChatMessageToolCall {
    pub id: String,
    pub name: String,
    pub arguments: serde_json::Map<String, serde_json::Value>,
}

/// `CheckGovernanceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CheckGovernanceRequest {
    pub agent_id: String,
    pub action: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
}

/// `CheckSpawnPermissionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CheckSpawnPermissionRequest {
    pub parent_agent_id: String,
    pub child_permissions: PermissionSet,
}

/// `ClearBillingBudgetResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ClearBillingBudgetResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `CloseSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CloseSessionResponse {
    pub deleted: bool,
    pub session_id: String,
}

/// Autonomous agent company — strategist + teams pursuing strategic goals.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Company {
    pub company_id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mission: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategic_goals: Option<Vec<StrategicGoal>>,
    pub strategist_agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_agent_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    /// When the company loop last ATTEMPTED a tick, success or failure. The tick schedule is
    /// computed from this (falling back to updated_at while absent), so an ordinary edit no longer
    /// postpones the next tick.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_tick_at: Option<String>,
    /// When the company loop last completed a tick whose strategist run SUCCEEDED. The `stuck`
    /// escalation reads this (falling back to updated_at while absent).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_successful_tick_at: Option<String>,
}

/// companies.ts — a company_activity row; `success` only when recorded.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CompanyActivityEntry {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
}

/// Body for `POST /api/v1/companies` (`CreateCompanySchema`).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CompanyCreate {
    pub name: String,
    /// What the company exists to do.
    pub mission: String,
    /// Spend ceiling and pacing for the company.
    pub budget: CompanyCreateBudget,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategic_goals: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
}

/// Spend ceiling and pacing for the company.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CompanyCreateBudget {
    pub total_usd: f64,
    pub daily_limit_usd: f64,
    pub alert_threshold_pct: f64,
    /// Metered by the platform. Ignored on create (set to 0) and on update.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spent_usd: Option<f64>,
}

/// Body for `PUT /api/v1/companies/{companyId}`. Every field optional — send only what changes.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CompanyUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mission: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategic_goals: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `CompleteOAuthLoginResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CompleteOAuthLoginResponse {
    pub api_key: String,
    pub email: String,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; api/lib/conformity-report.ts
/// — three sections, plus the same content as markdown. `?format=markdown` answers
/// text/markdown instead.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConformityReport {
    pub tenant_id: String,
    pub sections: Vec<ConformityReportSection>,
    pub markdown: String,
}

/// `ConformityReportSection` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConformityReportSection {
    pub title: String,
    pub content: String,
}

/// `ConnectorConfigField` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConnectorConfigField {
    pub r#type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub required: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// `ConstitutionAmendment` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConstitutionAmendment {
    pub amendment_id: String,
    pub rule_id: String,
    pub action: ConstitutionAmendmentAction,
    /// The new rule, for `add` and `modify`. Absent on `remove`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rule: Option<ConstitutionRule>,
    pub proposed_by: String,
    /// The founder, or the consensus that carried it.
    pub approved_by: String,
    pub rationale: String,
    pub applied_at: String,
}

/// `ConstitutionAmendmentAction` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConstitutionAmendmentAction {
    #[default]
    #[serde(rename = "add")]
    Add,
    #[serde(rename = "modify")]
    Modify,
    #[serde(rename = "remove")]
    Remove,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ConstitutionAmendmentAction {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Add => "add",
            Self::Modify => "modify",
            Self::Remove => "remove",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ConstitutionAmendmentAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConstitutionAmendmentAction {
    fn from(value: &str) -> Self {
        match value {
            "add" => Self::Add,
            "modify" => Self::Modify,
            "remove" => Self::Remove,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ConstitutionDocument` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConstitutionDocument {
    pub tenant_id: String,
    pub version: i64,
    pub rules: Vec<ConstitutionRule>,
    pub amendments: Vec<ConstitutionAmendment>,
    /// Who created the genesis document.
    pub founder_id: String,
    pub created_at: String,
    /// Present and `true` only when no document is stored and these are the genesis defaults
    /// computed on read; absent on a stored document (measured 2026-09-10).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#virtual: Option<bool>,
    pub updated_at: String,
}

/// `ConstitutionRule` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConstitutionRule {
    /// Stable slug, e.g. `no-privilege-escalation`.
    pub id: String,
    pub rule_type: ConstitutionRuleRuleType,
    /// Who the rule binds. The document previously listed `global`/`tenant`/`agent`, none of which
    /// the server has ever emitted.
    pub scope: ConstitutionRuleScope,
    /// Agent ids, team ids or role names, depending on `scope`. Absent for `all_agents`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope_targets: Option<Vec<String>>,
    /// The action the rule governs, e.g. `modify_constitution`.
    pub action: String,
    /// For `requirement` rules: the action that must be performed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub obligated_action: Option<String>,
    pub penalty: ConstitutionRulePenalty,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Genesis rules cannot be amended or removed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub immutable: Option<bool>,
    /// Conflict resolution — higher wins. Defaults to 0.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority: Option<i64>,
    /// True when no code path can ever raise this rule — the platform emits no such action (the
    /// constitution digest lists it under ADVISORY and boot logs "Constitution rules that can never
    /// fire"). A rulebook used to show these as enforced and LOCKED over an audit page with no such
    /// entries. Served since 2026-09-11; absent on older servers means unknown, not false.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub advisory: Option<bool>,
}

/// `ConstitutionRulePenalty` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConstitutionRulePenalty {
    #[default]
    #[serde(rename = "block")]
    Block,
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "log")]
    Log,
    #[serde(rename = "terminate_agent")]
    TerminateAgent,
    #[serde(rename = "revoke_permissions")]
    RevokePermissions,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ConstitutionRulePenalty {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Block => "block",
            Self::Warn => "warn",
            Self::Log => "log",
            Self::TerminateAgent => "terminate_agent",
            Self::RevokePermissions => "revoke_permissions",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ConstitutionRulePenalty {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConstitutionRulePenalty {
    fn from(value: &str) -> Self {
        match value {
            "block" => Self::Block,
            "warn" => Self::Warn,
            "log" => Self::Log,
            "terminate_agent" => Self::TerminateAgent,
            "revoke_permissions" => Self::RevokePermissions,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ConstitutionRuleRuleType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConstitutionRuleRuleType {
    #[default]
    #[serde(rename = "prohibition")]
    Prohibition,
    #[serde(rename = "requirement")]
    Requirement,
    #[serde(rename = "permission")]
    Permission,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ConstitutionRuleRuleType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Prohibition => "prohibition",
            Self::Requirement => "requirement",
            Self::Permission => "permission",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ConstitutionRuleRuleType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConstitutionRuleRuleType {
    fn from(value: &str) -> Self {
        match value {
            "prohibition" => Self::Prohibition,
            "requirement" => Self::Requirement,
            "permission" => Self::Permission,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Who the rule binds. The document previously listed `global`/`tenant`/`agent`, none of which
/// the server has ever emitted.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConstitutionRuleScope {
    #[default]
    #[serde(rename = "all_agents")]
    AllAgents,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "role")]
    Role,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ConstitutionRuleScope {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::AllAgents => "all_agents",
            Self::Team => "team",
            Self::Agent => "agent",
            Self::Role => "role",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ConstitutionRuleScope {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConstitutionRuleScope {
    fn from(value: &str) -> Self {
        match value {
            "all_agents" => Self::AllAgents,
            "team" => Self::Team,
            "agent" => Self::Agent,
            "role" => Self::Role,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ConstitutionViolation` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConstitutionViolation {
    pub rule_id: String,
    pub rule_type: ConstitutionRuleRuleType,
    pub action: String,
    pub agent_id: String,
    pub penalty: ConstitutionRulePenalty,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub timestamp: String,
}

/// `ContentReport` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ContentReport {
    pub id: String,
    pub target_type: ContentReportInputTargetType,
    pub target_id: String,
    pub reason: ContentReportInputReason,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<String>,
    /// Tenant that owns the reported content — the queue this report lands in.
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    pub origin: ContentReportOrigin,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reporter_tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reporter_user_id: Option<String>,
    /// Truncated SHA-256 of the reporter's IP. Never the raw address; enough to spot one source
    /// flooding the queue.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reporter_fingerprint: Option<String>,
    pub status: ContentReportStatus,
    pub severity: ContentReportSeverity,
    pub created_at: String,
}

/// `ContentReportAccepted` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ContentReportAccepted {
    pub report_id: String,
    pub status: ContentReportAcceptedStatus,
}

/// `ContentReportAcceptedStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ContentReportAcceptedStatus {
    #[default]
    #[serde(rename = "received")]
    Received,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ContentReportAcceptedStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Received => "received",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ContentReportAcceptedStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ContentReportAcceptedStatus {
    fn from(value: &str) -> Self {
        match value {
            "received" => Self::Received,
            other => Self::Other(other.to_string()),
        }
    }
}

/// An abuse/moderation report. Same body shape for the authenticated and anonymous endpoints.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ContentReportInput {
    pub target_type: ContentReportInputTargetType,
    pub target_id: String,
    /// Closed vocabulary — unknown values are rejected with 422. `self_harm` raises the resulting
    /// operator notification to critical priority.
    pub reason: ContentReportInputReason,
    /// Optional free-text note from the reporter.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<String>,
}

/// Closed vocabulary — unknown values are rejected with 422. `self_harm` raises the resulting
/// operator notification to critical priority.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ContentReportInputReason {
    #[default]
    #[serde(rename = "harassment")]
    Harassment,
    #[serde(rename = "hate")]
    Hate,
    #[serde(rename = "sexual")]
    Sexual,
    #[serde(rename = "violence")]
    Violence,
    #[serde(rename = "self_harm")]
    SelfHarm,
    #[serde(rename = "illegal")]
    Illegal,
    #[serde(rename = "spam")]
    Spam,
    #[serde(rename = "other")]
    Other,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Unknown(String),
}

impl ContentReportInputReason {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Harassment => "harassment",
            Self::Hate => "hate",
            Self::Sexual => "sexual",
            Self::Violence => "violence",
            Self::SelfHarm => "self_harm",
            Self::Illegal => "illegal",
            Self::Spam => "spam",
            Self::Other => "other",
            Self::Unknown(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ContentReportInputReason {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ContentReportInputReason {
    fn from(value: &str) -> Self {
        match value {
            "harassment" => Self::Harassment,
            "hate" => Self::Hate,
            "sexual" => Self::Sexual,
            "violence" => Self::Violence,
            "self_harm" => Self::SelfHarm,
            "illegal" => Self::Illegal,
            "spam" => Self::Spam,
            "other" => Self::Other,
            other => Self::Unknown(other.to_string()),
        }
    }
}

/// `ContentReportInputTargetType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ContentReportInputTargetType {
    #[default]
    #[serde(rename = "message")]
    Message,
    #[serde(rename = "session")]
    Session,
    #[serde(rename = "agent")]
    Agent,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ContentReportInputTargetType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Message => "message",
            Self::Session => "session",
            Self::Agent => "agent",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ContentReportInputTargetType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ContentReportInputTargetType {
    fn from(value: &str) -> Self {
        match value {
            "message" => Self::Message,
            "session" => Self::Session,
            "agent" => Self::Agent,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ContentReportOrigin` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ContentReportOrigin {
    #[default]
    #[serde(rename = "authenticated")]
    Authenticated,
    #[serde(rename = "public_session")]
    PublicSession,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ContentReportOrigin {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Authenticated => "authenticated",
            Self::PublicSession => "public_session",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ContentReportOrigin {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ContentReportOrigin {
    fn from(value: &str) -> Self {
        match value {
            "authenticated" => Self::Authenticated,
            "public_session" => Self::PublicSession,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ContentReportSeverity` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ContentReportSeverity {
    #[default]
    #[serde(rename = "critical")]
    Critical,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "normal")]
    Normal,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ContentReportSeverity {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Critical => "critical",
            Self::High => "high",
            Self::Normal => "normal",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ContentReportSeverity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ContentReportSeverity {
    fn from(value: &str) -> Self {
        match value {
            "critical" => Self::Critical,
            "high" => Self::High,
            "normal" => Self::Normal,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ContentReportStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ContentReportStatus {
    #[default]
    #[serde(rename = "received")]
    Received,
    #[serde(rename = "reviewing")]
    Reviewing,
    #[serde(rename = "actioned")]
    Actioned,
    #[serde(rename = "dismissed")]
    Dismissed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ContentReportStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Received => "received",
            Self::Reviewing => "reviewing",
            Self::Actioned => "actioned",
            Self::Dismissed => "dismissed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ContentReportStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ContentReportStatus {
    fn from(value: &str) -> Self {
        match value {
            "received" => Self::Received,
            "reviewing" => Self::Reviewing,
            "actioned" => Self::Actioned,
            "dismissed" => Self::Dismissed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ContinueRunRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ContinueRunRequest {
    /// Opaque base64-encoded continuation token
    pub continuation_token: String,
}

/// `ContinueRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ContinueRunResponse {
    pub continued: bool,
    pub run_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub checkpoint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resume_step: Option<i64>,
}

/// One entry of a session transcript — what GET /sessions/{sessionId}/messages serves in both
/// `messages` and `items` (types/session.ts ConversationEntry, enriched on read by sessions.ts
/// with the run's metrics and cost). Measured 2026-09-10 on e2e-canon: a user turn carries
/// role, content, run_id, timestamp, compacted, importance; an assistant turn adds tool_calls,
/// thinking, run_metrics, cost_usd.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntry {
    /// The stable id of this entry — derived on read (lib/message-ids.ts), never stored, so every
    /// transcript has it: the first user turn of a run is `{run_id}`, the first assistant reply
    /// `{run_id}-reply`, further replies `{run_id}-reply-2`…, a second human turn of the same run
    /// `{run_id}-user-2`… (lib/message-ids.ts:16-19), tool results `{run_id}-tool-N` and system
    /// entries `{run_id}-system-N` numbered from 1 (the first is `-tool-1`, never bare `-tool`).
    /// Counted per run over the whole history before compaction, so it does not move. This is the
    /// canonical `message_id` for reactions (PUT /runs/{runId}/feedback), bookmarks
    /// (/agents/{agentId}/bookmarks/{messageId}) and annotations (POST
    /// /sessions/{sessionId}/annotations); it is a safe path segment.
    pub message_id: String,
    pub role: PublicSessionViewMessageRole,
    /// The text, or content parts for a multimodal turn (types/llm.ts MessageContent). v1 emits the
    /// string arm: every writer (renderUserTurn, SessionMessageSchema.content,
    /// ImportSessionMessageSchema) stores a string, and every stored entry on production is one (8
    /// 427 of 8 427, measured 2026-09-11). The array arm is the LLM wire type (types/llm.ts
    /// MessageContent) the schema inherits; a v2 server accepts only the string.
    pub content: serde_json::Value,
    pub run_id: String,
    pub timestamp: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compacted: Option<bool>,
    /// Persisted on assistant entries when the run executed tools. Reload re-paints these blocks
    /// underneath the assistant turn (matches what the SSE stream renders during the live run).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<ConversationEntryToolCall>>,
    /// Reasoning / thinking content (DeepSeek `reasoning_content`, Anthropic extended thinking,
    /// GLM/Qwen `\<think\>` blocks). Persisted on assistant entries so reload re-paints the
    /// Thinking section above the assistant text.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub importance: Option<ConversationEntryImportance>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attachments: Option<Vec<ConversationEntryAttachment>>,
    /// On an assistant entry: the run's metrics as served by GET /runs/{runId} (sessions.ts
    /// publicRunMetrics).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_metrics: Option<ConversationEntryRunMetrics>,
    /// On an assistant entry, when the run recorded a cost.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_usd: Option<f64>,
    /// The reply came from a run a Todo triggered.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_todo: Option<bool>,
    /// The model ran out of output tokens — see RunOutput.output_truncated.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_truncated: Option<bool>,
}

/// `ConversationEntryAttachment` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntryAttachment {
    pub file_id: String,
    pub filename: String,
    pub mime_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<i64>,
}

/// `ConversationEntryContentVariant2item` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntryContentVariant2item {
    pub r#type: ChatMessageContentVariant2itemType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub media: Option<ConversationEntryContentVariant2itemMedia>,
}

/// `ConversationEntryContentVariant2itemMedia` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntryContentVariant2itemMedia {
    pub mime_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// `ConversationEntryImportance` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConversationEntryImportance {
    #[default]
    #[serde(rename = "high")]
    High,
    #[serde(rename = "normal")]
    Normal,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ConversationEntryImportance {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::High => "high",
            Self::Normal => "normal",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ConversationEntryImportance {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConversationEntryImportance {
    fn from(value: &str) -> Self {
        match value {
            "high" => Self::High,
            "normal" => Self::Normal,
            other => Self::Other(other.to_string()),
        }
    }
}

/// On an assistant entry: the run's metrics as served by GET /runs/{runId} (sessions.ts
/// publicRunMetrics).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntryRunMetrics {
    /// How the cost was priced (measured 2026-09-10 on e2e-canon; billing/cost-estimator.ts).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pricing_confidence: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub steps_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm_calls_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrail_checks: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrail_violations: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_retrievals: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_extractions: Option<i64>,
    /// Estimated total cost in USD
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_cost_usd: Option<f64>,
}

/// `ConversationEntryToolCall` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntryToolCall {
    pub id: String,
    pub name: String,
    pub status: ConversationEntryToolCallStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `ConversationEntryToolCallStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConversationEntryToolCallStatus {
    #[default]
    #[serde(rename = "done")]
    Done,
    #[serde(rename = "error")]
    Error,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ConversationEntryToolCallStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Done => "done",
            Self::Error => "error",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ConversationEntryToolCallStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConversationEntryToolCallStatus {
    fn from(value: &str) -> Self {
        match value {
            "done" => Self::Done,
            "error" => Self::Error,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CopyWorkspaceFileRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CopyWorkspaceFileRequest {
    pub source_path: String,
    pub dest_path: String,
}

/// `CoreMemoryBlock` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CoreMemoryBlock {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub block_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z;
/// billing/cost-reconciliation.ts ReconciliationResult — `truncated` and `details` conditional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CostReconciliationResult {
    pub tenant_id: String,
    pub period: String,
    pub runs_total_cost_usd: f64,
    pub usage_tracker_cost_usd: f64,
    pub drift_usd: f64,
    pub drift_pct: f64,
    pub runs_scanned: i64,
    pub runs_missing_cost: i64,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub truncated: Option<bool>,
}

/// `CreateA2ATaskRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateA2ATaskRequest {
    pub agent_id: String,
    /// At least one `user` message must carry input: a text part with non-empty `text`, a `data`
    /// part, or a `file` part with inline `data` (a `uri`-only file is not fetched on this route).
    /// Anything else is refused with **422** before a task or run exists (schemas/mod.ts
    /// A2AMessagesSchema).
    pub messages: Vec<CreateA2ATaskRequestMessage>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `CreateA2ATaskRequestMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateA2ATaskRequestMessage {
    pub role: DrawingJournalEntryAuthorKind,
    pub parts: Vec<A2APart>,
}

/// `CreateAdminBlogPostRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAdminBlogPostRequest {
    pub title: String,
    pub body: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<BlogPostStatus>,
}

/// `CreateAdminBlogPostResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAdminBlogPostResponse {
    pub post: BlogPost,
}

/// `CreateAdminProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAdminProviderResponse {
    pub id: String,
    pub name: String,
    pub default_endpoint: String,
    pub is_custom: bool,
    pub requires_api_key: bool,
    pub canonical: String,
    /// Only when the body sent it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_capabilities: Option<CreateAdminProviderResponseDefaultCapabilities>,
}

/// Only when the body sent it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAdminProviderResponseDefaultCapabilities {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_tool_calls: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_streaming: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_json_mode: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_vision: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_context_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_output_tokens: Option<i64>,
}

/// `CreateAgentBookmarkRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAgentBookmarkRequest {
    pub message_id: String,
    pub kind: AgentBookmarkKind,
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

/// `CreateAgentFriaRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAgentFriaRequest {
    /// One entry per fundamental right considered.
    pub rights_assessed: Vec<CreateAgentFriaRequestRightsAssessedItem>,
    pub mitigations: String,
    pub assessor: String,
    /// When the assessment must be revisited.
    pub next_review: String,
}

/// `CreateAgentFriaRequestRightsAssessedItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAgentFriaRequestRightsAssessedItem {
    pub right: String,
    pub impact: FriaRightImpact,
    pub justification: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mitigation: Option<String>,
}

/// `CreateAgentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAgentRequest {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<AgentModelConfigInput>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// `prompts.system` is accepted and IGNORED: the per-agent system prompt is managed by the Head
    /// Agent (system prompt lockdown, 2026-08-04). A new agent stores a neutral default; an update
    /// keeps the stored prompt. `prompts.developer` is stored. For the prompt a public chat uses,
    /// set `public_config.system_prompt`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompts: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking: Option<serde_json::Map<String, serde_json::Value>>,
    /// How runs execute. Accepted by `CreateAgentSchema` (schemas/mod.ts:499) and undocumented
    /// until now — `bridge` is deliberately NOT selectable here: bridge agents are created by the
    /// bridge registration path, not by this route.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_mode: Option<CreateAgentRequestExecutionMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrails: Option<serde_json::Map<String, serde_json::Value>>,
}

/// How runs execute. Accepted by `CreateAgentSchema` (schemas/mod.ts:499) and undocumented
/// until now — `bridge` is deliberately NOT selectable here: bridge agents are created by the
/// bridge registration path, not by this route.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CreateAgentRequestExecutionMode {
    #[default]
    #[serde(rename = "async")]
    Async,
    #[serde(rename = "worker")]
    Worker,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CreateAgentRequestExecutionMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Async => "async",
            Self::Worker => "worker",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CreateAgentRequestExecutionMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CreateAgentRequestExecutionMode {
    fn from(value: &str) -> Self {
        match value {
            "async" => Self::Async,
            "worker" => Self::Worker,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CreateAgentVersionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAgentVersionRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub changelog: Option<String>,
}

/// `CreateAmbassadorRequestRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAmbassadorRequestRequest {
    pub from_agent_id: String,
    pub r#type: String,
    pub subject: String,
    pub body: String,
}

/// `CreateAPIKeyRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateAPIKeyRequest {
    pub name: String,
    /// Server default:
    /// `\["agents:read","agents:write","runs:create","runs:read","notifications:read","notifications:write","memory:read","memory:write","files:read","files:write"\]`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
}

/// `CreateBillingPortalSessionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateBillingPortalSessionRequest {
    /// Where to send the customer afterwards (billing.ts resolveReturnTarget, since #457): a path,
    /// resolved against the caller's origin (`Origin`, then `Referer`) or, without one, the public
    /// web origin (<https://snaga.ai> on production); an absolute URL on one of those two origins;
    /// or the app's own scheme — `snaga://…`, the same test the OAuth callback uses
    /// (isMobileReturnTo), which is what the iOS and Android apps send. Anything else is 422.
    /// Absent or empty: the billing settings page (`/browser/settings/billing`) on that origin.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub return_url: Option<String>,
}

/// `CreateBillingPortalSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateBillingPortalSessionResponse {
    pub url: String,
}

/// `CreateCheckoutSessionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateCheckoutSessionRequest {
    pub plan_id: String,
    /// Where to send the customer afterwards (billing.ts resolveReturnTarget, since #457): a path,
    /// resolved against the caller's origin (`Origin`, then `Referer`) or, without one, the public
    /// web origin (<https://snaga.ai> on production); an absolute URL on one of those two origins;
    /// or the app's own scheme — `snaga://…`, the same test the OAuth callback uses
    /// (isMobileReturnTo), which is what the iOS and Android apps send. Anything else is 422.
    /// Absent or empty: `/browser/settings/billing?success=1` on that origin.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success_url: Option<String>,
    /// Where to send the customer afterwards (billing.ts resolveReturnTarget, since #457): a path,
    /// resolved against the caller's origin (`Origin`, then `Referer`) or, without one, the public
    /// web origin (<https://snaga.ai> on production); an absolute URL on one of those two origins;
    /// or the app's own scheme — `snaga://…`, the same test the OAuth callback uses
    /// (isMobileReturnTo), which is what the iOS and Android apps send. Anything else is 422.
    /// Absent or empty: the billing settings page (`/browser/settings/billing`) on that origin.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cancel_url: Option<String>,
}

/// `CreateCheckoutSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateCheckoutSessionResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// `CreateDatasetRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateDatasetRequest {
    pub name: String,
    pub cases: Vec<CreateDatasetRequestCas>,
}

/// `CreateDatasetRequestCas` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateDatasetRequestCas {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_output: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
}

/// `CreateDrawingMaskRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateDrawingMaskRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shape: Option<DrawingSelectionShape>,
    /// An L8 PNG of the drawing's exact size.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
}

/// sessions.ts handleCreateTask — a projection, not the Todo record. `parent_task_id` only on a
/// multi-agent fan-out; `due_at` omitted for a backlog task; per item, `agent_id`/`team_id`
/// name the assignee and `run_id`/`team_run_id` appear only when the item was dispatched
/// immediately.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatedTask {
    pub task_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_task_id: Option<String>,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub due_at: Option<String>,
    pub items: Vec<CreatedTaskItem>,
}

/// `CreatedTaskItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatedTaskItem {
    pub session_id: String,
    pub todo_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_run_id: Option<String>,
    pub status: CreatedTaskItemStatus,
}

/// `CreatedTaskItemStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CreatedTaskItemStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "pending_confirmation")]
    PendingConfirmation,
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "cancelled")]
    Cancelled,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CreatedTaskItemStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::PendingConfirmation => "pending_confirmation",
            Self::InProgress => "in_progress",
            Self::Cancelled => "cancelled",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CreatedTaskItemStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CreatedTaskItemStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "pending_confirmation" => Self::PendingConfirmation,
            "in_progress" => Self::InProgress,
            "cancelled" => Self::Cancelled,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CreateExperimentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateExperimentRequest {
    pub name: String,
    pub dataset_id: String,
    pub variants: Vec<CreateExperimentRequestVariant>,
}

/// `CreateExperimentRequestVariant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateExperimentRequestVariant {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub eval_run_id: Option<String>,
}

/// `CreateGoalRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateGoalRequest {
    /// The agent the goal is for.
    pub agent_id: String,
    pub title: String,
    pub description: String,
    pub rationale: String,
    /// How the goal sits with the constitution — what the later check reads.
    pub alignment_justification: String,
    pub expected_impact: String,
    /// What it is expected to cost. The vote acts on this number.
    pub resource_estimate_usd: f64,
}

/// `CreateGuardrailRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateGuardrailRequest {
    pub name: String,
    /// Where the guardrail is called. Checked against the security-policy denylist and resolved
    /// through DNS before it is accepted.
    pub webhook_url: String,
    pub phase: GuardrailConfigItemPhase,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<GuardrailAction>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    /// Shared secret used to sign calls to `webhook_url`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<String>,
}

/// `CreateImprovementProposalRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateImprovementProposalRequest {
    /// What kind of change is proposed.
    pub r#type: String,
    pub title: String,
    pub description: String,
    pub rationale: String,
    /// The runs this is a response to — the evidence the review stages judge.
    pub failed_run_ids: Vec<String>,
    /// The change itself, in the shape the proposal type implies.
    pub changes: serde_json::Map<String, serde_json::Value>,
    /// What the agent achieves today, so it can be measured against something.
    pub baseline_success_rate: f64,
}

/// `CreateIntegrationRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateIntegrationRequest {
    pub connector_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// `CreateMCPServerRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateMCPServerRequest {
    pub name: String,
    pub transport: MCPTransport,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// Secrets for this server. Encrypted at rest and never returned; only `env_count` is
    /// disclosed. For an http server the key named by `auth.env_key` (default `MCP_API_KEY`) is the
    /// one sent as the credential.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth: Option<MCPServerAuth>,
    /// Agents to connect the server to. Omit or leave empty and no agent sees its tools.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    /// Names an environment variable of the API process whose value is sent to this server as a
    /// bearer token. It MUST begin `MCP_` — 422 otherwise. The namespace is the whole security
    /// boundary: before it existed, the HTTP transport read ANY variable of the API process, so a
    /// tenant admin registering `{url: \<their server\>, api_key_ref: "UARP_ENCRYPTION_KEY"}` was
    /// mailed the platform's at-rest key on the first connect (found 2026-09-15). The variable is
    /// never echoed back; only the ref is stored.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api_key_ref: Option<String>,
    /// Hosts this server may be reached at, checked with DNS resolution.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub egress_allowlist: Option<Vec<String>>,
}

/// `CreateMyTenantRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateMyTenantRequest {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
}

/// `CreateMyTenantResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateMyTenantResponse {
    pub created: bool,
    pub tenant_id: String,
    pub name: String,
    pub slug: String,
    pub role: String,
    pub user_id: String,
}

/// `CreatePlanStripePriceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatePlanStripePriceRequest {
    pub amount_cents: i64,
    /// Server default: `"usd"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    /// Server default: `"month"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interval: Option<CreatePlanStripePriceRequestInterval>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub product_name: Option<String>,
}

/// `CreatePlanStripePriceRequestInterval` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CreatePlanStripePriceRequestInterval {
    #[default]
    #[serde(rename = "month")]
    Month,
    #[serde(rename = "year")]
    Year,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CreatePlanStripePriceRequestInterval {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Month => "month",
            Self::Year => "year",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CreatePlanStripePriceRequestInterval {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CreatePlanStripePriceRequestInterval {
    fn from(value: &str) -> Self {
        match value {
            "month" => Self::Month,
            "year" => Self::Year,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CreatePlanStripePriceResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatePlanStripePriceResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_price_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_product_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub amount_cents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interval: Option<String>,
}

/// `CreateProgramRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateProgramRequest {
    pub name: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub listing_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub steps: Vec<CreateProgramRequestStep>,
}

/// `CreateProgramRequestStep` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateProgramRequestStep {
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub order_index: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub suggested_due_offset_days: Option<f64>,
}

/// `CreateProjectRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateProjectRequest {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<ProjectVisibility>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<ProjectGrant>>,
}

/// `CreatePublicSessionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatePublicSessionRequest {
    pub agent_id: String,
}

/// `CreatePublicSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreatePublicSessionResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub token: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub greeting: Option<String>,
}

/// `CreateResponseRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateResponseRequest {
    /// Agent ID or model alias resolvable via `/v1/models`.
    pub model: String,
    /// Input string or structured turn array.
    pub input: serde_json::Value,
    /// Chain to an earlier response in the same conversation.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub previous_response_id: Option<String>,
    /// System-prompt override for this call only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    /// Server default: `false`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stream: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `CreateResponseResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateResponseResponse {
    pub id: String,
    /// Always `response`.
    pub object: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<i64>,
    pub model: String,
    pub output: Vec<ResponsesOutputItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<CreateResponseResponseUsage>,
}

/// `CreateResponseResponseUsage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateResponseResponseUsage {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_tokens: Option<i64>,
}

/// runs.ts createRunCheckpoint — the checkpoint record; it carries no messages (those live in
/// the stored checkpoint read back by GET /runs/{runId}/checkpoints).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateRunCheckpointResponse {
    pub checkpoint_id: String,
    pub run_id: String,
    pub status: String,
    pub step_seq: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<serde_json::Map<String, serde_json::Value>>,
    pub created_at: String,
}

/// `CreateRunRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateRunRequest {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    /// Free-form input for the agent; `message` is the conventional field. `file_ids` attaches
    /// uploaded files (at most 20): every id is resolved against THIS tenant before the run is
    /// created, and an id with no file here is refused with 422 rather than accepted and dropped —
    /// an unresolvable id would otherwise travel to the agent, and to a bridge agent's machine, as
    /// an attachment that cannot be fetched.
    ///
    /// Server default: `{}`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<CreateRunRequestInput>,
    /// Pin to a specific agent version (1-based). When omitted, runs against the agent's current
    /// head version.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Free-form input for the agent; `message` is the conventional field. `file_ids` attaches
/// uploaded files (at most 20): every id is resolved against THIS tenant before the run is
/// created, and an id with no file here is refused with 422 rather than accepted and dropped —
/// an unresolvable id would otherwise travel to the agent, and to a bridge agent's machine, as
/// an attachment that cannot be fetched.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateRunRequestInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_ids: Option<Vec<String>>,
}

/// `CreateSessionAnnotationRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionAnnotationRequest {
    pub message_id: String,
    pub content: String,
}

/// `CreateSessionAnnotationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionAnnotationResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub author: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolved: Option<bool>,
}

/// `CreateSessionBranchRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionBranchRequest {
    /// Defaults to the session's most recent run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fork_point_run_id: Option<String>,
    /// Defaults to 0.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fork_point_step_seq: Option<i64>,
    /// Defaults to the session's active branch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_branch_id: Option<String>,
    /// Defaults to `branch-\<first 8 characters of the branch id\>`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `CreateSessionDrawingRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionDrawingRequest {
    pub width: i64,
    pub height: i64,
    /// `#rrggbb` or `transparent`; default `#ffffff`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub background: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dpi: Option<i64>,
    /// Name of the first layer.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `CreateSessionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionRequest {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `CreateSessionShareRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionShareRequest {
    pub role: CreateSessionShareRequestRole,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_in_hours: Option<f64>,
}

/// `CreateSessionShareRequestRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CreateSessionShareRequestRole {
    #[default]
    #[serde(rename = "viewer")]
    Viewer,
    #[serde(rename = "editor")]
    Editor,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CreateSessionShareRequestRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Viewer => "viewer",
            Self::Editor => "editor",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CreateSessionShareRequestRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CreateSessionShareRequestRole {
    fn from(value: &str) -> Self {
        match value {
            "viewer" => Self::Viewer,
            "editor" => Self::Editor,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CreateSessionShareResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionShareResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub share_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
}

/// `CreateSessionTodoRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSessionTodoRequest {
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub due_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assign_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `CreateSpecPackageCheckoutSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSpecPackageCheckoutSessionResponse {
    pub error: InvokeListingAgentResponseError,
    pub message: String,
    pub retry_after_seconds: i64,
}

/// `CreateVotingProposalRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateVotingProposalRequest {
    pub title: String,
    pub description: String,
    pub proposal_type: String,
}

/// `CreateWebhookRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateWebhookRequest {
    pub url: String,
    pub events: Vec<WebhookDeliveryAttemptEventType>,
}

/// `CreateWorkspaceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateWorkspaceRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `CustomPlan` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CustomPlan {
    /// Lower-cased. The identity — not settable through the body.
    pub id: String,
    pub name: String,
    /// Absent when unset.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Pairs the plan with a promo program. Absent when unset.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<String>,
    pub base_plan: CustomPlanBasePlan,
    pub price_amount_cents: i64,
    pub price_currency: String,
    /// Absent when unset.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_price_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quotas: Option<TenantQuotas>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm: Option<PlanLLMLimits>,
    pub visibility: CustomPlanVisibility,
    pub active: bool,
    pub created_at: String,
    pub updated_at: String,
}

/// `CustomPlanBasePlan` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CustomPlanBasePlan {
    #[default]
    #[serde(rename = "free")]
    Free,
    #[serde(rename = "starter")]
    Starter,
    #[serde(rename = "pro")]
    Pro,
    #[serde(rename = "enterprise")]
    Enterprise,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CustomPlanBasePlan {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Free => "free",
            Self::Starter => "starter",
            Self::Pro => "pro",
            Self::Enterprise => "enterprise",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CustomPlanBasePlan {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CustomPlanBasePlan {
    fn from(value: &str) -> Self {
        match value {
            "free" => Self::Free,
            "starter" => Self::Starter,
            "pro" => Self::Pro,
            "enterprise" => Self::Enterprise,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `CustomPlanInput` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CustomPlanInput {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<String>,
    pub base_plan: CustomPlanBasePlan,
    pub price_amount_cents: i64,
    /// Server default: `"usd"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_price_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quotas: Option<TenantQuotas>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm: Option<PlanLLMLimits>,
    /// Omitting this on an update HIDES a previously public plan.
    ///
    /// Server default: `"hidden"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<CustomPlanVisibility>,
    /// Omitting this on an update REACTIVATES a deactivated plan. Send it explicitly on every
    /// write.
    ///
    /// Server default: `true`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
}

/// `CustomPlanVisibility` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CustomPlanVisibility {
    #[default]
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "hidden")]
    Hidden,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl CustomPlanVisibility {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Public => "public",
            Self::Hidden => "hidden",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for CustomPlanVisibility {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CustomPlanVisibility {
    fn from(value: &str) -> Self {
        match value {
            "public" => Self::Public,
            "hidden" => Self::Hidden,
            other => Self::Other(other.to_string()),
        }
    }
}

/// admin-data-explorer.ts handleGetKeys — one KV entry, prefix stripped.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DataExplorerKey {
    pub key: Vec<serde_json::Value>,
    pub value_preview: String,
    pub size_bytes: i64,
    pub r#type: String,
    pub sensitive: bool,
}

/// `DataExplorerNamespace` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DataExplorerNamespace {
    pub id: String,
    pub label: String,
    pub description: String,
    pub count: i64,
}

/// data-subject.ts dataSubjectAccess — ids per store plus their counts; every field always
/// present.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DataSubjectAccessReport {
    pub subject_id: String,
    pub tenant_id: String,
    pub runs: Vec<String>,
    pub sessions: Vec<String>,
    pub memory: Vec<String>,
    pub files: Vec<String>,
    pub feedback: Vec<String>,
    /// Core-memory labels, when the subject is an agent. A human subject has no core-memory rows of
    /// their own.
    pub core_memory: Vec<String>,
    pub runs_count: i64,
    pub sessions_count: i64,
    pub memory_count: i64,
    pub core_memory_count: i64,
    pub files_count: i64,
    pub feedback_count: i64,
    /// What this endpoint does NOT return, named rather than left to be assumed: the record
    /// CONTENTS (each list is identifiers, to be fetched through the per-record routes), and the
    /// families that carry no subject identifier at all — knowledge-base documents and workspace
    /// files.
    pub not_exported: Vec<String>,
    pub swept: SubjectSweep,
}

/// data-subject.ts dataSubjectErasure — `erased` plus the SubjectErasureCounts spread.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DataSubjectErasureResult {
    pub erased: bool,
    pub subject_id: String,
    pub runs_deleted: i64,
    pub sessions_deleted: i64,
    pub memory_deleted: i64,
    pub core_memory_deleted: i64,
    pub files_deleted: i64,
    pub feedback_deleted: i64,
    /// Record families this sweep did not touch, and why. Knowledge-base documents and workspace
    /// files carry no subject identifier of any kind, so there is nothing to match a subject on and
    /// no honest way to erase theirs without erasing everyone's — the caller is told, with the
    /// route to do it by hand.
    pub not_erased: Vec<String>,
    pub swept: SubjectSweep,
}

/// `DeactivateSafeModeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeactivateSafeModeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<String>,
}

/// governance/emergency.ts DeadlockReport — computed, not stored. Field names are camelCase on
/// the wire.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeadlockReport {
    /// Deprecated spelling of `has_deadlock` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `has_deadlock`.
    #[serde(rename = "hasDeadlock")]
    pub has_deadlock: bool,
    /// Deprecated spelling of `conflicting_rules` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `conflicting_rules`.
    #[serde(rename = "conflictingRules")]
    pub conflicting_rules: Vec<DeadlockReportConflictingRule>,
    pub recommendation: String,
    pub checked_at: String,
    #[serde(rename = "has_deadlock")]
    pub has_deadlock_: bool,
    #[serde(rename = "conflicting_rules")]
    pub conflicting_rules_: Vec<DeadlockReportConflictingRule2>,
}

/// `DeadlockReportConflictingRule` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeadlockReportConflictingRule {
    pub prohibition: String,
    pub requirement: String,
}

/// `DeadlockReportConflictingRule2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeadlockReportConflictingRule2 {
    pub prohibition: String,
    pub requirement: String,
}

/// `DeclineInviteFromPickerResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeclineInviteFromPickerResponse {
    pub declined: bool,
    pub invite: Invite,
}

/// `DeleteAdminBlogPostResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAdminBlogPostResponse {
    pub deleted: bool,
}

/// `DeleteAdminIntegrationOAuthProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAdminIntegrationOAuthProviderResponse {
    pub provider: String,
    /// Always false here.
    pub configured: bool,
}

/// `DeleteAdminLLMDefaultResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAdminLLMDefaultResponse {
    pub provider: String,
    /// Always false here — the key is gone.
    pub configured: bool,
}

/// `DeleteAdminProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAdminProviderResponse {
    pub deleted: bool,
    pub id: String,
}

/// `DeleteAgentBookmarkResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAgentBookmarkResponse {
    pub removed: bool,
    pub message_id: String,
}

/// `DeleteAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAgentResponse {
    pub deleted: bool,
    pub agent_id: String,
}

/// `DeleteAllAgentBookmarksResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteAllAgentBookmarksResponse {
    pub removed: i64,
}

/// `DeleteCustomPlanResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteCustomPlanResponse {
    pub deleted: bool,
    pub id: String,
    /// Tenants moved off the plan, when forced.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reassigned: Option<i64>,
}

/// `DeleteDataExplorerValueResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteDataExplorerValueResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
}

/// `DeleteDrawingResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteDrawingResponse {
    pub deleted: bool,
    pub drawing_id: String,
    /// Journal entries the cascade removed.
    pub ops: i64,
    pub masks: i64,
}

/// `DeleteGuardrailResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteGuardrailResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrail_id: Option<String>,
}

/// `DeleteLLMProviderKeyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteLLMProviderKeyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_id: Option<String>,
}

/// `DeleteMCPServerResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteMCPServerResponse {
    pub ok: bool,
    pub cascade: DeleteMCPServerResponseCascade,
}

/// `DeleteMCPServerResponseCascade` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteMCPServerResponseCascade {
    pub agents_with_stale_ref: i64,
    /// Capped at 50.
    pub agent_ids: Vec<String>,
}

/// `DeleteMeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteMeResponse {
    pub deleted: bool,
    pub tenants: Vec<DeleteMeResponseTenant>,
    pub sessions_revoked: i64,
    /// What the data sweep actually removed, summed across every membership. Present since
    /// 2026-09-16: the sweep's counts used to be discarded here, so `deleted: true` sat beside a
    /// real `sessions_revoked` number while the sweep itself matched a field nothing writes and
    /// deleted nothing.
    pub erased: DeleteMeResponseErased,
    /// Record families the sweep cannot reach, named rather than left to be assumed. Same list as
    /// `/data-subject/erasure`.
    pub not_erased: Vec<String>,
}

/// What the data sweep actually removed, summed across every membership. Present since
/// 2026-09-16: the sweep's counts used to be discarded here, so `deleted: true` sat beside a
/// real `sessions_revoked` number while the sweep itself matched a field nothing writes and
/// deleted nothing.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteMeResponseErased {
    pub runs: i64,
    pub sessions: i64,
    pub memory: i64,
    pub core_memory: i64,
    pub files: i64,
    pub feedback: i64,
}

/// `DeleteMeResponseTenant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteMeResponseTenant {
    pub tenant_id: String,
}

/// `DeleteModelPricingOverrideResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteModelPricingOverrideResponse {
    /// Deprecated spelling of `model_ref` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `model_ref`.
    #[serde(rename = "modelRef")]
    pub model_ref: String,
    pub deleted: bool,
    #[serde(rename = "model_ref")]
    pub model_ref_: String,
}

/// `DeleteNotificationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteNotificationResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// `DeleteNotificationTargetResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteNotificationTargetResponse {
    pub ok: bool,
}

/// `DeleteProjectResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteProjectResponse {
    pub deleted: bool,
    pub project_id: String,
    pub chats_kept: i64,
}

/// `DeletePromoCodeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeletePromoCodeResponse {
    pub deleted: bool,
    /// Upper-cased, which may differ from what was sent.
    pub code: String,
}

/// `DeleteSessionBranchResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSessionBranchResponse {
    pub deleted: bool,
    pub session_id: String,
    pub branch_id: String,
    /// How many runs the branch listed and the cascade removed.
    pub runs: i64,
}

/// `DeleteSessionTodoResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSessionTodoResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub todo_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

/// `DeleteSpawnPolicyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSpawnPolicyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// `DeleteSquadGraphEdgeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSquadGraphEdgeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edge_id: Option<String>,
}

/// `DeleteSquadGraphNodeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSquadGraphNodeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// `DeleteSquadResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSquadResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
}

/// `DeleteTeamGraphEdgeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteTeamGraphEdgeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edge_id: Option<String>,
}

/// `DeleteTeamGraphNodeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteTeamGraphNodeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// `DeleteTeamResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteTeamResponse {
    pub deleted: bool,
    pub team_id: String,
}

/// `DeleteUserResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteUserResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
}

/// `DeleteWebhookResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteWebhookResponse {
    pub deleted: bool,
    pub webhook_id: String,
}

/// `DeleteWorkspaceFileResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteWorkspaceFileResponse {
    pub trashed: bool,
    pub trash_path: String,
    pub original_path: String,
}

/// `DeleteWorkspaceFileTrash` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DeleteWorkspaceFileTrash {
    #[default]
    #[serde(rename = "false")]
    False,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DeleteWorkspaceFileTrash {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::False => "false",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DeleteWorkspaceFileTrash {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DeleteWorkspaceFileTrash {
    fn from(value: &str) -> Self {
        match value {
            "false" => Self::False,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Governance-builder request to design a new agent (packages/governance/builder-flow.ts).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DesignRequest {
    pub request_id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub submitted_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
    pub status: DesignRequestStatus,
    /// Set once the request enters a vote.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub proposal_id: Option<String>,
    /// Set once the approved design has been created.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spawned_agent_id: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

/// Body for `POST /api/v1/governance/builder/requests`. What `DesignRequestSubmitSchema`
/// requires: `agent_name` and `agent_description`, neither optional. `submitted_by` is NOT
/// accepted from the body — it comes from the authenticated caller. The block carried no
/// `required` at all until 2026-09-18.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DesignRequestCreate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub submitted_by: Option<String>,
    pub agent_name: String,
    pub agent_description: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
}

/// `DesignRequestStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DesignRequestStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "voting")]
    Voting,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "rejected")]
    Rejected,
    #[serde(rename = "spawned")]
    Spawned,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DesignRequestStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Voting => "voting",
            Self::Approved => "approved",
            Self::Rejected => "rejected",
            Self::Spawned => "spawned",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DesignRequestStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DesignRequestStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "voting" => Self::Voting,
            "approved" => Self::Approved,
            "rejected" => Self::Rejected,
            "spawned" => Self::Spawned,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DisableMfaResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DisableMfaResponse {
    pub disabled: bool,
}

/// `DomainCertLifecycle` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DomainCertLifecycle {
    /// `renewal_due` is entered 14 days or less before `not_after`.
    pub state: DomainCertLifecycleState,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub not_before: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub not_after: Option<String>,
    /// Issuer CN, so a CA migration is visible without parsing the leaf.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub issuer_cn: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_checked_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_error: Option<String>,
}

/// `renewal_due` is entered 14 days or less before `not_after`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DomainCertLifecycleState {
    #[default]
    #[serde(rename = "none")]
    None,
    #[serde(rename = "provisioning")]
    Provisioning,
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "renewal_due")]
    RenewalDue,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "revoked")]
    Revoked,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DomainCertLifecycleState {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::None => "none",
            Self::Provisioning => "provisioning",
            Self::Active => "active",
            Self::RenewalDue => "renewal_due",
            Self::Failed => "failed",
            Self::Revoked => "revoked",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DomainCertLifecycleState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DomainCertLifecycleState {
    fn from(value: &str) -> Self {
        match value {
            "none" => Self::None,
            "provisioning" => Self::Provisioning,
            "active" => Self::Active,
            "renewal_due" => Self::RenewalDue,
            "failed" => Self::Failed,
            "revoked" => Self::Revoked,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DomainDnsLifecycle` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DomainDnsLifecycle {
    /// `drift` means it verified once and no longer matches — distinct from `failed`, which never
    /// verified.
    pub state: DomainDnsLifecycleState,
    pub method: DomainDnsLifecycleMethod,
    /// What the customer points DNS at. Stored per record so changing the platform target does not
    /// silently invalidate domains already pinned to the old one.
    pub target: String,
    /// Most recent lookup, whatever its result.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_checked_at: Option<String>,
    /// First time it matched. Sticky across verified → drift → verified, so it is not the time of
    /// the LAST success.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verified_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_error: Option<String>,
}

/// `DomainDnsLifecycleMethod` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DomainDnsLifecycleMethod {
    #[default]
    #[serde(rename = "cname")]
    Cname,
    #[serde(rename = "a")]
    A,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DomainDnsLifecycleMethod {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Cname => "cname",
            Self::A => "a",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DomainDnsLifecycleMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DomainDnsLifecycleMethod {
    fn from(value: &str) -> Self {
        match value {
            "cname" => Self::Cname,
            "a" => Self::A,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `drift` means it verified once and no longer matches — distinct from `failed`, which never
/// verified.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DomainDnsLifecycleState {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "verified")]
    Verified,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "drift")]
    Drift,
    #[serde(rename = "deactivated")]
    Deactivated,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DomainDnsLifecycleState {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Verified => "verified",
            Self::Failed => "failed",
            Self::Drift => "drift",
            Self::Deactivated => "deactivated",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DomainDnsLifecycleState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DomainDnsLifecycleState {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "verified" => Self::Verified,
            "failed" => Self::Failed,
            "drift" => Self::Drift,
            "deactivated" => Self::Deactivated,
            other => Self::Other(other.to_string()),
        }
    }
}

/// A drawing a person and an agent share in real time (docs/DESIGNER-CANVAS.md §4.1). Pixels
/// live in 256×256 tiles behind the journal; this record is the structure.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Drawing {
    pub drawing_id: String,
    pub session_id: String,
    pub workspace_id: String,
    pub width: i64,
    pub height: i64,
    pub dpi: i64,
    /// `#rrggbb` or `transparent`.
    pub background: String,
    pub layers: Vec<DrawingLayer>,
    /// The last journal entry applied to this drawing.
    pub seq: i64,
    /// The seq up to which tiles are materialised; 0 until the first snapshot.
    pub snapshot_seq: i64,
    pub created_at: String,
    pub updated_at: String,
}

/// `DrawingBrush` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingBrush {
    pub preset: String,
    /// Diameter in canvas pixels.
    pub size: f64,
    pub hardness: i64,
    pub opacity: i64,
    pub flow: i64,
    /// Percent of `size` between dabs; the client spaces the points, the renderer stamps every
    /// point it is given.
    pub spacing: f64,
    /// Absent on `erase`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
}

/// `DrawingJournalEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingJournalEntry {
    pub seq: i64,
    pub client_op_id: String,
    pub author: DrawingJournalEntryAuthor,
    pub at: String,
    pub op: DrawingOp,
}

/// `DrawingJournalEntryAuthor` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingJournalEntryAuthor {
    pub kind: DrawingJournalEntryAuthorKind,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
}

/// `DrawingJournalEntryAuthorKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingJournalEntryAuthorKind {
    #[default]
    #[serde(rename = "user")]
    User,
    #[serde(rename = "agent")]
    Agent,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingJournalEntryAuthorKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::User => "user",
            Self::Agent => "agent",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingJournalEntryAuthorKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingJournalEntryAuthorKind {
    fn from(value: &str) -> Self {
        match value {
            "user" => Self::User,
            "agent" => Self::Agent,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DrawingLayer` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingLayer {
    pub layer_id: String,
    pub name: String,
    /// An integer 0–255, like every channel value in a drawing (docs/DESIGNER-CANVAS.md §4.4).
    pub opacity: i64,
    pub blend: DrawingLayerBlend,
    pub visible: bool,
    pub locked: bool,
    pub kind: DrawingLayerKind,
    /// Set when the layer was placed from a generated or uploaded image.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<DrawingLayerSource>,
}

/// `DrawingLayerBlend` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingLayerBlend {
    #[default]
    #[serde(rename = "normal")]
    Normal,
    #[serde(rename = "multiply")]
    Multiply,
    #[serde(rename = "screen")]
    Screen,
    #[serde(rename = "overlay")]
    Overlay,
    #[serde(rename = "darken")]
    Darken,
    #[serde(rename = "lighten")]
    Lighten,
    #[serde(rename = "add")]
    Add,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingLayerBlend {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Normal => "normal",
            Self::Multiply => "multiply",
            Self::Screen => "screen",
            Self::Overlay => "overlay",
            Self::Darken => "darken",
            Self::Lighten => "lighten",
            Self::Add => "add",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingLayerBlend {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingLayerBlend {
    fn from(value: &str) -> Self {
        match value {
            "normal" => Self::Normal,
            "multiply" => Self::Multiply,
            "screen" => Self::Screen,
            "overlay" => Self::Overlay,
            "darken" => Self::Darken,
            "lighten" => Self::Lighten,
            "add" => Self::Add,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DrawingLayerKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingLayerKind {
    #[default]
    #[serde(rename = "raster")]
    Raster,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingLayerKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Raster => "raster",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingLayerKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingLayerKind {
    fn from(value: &str) -> Self {
        match value {
            "raster" => Self::Raster,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Set when the layer was placed from a generated or uploaded image.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingLayerSource {
    pub file_id: String,
    pub tool: String,
}

/// What a person hands the agent (docs/DESIGNER-CANVAS.md §4.3): the selection as an L8 PNG of
/// the drawing's size plus its bounding box.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingMask {
    pub mask_id: String,
    pub drawing_id: String,
    pub width: i64,
    pub height: i64,
    pub bbox: DrawingMaskBbox,
    /// The L8 PNG in the workspace; also served by `…/masks/{maskId}/content`.
    pub file_id: String,
    pub created_at: String,
}

/// `DrawingMaskBbox` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingMaskBbox {
    pub x: i64,
    pub y: i64,
    pub w: i64,
    pub h: i64,
}

/// One journal op (docs/DESIGNER-CANVAS.md §4.2), discriminated by `type`: stroke, erase, fill,
/// place_image, layer_add, layer_remove, layer_update, layer_reorder, undo, redo. A stroke
/// longer than 1 024 points is sent in parts that share `stroke_id`, count `part` from 0 and
/// carry `continues: true` on every part but the last; `t` runs across the parts. `encoding` is
/// required and is `json` in v1.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingOp {
    pub r#type: DrawingOpType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub layer_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub brush: Option<DrawingBrush>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub encoding: Option<DrawingOpEncoding>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub points: Option<Vec<DrawingStrokePoint>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stroke_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub part: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub continues: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub x: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub y: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub w: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub h: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tolerance: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub contiguous: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fit: Option<DrawingOpFit>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub layer: Option<DrawingLayer>,
    /// Values below 0 are clamped, not refused.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub index: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub patch: Option<DrawingOpPatch>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub order: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub undo_of: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub redo_of: Option<i64>,
}

/// `DrawingOpEncoding` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingOpEncoding {
    #[default]
    #[serde(rename = "json")]
    JSON,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingOpEncoding {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::JSON => "json",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingOpEncoding {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingOpEncoding {
    fn from(value: &str) -> Self {
        match value {
            "json" => Self::JSON,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DrawingOpFit` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingOpFit {
    #[default]
    #[serde(rename = "stretch")]
    Stretch,
    #[serde(rename = "contain")]
    Contain,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingOpFit {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Stretch => "stretch",
            Self::Contain => "contain",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingOpFit {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingOpFit {
    fn from(value: &str) -> Self {
        match value {
            "stretch" => Self::Stretch,
            "contain" => Self::Contain,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DrawingOpPatch` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingOpPatch {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub opacity: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub blend: Option<DrawingLayerBlend>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visible: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub locked: Option<bool>,
}

/// `DrawingOpType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingOpType {
    #[default]
    #[serde(rename = "stroke")]
    Stroke,
    #[serde(rename = "erase")]
    Erase,
    #[serde(rename = "fill")]
    Fill,
    #[serde(rename = "place_image")]
    PlaceImage,
    #[serde(rename = "layer_add")]
    LayerAdd,
    #[serde(rename = "layer_remove")]
    LayerRemove,
    #[serde(rename = "layer_update")]
    LayerUpdate,
    #[serde(rename = "layer_reorder")]
    LayerReorder,
    #[serde(rename = "undo")]
    Undo,
    #[serde(rename = "redo")]
    Redo,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingOpType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Stroke => "stroke",
            Self::Erase => "erase",
            Self::Fill => "fill",
            Self::PlaceImage => "place_image",
            Self::LayerAdd => "layer_add",
            Self::LayerRemove => "layer_remove",
            Self::LayerUpdate => "layer_update",
            Self::LayerReorder => "layer_reorder",
            Self::Undo => "undo",
            Self::Redo => "redo",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingOpType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingOpType {
    fn from(value: &str) -> Self {
        match value {
            "stroke" => Self::Stroke,
            "erase" => Self::Erase,
            "fill" => Self::Fill,
            "place_image" => Self::PlaceImage,
            "layer_add" => Self::LayerAdd,
            "layer_remove" => Self::LayerRemove,
            "layer_update" => Self::LayerUpdate,
            "layer_reorder" => Self::LayerReorder,
            "undo" => Self::Undo,
            "redo" => Self::Redo,
            other => Self::Other(other.to_string()),
        }
    }
}

/// A selection in canvas pixels: `rect` {x, y, w, h}, `ellipse` {cx, cy, rx, ry} or `lasso`
/// {points\[\]}.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingSelectionShape {
    pub kind: DrawingSelectionShapeKind,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub x: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub y: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub w: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub h: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cx: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cy: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rx: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ry: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub points: Option<Vec<DrawingSelectionShapePoint>>,
}

/// `DrawingSelectionShapeKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum DrawingSelectionShapeKind {
    #[default]
    #[serde(rename = "rect")]
    Rect,
    #[serde(rename = "ellipse")]
    Ellipse,
    #[serde(rename = "lasso")]
    Lasso,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl DrawingSelectionShapeKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Rect => "rect",
            Self::Ellipse => "ellipse",
            Self::Lasso => "lasso",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for DrawingSelectionShapeKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for DrawingSelectionShapeKind {
    fn from(value: &str) -> Self {
        match value {
            "rect" => Self::Rect,
            "ellipse" => Self::Ellipse,
            "lasso" => Self::Lasso,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `DrawingSelectionShapePoint` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingSelectionShapePoint {
    pub x: f64,
    pub y: f64,
}

/// `DrawingStrokePoint` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DrawingStrokePoint {
    pub x: f64,
    pub y: f64,
    /// Pressure.
    pub p: i64,
    /// Tilt.
    pub tx: f64,
    pub ty: f64,
    /// Milliseconds from the start of the stroke, across every part.
    pub t: f64,
}

/// The mascot character of an agent (DropGenome in @uarp/runtime): silhouette, motion and
/// affect parameters plus a signature pose. Written by the platform at create/backfill or by a
/// client from the builder.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DropGenome {
    pub v: i64,
    pub archetype: String,
    pub silhouette: DropGenomeSilhouette,
    pub motion: DropGenomeMotion,
    pub affect: DropGenomeAffect,
    pub signature_pose: String,
}

/// `DropGenomeAffect` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DropGenomeAffect {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expressiveness: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub baseline_valence: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reactivity: Option<f64>,
}

/// `DropGenomeMotion` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DropGenomeMotion {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tempo: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub springiness: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub amplitude: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub jitter: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub settle_bias: Option<f64>,
}

/// `DropGenomeSilhouette` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DropGenomeSilhouette {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub height: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub width: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tip: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub weight: Option<f64>,
}

/// types/mcp.ts EgressRule — a host glob with optional ports (default \[443\]) and protocol
/// (default https).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EgressRule {
    pub host_pattern: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ports: Option<Vec<i64>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub protocol: Option<EgressRuleProtocol>,
}

/// `EgressRuleProtocol` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum EgressRuleProtocol {
    #[default]
    #[serde(rename = "https")]
    HTTPS,
    #[serde(rename = "http")]
    HTTP,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl EgressRuleProtocol {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::HTTPS => "https",
            Self::HTTP => "http",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for EgressRuleProtocol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for EgressRuleProtocol {
    fn from(value: &str) -> Self {
        match value {
            "https" => Self::HTTPS,
            "http" => Self::HTTP,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `EmbeddingsRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EmbeddingsRequest {
    /// Embedding model (optional; platform default used)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    /// Input text or array of texts
    pub input: serde_json::Value,
    /// Server default: `"float"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub encoding_format: Option<EmbeddingsRequestEncodingFormat>,
    /// Requested embedding dimensions. **Currently ignored**: handler always emits the
    /// platform-configured dimension (256 for the default `multilingual-e5-large-instruct` model).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dimensions: Option<i64>,
}

/// `EmbeddingsRequestEncodingFormat` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum EmbeddingsRequestEncodingFormat {
    #[default]
    #[serde(rename = "float")]
    Float,
    #[serde(rename = "base64")]
    Base64,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl EmbeddingsRequestEncodingFormat {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Float => "float",
            Self::Base64 => "base64",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for EmbeddingsRequestEncodingFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for EmbeddingsRequestEncodingFormat {
    fn from(value: &str) -> Self {
        match value {
            "float" => Self::Float,
            "base64" => Self::Base64,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `EmbeddingsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EmbeddingsResponse {
    /// Always `list`.
    pub object: String,
    pub data: Vec<EmbeddingsResponseDataItem>,
    pub model: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<EmbeddingsResponseUsage>,
}

/// `EmbeddingsResponseDataItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EmbeddingsResponseDataItem {
    /// Always `embedding`.
    pub object: String,
    pub embedding: Vec<f64>,
    pub index: i64,
}

/// `EmbeddingsResponseUsage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EmbeddingsResponseUsage {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompt_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_tokens: Option<i64>,
}

/// `EmergencyState` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EmergencyState {
    pub mode: EmergencyStateMode,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub activated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub activated_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
}

/// `EmergencyStateMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum EmergencyStateMode {
    #[default]
    #[serde(rename = "normal")]
    Normal,
    #[serde(rename = "safe_mode")]
    SafeMode,
    #[serde(rename = "arbitration_safe_mode")]
    ArbitrationSafeMode,
    #[serde(rename = "bootstrap")]
    Bootstrap,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl EmergencyStateMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Normal => "normal",
            Self::SafeMode => "safe_mode",
            Self::ArbitrationSafeMode => "arbitration_safe_mode",
            Self::Bootstrap => "bootstrap",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for EmergencyStateMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for EmergencyStateMode {
    fn from(value: &str) -> Self {
        match value {
            "normal" => Self::Normal,
            "safe_mode" => Self::SafeMode,
            "arbitration_safe_mode" => Self::ArbitrationSafeMode,
            "bootstrap" => Self::Bootstrap,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `EmptyWorkspaceTrashResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EmptyWorkspaceTrashResponse {
    pub deleted_count: i64,
    pub message: String,
}

/// middleware/rate-limit.ts EndpointRateLimitConfig — camelCase on the wire.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EndpointRateLimit {
    pub pattern: String,
    /// Deprecated spelling of `max_requests` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `max_requests`.
    #[serde(rename = "maxRequests")]
    pub max_requests: i64,
    /// Deprecated spelling of `window_sec` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `window_sec`.
    #[serde(rename = "windowSec")]
    pub window_sec: i64,
    pub source: GuardrailConfigItemSource,
    #[serde(rename = "max_requests")]
    pub max_requests_: i64,
    #[serde(rename = "window_sec")]
    pub window_sec_: i64,
}

/// `EnforcementResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResult {
    /// False when any matched rule carries a blocking penalty.
    pub allowed: bool,
    /// Deprecated spelling of `check_result` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `check_result`.
    #[serde(rename = "checkResult")]
    pub check_result: EnforcementResultCheckResult,
    /// What the matched rules call for. Empty when nothing matched.
    pub penalties: Vec<EnforcementResultPenalty>,
    #[serde(rename = "check_result")]
    pub check_result_: EnforcementResultCheckResult2,
}

/// Deprecated spelling of `check_result` — the same value, kept for the compatibility window
/// and removed in the next breaking release (the one that moves `X-API-Version`). Read
/// `check_result`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResultCheckResult {
    pub allowed: bool,
    /// Rule ids actually evaluated. Empty means no rule applied — never that nothing was checked.
    pub checked_rules: Vec<String>,
    pub violations: Vec<ConstitutionViolation>,
    pub checked_at: String,
}

/// `EnforcementResultCheckResult2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResultCheckResult2 {
    pub allowed: bool,
    /// Rule ids actually evaluated. Empty means no rule applied — never that nothing was checked.
    pub checked_rules: Vec<String>,
    pub violations: Vec<ConstitutionViolation>,
    pub checked_at: String,
}

/// `EnforcementResultPenalty` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResultPenalty {
    /// Deprecated spelling of `rule_id` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `rule_id`.
    #[serde(rename = "ruleId")]
    pub rule_id: String,
    pub penalty: ConstitutionRulePenalty,
    #[serde(rename = "rule_id")]
    pub rule_id_: String,
}

/// `EnrolMfaRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnrolMfaRequest {
    /// Account label embedded in otpauth URL (defaults to user id).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    /// Issuer string embedded in otpauth URL (defaults to `UARP`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub issuer: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub algorithm: Option<EnrolMfaRequestAlgorithm>,
}

/// `EnrolMfaRequestAlgorithm` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum EnrolMfaRequestAlgorithm {
    #[default]
    #[serde(rename = "SHA-1")]
    Sha1,
    #[serde(rename = "SHA-256")]
    Sha256,
    #[serde(rename = "SHA-512")]
    Sha512,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl EnrolMfaRequestAlgorithm {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Sha1 => "SHA-1",
            Self::Sha256 => "SHA-256",
            Self::Sha512 => "SHA-512",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for EnrolMfaRequestAlgorithm {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for EnrolMfaRequestAlgorithm {
    fn from(value: &str) -> Self {
        match value {
            "SHA-1" => Self::Sha1,
            "SHA-256" => Self::Sha256,
            "SHA-512" => Self::Sha512,
            other => Self::Other(other.to_string()),
        }
    }
}

/// RFC 9457 problem document; `correlation_id` (the request id, echoed from `X-Request-Id`) for
/// tracing — `correlationId` is the same value for the compatibility window.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Error {
    pub r#type: String,
    /// The HTTP reason phrase of `status` — one dictionary for every status the platform answers
    /// with (lib/error-titles.ts; the enum is built from it). The one deliberate exception: 422
    /// says "Validation Error", as it always has. Never an exception class name; that lives in
    /// `code`.
    pub title: ErrorTitle,
    pub status: i64,
    /// The sentence a person reads — specific to this occurrence, never empty, never a repeat of
    /// `title`. On a 500 it is the fixed sentence the sanitizer allows; 501–504 carry the handler's
    /// own operator guidance.
    pub detail: String,
    /// What a client should DO about this, as a value it can switch on — `detail` is for the person
    /// reading. The enum is built from the one dictionary in `types/error-codes.ts`, so the
    /// document and the wire cannot drift apart. Two casings are on the wire and both are
    /// load-bearing: SCREAMING_SNAKE came from the `UarpError` hierarchy, lower_snake from the
    /// hand-written limit refusals, and clients match on each exactly. Absent when the refusal has
    /// no machine-readable class.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<ErrorCode>,
    /// Request ID for tracing Deprecated spelling of `correlation_id` — the same value, kept for
    /// the compatibility window and removed in the next breaking release (the one that moves
    /// `X-API-Version`). Read `correlation_id`.
    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
    pub correlation_id: Option<String>,
    /// Field-level validation errors (present on 422 responses)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub errors: Option<Vec<ErrorError>>,
    /// Request ID for tracing
    #[serde(rename = "correlation_id", default, skip_serializing_if = "Option::is_none")]
    pub correlation_id_: Option<String>,
}

/// What a client should DO about this, as a value it can switch on — `detail` is for the person
/// reading. The enum is built from the one dictionary in `types/error-codes.ts`, so the
/// document and the wire cannot drift apart. Two casings are on the wire and both are
/// load-bearing: SCREAMING_SNAKE came from the `UarpError` hierarchy, lower_snake from the
/// hand-written limit refusals, and clients match on each exactly. Absent when the refusal has
/// no machine-readable class.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ErrorCode {
    #[default]
    #[serde(rename = "AAR_NOT_AVAILABLE")]
    AarNotAvailable,
    #[serde(rename = "ARTIFACT_INTEGRITY_ERROR")]
    ArtifactIntegrityError,
    #[serde(rename = "AUTH_ERROR")]
    AuthError,
    #[serde(rename = "BILLING_CANCELLED")]
    BillingCancelled,
    #[serde(rename = "BILLING_DISPUTED")]
    BillingDisputed,
    #[serde(rename = "BILLING_PAST_DUE")]
    BillingPastDue,
    #[serde(rename = "BUDGET_EXCEEDED")]
    BudgetExceeded,
    #[serde(rename = "CHECKSUM_MISMATCH")]
    ChecksumMismatch,
    #[serde(rename = "CONFIGURATION_ERROR")]
    ConfigurationError,
    #[serde(rename = "EVENT_STORE_ERROR")]
    EventStoreError,
    #[serde(rename = "EXTERNAL_SERVICE_ERROR")]
    ExternalServiceError,
    #[serde(rename = "FORBIDDEN")]
    Forbidden,
    #[serde(rename = "GUARDRAIL_VIOLATION")]
    GuardrailViolation,
    #[serde(rename = "INVALID_QUERY")]
    InvalidQuery,
    #[serde(rename = "INVALID_SHARE_LIST")]
    InvalidShareList,
    #[serde(rename = "INVALID_SHARE_TARGET")]
    InvalidShareTarget,
    #[serde(rename = "LLM_ERROR")]
    LLMError,
    #[serde(rename = "MAX_DURATION_EXCEEDED")]
    MaxDurationExceeded,
    #[serde(rename = "MAX_TOKENS_EXCEEDED")]
    MaxTokensExceeded,
    #[serde(rename = "MIGRATION_CONFLICT")]
    MigrationConflict,
    #[serde(rename = "MISSION_ALREADY_RUNNING")]
    MissionAlreadyRunning,
    #[serde(rename = "MISSION_CONCURRENCY_LIMIT")]
    MissionConcurrencyLimit,
    #[serde(rename = "MISSION_NOT_FOUND")]
    MissionNotFound,
    #[serde(rename = "MISSION_NOT_RUNNABLE")]
    MissionNotRunnable,
    #[serde(rename = "MISSION_NOT_RUNNING")]
    MissionNotRunning,
    #[serde(rename = "MISSION_ROUTE_NOT_FOUND")]
    MissionRouteNotFound,
    #[serde(rename = "NOT_FOUND")]
    NotFound,
    #[serde(rename = "NOT_YANKED")]
    NotYanked,
    #[serde(rename = "PAYLOAD_TOO_LARGE")]
    PayloadTooLarge,
    #[serde(rename = "PERSISTENCE_ERROR")]
    PersistenceError,
    #[serde(rename = "PLANNER_OUTPUT_INVALID")]
    PlannerOutputInvalid,
    #[serde(rename = "PLANNER_REFUSED")]
    PlannerRefused,
    #[serde(rename = "PRECONDITION_FAILED")]
    PreconditionFailed,
    #[serde(rename = "PRIVATE_NOT_SHARED")]
    PrivateNotShared,
    #[serde(rename = "PROMO_REDEMPTION_FAILED")]
    PromoRedemptionFailed,
    #[serde(rename = "QUOTA_EXCEEDED")]
    QuotaExceeded,
    #[serde(rename = "RATE_LIMIT_EXCEEDED")]
    RateLimitExceeded,
    #[serde(rename = "RESERVED_SCOPE")]
    ReservedScope,
    #[serde(rename = "RUN_CANCELLED")]
    RunCancelled,
    #[serde(rename = "SCOPE_MISMATCH")]
    ScopeMismatch,
    #[serde(rename = "SCOPE_TAKEN")]
    ScopeTaken,
    #[serde(rename = "SHARE_LIST_CONFLICT")]
    ShareListConflict,
    #[serde(rename = "SIZE_LIMIT")]
    SizeLimit,
    #[serde(rename = "SPEC_NOT_FOUND")]
    SpecNotFound,
    #[serde(rename = "TASK_GRAPH_FAILED")]
    TaskGraphFailed,
    #[serde(rename = "TEAM_ABORT")]
    TeamAbort,
    #[serde(rename = "VALIDATION_ERROR")]
    ValidationError,
    #[serde(rename = "VERSION_CONFLICT")]
    VersionConflict,
    #[serde(rename = "VERSION_NOT_FOUND")]
    VersionNotFound,
    #[serde(rename = "WORKSPACE_STORAGE_LIMIT")]
    WorkspaceStorageLimit,
    #[serde(rename = "YANK_CONFLICT")]
    YankConflict,
    #[serde(rename = "agent_not_found")]
    AgentNotFound,
    #[serde(rename = "already_bootstrapped")]
    AlreadyBootstrapped,
    #[serde(rename = "approval_rejected")]
    ApprovalRejected,
    #[serde(rename = "billing_not_configured")]
    BillingNotConfigured,
    #[serde(rename = "governance_not_enabled")]
    GovernanceNotEnabled,
    #[serde(rename = "incomplete_record")]
    IncompleteRecord,
    #[serde(rename = "inert_policy_field")]
    InertPolicyField,
    #[serde(rename = "inert_public_config_field")]
    InertPublicConfigField,
    #[serde(rename = "kb_chunk_limit")]
    KbChunkLimit,
    #[serde(rename = "kb_document_body_invalid")]
    KbDocumentBodyInvalid,
    #[serde(rename = "kb_document_too_large")]
    KbDocumentTooLarge,
    #[serde(rename = "kb_embedding_failed")]
    KbEmbeddingFailed,
    #[serde(rename = "kb_storage_limit")]
    KbStorageLimit,
    #[serde(rename = "kb_text_extraction_failed")]
    KbTextExtractionFailed,
    #[serde(rename = "limit_reached")]
    LimitReached,
    #[serde(rename = "plan_upgrade_required")]
    PlanUpgradeRequired,
    #[serde(rename = "provider_auth_failed")]
    ProviderAuthFailed,
    #[serde(rename = "provider_circuit_open")]
    ProviderCircuitOpen,
    #[serde(rename = "provider_not_configured")]
    ProviderNotConfigured,
    #[serde(rename = "provider_rate_limited")]
    ProviderRateLimited,
    #[serde(rename = "quota_exceeded")]
    QuotaExceeded2,
    #[serde(rename = "rate_limited")]
    RateLimited,
    #[serde(rename = "resource_limit_reached")]
    ResourceLimitReached,
    #[serde(rename = "run_input_timeout")]
    RunInputTimeout,
    #[serde(rename = "run_never_claimed")]
    RunNeverClaimed,
    #[serde(rename = "run_orphaned_restart")]
    RunOrphanedRestart,
    #[serde(rename = "run_quota_exceeded")]
    RunQuotaExceeded,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ErrorCode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::AarNotAvailable => "AAR_NOT_AVAILABLE",
            Self::ArtifactIntegrityError => "ARTIFACT_INTEGRITY_ERROR",
            Self::AuthError => "AUTH_ERROR",
            Self::BillingCancelled => "BILLING_CANCELLED",
            Self::BillingDisputed => "BILLING_DISPUTED",
            Self::BillingPastDue => "BILLING_PAST_DUE",
            Self::BudgetExceeded => "BUDGET_EXCEEDED",
            Self::ChecksumMismatch => "CHECKSUM_MISMATCH",
            Self::ConfigurationError => "CONFIGURATION_ERROR",
            Self::EventStoreError => "EVENT_STORE_ERROR",
            Self::ExternalServiceError => "EXTERNAL_SERVICE_ERROR",
            Self::Forbidden => "FORBIDDEN",
            Self::GuardrailViolation => "GUARDRAIL_VIOLATION",
            Self::InvalidQuery => "INVALID_QUERY",
            Self::InvalidShareList => "INVALID_SHARE_LIST",
            Self::InvalidShareTarget => "INVALID_SHARE_TARGET",
            Self::LLMError => "LLM_ERROR",
            Self::MaxDurationExceeded => "MAX_DURATION_EXCEEDED",
            Self::MaxTokensExceeded => "MAX_TOKENS_EXCEEDED",
            Self::MigrationConflict => "MIGRATION_CONFLICT",
            Self::MissionAlreadyRunning => "MISSION_ALREADY_RUNNING",
            Self::MissionConcurrencyLimit => "MISSION_CONCURRENCY_LIMIT",
            Self::MissionNotFound => "MISSION_NOT_FOUND",
            Self::MissionNotRunnable => "MISSION_NOT_RUNNABLE",
            Self::MissionNotRunning => "MISSION_NOT_RUNNING",
            Self::MissionRouteNotFound => "MISSION_ROUTE_NOT_FOUND",
            Self::NotFound => "NOT_FOUND",
            Self::NotYanked => "NOT_YANKED",
            Self::PayloadTooLarge => "PAYLOAD_TOO_LARGE",
            Self::PersistenceError => "PERSISTENCE_ERROR",
            Self::PlannerOutputInvalid => "PLANNER_OUTPUT_INVALID",
            Self::PlannerRefused => "PLANNER_REFUSED",
            Self::PreconditionFailed => "PRECONDITION_FAILED",
            Self::PrivateNotShared => "PRIVATE_NOT_SHARED",
            Self::PromoRedemptionFailed => "PROMO_REDEMPTION_FAILED",
            Self::QuotaExceeded => "QUOTA_EXCEEDED",
            Self::RateLimitExceeded => "RATE_LIMIT_EXCEEDED",
            Self::ReservedScope => "RESERVED_SCOPE",
            Self::RunCancelled => "RUN_CANCELLED",
            Self::ScopeMismatch => "SCOPE_MISMATCH",
            Self::ScopeTaken => "SCOPE_TAKEN",
            Self::ShareListConflict => "SHARE_LIST_CONFLICT",
            Self::SizeLimit => "SIZE_LIMIT",
            Self::SpecNotFound => "SPEC_NOT_FOUND",
            Self::TaskGraphFailed => "TASK_GRAPH_FAILED",
            Self::TeamAbort => "TEAM_ABORT",
            Self::ValidationError => "VALIDATION_ERROR",
            Self::VersionConflict => "VERSION_CONFLICT",
            Self::VersionNotFound => "VERSION_NOT_FOUND",
            Self::WorkspaceStorageLimit => "WORKSPACE_STORAGE_LIMIT",
            Self::YankConflict => "YANK_CONFLICT",
            Self::AgentNotFound => "agent_not_found",
            Self::AlreadyBootstrapped => "already_bootstrapped",
            Self::ApprovalRejected => "approval_rejected",
            Self::BillingNotConfigured => "billing_not_configured",
            Self::GovernanceNotEnabled => "governance_not_enabled",
            Self::IncompleteRecord => "incomplete_record",
            Self::InertPolicyField => "inert_policy_field",
            Self::InertPublicConfigField => "inert_public_config_field",
            Self::KbChunkLimit => "kb_chunk_limit",
            Self::KbDocumentBodyInvalid => "kb_document_body_invalid",
            Self::KbDocumentTooLarge => "kb_document_too_large",
            Self::KbEmbeddingFailed => "kb_embedding_failed",
            Self::KbStorageLimit => "kb_storage_limit",
            Self::KbTextExtractionFailed => "kb_text_extraction_failed",
            Self::LimitReached => "limit_reached",
            Self::PlanUpgradeRequired => "plan_upgrade_required",
            Self::ProviderAuthFailed => "provider_auth_failed",
            Self::ProviderCircuitOpen => "provider_circuit_open",
            Self::ProviderNotConfigured => "provider_not_configured",
            Self::ProviderRateLimited => "provider_rate_limited",
            Self::QuotaExceeded2 => "quota_exceeded",
            Self::RateLimited => "rate_limited",
            Self::ResourceLimitReached => "resource_limit_reached",
            Self::RunInputTimeout => "run_input_timeout",
            Self::RunNeverClaimed => "run_never_claimed",
            Self::RunOrphanedRestart => "run_orphaned_restart",
            Self::RunQuotaExceeded => "run_quota_exceeded",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ErrorCode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ErrorCode {
    fn from(value: &str) -> Self {
        match value {
            "AAR_NOT_AVAILABLE" => Self::AarNotAvailable,
            "ARTIFACT_INTEGRITY_ERROR" => Self::ArtifactIntegrityError,
            "AUTH_ERROR" => Self::AuthError,
            "BILLING_CANCELLED" => Self::BillingCancelled,
            "BILLING_DISPUTED" => Self::BillingDisputed,
            "BILLING_PAST_DUE" => Self::BillingPastDue,
            "BUDGET_EXCEEDED" => Self::BudgetExceeded,
            "CHECKSUM_MISMATCH" => Self::ChecksumMismatch,
            "CONFIGURATION_ERROR" => Self::ConfigurationError,
            "EVENT_STORE_ERROR" => Self::EventStoreError,
            "EXTERNAL_SERVICE_ERROR" => Self::ExternalServiceError,
            "FORBIDDEN" => Self::Forbidden,
            "GUARDRAIL_VIOLATION" => Self::GuardrailViolation,
            "INVALID_QUERY" => Self::InvalidQuery,
            "INVALID_SHARE_LIST" => Self::InvalidShareList,
            "INVALID_SHARE_TARGET" => Self::InvalidShareTarget,
            "LLM_ERROR" => Self::LLMError,
            "MAX_DURATION_EXCEEDED" => Self::MaxDurationExceeded,
            "MAX_TOKENS_EXCEEDED" => Self::MaxTokensExceeded,
            "MIGRATION_CONFLICT" => Self::MigrationConflict,
            "MISSION_ALREADY_RUNNING" => Self::MissionAlreadyRunning,
            "MISSION_CONCURRENCY_LIMIT" => Self::MissionConcurrencyLimit,
            "MISSION_NOT_FOUND" => Self::MissionNotFound,
            "MISSION_NOT_RUNNABLE" => Self::MissionNotRunnable,
            "MISSION_NOT_RUNNING" => Self::MissionNotRunning,
            "MISSION_ROUTE_NOT_FOUND" => Self::MissionRouteNotFound,
            "NOT_FOUND" => Self::NotFound,
            "NOT_YANKED" => Self::NotYanked,
            "PAYLOAD_TOO_LARGE" => Self::PayloadTooLarge,
            "PERSISTENCE_ERROR" => Self::PersistenceError,
            "PLANNER_OUTPUT_INVALID" => Self::PlannerOutputInvalid,
            "PLANNER_REFUSED" => Self::PlannerRefused,
            "PRECONDITION_FAILED" => Self::PreconditionFailed,
            "PRIVATE_NOT_SHARED" => Self::PrivateNotShared,
            "PROMO_REDEMPTION_FAILED" => Self::PromoRedemptionFailed,
            "QUOTA_EXCEEDED" => Self::QuotaExceeded,
            "RATE_LIMIT_EXCEEDED" => Self::RateLimitExceeded,
            "RESERVED_SCOPE" => Self::ReservedScope,
            "RUN_CANCELLED" => Self::RunCancelled,
            "SCOPE_MISMATCH" => Self::ScopeMismatch,
            "SCOPE_TAKEN" => Self::ScopeTaken,
            "SHARE_LIST_CONFLICT" => Self::ShareListConflict,
            "SIZE_LIMIT" => Self::SizeLimit,
            "SPEC_NOT_FOUND" => Self::SpecNotFound,
            "TASK_GRAPH_FAILED" => Self::TaskGraphFailed,
            "TEAM_ABORT" => Self::TeamAbort,
            "VALIDATION_ERROR" => Self::ValidationError,
            "VERSION_CONFLICT" => Self::VersionConflict,
            "VERSION_NOT_FOUND" => Self::VersionNotFound,
            "WORKSPACE_STORAGE_LIMIT" => Self::WorkspaceStorageLimit,
            "YANK_CONFLICT" => Self::YankConflict,
            "agent_not_found" => Self::AgentNotFound,
            "already_bootstrapped" => Self::AlreadyBootstrapped,
            "approval_rejected" => Self::ApprovalRejected,
            "billing_not_configured" => Self::BillingNotConfigured,
            "governance_not_enabled" => Self::GovernanceNotEnabled,
            "incomplete_record" => Self::IncompleteRecord,
            "inert_policy_field" => Self::InertPolicyField,
            "inert_public_config_field" => Self::InertPublicConfigField,
            "kb_chunk_limit" => Self::KbChunkLimit,
            "kb_document_body_invalid" => Self::KbDocumentBodyInvalid,
            "kb_document_too_large" => Self::KbDocumentTooLarge,
            "kb_embedding_failed" => Self::KbEmbeddingFailed,
            "kb_storage_limit" => Self::KbStorageLimit,
            "kb_text_extraction_failed" => Self::KbTextExtractionFailed,
            "limit_reached" => Self::LimitReached,
            "plan_upgrade_required" => Self::PlanUpgradeRequired,
            "provider_auth_failed" => Self::ProviderAuthFailed,
            "provider_circuit_open" => Self::ProviderCircuitOpen,
            "provider_not_configured" => Self::ProviderNotConfigured,
            "provider_rate_limited" => Self::ProviderRateLimited,
            "quota_exceeded" => Self::QuotaExceeded2,
            "rate_limited" => Self::RateLimited,
            "resource_limit_reached" => Self::ResourceLimitReached,
            "run_input_timeout" => Self::RunInputTimeout,
            "run_never_claimed" => Self::RunNeverClaimed,
            "run_orphaned_restart" => Self::RunOrphanedRestart,
            "run_quota_exceeded" => Self::RunQuotaExceeded,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ErrorError` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ErrorError {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub field: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// What a person reported from the “report to the team” button, or general feedback. Reports
/// are stored in ONE global inbox across all tenants, and expire after 90 days — the inbox is a
/// working queue, not an archive.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ErrorReport {
    pub id: String,
    /// The tenant the report came FROM, not the inbox it is stored in.
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key_id: Option<String>,
    /// The toast headline. Defaults to “Reported error” when the caller sends none.
    pub title: String,
    pub message: String,
    /// What the person was doing — action, component.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_agent: Option<String>,
    /// Anything other than `feedback` is filed as an `error`.
    pub kind: ErrorReportKind,
    pub status: ErrorReportStatus,
    pub created_at: String,
}

/// Anything other than `feedback` is filed as an `error`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ErrorReportKind {
    #[default]
    #[serde(rename = "error")]
    Error,
    #[serde(rename = "feedback")]
    Feedback,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ErrorReportKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Error => "error",
            Self::Feedback => "feedback",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ErrorReportKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ErrorReportKind {
    fn from(value: &str) -> Self {
        match value {
            "error" => Self::Error,
            "feedback" => Self::Feedback,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ErrorReportStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ErrorReportStatus {
    #[default]
    #[serde(rename = "new")]
    New,
    #[serde(rename = "resolved")]
    Resolved,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ErrorReportStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::New => "new",
            Self::Resolved => "resolved",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ErrorReportStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ErrorReportStatus {
    fn from(value: &str) -> Self {
        match value {
            "new" => Self::New,
            "resolved" => Self::Resolved,
            other => Self::Other(other.to_string()),
        }
    }
}

/// The HTTP reason phrase of `status` — one dictionary for every status the platform answers
/// with (lib/error-titles.ts; the enum is built from it). The one deliberate exception: 422
/// says "Validation Error", as it always has. Never an exception class name; that lives in
/// `code`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ErrorTitle {
    #[default]
    #[serde(rename = "Bad Request")]
    BadRequest,
    #[serde(rename = "Unauthorized")]
    Unauthorized,
    #[serde(rename = "Payment Required")]
    PaymentRequired,
    #[serde(rename = "Forbidden")]
    Forbidden,
    #[serde(rename = "Not Found")]
    NotFound,
    #[serde(rename = "Method Not Allowed")]
    MethodNotAllowed,
    #[serde(rename = "Conflict")]
    Conflict,
    #[serde(rename = "Gone")]
    Gone,
    #[serde(rename = "Length Required")]
    LengthRequired,
    #[serde(rename = "Precondition Failed")]
    PreconditionFailed,
    #[serde(rename = "Payload Too Large")]
    PayloadTooLarge,
    #[serde(rename = "Unsupported Media Type")]
    UnsupportedMediaType,
    #[serde(rename = "Validation Error")]
    ValidationError,
    #[serde(rename = "Locked")]
    Locked,
    #[serde(rename = "Precondition Required")]
    PreconditionRequired,
    #[serde(rename = "Too Many Requests")]
    TooManyRequests,
    #[serde(rename = "Internal Server Error")]
    InternalServerError,
    #[serde(rename = "Not Implemented")]
    NotImplemented,
    #[serde(rename = "Bad Gateway")]
    BadGateway,
    #[serde(rename = "Service Unavailable")]
    ServiceUnavailable,
    #[serde(rename = "Gateway Timeout")]
    GatewayTimeout,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ErrorTitle {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::BadRequest => "Bad Request",
            Self::Unauthorized => "Unauthorized",
            Self::PaymentRequired => "Payment Required",
            Self::Forbidden => "Forbidden",
            Self::NotFound => "Not Found",
            Self::MethodNotAllowed => "Method Not Allowed",
            Self::Conflict => "Conflict",
            Self::Gone => "Gone",
            Self::LengthRequired => "Length Required",
            Self::PreconditionFailed => "Precondition Failed",
            Self::PayloadTooLarge => "Payload Too Large",
            Self::UnsupportedMediaType => "Unsupported Media Type",
            Self::ValidationError => "Validation Error",
            Self::Locked => "Locked",
            Self::PreconditionRequired => "Precondition Required",
            Self::TooManyRequests => "Too Many Requests",
            Self::InternalServerError => "Internal Server Error",
            Self::NotImplemented => "Not Implemented",
            Self::BadGateway => "Bad Gateway",
            Self::ServiceUnavailable => "Service Unavailable",
            Self::GatewayTimeout => "Gateway Timeout",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ErrorTitle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ErrorTitle {
    fn from(value: &str) -> Self {
        match value {
            "Bad Request" => Self::BadRequest,
            "Unauthorized" => Self::Unauthorized,
            "Payment Required" => Self::PaymentRequired,
            "Forbidden" => Self::Forbidden,
            "Not Found" => Self::NotFound,
            "Method Not Allowed" => Self::MethodNotAllowed,
            "Conflict" => Self::Conflict,
            "Gone" => Self::Gone,
            "Length Required" => Self::LengthRequired,
            "Precondition Failed" => Self::PreconditionFailed,
            "Payload Too Large" => Self::PayloadTooLarge,
            "Unsupported Media Type" => Self::UnsupportedMediaType,
            "Validation Error" => Self::ValidationError,
            "Locked" => Self::Locked,
            "Precondition Required" => Self::PreconditionRequired,
            "Too Many Requests" => Self::TooManyRequests,
            "Internal Server Error" => Self::InternalServerError,
            "Not Implemented" => Self::NotImplemented,
            "Bad Gateway" => Self::BadGateway,
            "Service Unavailable" => Self::ServiceUnavailable,
            "Gateway Timeout" => Self::GatewayTimeout,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `EstimateRunCostRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EstimateRunCostRequest {
    pub agent_id: String,
    /// The prompt, used for the input-token estimate.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_text: Option<String>,
    /// Picks up a per-session model override, when one is set.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

/// evaluation/evaluator.ts EvalCase.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EvalCase {
    pub case_id: String,
    pub input: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_output: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_tool_calls: Option<Vec<String>>,
    pub tags: Vec<String>,
    pub metadata: serde_json::Map<String, serde_json::Value>,
}

/// evaluation/evaluator.ts EvalDataset — the stored record, unsanitized.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EvalDataset {
    pub dataset_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    pub name: String,
    pub cases: Vec<EvalCase>,
    pub created_at: String,
}

/// evaluation/evaluator.ts EvalRun — the stored record; `agent_version`, `errored_cases` and
/// `summary` are conditional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EvalRun {
    pub eval_run_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    pub dataset_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_version: Option<String>,
    pub results: Vec<EvalRunResult>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub errored_cases: Option<Vec<EvalRunErroredCas>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<EvalRunSummary>,
    pub created_at: String,
}

/// `EvalRunErroredCas` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EvalRunErroredCas {
    pub case_id: String,
    pub error: String,
}

/// `EvalRunResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EvalRunResult {
    pub case_id: String,
    pub run_id: String,
    pub scores: serde_json::Map<String, serde_json::Value>,
    pub passed: bool,
    pub duration_ms: f64,
    pub tokens_used: f64,
}

/// `EvalRunSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EvalRunSummary {
    pub total_cases: i64,
    pub passed: i64,
    pub failed: i64,
    pub errored: i64,
    pub avg_scores: serde_json::Map<String, serde_json::Value>,
    pub avg_duration_ms: f64,
    pub total_tokens: f64,
    pub total_cost_usd: f64,
    pub regression_detected: bool,
}

/// `Experiment` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Experiment {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub experiment_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dataset_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variants: Option<Vec<ExperimentVariant>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<ExperimentStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comparison: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

/// `ExperimentStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ExperimentStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "running")]
    Running,
    #[serde(rename = "completed")]
    Completed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ExperimentStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Running => "running",
            Self::Completed => "completed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ExperimentStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ExperimentStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "running" => Self::Running,
            "completed" => Self::Completed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ExperimentVariant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ExperimentVariant {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub eval_run_id: Option<String>,
}

/// `ExportAdminConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ExportAdminConfigResponse {
    pub exported_at: String,
    pub section_count: i64,
    pub sections: serde_json::Map<String, serde_json::Value>,
}

/// `ExportDataExplorerIncludeSensitive` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ExportDataExplorerIncludeSensitive {
    #[default]
    #[serde(rename = "1")]
    V1,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ExportDataExplorerIncludeSensitive {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::V1 => "1",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ExportDataExplorerIncludeSensitive {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ExportDataExplorerIncludeSensitive {
    fn from(value: &str) -> Self {
        match value {
            "1" => Self::V1,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ExportMyAccountFormat` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ExportMyAccountFormat {
    #[default]
    #[serde(rename = "zip")]
    Zip,
    #[serde(rename = "json")]
    JSON,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ExportMyAccountFormat {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Zip => "zip",
            Self::JSON => "json",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ExportMyAccountFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ExportMyAccountFormat {
    fn from(value: &str) -> Self {
        match value {
            "zip" => Self::Zip,
            "json" => Self::JSON,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ExportSessionFormat` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ExportSessionFormat {
    #[default]
    #[serde(rename = "md")]
    Md,
    #[serde(rename = "json")]
    JSON,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ExportSessionFormat {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Md => "md",
            Self::JSON => "json",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ExportSessionFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ExportSessionFormat {
    fn from(value: &str) -> Self {
        match value {
            "md" => Self::Md,
            "json" => Self::JSON,
            other => Self::Other(other.to_string()),
        }
    }
}

/// admin-config.ts mergeFeatureFlags — a closed set of ids; `rollout_pct` only when an override
/// set it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FeatureFlag {
    pub id: String,
    pub label: String,
    pub description: String,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rollout_pct: Option<i64>,
    pub source: GuardrailConfigItemSource,
}

/// `FeedEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FeedEntry {
    pub feed_id: String,
    pub tenant_id: String,
    pub timestamp: String,
    pub event_type: FeedEntryEventType,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub company_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub company_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<FeedEntryMetrics>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `FeedEntryEventType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum FeedEntryEventType {
    #[default]
    #[serde(rename = "run.started")]
    RunStarted,
    #[serde(rename = "run.completed")]
    RunCompleted,
    #[serde(rename = "run.failed")]
    RunFailed,
    #[serde(rename = "run.timeout")]
    RunTimeout,
    #[serde(rename = "run.cancelled")]
    RunCancelled,
    #[serde(rename = "session.created")]
    SessionCreated,
    #[serde(rename = "company.tick_start")]
    CompanyTickStart,
    #[serde(rename = "company.tick_end")]
    CompanyTickEnd,
    #[serde(rename = "company.paused")]
    CompanyPaused,
    #[serde(rename = "company.resumed")]
    CompanyResumed,
    #[serde(rename = "company.escalation")]
    CompanyEscalation,
    #[serde(rename = "team.round_start")]
    TeamRoundStart,
    #[serde(rename = "team.round_end")]
    TeamRoundEnd,
    #[serde(rename = "objective.created")]
    ObjectiveCreated,
    #[serde(rename = "objective.completed")]
    ObjectiveCompleted,
    #[serde(rename = "agent.created")]
    AgentCreated,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl FeedEntryEventType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::RunStarted => "run.started",
            Self::RunCompleted => "run.completed",
            Self::RunFailed => "run.failed",
            Self::RunTimeout => "run.timeout",
            Self::RunCancelled => "run.cancelled",
            Self::SessionCreated => "session.created",
            Self::CompanyTickStart => "company.tick_start",
            Self::CompanyTickEnd => "company.tick_end",
            Self::CompanyPaused => "company.paused",
            Self::CompanyResumed => "company.resumed",
            Self::CompanyEscalation => "company.escalation",
            Self::TeamRoundStart => "team.round_start",
            Self::TeamRoundEnd => "team.round_end",
            Self::ObjectiveCreated => "objective.created",
            Self::ObjectiveCompleted => "objective.completed",
            Self::AgentCreated => "agent.created",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for FeedEntryEventType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for FeedEntryEventType {
    fn from(value: &str) -> Self {
        match value {
            "run.started" => Self::RunStarted,
            "run.completed" => Self::RunCompleted,
            "run.failed" => Self::RunFailed,
            "run.timeout" => Self::RunTimeout,
            "run.cancelled" => Self::RunCancelled,
            "session.created" => Self::SessionCreated,
            "company.tick_start" => Self::CompanyTickStart,
            "company.tick_end" => Self::CompanyTickEnd,
            "company.paused" => Self::CompanyPaused,
            "company.resumed" => Self::CompanyResumed,
            "company.escalation" => Self::CompanyEscalation,
            "team.round_start" => Self::TeamRoundStart,
            "team.round_end" => Self::TeamRoundEnd,
            "objective.created" => Self::ObjectiveCreated,
            "objective.completed" => Self::ObjectiveCompleted,
            "agent.created" => Self::AgentCreated,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `FeedEntryMetrics` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FeedEntryMetrics {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens_used: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub steps: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<i64>,
}

/// `FileArbiterAppealRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FileArbiterAppealRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filed_by: Option<String>,
    pub reason: String,
}

/// `FileArbiterAppealResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FileArbiterAppealResponse {
    pub appeal_id: String,
    pub case_id: String,
    pub filed_by: String,
    pub reason: String,
    pub panel_arbiter_ids: Vec<String>,
    pub status: FileArbiterAppealResponseStatus,
    pub filed_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolved_at: Option<String>,
}

/// `FileArbiterAppealResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum FileArbiterAppealResponseStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "upheld")]
    Upheld,
    #[serde(rename = "overturned")]
    Overturned,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl FileArbiterAppealResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Upheld => "upheld",
            Self::Overturned => "overturned",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for FileArbiterAppealResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for FileArbiterAppealResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "upheld" => Self::Upheld,
            "overturned" => Self::Overturned,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `FileArbiterCaseRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FileArbiterCaseRequest {
    pub filed_by: String,
    pub against_agent_id: String,
    /// Which constitution rules the case alleges were broken. At least one — a case against no rule
    /// is not arbitrable.
    pub rule_ids: Vec<String>,
    /// The dispute in the filer's words, and what the reader returns as `description`. There is no
    /// `reason` field: the handler validates with `.strip()`, so a body written from the old
    /// version of this block had its text discarded and was then refused 422 for the two fields the
    /// block never mentioned (measured 2026-09-17).
    pub description: String,
    /// Free-form supporting material. Optional.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub evidence: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `FileEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FileEntry {
    pub created_at: String,
    pub file_id: String,
    pub filename: String,
    pub mime_type: String,
    pub sha256: String,
    pub size_bytes: i64,
    pub tenant_id: String,
}

/// A stored file as GET /files/{fileId} serves it (measured 2026-09-10 on e2e-canon). POST
/// /files returns the same record plus `url`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FileRecord {
    pub file_id: String,
    pub tenant_id: String,
    pub filename: String,
    pub mime_type: String,
    pub size_bytes: i64,
    pub sha256: String,
    pub created_at: String,
}

/// The operator's canvas: where each agent sits, how they are wired, and the notes and
/// not-yet-real nodes drawn around them. Persisted as one record per tenant.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayout {
    /// Agent id → its place on the canvas.
    pub positions: HashMap<String, Value4>,
    pub edges: Vec<FleetLayoutEdge>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notes: Option<Vec<FleetLayoutNote>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub drafts: Option<Vec<FleetLayoutDraft>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    /// Present ONLY when the save discarded something. Counts per collection of the items that did
    /// not survive the caps or validation. A 200 without this field saved everything.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dropped: Option<FleetLayoutDropped>,
}

/// `FleetLayoutDraft` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutDraft {
    pub id: String,
    /// memory / knowledge / tool / condition / … — a node the operator drew that is not a backend
    /// entity yet.
    pub kind: String,
    pub x: f64,
    pub y: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Present ONLY when the save discarded something. Counts per collection of the items that did
/// not survive the caps or validation. A 200 without this field saved everything.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutDropped {
    pub positions: i64,
    pub edges: i64,
    pub notes: i64,
    pub drafts: i64,
}

/// `FleetLayoutEdge` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutEdge {
    pub id: String,
    /// Agent id.
    pub source: String,
    /// Agent id.
    pub target: String,
    /// Edge kind; a workflow edge is what makes the graph runnable.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// `FleetLayoutNote` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutNote {
    pub id: String,
    pub x: f64,
    pub y: f64,
    pub w: f64,
    pub h: f64,
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    /// A frame is a large titled rectangle drawn BEHIND the nodes to group a squad.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub frame: Option<bool>,
}

/// What a client SENDS when saving the canvas. The stored record additionally carries
/// `updated_at`, and the response may carry `dropped` — both are produced by the server, so
/// neither belongs in a request.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutUpdate {
    /// Agent id → its place on the canvas.
    pub positions: HashMap<String, Value3>,
    pub edges: Vec<FleetLayoutUpdateEdge>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notes: Option<Vec<FleetLayoutUpdateNote>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub drafts: Option<Vec<FleetLayoutUpdateDraft>>,
}

/// `FleetLayoutUpdateDraft` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutUpdateDraft {
    pub id: String,
    pub kind: String,
    pub x: f64,
    pub y: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `FleetLayoutUpdateEdge` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutUpdateEdge {
    pub id: String,
    pub source: String,
    pub target: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// `FleetLayoutUpdateNote` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FleetLayoutUpdateNote {
    pub id: String,
    pub x: f64,
    pub y: f64,
    pub w: f64,
    pub h: f64,
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub frame: Option<bool>,
}

/// `FounderIdentity` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FounderIdentity {
    /// Empty string when unset — this read never omits the key.
    pub founder_id: String,
    pub founder_name: String,
    pub founder_public_key: String,
}

/// `FriaReport` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FriaReport {
    pub agent_id: String,
    pub risk_level: String,
    pub rights_assessed: Vec<FriaRight>,
    pub mitigations: String,
    pub assessor: String,
    pub assessed_at: String,
    pub next_review: String,
}

/// `FriaRight` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct FriaRight {
    pub right: String,
    pub impact: FriaRightImpact,
    pub justification: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mitigation: Option<String>,
}

/// `FriaRightImpact` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum FriaRightImpact {
    #[default]
    #[serde(rename = "none")]
    None,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl FriaRightImpact {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::None => "none",
            Self::Low => "low",
            Self::Medium => "medium",
            Self::High => "high",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for FriaRightImpact {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for FriaRightImpact {
    fn from(value: &str) -> Self {
        match value {
            "none" => Self::None,
            "low" => Self::Low,
            "medium" => Self::Medium,
            "high" => Self::High,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GenerateAdminBlogPostResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GenerateAdminBlogPostResponse {
    pub post: BlogPost,
}

/// `GetActivityFeedResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetActivityFeedResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<FeedEntry>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `GetAdminBlogConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminBlogConfigResponse {
    pub config: BlogConfig,
}

/// `GetAdminDisabledToolsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminDisabledToolsResponse {
    pub ok: bool,
    pub disabled_tools: Vec<String>,
}

/// `GetAdminIntegrationOAuthProviderProvider` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetAdminIntegrationOAuthProviderProvider {
    #[default]
    #[serde(rename = "github")]
    Github,
    #[serde(rename = "google")]
    Google,
    #[serde(rename = "slack")]
    Slack,
    #[serde(rename = "notion")]
    Notion,
    #[serde(rename = "stripe")]
    Stripe,
    #[serde(rename = "jira")]
    Jira,
    #[serde(rename = "zendesk")]
    Zendesk,
    #[serde(rename = "hubspot")]
    Hubspot,
    #[serde(rename = "linkedin")]
    Linkedin,
    #[serde(rename = "youtube")]
    Youtube,
    #[serde(rename = "instagram")]
    Instagram,
    #[serde(rename = "x_twitter")]
    XTwitter,
    #[serde(rename = "facebook")]
    Facebook,
    #[serde(rename = "tiktok")]
    Tiktok,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetAdminIntegrationOAuthProviderProvider {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Github => "github",
            Self::Google => "google",
            Self::Slack => "slack",
            Self::Notion => "notion",
            Self::Stripe => "stripe",
            Self::Jira => "jira",
            Self::Zendesk => "zendesk",
            Self::Hubspot => "hubspot",
            Self::Linkedin => "linkedin",
            Self::Youtube => "youtube",
            Self::Instagram => "instagram",
            Self::XTwitter => "x_twitter",
            Self::Facebook => "facebook",
            Self::Tiktok => "tiktok",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetAdminIntegrationOAuthProviderProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetAdminIntegrationOAuthProviderProvider {
    fn from(value: &str) -> Self {
        match value {
            "github" => Self::Github,
            "google" => Self::Google,
            "slack" => Self::Slack,
            "notion" => Self::Notion,
            "stripe" => Self::Stripe,
            "jira" => Self::Jira,
            "zendesk" => Self::Zendesk,
            "hubspot" => Self::Hubspot,
            "linkedin" => Self::Linkedin,
            "youtube" => Self::Youtube,
            "instagram" => Self::Instagram,
            "x_twitter" => Self::XTwitter,
            "facebook" => Self::Facebook,
            "tiktok" => Self::Tiktok,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetAdminIntegrationOAuthProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminIntegrationOAuthProviderResponse {
    pub provider: String,
    pub enabled: bool,
    pub configured: bool,
    /// Present only when `configured` is true.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    /// Last four characters behind dots. Present only when `configured` is true; null when the
    /// stored secret is empty.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_secret_hint: Option<String>,
    /// Override of the default scope list. Present only when `configured` is true; null when no
    /// override is stored.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
}

/// `GetAdminLLMDefaultsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminLLMDefaultsResponse {
    pub providers: Vec<GetAdminLLMDefaultsResponseProvider>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_endpoint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_endpoint: Option<String>,
}

/// `GetAdminLLMDefaultsResponseProvider` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminLLMDefaultsResponseProvider {
    pub provider_id: String,
    /// Always true — the list holds configured providers only.
    pub configured: bool,
    /// Masked key: first four and last four, or all dots when the key is 10 characters or fewer.
    pub key_hint: String,
}

/// `GetAdminPlansResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminPlansResponse {
    pub plans: Vec<GetAdminPlansResponsePlan>,
}

/// `GetAdminPlansResponsePlan` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminPlansResponsePlan {
    pub id: String,
    pub name: String,
    /// Per-plan limits (`max_agents`, `max_monthly_tokens`, …).
    pub quotas: serde_json::Map<String, serde_json::Value>,
}

/// `GetAdminStatsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminStatsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_tenants: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_agents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_runs: Option<i64>,
}

/// `GetAdminToolOverridesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminToolOverridesResponse {
    pub ok: bool,
    pub overrides: HashMap<String, ToolOverride>,
}

/// `GetAdminTraceResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminTraceResponse {
    pub trace_id: String,
    pub count: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub truncated: Option<bool>,
    pub runs: Vec<GetAdminTraceResponseRun>,
}

/// `GetAdminTraceResponseRun` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminTraceResponseRun {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dag_trace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `GetAgentActivityStatsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentActivityStatsResponse {
    /// Deprecated spelling of `total_runs` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `total_runs`.
    #[serde(rename = "totalRuns", default, skip_serializing_if = "Option::is_none")]
    pub total_runs: Option<i64>,
    /// Deprecated spelling of `completed_runs` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `completed_runs`.
    #[serde(rename = "completedRuns", default, skip_serializing_if = "Option::is_none")]
    pub completed_runs: Option<i64>,
    /// Deprecated spelling of `failed_runs` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `failed_runs`.
    #[serde(rename = "failedRuns", default, skip_serializing_if = "Option::is_none")]
    pub failed_runs: Option<i64>,
    /// Deprecated spelling of `cancelled_runs` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `cancelled_runs`.
    #[serde(rename = "cancelledRuns", default, skip_serializing_if = "Option::is_none")]
    pub cancelled_runs: Option<i64>,
    /// Deprecated spelling of `guardrail_blocked_runs` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `guardrail_blocked_runs`.
    #[serde(rename = "guardrailBlockedRuns", default, skip_serializing_if = "Option::is_none")]
    pub guardrail_blocked_runs: Option<i64>,
    /// Deprecated spelling of `error_rate_percent` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `error_rate_percent`.
    #[serde(rename = "errorRatePercent", default, skip_serializing_if = "Option::is_none")]
    pub error_rate_percent: Option<f64>,
    /// Deprecated spelling of `avg_steps_per_run` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `avg_steps_per_run`.
    #[serde(rename = "avgStepsPerRun", default, skip_serializing_if = "Option::is_none")]
    pub avg_steps_per_run: Option<f64>,
    /// Deprecated spelling of `avg_duration_ms` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `avg_duration_ms`.
    #[serde(rename = "avgDurationMs", default, skip_serializing_if = "Option::is_none")]
    pub avg_duration_ms: Option<f64>,
    /// Deprecated spelling of `avg_input_tokens` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `avg_input_tokens`.
    #[serde(rename = "avgInputTokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_input_tokens: Option<f64>,
    /// Deprecated spelling of `avg_output_tokens` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `avg_output_tokens`.
    #[serde(rename = "avgOutputTokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_output_tokens: Option<f64>,
    /// Deprecated spelling of `avg_thinking_tokens` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `avg_thinking_tokens`.
    #[serde(rename = "avgThinkingTokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_thinking_tokens: Option<f64>,
    /// Deprecated spelling of `tool_breakdown` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `tool_breakdown`.
    #[serde(rename = "toolBreakdown", default, skip_serializing_if = "Option::is_none")]
    pub tool_breakdown: Option<Vec<ToolBreakdownEntry>>,
    /// Deprecated spelling of `top_error_messages` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `top_error_messages`.
    #[serde(rename = "topErrorMessages", default, skip_serializing_if = "Option::is_none")]
    pub top_error_messages: Option<Vec<GetAgentActivityStatsResponseTopErrorMessage>>,
    /// Deprecated spelling of `runs_by_day` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `runs_by_day`.
    #[serde(rename = "runsByDay", default, skip_serializing_if = "Option::is_none")]
    pub runs_by_day: Option<Vec<GetAgentActivityStatsResponseRunsByDayItem>>,
    #[serde(rename = "total_runs", default, skip_serializing_if = "Option::is_none")]
    pub total_runs_: Option<i64>,
    #[serde(rename = "completed_runs", default, skip_serializing_if = "Option::is_none")]
    pub completed_runs_: Option<i64>,
    #[serde(rename = "failed_runs", default, skip_serializing_if = "Option::is_none")]
    pub failed_runs_: Option<i64>,
    #[serde(rename = "cancelled_runs", default, skip_serializing_if = "Option::is_none")]
    pub cancelled_runs_: Option<i64>,
    #[serde(rename = "guardrail_blocked_runs", default, skip_serializing_if = "Option::is_none")]
    pub guardrail_blocked_runs_: Option<i64>,
    #[serde(rename = "error_rate_percent", default, skip_serializing_if = "Option::is_none")]
    pub error_rate_percent_: Option<f64>,
    #[serde(rename = "avg_steps_per_run", default, skip_serializing_if = "Option::is_none")]
    pub avg_steps_per_run_: Option<f64>,
    #[serde(rename = "avg_duration_ms", default, skip_serializing_if = "Option::is_none")]
    pub avg_duration_ms_: Option<f64>,
    #[serde(rename = "avg_input_tokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_input_tokens_: Option<f64>,
    #[serde(rename = "avg_output_tokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_output_tokens_: Option<f64>,
    #[serde(rename = "avg_thinking_tokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_thinking_tokens_: Option<f64>,
    #[serde(rename = "tool_breakdown", default, skip_serializing_if = "Option::is_none")]
    pub tool_breakdown_: Option<Vec<ToolBreakdownEntry>>,
    #[serde(rename = "top_error_messages", default, skip_serializing_if = "Option::is_none")]
    pub top_error_messages_: Option<Vec<GetAgentActivityStatsResponseTopErrorMessage2>>,
    #[serde(rename = "runs_by_day", default, skip_serializing_if = "Option::is_none")]
    pub runs_by_day_: Option<Vec<GetAgentActivityStatsResponseRunsByDayItem2>>,
}

/// `GetAgentActivityStatsResponseRunsByDayItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentActivityStatsResponseRunsByDayItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub day: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failed: Option<i64>,
}

/// `GetAgentActivityStatsResponseRunsByDayItem2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentActivityStatsResponseRunsByDayItem2 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub day: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failed: Option<i64>,
}

/// `GetAgentActivityStatsResponseTopErrorMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentActivityStatsResponseTopErrorMessage {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
}

/// `GetAgentActivityStatsResponseTopErrorMessage2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentActivityStatsResponseTopErrorMessage2 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
}

/// `GetAgentIdentityResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentIdentityResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

/// `GetAgentObligationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentObligationsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rules: Option<Vec<ConstitutionRule>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
}

/// `GetAgentSystemCardFormat` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetAgentSystemCardFormat {
    #[default]
    #[serde(rename = "json")]
    JSON,
    #[serde(rename = "markdown")]
    Markdown,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetAgentSystemCardFormat {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::JSON => "json",
            Self::Markdown => "markdown",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetAgentSystemCardFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetAgentSystemCardFormat {
    fn from(value: &str) -> Self {
        match value {
            "json" => Self::JSON,
            "markdown" => Self::Markdown,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetAgentTrafficResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentTrafficResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<GetAgentTrafficResponseEntry>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `GetAgentTrafficResponseEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentTrafficResponseEntry {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub weight: Option<f64>,
}

/// `GetAgentVersionDiffResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentVersionDiffResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version_from: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version_to: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub diff: Option<HashMap<String, Value5>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub changed_fields: Option<Vec<String>>,
}

/// `GetAgentViolationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAgentViolationsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub violations: Option<Vec<ConstitutionViolation>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
}

/// `GetAndroidTestingStatusResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAndroidTestingStatusResponse {
    pub registered: bool,
    pub emailed: bool,
}

/// `GetAppleAppSiteAssociationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAppleAppSiteAssociationResponse {
    pub applinks: GetAppleAppSiteAssociationResponseApplinks,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webcredentials: Option<GetAppleAppSiteAssociationResponseWebcredentials>,
}

/// `GetAppleAppSiteAssociationResponseApplinks` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAppleAppSiteAssociationResponseApplinks {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub apps: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<Vec<GetAppleAppSiteAssociationResponseApplinksDetail>>,
}

/// `GetAppleAppSiteAssociationResponseApplinksDetail` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAppleAppSiteAssociationResponseApplinksDetail {
    #[serde(rename = "appIDs", default, skip_serializing_if = "Option::is_none")]
    pub app_i_ds: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub components: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

/// `GetAppleAppSiteAssociationResponseWebcredentials` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAppleAppSiteAssociationResponseWebcredentials {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub apps: Option<Vec<String>>,
}

/// `GetBillingBudgetResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBillingBudgetResponse {
    pub configured: bool,
    #[serde(default)]
    pub budget: Option<GetBillingBudgetResponseBudget>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetBillingBudgetResponseBudget` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBillingBudgetResponseBudget {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit_usd: Option<f64>,
    /// Fraction, not percent: 0.8 alerts at 80%.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub soft_threshold: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hard_threshold: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub period: Option<GetBillingBudgetResponseBudgetPeriod>,
}

/// `GetBillingBudgetResponseBudgetPeriod` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetBillingBudgetResponseBudgetPeriod {
    #[default]
    #[serde(rename = "monthly")]
    Monthly,
    #[serde(rename = "weekly")]
    Weekly,
    #[serde(rename = "daily")]
    Daily,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetBillingBudgetResponseBudgetPeriod {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Monthly => "monthly",
            Self::Weekly => "weekly",
            Self::Daily => "daily",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetBillingBudgetResponseBudgetPeriod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetBillingBudgetResponseBudgetPeriod {
    fn from(value: &str) -> Self {
        match value {
            "monthly" => Self::Monthly,
            "weekly" => Self::Weekly,
            "daily" => Self::Daily,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetBillingOverageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBillingOverageResponse {
    pub enabled: bool,
    /// Always true: overage cannot be enabled without a spend cap.
    pub requires_cap: bool,
    pub cap_configured: bool,
    pub metered_to_stripe: bool,
}

/// `GetBillingTrialResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBillingTrialResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ends_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub days_left: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub recommended_plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signals: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetBridgeAgentSpecsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBridgeAgentSpecsResponse {
    pub agent_id: String,
    /// SHA-256 over the list
    pub revision: String,
    pub specs: Vec<GetBridgeAgentSpecsResponseSpec>,
}

/// `GetBridgeAgentSpecsResponseSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBridgeAgentSpecsResponseSpec {
    pub spec_id: String,
    pub version: String,
    pub enabled: bool,
    /// null when the registry has no row for the SPEC; the reconciler skips it
    #[serde(default)]
    pub runtime_scope: Option<String>,
    pub permissions_granted: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_allowlist: Option<Vec<String>>,
}

/// `GetBridgeTaskApprovalResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetBridgeTaskApprovalResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approval_response: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetClientConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetClientConfigResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub features: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetCompanyActivityResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetCompanyActivityResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<CompanyActivityEntry>>,
}

/// `GetCompanyBudgetResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetCompanyBudgetResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spent_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub daily_limit_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alert_threshold_pct: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub remaining_usd: Option<f64>,
}

/// `GetCompanyObjectivesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetCompanyObjectivesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub trees: Option<Vec<ObjectiveTree>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub objectives: Option<Vec<Objective>>,
}

/// `GetDataExplorerValueResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetDataExplorerValueResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// `GetGovernanceLedgerResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetGovernanceLedgerResponse {
    pub entries: Vec<GovernanceLedgerEntry>,
    pub head: GovernanceLedgerHead,
    /// Number of entries IN THIS RESPONSE, not the size of the ledger. Measured 2026-08-20: `total`
    /// was 16 while `GET /governance/ledger/verify` reported `entries_checked: 6698` against the
    /// same ledger a second later. Rendering this as "events recorded" understates the ledger by
    /// three orders of magnitude. For the size, read `tenant_total`.
    pub total: i64,
    /// How many entries in the whole ledger belong to the calling tenant — the number to render as
    /// "ledger entries". Independent of `count`/`from`/`to`. Not `entries_checked` from
    /// `/governance/ledger/verify` (that walks every tenant) and not `head.seq` (global sequence).
    pub tenant_total: i64,
}

/// `GetHealthResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetHealthResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<GetHealthResponseStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kv_connected: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uptime_seconds: Option<f64>,
    /// The API contract version, a DATE STAMP — `2026-09-10` — bumped only on a breaking change,
    /// and the same value the `X-API-Version` RESPONSE header carries. The server does not read a
    /// request header of that name: pinning a date negotiates nothing. Not a release number and not
    /// semver: it cannot be ordered against a semver string, so a client that compares it to one is
    /// wrong in a way that appears to work for as long as both happen to sort the same. Compare it
    /// for equality, or read it as a date. It says nothing about which BUILD is running — for that,
    /// read `build_sha`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    /// The commit this running build was made from, baked in at image build time. This is the only
    /// value on the wire that identifies the deployed code: `version` is the contract stamp and is
    /// constant across deploys, and a restart proves a restart rather than an identity. `"unknown"`
    /// means the image was built without the build argument (a local build, or a deploy predating
    /// this field) and must be read as UNKNOWN, never as a match. Documentation that pins a claim
    /// about platform behaviour can cite it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub build_sha: Option<String>,
    /// Always 0. Kept for compatibility — there is no resume-parking state: `RunStatus` has no
    /// `waiting_for_resume`, and startup reconciliation FAILS an interrupted run rather than
    /// holding it for resume. It previously reported the queue depth under this name, which reads
    /// as recovery progress on the one endpoint an operator watches during a deploy. Use
    /// `runs_queued` for the queue, and run status for recovery.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pending_resumes: Option<i64>,
    /// Runs currently queued. After a restart this includes runs reconciliation re-queued, so it
    /// falls as they are picked up — but it is a queue depth, not a count of recoveries.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs_queued: Option<i64>,
}

/// `GetHealthResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetHealthResponseStatus {
    #[default]
    #[serde(rename = "healthy")]
    Healthy,
    #[serde(rename = "degraded")]
    Degraded,
    #[serde(rename = "unhealthy")]
    Unhealthy,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetHealthResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Healthy => "healthy",
            Self::Degraded => "degraded",
            Self::Unhealthy => "unhealthy",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetHealthResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetHealthResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "healthy" => Self::Healthy,
            "degraded" => Self::Degraded,
            "unhealthy" => Self::Unhealthy,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetImmutableAuditResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetImmutableAuditResponse {
    pub events: Vec<ImmutableAuditEvent>,
    pub total: i64,
}

/// `GetLinkPreviewResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetLinkPreviewResponse {
    pub preview: LinkPreview,
}

/// `GetListingReviewsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetListingReviewsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reviews: Option<Vec<MarketplaceListingRating>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// `GetMarketplaceCategoriesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMarketplaceCategoriesResponse {
    pub categories: Vec<String>,
}

/// `GetMarkupConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMarkupConfigResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub markup: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetMediaUsageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMediaUsageResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub images: Option<GetMediaUsageResponseImages>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub videos: Option<GetMediaUsageResponseVideos>,
}

/// `GetMediaUsageResponseImages` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMediaUsageResponseImages {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub monthly_used: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub daily_used: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub monthly_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub daily_limit: Option<i64>,
}

/// `GetMediaUsageResponseVideos` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMediaUsageResponseVideos {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub monthly_used: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub monthly_limit: Option<i64>,
}

/// `GetMemoriesByEntityResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMemoriesByEntityResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<MemoryEntry>>,
}

/// `GetMeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMeResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<GetMeResponseUser>,
    pub tenant: GetMeResponseTenant,
    pub role: String,
    pub scopes: Vec<String>,
    pub auth_method: GetMeResponseAuthMethod,
    pub memberships: Vec<GetMeResponseMembership>,
}

/// `GetMeResponseAuthMethod` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetMeResponseAuthMethod {
    #[default]
    #[serde(rename = "api_key")]
    APIKey,
    #[serde(rename = "cookie")]
    Cookie,
    #[serde(rename = "jwt")]
    JWT,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetMeResponseAuthMethod {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::APIKey => "api_key",
            Self::Cookie => "cookie",
            Self::JWT => "jwt",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetMeResponseAuthMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetMeResponseAuthMethod {
    fn from(value: &str) -> Self {
        match value {
            "api_key" => Self::APIKey,
            "cookie" => Self::Cookie,
            "jwt" => Self::JWT,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetMeResponseMembership` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMeResponseMembership {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
}

/// `GetMeResponseTenant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMeResponseTenant {
    pub tenant_id: String,
    pub name: String,
    pub slug: String,
    pub plan: String,
}

/// `GetMeResponseUser` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMeResponseUser {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub avatar_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_login_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

/// `GetMfaStatusResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMfaStatusResponse {
    pub enrolled: bool,
    pub recovery_remaining: i64,
}

/// `GetMyHeadAgentTemplateResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMyHeadAgentTemplateResponse {
    pub plan: String,
    pub recommended: GetMyHeadAgentTemplateResponseRecommended,
    pub tiers: Vec<GetMyHeadAgentTemplateResponseTier>,
}

/// `GetMyHeadAgentTemplateResponseRecommended` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetMyHeadAgentTemplateResponseRecommended {
    #[default]
    #[serde(rename = "basic")]
    Basic,
    #[serde(rename = "standard")]
    Standard,
    #[serde(rename = "full")]
    Full,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetMyHeadAgentTemplateResponseRecommended {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Basic => "basic",
            Self::Standard => "standard",
            Self::Full => "full",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetMyHeadAgentTemplateResponseRecommended {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetMyHeadAgentTemplateResponseRecommended {
    fn from(value: &str) -> Self {
        match value {
            "basic" => Self::Basic,
            "standard" => Self::Standard,
            "full" => Self::Full,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetMyHeadAgentTemplateResponseTier` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMyHeadAgentTemplateResponseTier {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tier: Option<GetMyHeadAgentTemplateResponseTierTier>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub available: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub install_specs: Option<Vec<GetMyHeadAgentTemplateResponseTierInstallSpec>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_approve_tools: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_tool_count: Option<i64>,
}

/// `GetMyHeadAgentTemplateResponseTierInstallSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMyHeadAgentTemplateResponseTierInstallSpec {
    pub spec_id: String,
}

/// `GetMyHeadAgentTemplateResponseTierTier` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetMyHeadAgentTemplateResponseTierTier {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<GetMyHeadAgentTemplateResponseRecommended>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub required_plan: Option<GetMyHeadAgentTemplateResponseTierTierRequiredPlan>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub spec_ids: Option<Vec<String>>,
}

/// `GetMyHeadAgentTemplateResponseTierTierRequiredPlan` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetMyHeadAgentTemplateResponseTierTierRequiredPlan {
    #[default]
    #[serde(rename = "free")]
    Free,
    #[serde(rename = "starter")]
    Starter,
    #[serde(rename = "pro")]
    Pro,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetMyHeadAgentTemplateResponseTierTierRequiredPlan {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Free => "free",
            Self::Starter => "starter",
            Self::Pro => "pro",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetMyHeadAgentTemplateResponseTierTierRequiredPlan {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetMyHeadAgentTemplateResponseTierTierRequiredPlan {
    fn from(value: &str) -> Self {
        match value {
            "free" => Self::Free,
            "starter" => Self::Starter,
            "pro" => Self::Pro,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetPromoStateResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPromoStateResponse {
    #[serde(default)]
    pub applied_code: Option<GetPromoStateResponseAppliedCode>,
    pub bonus_tokens_balance: i64,
    /// Codes this tenant OWNS (it is the referrer), with their reward totals. Empty for everyone
    /// else.
    pub owned_codes: Vec<GetPromoStateResponseOwnedCode>,
}

/// `GetPromoStateResponseAppliedCode` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPromoStateResponseAppliedCode {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub redeemed_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discount_percent: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rewarded: Option<bool>,
}

/// `GetPromoStateResponseOwnedCode` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPromoStateResponseOwnedCode {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uses: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_uses: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reward_tokens_per_subscription: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subscriber_bonus_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discount_percent: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_rewarded_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rewarded_subscriptions: Option<i64>,
}

/// `GetPublicBlogPostResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPublicBlogPostResponse {
    pub post: PublicBlogPost,
}

/// `GetPublicFeaturedAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPublicFeaturedAgentResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetPublicStateResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPublicStateResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marketplace: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub governance: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branding: Option<serde_json::Map<String, serde_json::Value>>,
    pub category: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
    pub short_description: String,
    pub slug: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub social_links: Option<TenantSocialLinks>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stats: Option<serde_json::Map<String, serde_json::Value>>,
    pub tags: Vec<String>,
    pub tenant_id: String,
    /// Only this route joins the state's agents (public.ts); the list does not carry them.
    pub agents: Vec<PublicStateAgent>,
}

/// `GetReadyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetReadyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<GetReadyResponseStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub checks: Option<GetReadyResponseChecks>,
}

/// `GetReadyResponseChecks` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetReadyResponseChecks {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kv: Option<String>,
}

/// `GetReadyResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetReadyResponseStatus {
    #[default]
    #[serde(rename = "ready")]
    Ready,
    #[serde(rename = "not_ready")]
    NotReady,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetReadyResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Ready => "ready",
            Self::NotReady => "not_ready",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetReadyResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetReadyResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "ready" => Self::Ready,
            "not_ready" => Self::NotReady,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetReconciliationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetReconciliationResponse {
    #[serde(default)]
    pub reconciliation: Option<CostReconciliationResult>,
    pub period: String,
    /// Only when there is no result for the period.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `GetRegistrationStatusResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRegistrationStatusResponse {
    pub registration_open: bool,
}

/// `GetResponseResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetResponseResponse {
    pub id: String,
    pub object: GetResponseResponseObject,
    pub output: Vec<GetResponseResponseOutputItem>,
    pub usage: GetResponseResponseUsage,
    /// The agent id.
    pub model: String,
    /// Unix seconds.
    pub created_at: i64,
}

/// `GetResponseResponseObject` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetResponseResponseObject {
    #[default]
    #[serde(rename = "response")]
    Response,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetResponseResponseObject {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Response => "response",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetResponseResponseObject {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetResponseResponseObject {
    fn from(value: &str) -> Self {
        match value {
            "response" => Self::Response,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetResponseResponseOutputItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetResponseResponseOutputItem {
    pub r#type: ResponsesOutputItemType,
    pub role: OpenAiChatCompletionChoiceMessageRole,
    pub content: Vec<GetResponseResponseOutputItemContentItem>,
}

/// `GetResponseResponseOutputItemContentItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetResponseResponseOutputItemContentItem {
    pub r#type: ResponsesOutputItemContentItemType,
    pub text: String,
}

/// `GetResponseResponseUsage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetResponseResponseUsage {
    pub input_tokens: i64,
    pub output_tokens: i64,
    pub total_tokens: i64,
}

/// `GetRootAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRootAgentResponse {
    /// Designated root agent, or null when none is set.
    #[serde(default)]
    pub root_agent_id: Option<String>,
}

/// `GetRunAuditLogResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunAuditLogResponse {
    pub run_id: String,
    pub audit_log: Vec<AuditLogEntry>,
    pub total: i64,
}

/// `GetRunChangedFiles` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetRunChangedFiles {
    #[default]
    #[serde(rename = "true")]
    True,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetRunChangedFiles {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::True => "true",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetRunChangedFiles {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetRunChangedFiles {
    fn from(value: &str) -> Self {
        match value {
            "true" => Self::True,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetRunQueuePositionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunQueuePositionResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    /// 0 means not in queue or currently running
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_position: Option<i64>,
}

/// `GetRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunResponse {
    /// Absent for platform-dispatched cloud runs. `bridge` is written by the platform when a local
    /// agent takes the run (run-dispatch.ts, bridge.ts); `async` is only ever an echo of a
    /// client-supplied value and has never been stored on production (measured 2026-09-10 over 8605
    /// run records: absent 7738, bridge 867, async 0).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_mode: Option<RunExecutionMode>,
    pub run_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    pub status: RunStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    /// Run output — the same object rides in run events and in a public session's stream
    /// (RunOutput). When a run is truncated by its step-budget cutoff (output.truncated === true)
    /// AND the platform has UARP_CONTINUATION_TOKEN_KEY configured, output.continuation_token
    /// carries an opaque HMAC-signed token that resumes the run via POST /runs/{id}/continue. With
    /// no key configured no token is minted and the field is absent; the token is an opaque string
    /// to every client.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<RunOutput>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<RunMetrics>,
    /// The sentence a person reads. English on every deployment — nothing here varies by
    /// `Accept-Language` — so branch on `error_code`, not on this.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /// Why the run failed, as a value from the `code` dictionary (see the `Error` schema's enum).
    /// Absent when the failure carries nothing a client can branch on — which is deliberate: a code
    /// meaning "something went wrong" would be worse than none. Populated since 2026-09-21; before
    /// that a client had to regex-test `error`. `approval_rejected` (since 2026-09-22) means a
    /// person refused the tool call the run was waiting on — `status` is still `failed`, and
    /// `error` is the reviewer's own reason.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_code: Option<String>,
    /// Numbers the code cannot carry: `retry_after_ms` with `provider_circuit_open`,
    /// `quota_exhausted` with `provider_rate_limited`, `stale_seconds` with `run_input_timeout`.
    /// Never a provider id — this reaches a screen, and the product does not name the model it
    /// picked.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_details: Option<serde_json::Map<String, serde_json::Value>>,
    /// Every human decision on a tool approval this run waited for, oldest first. Absent when the
    /// run never waited for one. Recorded since 2026-09-22; before that an approved call left no
    /// trace on the run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approvals: Option<Vec<GetRunResponseApproval>>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub started_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
    /// Team run ID if part of a team execution
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_run_id: Option<String>,
    /// User-supplied metadata
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    /// Current step sequence number
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub step_seq: Option<i64>,
    /// Run artifacts
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub artifacts: Option<Vec<Artifact>>,
    /// Resource limits for the run
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<GetRunResponseResourceLimits>,
    /// Workspace paths this run WROTE, sorted, present only when the request carries
    /// `?changed_files=true`. Recorded per (run, path) at write time, so a file rewritten three
    /// times appears once and two concurrent tool calls cannot lose one another's entry.
    ///
    /// It is a record of writes, not a diff: a path the run DELETED or moved is not here, and
    /// neither is a change made by something else while the run was going. Recording is best-effort
    /// after the write has already succeeded — a failure to record is logged and leaves the list
    /// short rather than failing the edit — so treat it as "at least these" rather than proof that
    /// nothing else changed. Capped at 500 paths. Rows expire 30 days after the run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub changed_files: Option<Vec<String>>,
    /// Tool calls the run is blocked on, taken from the most recent `run.awaiting_approval` event.
    /// ABSENT — not empty — when the run is not awaiting approval, and absent too if the scan
    /// fails, which is deliberate: a failed scan must not turn a readable run into an error.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pending_approvals: Option<Vec<PendingApproval>>,
    /// The question the run is blocked on, taken from the most recent `run.awaiting_input` event
    /// (runs.ts:673-681). Like `pending_approvals` it is ABSENT rather than empty when the run is
    /// not awaiting input. A squad chat reads this to render the prompt; the document never
    /// mentioned it, so a client written from the document alone showed a blocked run as merely
    /// running.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pending_input: Option<GetRunResponsePendingInput>,
}

/// `GetRunResponseApproval` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunResponseApproval {
    pub decision: RunApprovalDecision,
    /// Tools the run was waiting on when the decision was made.
    pub tools: Vec<String>,
    pub decided_at: String,
    /// User id of the person who decided; the credential id when no person stands behind it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decided_by: Option<String>,
    /// The reviewer's reason, on a rejection.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// The question the run is blocked on, taken from the most recent `run.awaiting_input` event
/// (runs.ts:673-681). Like `pending_approvals` it is ABSENT rather than empty when the run is
/// not awaiting input. A squad chat reads this to render the prompt; the document never
/// mentioned it, so a client written from the document alone showed a blocked run as merely
/// running.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunResponsePendingInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_call_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<String>>,
}

/// Resource limits for the run
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunResponseResourceLimits {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_steps: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tool_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens_per_run: Option<i64>,
}

/// `GetRunStepsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRunStepsResponse {
    pub steps: Vec<RunStep>,
    pub total: i64,
}

/// `GetRuntimeConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetRuntimeConfigResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runtime: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetSessionAuditLogResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetSessionAuditLogResponse {
    pub session_id: String,
    pub audit_log: Vec<AuditLogEntry>,
    pub total: i64,
}

/// `GetSessionMessagesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetSessionMessagesResponse {
    /// The transcript; the key clients read first. `items` is the Wave 7.2 list alias of the same
    /// array.
    pub messages: Vec<ConversationEntry>,
    /// The same list as `messages` — the canonical list key (Wave 7.2); both are served so no
    /// client moves.
    pub items: Vec<ConversationEntry>,
    pub total: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_run_status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_run_partial_content: Option<String>,
}

/// `GetSessionShareResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetSessionShareResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub share_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
}

/// `GetSquadChatHistoryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetSquadChatHistoryResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_history: Option<Vec<TeamChatTurn>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chat_state: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetSquadGraphResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetSquadGraphResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nodes: Option<Vec<TeamGraphNode>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edges: Option<Vec<TeamGraphEdge>>,
}

/// `GetSquadRunMessagesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetSquadRunMessagesResponse {
    pub team_id: String,
    pub team_run_id: String,
    pub messages: Vec<TeamRunChatTurn>,
    pub protocol_messages: Vec<TeamMessage>,
    pub total: i64,
}

/// `GetTeamChatHistoryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetTeamChatHistoryResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_history: Option<Vec<TeamChatTurn>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chat_state: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetTeamGraphResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetTeamGraphResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nodes: Option<Vec<TeamGraphNode>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edges: Option<Vec<TeamGraphEdge>>,
}

/// `GetTeamRunMessagesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetTeamRunMessagesResponse {
    pub team_id: String,
    pub team_run_id: String,
    pub messages: Vec<TeamRunChatTurn>,
    pub protocol_messages: Vec<TeamMessage>,
    pub total: i64,
}

/// `GetTenantDomainHealthResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetTenantDomainHealthResponse {
    /// Hostname only — no scheme, no path.
    pub domain: String,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dns: Option<DomainDnsLifecycle>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<DomainCertLifecycle>,
}

/// `GetTenantUsageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetTenantUsageResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub period: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `GetUnreadCountResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetUnreadCountResponse {
    pub count: i64,
    pub unread_count: i64,
    /// Deprecated spelling of `unread_count` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `unread_count`.
    #[serde(rename = "unreadCount")]
    pub unread_count_: i64,
}

/// `GetUsageTimeseriesMetric` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetUsageTimeseriesMetric {
    #[default]
    #[serde(rename = "runs")]
    Runs,
    #[serde(rename = "tokens")]
    Tokens,
    #[serde(rename = "cost")]
    Cost,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GetUsageTimeseriesMetric {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Runs => "runs",
            Self::Tokens => "tokens",
            Self::Cost => "cost",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GetUsageTimeseriesMetric {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetUsageTimeseriesMetric {
    fn from(value: &str) -> Self {
        match value {
            "runs" => Self::Runs,
            "tokens" => Self::Tokens,
            "cost" => Self::Cost,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GetUsageTimeseriesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetUsageTimeseriesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<Vec<GetUsageTimeseriesResponseDataItem>>,
}

/// `GetUsageTimeseriesResponseDataItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetUsageTimeseriesResponseDataItem {
    /// The bucket's label — `M/D` in UTC without padding (`8/28`), not a date or an instant
    /// (usage-tracker.ts getTimeseries; measured 2026-09-10). Do not parse it as a Date.
    pub label: String,
    pub value: f64,
}

/// `Goal` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Goal {
    pub goal_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
    /// How the goal squares with the constitution — written by the formulating agent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub alignment_justification: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expected_impact: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_estimate_usd: Option<f64>,
    pub status: GoalStatus,
    /// Set once the goal reaches a vote. Absent before that.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub proposal_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub constitution_check_passed: Option<bool>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `GoalStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GoalStatus {
    #[default]
    #[serde(rename = "proposed")]
    Proposed,
    #[serde(rename = "checking")]
    Checking,
    #[serde(rename = "voting")]
    Voting,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "rejected")]
    Rejected,
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "completed")]
    Completed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GoalStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Proposed => "proposed",
            Self::Checking => "checking",
            Self::Voting => "voting",
            Self::Approved => "approved",
            Self::Rejected => "rejected",
            Self::Active => "active",
            Self::Completed => "completed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GoalStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GoalStatus {
    fn from(value: &str) -> Self {
        match value {
            "proposed" => Self::Proposed,
            "checking" => Self::Checking,
            "voting" => Self::Voting,
            "approved" => Self::Approved,
            "rejected" => Self::Rejected,
            "active" => Self::Active,
            "completed" => Self::Completed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GoogleOneTapAuthRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GoogleOneTapAuthRequest {
    /// Google-signed JWT delivered by `google.accounts.id` to the GSI callback.
    pub credential: String,
    /// Optional device name surfaced on the minted api_key for `/me/sessions`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_label: Option<String>,
}

/// `GoogleOneTapAuthResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GoogleOneTapAuthResponse {
    pub api_key: String,
    pub email: String,
}

/// `GovernanceLedgerEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GovernanceLedgerEntry {
    /// Position in the ONE global chain shared by all tenants — not a per-tenant sequence.
    /// Consecutive rows in a tenant's page usually have gaps here; the missing numbers are other
    /// tenants' entries (see the /governance/ledger description). For the tenant's own count use
    /// `tenant_total` on the list response.
    pub seq: i64,
    /// What happened, e.g. `run_complete`, `constitution_amended`.
    pub action: String,
    /// Coarse grouping, e.g. `execution`, `governance`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    /// Action-specific detail; shape varies by `action`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub payload: Option<serde_json::Map<String, serde_json::Value>>,
    pub timestamp: String,
    /// Hash of the preceding entry. Null only for the genesis entry.
    #[serde(default)]
    pub prev_hash: Option<String>,
    pub hash: String,
}

/// `GovernanceLedgerHead` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GovernanceLedgerHead {
    /// Global sequence of the newest ledger entry across ALL tenants — not the newest entry in the
    /// accompanying page. Measured 2026-08-20: `head.seq` was 6698 while the last visible entry was
    /// 6697, and the gap is another tenant's row. A client must not use this to decide whether it
    /// holds the latest page.
    pub seq: i64,
    pub hash: String,
}

/// A webhook called before or after a run to allow, redact or block it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Guardrail {
    pub guardrail_id: String,
    pub tenant_id: String,
    pub name: String,
    pub webhook_url: String,
    pub phase: GuardrailConfigItemPhase,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<GuardrailAction>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

/// `GuardrailAction` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GuardrailAction {
    #[default]
    #[serde(rename = "block")]
    Block,
    #[serde(rename = "redact")]
    Redact,
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "log")]
    Log,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GuardrailAction {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Block => "block",
            Self::Redact => "redact",
            Self::Warn => "warn",
            Self::Log => "log",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GuardrailAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GuardrailAction {
    fn from(value: &str) -> Self {
        match value {
            "block" => Self::Block,
            "redact" => Self::Redact,
            "warn" => Self::Warn,
            "log" => Self::Log,
            other => Self::Other(other.to_string()),
        }
    }
}

/// admin-config.ts GuardrailConfigItem.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GuardrailConfigItem {
    pub id: String,
    pub name: String,
    pub description: String,
    pub phase: GuardrailConfigItemPhase,
    pub default_action: GuardrailConfigItemDefaultAction,
    pub enabled: bool,
    pub mandatory: bool,
    pub source: GuardrailConfigItemSource,
}

/// `GuardrailConfigItemDefaultAction` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GuardrailConfigItemDefaultAction {
    #[default]
    #[serde(rename = "block")]
    Block,
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "redact")]
    Redact,
    #[serde(rename = "log")]
    Log,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GuardrailConfigItemDefaultAction {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Block => "block",
            Self::Warn => "warn",
            Self::Redact => "redact",
            Self::Log => "log",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GuardrailConfigItemDefaultAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GuardrailConfigItemDefaultAction {
    fn from(value: &str) -> Self {
        match value {
            "block" => Self::Block,
            "warn" => Self::Warn,
            "redact" => Self::Redact,
            "log" => Self::Log,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GuardrailConfigItemPhase` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GuardrailConfigItemPhase {
    #[default]
    #[serde(rename = "input")]
    Input,
    #[serde(rename = "output")]
    Output,
    #[serde(rename = "both")]
    Both,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GuardrailConfigItemPhase {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Input => "input",
            Self::Output => "output",
            Self::Both => "both",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GuardrailConfigItemPhase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GuardrailConfigItemPhase {
    fn from(value: &str) -> Self {
        match value {
            "input" => Self::Input,
            "output" => Self::Output,
            "both" => Self::Both,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `GuardrailConfigItemSource` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GuardrailConfigItemSource {
    #[default]
    #[serde(rename = "kv")]
    Kv,
    #[serde(rename = "default")]
    Default,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl GuardrailConfigItemSource {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Kv => "kv",
            Self::Default => "default",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for GuardrailConfigItemSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GuardrailConfigItemSource {
    fn from(value: &str) -> Self {
        match value {
            "kv" => Self::Kv,
            "default" => Self::Default,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `HandleStripeWebhookRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HandleStripeWebhookRequest {
    pub r#type: String,
    pub data: serde_json::Map<String, serde_json::Value>,
}

/// `HandleStripeWebhookResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HandleStripeWebhookResponse {
    pub received: bool,
    pub handled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duplicate: Option<bool>,
}

/// `HealthCheckV1aliasResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HealthCheckV1aliasResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<GetHealthResponseStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kv_connected: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uptime_seconds: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub build_sha: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pending_resumes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs_queued: Option<i64>,
}

/// `HealthLiveResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HealthLiveResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `HealthzAliasResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HealthzAliasResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `HostDroplet` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct HostDroplet {
    pub id: i64,
    pub name: String,
    pub status: String,
    pub region: String,
    pub size_slug: String,
    pub price_monthly_usd: f64,
    pub price_hourly_usd: f64,
    pub memory_mb: i64,
    pub vcpus: i64,
    pub disk_gb: i64,
    pub created_at: String,
}

/// `ImageProviderList` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImageProviderList {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<Vec<MediaProvider>>,
}

/// audit/immutable-audit-log.ts AuditEvent — an HMAC-chained record; `hmac` absent when
/// UARP_AUDIT_HMAC_KEY is unset.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImmutableAuditEvent {
    pub event_id: String,
    pub timestamp: String,
    pub tenant_id: String,
    pub actor_agent_id: String,
    pub event_type: ImmutableAuditEventEventType,
    pub details: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prev_hmac: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hmac: Option<String>,
}

/// `ImmutableAuditEventEventType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ImmutableAuditEventEventType {
    #[default]
    #[serde(rename = "agent.created")]
    AgentCreated,
    #[serde(rename = "agent.updated")]
    AgentUpdated,
    #[serde(rename = "agent.terminated")]
    AgentTerminated,
    #[serde(rename = "agent.deposed")]
    AgentDeposed,
    #[serde(rename = "run.started")]
    RunStarted,
    #[serde(rename = "run.completed")]
    RunCompleted,
    #[serde(rename = "run.failed")]
    RunFailed,
    #[serde(rename = "tool.denied")]
    ToolDenied,
    #[serde(rename = "security.self_escalation_blocked")]
    SecuritySelfEscalationBlocked,
    #[serde(rename = "security.opcon_violation")]
    SecurityOpconViolation,
    #[serde(rename = "security.immutable_field_blocked")]
    SecurityImmutableFieldBlocked,
    #[serde(rename = "security.rate_limited")]
    SecurityRateLimited,
    #[serde(rename = "dag.created")]
    DagCreated,
    #[serde(rename = "dag.step_completed")]
    DagStepCompleted,
    #[serde(rename = "dag.cancelled")]
    DagCancelled,
    #[serde(rename = "budget.transfer")]
    BudgetTransfer,
    #[serde(rename = "budget.exceeded")]
    BudgetExceeded,
    #[serde(rename = "cascade.failure")]
    CascadeFailure,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ImmutableAuditEventEventType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::AgentCreated => "agent.created",
            Self::AgentUpdated => "agent.updated",
            Self::AgentTerminated => "agent.terminated",
            Self::AgentDeposed => "agent.deposed",
            Self::RunStarted => "run.started",
            Self::RunCompleted => "run.completed",
            Self::RunFailed => "run.failed",
            Self::ToolDenied => "tool.denied",
            Self::SecuritySelfEscalationBlocked => "security.self_escalation_blocked",
            Self::SecurityOpconViolation => "security.opcon_violation",
            Self::SecurityImmutableFieldBlocked => "security.immutable_field_blocked",
            Self::SecurityRateLimited => "security.rate_limited",
            Self::DagCreated => "dag.created",
            Self::DagStepCompleted => "dag.step_completed",
            Self::DagCancelled => "dag.cancelled",
            Self::BudgetTransfer => "budget.transfer",
            Self::BudgetExceeded => "budget.exceeded",
            Self::CascadeFailure => "cascade.failure",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ImmutableAuditEventEventType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ImmutableAuditEventEventType {
    fn from(value: &str) -> Self {
        match value {
            "agent.created" => Self::AgentCreated,
            "agent.updated" => Self::AgentUpdated,
            "agent.terminated" => Self::AgentTerminated,
            "agent.deposed" => Self::AgentDeposed,
            "run.started" => Self::RunStarted,
            "run.completed" => Self::RunCompleted,
            "run.failed" => Self::RunFailed,
            "tool.denied" => Self::ToolDenied,
            "security.self_escalation_blocked" => Self::SecuritySelfEscalationBlocked,
            "security.opcon_violation" => Self::SecurityOpconViolation,
            "security.immutable_field_blocked" => Self::SecurityImmutableFieldBlocked,
            "security.rate_limited" => Self::SecurityRateLimited,
            "dag.created" => Self::DagCreated,
            "dag.step_completed" => Self::DagStepCompleted,
            "dag.cancelled" => Self::DagCancelled,
            "budget.transfer" => Self::BudgetTransfer,
            "budget.exceeded" => Self::BudgetExceeded,
            "cascade.failure" => Self::CascadeFailure,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ImportAdminConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportAdminConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    pub sections: serde_json::Map<String, serde_json::Value>,
}

/// `ImportAdminConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportAdminConfigResponse {
    pub imported: bool,
    pub applied: Vec<String>,
    pub skipped: Vec<String>,
    pub applied_count: i64,
    pub skipped_count: i64,
}

/// `ImportAgentMemoryRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportAgentMemoryRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<MemoryImportEntry>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agents: Option<Vec<ImportAgentMemoryRequestAgent>>,
}

/// `ImportAgentMemoryRequestAgent` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportAgentMemoryRequestAgent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    pub entries: Vec<MemoryImportEntry>,
}

/// `ImportAgentMemoryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportAgentMemoryResponse {
    pub imported: bool,
    pub agent_id: String,
    /// Entries in the file.
    pub offered: i64,
    /// New entries stored.
    pub added: i64,
    /// Entries the store already had.
    pub duplicates: i64,
}

/// `ImportDataExplorerRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportDataExplorerRequest {
    pub file: FilePart,
}

/// `ImportDataExplorerResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImportDataExplorerResponse {
    pub success: bool,
    pub imported: i64,
    pub skipped: i64,
    /// Rows refused because the read path would refuse them too — sensitive keys, and anything
    /// under the `__keys__` namespace auth authenticates against.
    pub refused_sensitive: i64,
    pub errors: Vec<String>,
    pub total_lines: i64,
}

/// Self-improvement proposal — multi-stage state machine (proposed → arbiter_review → voting →
/// sandbox_testing → approved → applied | rejected at any step).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ImprovementProposal {
    pub proposal_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    /// Was declared `string` here while the record has always carried a number.
    pub version: i64,
    pub r#type: ImprovementProposalType,
    /// The proposal's heading. Undeclared until now, so a client built from this document rendered
    /// the card without one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
    /// The failed runs that prompted the proposal.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failed_run_ids: Option<Vec<String>>,
    /// The proposed changes. Declared as `diff` here and stored as `changes`, so a client reading
    /// the documented name found nothing and showed "no diff" over a proposal that had one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub changes: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub baseline_success_rate: Option<f64>,
    /// Present only after the sandbox stage has run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sandbox_success_rate: Option<f64>,
    pub status: ImprovementProposalStatus,
    /// Set once the proposal reaches a vote.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vote_proposal_id: Option<String>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `ImprovementProposalStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ImprovementProposalStatus {
    #[default]
    #[serde(rename = "proposed")]
    Proposed,
    #[serde(rename = "arbiter_review")]
    ArbiterReview,
    #[serde(rename = "voting")]
    Voting,
    #[serde(rename = "sandbox_testing")]
    SandboxTesting,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "applied")]
    Applied,
    #[serde(rename = "rejected")]
    Rejected,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ImprovementProposalStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Proposed => "proposed",
            Self::ArbiterReview => "arbiter_review",
            Self::Voting => "voting",
            Self::SandboxTesting => "sandbox_testing",
            Self::Approved => "approved",
            Self::Applied => "applied",
            Self::Rejected => "rejected",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ImprovementProposalStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ImprovementProposalStatus {
    fn from(value: &str) -> Self {
        match value {
            "proposed" => Self::Proposed,
            "arbiter_review" => Self::ArbiterReview,
            "voting" => Self::Voting,
            "sandbox_testing" => Self::SandboxTesting,
            "approved" => Self::Approved,
            "applied" => Self::Applied,
            "rejected" => Self::Rejected,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ImprovementProposalType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ImprovementProposalType {
    #[default]
    #[serde(rename = "prompt_change")]
    PromptChange,
    #[serde(rename = "tool_addition")]
    ToolAddition,
    #[serde(rename = "tool_removal")]
    ToolRemoval,
    #[serde(rename = "model_change")]
    ModelChange,
    #[serde(rename = "parameter_tuning")]
    ParameterTuning,
    #[serde(rename = "skill_addition")]
    SkillAddition,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ImprovementProposalType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::PromptChange => "prompt_change",
            Self::ToolAddition => "tool_addition",
            Self::ToolRemoval => "tool_removal",
            Self::ModelChange => "model_change",
            Self::ParameterTuning => "parameter_tuning",
            Self::SkillAddition => "skill_addition",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ImprovementProposalType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ImprovementProposalType {
    fn from(value: &str) -> Self {
        match value {
            "prompt_change" => Self::PromptChange,
            "tool_addition" => Self::ToolAddition,
            "tool_removal" => Self::ToolRemoval,
            "model_change" => Self::ModelChange,
            "parameter_tuning" => Self::ParameterTuning,
            "skill_addition" => Self::SkillAddition,
            other => Self::Other(other.to_string()),
        }
    }
}

/// One run waiting on a person, with what it is actually asking rather than just its status.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InboxItem {
    pub id: String,
    pub kind: InboxItemKind,
    pub run_id: String,
    pub agent_id: String,
    pub agent_name: String,
    #[serde(default)]
    pub session_id: Option<String>,
    pub status: String,
    #[serde(default)]
    pub created_at: Option<String>,
    /// One line: the tool being requested, the question, or the error.
    pub summary: String,
    /// Longer body — tool arguments, error detail, question context. Empty string when there is
    /// none.
    pub detail: String,
    /// The agent's own choices, for `input` items. Empty otherwise.
    pub options: Vec<String>,
    /// `approval` items: each tool the run waits on, once, with how many calls named it — the facts
    /// behind `summary` (which is English prose), for a client that says them in its own language.
    /// Absent on other kinds. Since 2026-09-23.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<InboxItemTool>>,
}

/// `InboxItemKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum InboxItemKind {
    #[default]
    #[serde(rename = "approval")]
    Approval,
    #[serde(rename = "input")]
    Input,
    #[serde(rename = "paused")]
    Paused,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl InboxItemKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Approval => "approval",
            Self::Input => "input",
            Self::Paused => "paused",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for InboxItemKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for InboxItemKind {
    fn from(value: &str) -> Self {
        match value {
            "approval" => Self::Approval,
            "input" => Self::Input,
            "paused" => Self::Paused,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `InboxItemTool` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InboxItemTool {
    pub name: String,
    pub count: i64,
}

/// `IngestKbDocumentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IngestKbDocumentRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
}

/// `IngestKbDocumentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IngestKbDocumentResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub document_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chunks_created: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `IngestMemoryRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IngestMemoryRequest {
    /// Pre-uploaded file id (POST /api/v1/files first).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
    /// Inline text body when no file_id is provided. Max 2 MB.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    /// Override stored filename; defaults to file metadata or `created-doc.md`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
    /// Stored on every chunk, before the tags ingest always adds (`document`, the filename,
    /// `chunk:i/n`); a tag in both is kept once.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    /// Server default: `600`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chunk_size: Option<i64>,
}

/// `IngestMemoryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IngestMemoryResponse {
    pub ingested: bool,
    pub filename: String,
    pub text_length: i64,
    pub chunks_created: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
    pub entries: Vec<IngestMemoryResponseEntry>,
}

/// `IngestMemoryResponseEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IngestMemoryResponseEntry {
    pub entry_id: String,
    pub r#type: String,
    pub content_preview: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
}

/// OAuth/API integration record (Slack, GitHub, Linear, etc.).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Integration {
    pub id: String,
    pub tenant_id: String,
    /// Which connector this is: `github`, `slack`, `linear`, …
    pub connector_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Connector settings. Secrets are replaced with `\<redacted\>`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
    /// `active` is what the server sends for a working integration; the documented `connected` was
    /// never emitted.
    pub status: IntegrationStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_sync_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub migrated_at: Option<String>,
    /// Agents allowed to use this integration. Present on the live record and read by 7 files in
    /// the web; the document omitted it, so a generated client could not tell which agents an
    /// integration serves.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_ids: Option<Vec<String>>,
}

/// Available integration (connector) type in the catalog
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IntegrationCatalogItem {
    /// Connector id (e.g. github, stripe, notion, slack)
    pub id: String,
    pub name: String,
    pub description: String,
    pub icon: String,
    pub auth_type: IntegrationCatalogItemAuthType,
    /// Present when the connector authorises through another connector's OAuth provider
    /// (google_calendar, gmail, google_drive and google_sheets all say `google`). A client builds
    /// the authorize URL from this when set, from `id` otherwise. Absent for every other connector.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oauth_provider: Option<String>,
    /// The OAuth scopes the connector needs, so a client can show them BEFORE the visitor clicks
    /// Connect rather than leaving the IdP consent screen to be the first place they are seen.
    /// Absent — not empty — for api_key connectors and for OAuth connectors that declare none.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub required_oauth_scopes: Option<Vec<String>>,
    pub config_schema: HashMap<String, ConnectorConfigField>,
}

/// `IntegrationCatalogItemAuthType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum IntegrationCatalogItemAuthType {
    #[default]
    #[serde(rename = "api_key")]
    APIKey,
    #[serde(rename = "oauth2")]
    Oauth2,
    #[serde(rename = "webhook")]
    Webhook,
    #[serde(rename = "none")]
    None,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl IntegrationCatalogItemAuthType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::APIKey => "api_key",
            Self::Oauth2 => "oauth2",
            Self::Webhook => "webhook",
            Self::None => "none",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for IntegrationCatalogItemAuthType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for IntegrationCatalogItemAuthType {
    fn from(value: &str) -> Self {
        match value {
            "api_key" => Self::APIKey,
            "oauth2" => Self::Oauth2,
            "webhook" => Self::Webhook,
            "none" => Self::None,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `active` is what the server sends for a working integration; the documented `connected` was
/// never emitted.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum IntegrationStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "inactive")]
    Inactive,
    #[serde(rename = "error")]
    Error,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl IntegrationStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Inactive => "inactive",
            Self::Error => "error",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for IntegrationStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for IntegrationStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "inactive" => Self::Inactive,
            "error" => Self::Error,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `InternalVerifyDomainResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InternalVerifyDomainResponse {
    pub ok: bool,
}

/// An invite as an administrator sees it. The accept token (`secret`) is NOT here: it travels
/// in the email link and, for the recipient only, in `GET /me/tenants` `pending_invites`. Until
/// 2026-09-12 the tenant's list, the 201, resend and revoke echoed it, so `users:read` could
/// accept any pending invite of the tenant.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Invite {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invited_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// `InviteUserRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InviteUserRequest {
    pub email: String,
    pub role: String,
}

/// `InviteUserResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InviteUserResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invited_by: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub email_sent: bool,
}

/// `InvokeListingAgentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InvokeListingAgentRequest {
    pub input: serde_json::Map<String, serde_json::Value>,
}

/// `InvokeListingAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct InvokeListingAgentResponse {
    pub error: InvokeListingAgentResponseError,
    pub message: String,
    pub retry_after_seconds: i64,
}

/// `InvokeListingAgentResponseError` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum InvokeListingAgentResponseError {
    #[default]
    #[serde(rename = "Accepted")]
    Accepted,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl InvokeListingAgentResponseError {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Accepted => "Accepted",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for InvokeListingAgentResponseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for InvokeListingAgentResponseError {
    fn from(value: &str) -> Self {
        match value {
            "Accepted" => Self::Accepted,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `IssueArbiterRulingRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IssueArbiterRulingRequest {
    pub decision: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub penalties: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

/// `IssueArbiterRulingResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct IssueArbiterRulingResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// A JSON-RPC 2.0 envelope. Exactly one of `result` and `error` is present.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct JSONRpcResponse {
    pub jsonrpc: JSONRpcResponseJsonrpc,
    #[serde(default)]
    pub id: Option<serde_json::Value>,
    /// Method-specific.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<JSONRpcResponseError>,
}

/// `JSONRpcResponseError` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct JSONRpcResponseError {
    pub code: i64,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_json::Value>,
}

/// `JSONRpcResponseJsonrpc` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum JSONRpcResponseJsonrpc {
    #[default]
    #[serde(rename = "2.0")]
    V20,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl JSONRpcResponseJsonrpc {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::V20 => "2.0",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for JSONRpcResponseJsonrpc {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for JSONRpcResponseJsonrpc {
    fn from(value: &str) -> Self {
        match value {
            "2.0" => Self::V20,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `KnowledgeBase` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBase {
    pub id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// The embedding model recorded on the base: what the caller sent at create, or the
    /// deployment's model; rewritten to the model actually used on every reindex
    /// (knowledge-bases.ts:688).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub embedding_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chunk_size: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chunk_overlap: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub document_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_chunks: Option<i64>,
    /// Deliberately not an enum. The routes write several values for different notions of
    /// readiness, and publishing a guessed list is how a client comes to reject a state the server
    /// legitimately sends. `ready` is the one observed on a healthy base.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attached_agents: Option<Vec<KnowledgeBaseAttachedAgent>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attached_agent_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `KnowledgeBaseAttachedAgent` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBaseAttachedAgent {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// Body for `POST /api/v1/knowledge-bases`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBaseCreate {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Informational only — not a choice. The deployment has one embedding model, set by the
    /// super-admin in `PUT /admin/config/agent-memory`; ingest and search always use it, and `POST
    /// /knowledge-bases/{id}/reindex` overwrites this field with the model actually used. A string
    /// sent here is stored and echoed by GET until the first reindex, then replaced. `PUT
    /// /knowledge-bases/{id}` ignores it. Clients should send nothing (knowledge-bases.ts:395,
    /// :688).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub embedding_model: Option<String>,
}

/// `KnowledgeBaseDocument` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBaseDocument {
    pub id: String,
    pub kb_id: String,
    pub tenant_id: String,
    pub name: String,
    pub r#type: KnowledgeBaseDocumentType,
    pub size_bytes: i64,
    pub chunk_count: i64,
    pub status: KnowledgeBaseDocumentStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_message: Option<String>,
    pub created_at: String,
    pub updated_at: String,
    #[serde(default)]
    pub chunk_preview: Option<String>,
    /// `embedded` when the document's chunks have vectors; `keyword_only` when no embedding
    /// provider answered and the document is searchable by keywords only.
    pub embedding_status: KnowledgeBaseDocumentEmbeddingStatus,
}

/// `embedded` when the document's chunks have vectors; `keyword_only` when no embedding
/// provider answered and the document is searchable by keywords only.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum KnowledgeBaseDocumentEmbeddingStatus {
    #[default]
    #[serde(rename = "embedded")]
    Embedded,
    #[serde(rename = "keyword_only")]
    KeywordOnly,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl KnowledgeBaseDocumentEmbeddingStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Embedded => "embedded",
            Self::KeywordOnly => "keyword_only",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for KnowledgeBaseDocumentEmbeddingStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for KnowledgeBaseDocumentEmbeddingStatus {
    fn from(value: &str) -> Self {
        match value {
            "embedded" => Self::Embedded,
            "keyword_only" => Self::KeywordOnly,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `KnowledgeBaseDocumentStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum KnowledgeBaseDocumentStatus {
    #[default]
    #[serde(rename = "uploading")]
    Uploading,
    #[serde(rename = "processing")]
    Processing,
    #[serde(rename = "ready")]
    Ready,
    #[serde(rename = "error")]
    Error,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl KnowledgeBaseDocumentStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Uploading => "uploading",
            Self::Processing => "processing",
            Self::Ready => "ready",
            Self::Error => "error",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for KnowledgeBaseDocumentStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for KnowledgeBaseDocumentStatus {
    fn from(value: &str) -> Self {
        match value {
            "uploading" => Self::Uploading,
            "processing" => Self::Processing,
            "ready" => Self::Ready,
            "error" => Self::Error,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `KnowledgeBaseDocumentType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum KnowledgeBaseDocumentType {
    #[default]
    #[serde(rename = "pdf")]
    PDF,
    #[serde(rename = "markdown")]
    Markdown,
    #[serde(rename = "csv")]
    CSV,
    #[serde(rename = "html")]
    Html,
    #[serde(rename = "plain")]
    Plain,
    #[serde(rename = "docx")]
    Docx,
    #[serde(rename = "image")]
    Image,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl KnowledgeBaseDocumentType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::PDF => "pdf",
            Self::Markdown => "markdown",
            Self::CSV => "csv",
            Self::Html => "html",
            Self::Plain => "plain",
            Self::Docx => "docx",
            Self::Image => "image",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for KnowledgeBaseDocumentType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for KnowledgeBaseDocumentType {
    fn from(value: &str) -> Self {
        match value {
            "pdf" => Self::PDF,
            "markdown" => Self::Markdown,
            "csv" => Self::CSV,
            "html" => Self::Html,
            "plain" => Self::Plain,
            "docx" => Self::Docx,
            "image" => Self::Image,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `KnowledgeBaseSearchResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBaseSearchResult {
    pub status: KnowledgeBaseSearchResultStatus,
    pub query: String,
    /// Which pass produced the results; null when the knowledge base is empty and neither ran.
    #[serde(default)]
    pub mode: Option<String>,
    pub count: i64,
    pub results: Vec<KnowledgeBaseSearchResultResult>,
}

/// `KnowledgeBaseSearchResultResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBaseSearchResultResult {
    /// 1-based citation number.
    pub index: i64,
    /// Document label, sanitised before it is rendered into a prompt.
    pub source: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    pub text: String,
    pub score: f64,
}

/// `KnowledgeBaseSearchResultStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum KnowledgeBaseSearchResultStatus {
    #[default]
    #[serde(rename = "KB_EMPTY")]
    KbEmpty,
    #[serde(rename = "NO_MATCHES")]
    NoMatches,
    #[serde(rename = "RESULTS_FOUND")]
    ResultsFound,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl KnowledgeBaseSearchResultStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::KbEmpty => "KB_EMPTY",
            Self::NoMatches => "NO_MATCHES",
            Self::ResultsFound => "RESULTS_FOUND",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for KnowledgeBaseSearchResultStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for KnowledgeBaseSearchResultStatus {
    fn from(value: &str) -> Self {
        match value {
            "KB_EMPTY" => Self::KbEmpty,
            "NO_MATCHES" => Self::NoMatches,
            "RESULTS_FOUND" => Self::ResultsFound,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Body for `PUT /api/v1/knowledge-bases/{knowledgeBaseId}`. Every field optional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct KnowledgeBaseUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// bytes, Web super-admin, tenant Snaga Or…, 2026-09-10T22:38:17Z; admin-config.ts
/// LandingConfig, defaults-projected so every key is present.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LandingConfigSection {
    #[serde(default)]
    pub public_agent_id: Option<String>,
    pub texts: HashMap<String, Value>,
    pub multilang_enabled: bool,
    pub default_locale: String,
    pub partners_enabled: bool,
    #[serde(default)]
    pub partners: Option<Vec<LandingConfigSectionPartner>>,
}

/// `LandingConfigSectionPartner` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LandingConfigSectionPartner {
    pub id: String,
    pub name: String,
    pub tagline: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tagline_uk: Option<String>,
    pub href: String,
    pub logo: LandingConfigSectionPartnerLogo,
}

/// `LandingConfigSectionPartnerLogo` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LandingConfigSectionPartnerLogo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

/// Operator-set text and partner logos for the public landing page.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LandingOverrides {
    /// Override key → text. Empty when nothing is overridden.
    pub texts: serde_json::Map<String, serde_json::Value>,
    pub multilang_enabled: bool,
    pub default_locale: String,
    pub partners_enabled: bool,
    /// Null means never configured, which a client may render differently from an empty list.
    #[serde(default)]
    pub partners: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    /// KV versionstamp of the stored record. The admin form sends it back on write so two operators
    /// cannot silently overwrite each other.
    #[serde(default)]
    pub version: Option<String>,
}

/// `LandingStats` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LandingStats {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agents_deployed: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm_providers: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub registered_users: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls_today: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_sessions: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_tokens: Option<i64>,
}

/// `LeaveTenantResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LeaveTenantResponse {
    pub left: bool,
    pub tenant_id: String,
}

/// `LedgerIntegrity` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LedgerIntegrity {
    pub valid: bool,
    pub entries_checked: i64,
    /// Sequence of the first entry that failed verification. Absent when `valid` is true.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_invalid_seq: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    pub checked_at: String,
}

/// `LinkPreview` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LinkPreview {
    pub url: String,
    pub site: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub favicon: Option<String>,
}

/// `ListA2ATasksResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListA2ATasksResponse {
    pub tasks: Vec<A2ATask>,
    /// Offset to pass as `offset` for the next page; absent on the last page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    /// Size of the whole set.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
}

/// `ListAdminBlogPostsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAdminBlogPostsResponse {
    pub posts: Vec<BlogPost>,
}

/// `ListAdminDomainHealthResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAdminDomainHealthResponse {
    pub count: i64,
    pub rows: Vec<ListAdminDomainHealthResponseRow>,
}

/// `ListAdminDomainHealthResponseRow` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAdminDomainHealthResponseRow {
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    pub domain: String,
    pub dns: DomainDnsLifecycle,
    pub cert: DomainCertLifecycle,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `ListAdminIntegrationOAuthProvidersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAdminIntegrationOAuthProvidersResponse {
    pub providers: Vec<ListAdminIntegrationOAuthProvidersResponseProvider>,
}

/// `ListAdminIntegrationOAuthProvidersResponseProvider` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAdminIntegrationOAuthProvidersResponseProvider {
    pub id: String,
    /// A record exists for this provider.
    pub configured: bool,
    /// Enabled AND holding both a client id and a secret — a provider switched on with incomplete
    /// credentials reports false here, so this is readiness rather than the stored flag.
    pub enabled: bool,
}

/// `ListAdminProvidersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAdminProvidersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<Vec<AdminProviderSummary>>,
}

/// `ListAgentBookmarksResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentBookmarksResponse {
    pub items: Vec<AgentBookmark>,
}

/// `ListAgentIntegrationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentIntegrationsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub integrations: Option<Vec<AgentIntegration>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListAgentMailResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentMailResponse {
    pub messages: Vec<AgentMessage>,
    /// Agent id → name, resolved for display. An agent that no longer exists is simply absent.
    pub agent_names: serde_json::Map<String, serde_json::Value>,
    pub total_scanned: i64,
}

/// `ListAgentMCPServersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentMCPServersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub servers: Option<Vec<MCPServer>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListAgentScorersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentScorersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scorers: Option<Vec<AgentScorer>>,
}

/// `ListAgentsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentsResponse {
    pub items: Vec<Agent>,
    /// Opaque cursor for the next page; null when no more pages.
    #[serde(default)]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListAgentVersionsFields` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ListAgentVersionsFields {
    #[default]
    #[serde(rename = "summary")]
    Summary,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ListAgentVersionsFields {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Summary => "summary",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ListAgentVersionsFields {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ListAgentVersionsFields {
    fn from(value: &str) -> Self {
        match value {
            "summary" => Self::Summary,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ListAgentVersionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentVersionsResponse {
    pub items: Vec<AgentVersion>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub versions: Option<Vec<AgentVersion>>,
    /// `items.length` — the snapshots this response carries, which retention caps at the newest 50
    /// (agents.ts, GET /agents/:id/versions). Not a count of everything the agent was ever saved
    /// as, and there is no paging parameter to reach further back.
    pub total: i64,
    /// Present only with `limit`: whether older versions remain — the document's list convention
    /// (/agents, /sessions, /runs, /files answer the same pair).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
    /// Present only with `limit` and only while older versions remain: an opaque string to pass
    /// back as `cursor` for the next page (every cursor in this document is a string; the generated
    /// clients' paging helpers rely on it). Typed integer for one hour in #469 — no client had read
    /// it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

/// `ListAgentWorkspaceFilesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAgentWorkspaceFilesResponse {
    pub workspace_id: String,
    pub path: String,
    pub directories: Vec<String>,
    pub files: Vec<WorkspaceFile>,
}

/// `ListAllContentReportsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAllContentReportsResponse {
    pub items: Vec<ContentReport>,
    #[serde(default)]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListAmbassadorRequestsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAmbassadorRequestsResponse {
    pub requests: Vec<AmbassadorRequest>,
}

/// `ListAmbassadorVetoesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAmbassadorVetoesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vetoes: Option<Vec<VetoRecord>>,
}

/// `ListAndroidTestersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAndroidTestersResponse {
    pub testers: Vec<AndroidTester>,
    pub count: i64,
    pub not_yet_emailed: i64,
    pub given_up: i64,
    #[serde(default)]
    pub cursor: Option<String>,
}

/// `ListAPIKeysResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAPIKeysResponse {
    pub keys: Vec<APIKeySummary>,
    pub total: i64,
}

/// `ListArbiterCasesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListArbiterCasesResponse {
    pub cases: Vec<ArbiterCase>,
}

/// `ListAuthProvidersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAuthProvidersResponse {
    pub items: Vec<ListAuthProvidersResponseItem>,
    /// Legacy alias for `items`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<Vec<AuthProvider>>,
}

/// `ListAuthProvidersResponseItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListAuthProvidersResponseItem {
    pub id: ListAuthProvidersResponseItemId,
    pub linked: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sub: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub linked_at: Option<String>,
}

/// `ListAuthProvidersResponseItemId` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ListAuthProvidersResponseItemId {
    #[default]
    #[serde(rename = "otp")]
    Otp,
    #[serde(rename = "github")]
    Github,
    #[serde(rename = "google")]
    Google,
    #[serde(rename = "apple")]
    Apple,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ListAuthProvidersResponseItemId {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Otp => "otp",
            Self::Github => "github",
            Self::Google => "google",
            Self::Apple => "apple",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ListAuthProvidersResponseItemId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ListAuthProvidersResponseItemId {
    fn from(value: &str) -> Self {
        match value {
            "otp" => Self::Otp,
            "github" => Self::Github,
            "google" => Self::Google,
            "apple" => Self::Apple,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ListBallotsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListBallotsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ballots: Option<Vec<Ballot>>,
}

/// `ListBillingPlansResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListBillingPlansResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plans: Option<Vec<ListBillingPlansResponsePlan>>,
}

/// `ListBillingPlansResponsePlan` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListBillingPlansResponsePlan {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub checkout_available: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_amount_cents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_currency: Option<String>,
}

/// `ListBillingSpecPackagesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListBillingSpecPackagesResponse {
    pub packages: Vec<serde_json::Map<String, serde_json::Value>>,
}

/// `ListBuilderRequestsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListBuilderRequestsResponse {
    pub requests: Vec<DesignRequest>,
}

/// `ListCompaniesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListCompaniesResponse {
    pub items: Vec<Company>,
    /// Opaque cursor for the next page; null on the last page.
    #[serde(default)]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListContentReportsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListContentReportsResponse {
    pub items: Vec<ContentReport>,
    #[serde(default)]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListCoreMemoryBlocksResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListCoreMemoryBlocksResponse {
    /// Whether the runtime injects these blocks (`core_memory.enabled`).
    pub enabled: bool,
    pub blocks: Vec<CoreMemoryBlock>,
    pub total: i64,
}

/// `ListCustomPlansResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListCustomPlansResponse {
    pub plans: Vec<CustomPlan>,
    pub count: i64,
}

/// `ListDataExplorerKeysResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListDataExplorerKeysResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub keys: Option<Vec<DataExplorerKey>>,
    /// Opaque cursor for the next page; null on the last page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
}

/// `ListDataExplorerNamespacesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListDataExplorerNamespacesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespaces: Option<Vec<DataExplorerNamespace>>,
}

/// `ListDatasetsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListDatasetsResponse {
    pub datasets: Vec<EvalDataset>,
    pub total: i64,
}

/// `ListDrawingOpsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListDrawingOpsResponse {
    pub items: Vec<DrawingJournalEntry>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    pub has_more: bool,
    pub seq: i64,
}

/// `ListEvalRunsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListEvalRunsResponse {
    pub eval_runs: Vec<EvalRun>,
    pub total: i64,
}

/// `ListExperimentsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListExperimentsResponse {
    pub experiments: Vec<Experiment>,
    pub total: i64,
}

/// `ListFeaturedSpecsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListFeaturedSpecsResponse {
    pub featured: Vec<String>,
}

/// `ListFeedbackResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListFeedbackResponse {
    pub reports: Vec<ErrorReport>,
    pub count: i64,
    pub new_count: i64,
}

/// `ListFilesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListFilesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<FileEntry>>,
    /// Opaque cursor for the next page; null when no more pages.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
}

/// `ListGoalsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListGoalsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goals: Option<Vec<Goal>>,
}

/// `ListGuardrailsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListGuardrailsResponse {
    pub guardrails: Vec<Guardrail>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListIntegrationsCatalogResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListIntegrationsCatalogResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub connectors: Option<Vec<IntegrationCatalogItem>>,
}

/// `ListIntegrationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListIntegrationsResponse {
    pub integrations: Vec<Integration>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListInvitesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListInvitesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<Invite>>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invites: Option<Vec<Invite>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListKbDocumentsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListKbDocumentsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub documents: Option<Vec<KnowledgeBaseDocument>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListKnowledgeBasesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListKnowledgeBasesResponse {
    pub items: Vec<KnowledgeBase>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_bases: Option<Vec<KnowledgeBase>>,
    pub total: i64,
}

/// `ListLLMCredentialsProvidersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListLLMCredentialsProvidersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<Vec<ListLLMCredentialsProvidersResponseProvider>>,
}

/// `ListLLMCredentialsProvidersResponseProvider` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListLLMCredentialsProvidersResponseProvider {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Display name for UI (e.g. OpenAI, Stels)
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub local: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_endpoint: Option<String>,
}

/// `ListLLMModelsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListLLMModelsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub models: Option<Vec<LLMModel>>,
}

/// `ListMCPServersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMCPServersResponse {
    pub servers: Vec<MCPServer>,
}

/// `ListMemoriesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMemoriesResponse {
    pub memories: Vec<MemoryEntry>,
    pub total: i64,
}

/// `ListMeSessionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMeSessionsResponse {
    pub items: Vec<ActiveSession>,
    /// Legacy alias for `items`, byte-identical to it on the wire. It was described as a formless
    /// array while `items` carried the full shape, so a generated client saw one usable list and
    /// one bag of JSON for the same data.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sessions: Option<Vec<ActiveSession>>,
    pub total: i64,
}

/// `ListMissionObjectivesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMissionObjectivesResponse {
    pub items: Vec<Objective>,
    pub total: i64,
}

/// `ListMissionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMissionsResponse {
    pub items: Vec<Mission>,
    /// Length of `items` in this response, not a tenant-wide count.
    pub total: i64,
}

/// `ListModelsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListModelsResponse {
    /// Always `list`.
    pub object: String,
    pub data: Vec<ListModelsResponseDataItem>,
}

/// `ListModelsResponseDataItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListModelsResponseDataItem {
    pub id: String,
    /// Always `model`.
    pub object: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub owned_by: Option<String>,
}

/// `ListMyTenantsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMyTenantsResponse {
    pub user_id: String,
    pub email: String,
    pub memberships: Vec<ListMyTenantsResponseMembership>,
    pub pending_invites: Vec<ListMyTenantsResponsePendingInvite>,
}

/// `ListMyTenantsResponseMembership` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMyTenantsResponseMembership {
    pub tenant_id: String,
    pub user_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    pub role: String,
    pub is_sole_owner: bool,
    pub member_count: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub joined_at: Option<String>,
    /// Whether THIS credential can act in this tenant — its own tenant, or one an `X-Active-Tenant`
    /// override would be accepted for. The list is the PERSON's memberships and a credential may
    /// reach fewer of them: an api-key whose user has no record in the key's own tenant is refused
    /// everywhere but home. Without this field a client had to guess by matching `/me`.tenant.slug
    /// against the list. Describes the header only — `POST /me/tenants/switch` refuses every
    /// api-key regardless.
    pub accessible: bool,
}

/// `ListMyTenantsResponsePendingInvite` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMyTenantsResponsePendingInvite {
    pub invite_id: String,
    pub tenant_id: String,
    pub tenant_name: String,
    pub role: String,
    pub expires_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invited_by_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret: Option<String>,
}

/// `ListNotificationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListNotificationsResponse {
    pub notifications: Vec<Notification>,
}

/// `ListNotificationTargetsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListNotificationTargetsResponse {
    pub targets: Vec<NotificationTarget>,
}

/// `ListPlaygroundTemplatesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPlaygroundTemplatesResponse {
    pub templates: Vec<PlaygroundTemplate>,
}

/// `ListProgramsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListProgramsResponse {
    pub programs: Vec<Program>,
}

/// `ListProjectsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListProjectsResponse {
    pub items: Vec<Project>,
    pub total: i64,
    pub archived_count: i64,
}

/// `ListPromoCodesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPromoCodesResponse {
    pub codes: Vec<PromoCode>,
    pub count: i64,
}

/// `ListPromoRewardsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPromoRewardsResponse {
    pub rewards: Vec<ListPromoRewardsResponseReward>,
    pub count: i64,
}

/// `ListPromoRewardsResponseReward` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPromoRewardsResponseReward {
    pub code: String,
    pub owner_tenant_id: String,
    pub subscriber_tenant_id: String,
    pub tokens: i64,
    pub plan_id: String,
    pub granted_at: String,
}

/// `ListProviderModelsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListProviderModelsResponse {
    /// Registered provider id (admin → Providers).
    pub provider: String,
    /// Base URL for this provider's API (e.g. <https://api.openai.com/v1>). Empty for custom.
    pub endpoint_url: String,
    pub models: Vec<ListProviderModelsResponseModel>,
    /// Present when models could not be fetched (e.g. provider not configured).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `ListProviderModelsResponseModel` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListProviderModelsResponseModel {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `ListProvidersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListProvidersResponse {
    pub providers: Vec<LLMProvider>,
}

/// `ListPublicBlogPostsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicBlogPostsResponse {
    pub blog: ListPublicBlogPostsResponseBlog,
    pub posts: Vec<PublicBlogPostSummary>,
    pub all_tags: Vec<String>,
    pub total: i64,
    pub page: i64,
    pub limit: i64,
    pub total_pages: i64,
}

/// `ListPublicBlogPostsResponseBlog` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicBlogPostsResponseBlog {
    pub title: String,
    pub description: String,
}

/// `ListPublicIntegrationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicIntegrationsResponse {
    pub connectors: Vec<ListPublicIntegrationsResponseConnector>,
    pub total: i64,
    /// Counted here rather than by the caller: a total a page derives is a total a page can get
    /// wrong, which is the defect this endpoint replaces.
    pub oauth_count: i64,
    pub api_key_count: i64,
}

/// `ListPublicIntegrationsResponseConnector` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicIntegrationsResponseConnector {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    pub auth_type: ListPublicIntegrationsResponseConnectorAuthType,
}

/// `ListPublicIntegrationsResponseConnectorAuthType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ListPublicIntegrationsResponseConnectorAuthType {
    #[default]
    #[serde(rename = "oauth2")]
    Oauth2,
    #[serde(rename = "api_key")]
    APIKey,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ListPublicIntegrationsResponseConnectorAuthType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Oauth2 => "oauth2",
            Self::APIKey => "api_key",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ListPublicIntegrationsResponseConnectorAuthType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ListPublicIntegrationsResponseConnectorAuthType {
    fn from(value: &str) -> Self {
        match value {
            "oauth2" => Self::Oauth2,
            "api_key" => Self::APIKey,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ListPublicPlansResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicPlansResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plans: Option<Vec<PublicPlan>>,
}

/// `ListPublicStatesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicStatesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub states: Option<Vec<PublicState>>,
}

/// `ListPublicTenantsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListPublicTenantsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<PublicTenant>>,
    /// Opaque cursor for the next page; null when no more pages.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListRunArtifactsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListRunArtifactsResponse {
    pub run_id: String,
    pub artifacts: Vec<Artifact>,
    pub total: i64,
}

/// `ListRunCheckpointsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListRunCheckpointsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub checkpoints: Option<Vec<RunCheckpoint>>,
}

/// `ListRunsOrder` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ListRunsOrder {
    #[default]
    #[serde(rename = "asc")]
    Asc,
    #[serde(rename = "desc")]
    Desc,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ListRunsOrder {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Asc => "asc",
            Self::Desc => "desc",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ListRunsOrder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ListRunsOrder {
    fn from(value: &str) -> Self {
        match value {
            "asc" => Self::Asc,
            "desc" => Self::Desc,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ListRunsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListRunsResponse {
    pub items: Vec<Run>,
    /// Opaque cursor for the next page; null on the last page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListSchedulesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSchedulesResponse {
    pub schedules: Vec<ScheduleSummary>,
}

/// `ListSessionAnnotationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionAnnotationsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<ListSessionAnnotationsResponseItem>>,
}

/// `ListSessionAnnotationsResponseItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionAnnotationsResponseItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub author: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolved: Option<bool>,
}

/// `ListSessionArtifactsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionArtifactsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub artifacts: Option<Vec<Artifact>>,
}

/// `ListSessionBranchesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionBranchesResponse {
    pub session_id: String,
    pub branches: Vec<SessionBranch>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_branch: Option<String>,
    pub total: i64,
}

/// `ListSessionDrawingsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionDrawingsResponse {
    pub items: Vec<Drawing>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListSessionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionsResponse {
    pub items: Vec<ListSessionsResponseItem>,
    #[serde(default)]
    pub cursor: Option<String>,
    pub has_more: bool,
}

/// `ListSessionsResponseItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionsResponseItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_by: Option<String>,
    pub session_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    pub status: PublicSessionViewStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_history: Option<Vec<ConversationEntry>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    /// Team ID if session belongs to a team
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    /// Session branches for conversation forking
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branches: Option<Vec<SessionBranch>>,
    /// Currently active branch ID
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_branch: Option<String>,
    /// How to handle concurrent runs in this session
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_mode: Option<SessionQueueMode>,
    /// Per-conversation model override (in-chat model switcher). When set, runs in this session
    /// resolve their LLM from this config instead of the agent's default. Absent → agent default.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_override: Option<ListSessionsResponseItemModelOverride>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_user_message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message_count: Option<i64>,
}

/// Per-conversation model override (in-chat model switcher). When set, runs in this session
/// resolve their LLM from this config instead of the agent's default. Absent → agent default.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionsResponseItemModelOverride {
    pub provider: String,
    pub model_ref: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `ListSessionTodosResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSessionTodosResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<Todo>>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub todos: Option<Vec<Todo>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListSquadGraphEdgesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSquadGraphEdgesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edges: Option<Vec<TeamGraphEdge>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListSquadGraphNodesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSquadGraphNodesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nodes: Option<Vec<TeamGraphNode>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListSquadRunsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSquadRunsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs: Option<Vec<TeamRunSummary>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListSquadsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSquadsResponse {
    pub items: Vec<Team>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub teams: Option<Vec<Team>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListSubscriptionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListSubscriptionsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subscriptions: Option<Vec<MarketplaceSubscription>>,
}

/// `ListTeamGraphEdgesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListTeamGraphEdgesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edges: Option<Vec<TeamGraphEdge>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListTeamGraphNodesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListTeamGraphNodesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nodes: Option<Vec<TeamGraphNode>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListTeamRunsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListTeamRunsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs: Option<Vec<TeamRunSummary>>,
    /// Rows in THIS page, not the total across pages.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
    /// Pass back as `cursor` to continue. Absent on the last page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
}

/// `ListTeamsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListTeamsResponse {
    pub items: Vec<Team>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub teams: Option<Vec<Team>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListTenantsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListTenantsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenants: Option<Vec<Tenant>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListTodosResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListTodosResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub todos: Option<Vec<Todo>>,
}

/// `ListUsersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListUsersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<TenantUser>>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub users: Option<Vec<TenantUser>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListVideoProvidersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListVideoProvidersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<Vec<VideoProvider>>,
}

/// `ListVotingProposalsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListVotingProposalsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub proposals: Option<Vec<VotingProposal>>,
}

/// `ListWebhookDeliveriesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWebhookDeliveriesResponse {
    pub webhook_id: String,
    pub deliveries: Vec<WebhookDeliveryAttempt>,
    pub total: i64,
}

/// `ListWebhooksResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWebhooksResponse {
    pub webhooks: Vec<WebhookSubscription>,
    pub total: i64,
}

/// `ListWorkspaceFileHistoryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWorkspaceFileHistoryResponse {
    /// The `path` as sent, not normalised.
    pub path: String,
    pub versions: Vec<WorkspaceFileVersion>,
    pub total: i64,
}

/// The listing was documented as a description and nothing else, so a client could not learn
/// from the document that `etag` and `updated_at` are served here — the two fields a caller
/// needs to tell whether a file changed without downloading it, and the reason a console had to
/// diff whole workspaces. The projection is explicit in the handler: a field added to the
/// stored record does NOT appear here on its own.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWorkspaceFilesResponse {
    pub workspace_id: String,
    /// The directory listed, empty string for the workspace root.
    pub path: String,
    pub directories: Vec<String>,
    pub files: Vec<ListWorkspaceFilesResponseFile>,
}

/// `ListWorkspaceFilesResponseFile` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWorkspaceFilesResponseFile {
    pub file_id: String,
    pub path: String,
    pub filename: String,
    pub mime_type: String,
    pub size_bytes: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    /// When this file was last written. Absent on records written before the field existed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    /// Opaque version of this file's content. Compare two listings to find what a run changed
    /// without reading any bytes, and send it back as `If-Match` on a write to refuse an overwrite
    /// of something you have not seen. Absent on records written before the field existed — treat
    /// absence as UNKNOWN, not as unchanged.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub etag: Option<String>,
}

/// `ListWorkspacesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWorkspacesResponse {
    pub workspaces: Vec<Workspace>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `ListWorkspaceTrashResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListWorkspaceTrashResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<TrashManifestEntry>>,
}

/// `LLMModel` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMModel {
    pub display_name: String,
    pub id: String,
    pub max_context_tokens: i64,
    pub max_output_tokens: i64,
    pub pricing: serde_json::Map<String, serde_json::Value>,
    pub provider: String,
    pub supports_json_mode: bool,
    pub supports_streaming: bool,
    pub supports_tool_calls: bool,
    pub supports_vision: bool,
    pub tier: String,
}

/// An LLM provider the platform knows about, and whether a key is configured.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMProvider {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub canonical: Option<String>,
    pub configured: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured_level: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_endpoint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api_key_env: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub local: Option<bool>,
}

/// `LLMSynthesizeSpeechRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMSynthesizeSpeechRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    pub input: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub voice: Option<String>,
    /// Passed THROUGH to the configured speech provider unchanged — the platform neither validates
    /// nor translates it, so a rejection here is the provider's, not ours, and its message is the
    /// provider's too. Deliberately not an enum: the accepted set belongs to whichever provider is
    /// configured, and pinning one here would refuse values a future provider accepts. Measured on
    /// production 2026-09-01 by the iOS lane against the current provider: `raw`, `wav` and `mp3`
    /// work; `pcm_s16le` and `pcm_f32le` answer 400. `raw` streams chunked pcm_f32le/44100/mono
    /// with a first byte at roughly 0.4s, which is what progressive playback needs.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response_format: Option<String>,
}

/// `LLMTranscribeAudioRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMTranscribeAudioRequest {
    pub file: FilePart,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// The provider body, byte for byte (llm-proxy.ts handleAudioTranscriptions): `{ text }` for
/// the default `response_format: json`; `verbose_json` adds `task`, `language`, `duration`,
/// `segments`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMTranscribeAudioResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `LLMUsageSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMUsageSummary {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub billing_period: Option<LLMUsageSummaryBillingPeriod>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub by_model: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limits: Option<LLMUsageSummaryLimits>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<LLMUsageSummaryUsage>,
}

/// `LLMUsageSummaryBillingPeriod` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMUsageSummaryBillingPeriod {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start: Option<String>,
}

/// `LLMUsageSummaryLimits` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMUsageSummaryLimits {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_per_day: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_per_hour: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_per_minute: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens_per_month: Option<i64>,
}

/// `LLMUsageSummaryUsage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMUsageSummaryUsage {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_this_hour: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_this_minute: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_today: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens_remaining: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens_used: Option<i64>,
}

/// `LocateMyAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LocateMyAgentResponse {
    pub tenant_id: String,
}

/// `LogoutResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LogoutResponse {
    pub ok: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub already_revoked: Option<bool>,
}

/// `MaintenanceState` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MaintenanceState {
    pub enabled: bool,
    /// Plain text rendered on the blocked page; the API does not render HTML. Absent when no
    /// message is set — a message that trims to empty is not stored.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// When the most recent toggle happened.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled_at: Option<String>,
    /// Empty string for the synthetic default-off state — that state has no author.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled_by_email: Option<String>,
}

/// Whether the platform is closed for maintenance. Unauthenticated: a client that cannot sign
/// in still needs to know why. `message` is plain text and is never rendered as HTML by the
/// API.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MaintenanceStatus {
    pub enabled: bool,
    /// Absent when no message was set.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `MarkAllNotificationsReadResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarkAllNotificationsReadResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marked: Option<i64>,
}

/// `MarketplaceInvocation` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarketplaceInvocation {
    pub invocation_id: String,
    pub caller_tenant_id: String,
    pub publisher_tenant_id: String,
    pub listing_id: String,
    pub agent_id: String,
    pub agent_version: String,
    pub input: serde_json::Map<String, serde_json::Value>,
    pub status: MarketplaceInvocationStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<serde_json::Map<String, serde_json::Value>>,
    /// Set when the run succeeded but the publisher payout failed — not a failed run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revenue_error: Option<String>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
}

/// `MarketplaceInvocationStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MarketplaceInvocationStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "running")]
    Running,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MarketplaceInvocationStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Running => "running",
            Self::Completed => "completed",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MarketplaceInvocationStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MarketplaceInvocationStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "running" => Self::Running,
            "completed" => Self::Completed,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `MarketplaceListing` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarketplaceListing {
    pub listing_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    pub agent_version: String,
    pub name: String,
    pub description: String,
    pub category: MarketplaceListingCategory,
    pub tags: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon_url: Option<String>,
    pub readme: String,
    pub pricing: MarketplaceListingPricing,
    pub stats: MarketplaceListingStats,
    pub status: MarketplaceListingStatus,
    pub a2a_enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program_id: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

/// `MarketplaceListingCategory` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MarketplaceListingCategory {
    #[default]
    #[serde(rename = "coding")]
    Coding,
    #[serde(rename = "writing")]
    Writing,
    #[serde(rename = "research")]
    Research,
    #[serde(rename = "data")]
    Data,
    #[serde(rename = "automation")]
    Automation,
    #[serde(rename = "creative")]
    Creative,
    #[serde(rename = "education")]
    Education,
    #[serde(rename = "business")]
    Business,
    #[serde(rename = "other")]
    Other,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Unknown(String),
}

impl MarketplaceListingCategory {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Coding => "coding",
            Self::Writing => "writing",
            Self::Research => "research",
            Self::Data => "data",
            Self::Automation => "automation",
            Self::Creative => "creative",
            Self::Education => "education",
            Self::Business => "business",
            Self::Other => "other",
            Self::Unknown(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MarketplaceListingCategory {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MarketplaceListingCategory {
    fn from(value: &str) -> Self {
        match value {
            "coding" => Self::Coding,
            "writing" => Self::Writing,
            "research" => Self::Research,
            "data" => Self::Data,
            "automation" => Self::Automation,
            "creative" => Self::Creative,
            "education" => Self::Education,
            "business" => Self::Business,
            "other" => Self::Other,
            other => Self::Unknown(other.to_string()),
        }
    }
}

/// `MarketplaceListingPricing` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarketplaceListingPricing {
    pub model: MarketplaceListingPricingModel,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_per_run_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_per_1k_tokens_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_price_id: Option<String>,
}

/// `MarketplaceListingPricingModel` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MarketplaceListingPricingModel {
    #[default]
    #[serde(rename = "free")]
    Free,
    #[serde(rename = "per_run")]
    PerRun,
    #[serde(rename = "per_token")]
    PerToken,
    #[serde(rename = "subscription")]
    Subscription,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MarketplaceListingPricingModel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Free => "free",
            Self::PerRun => "per_run",
            Self::PerToken => "per_token",
            Self::Subscription => "subscription",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MarketplaceListingPricingModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MarketplaceListingPricingModel {
    fn from(value: &str) -> Self {
        match value {
            "free" => Self::Free,
            "per_run" => Self::PerRun,
            "per_token" => Self::PerToken,
            "subscription" => Self::Subscription,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `MarketplaceListingRating` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarketplaceListingRating {
    pub rating_id: String,
    pub listing_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub rating: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub review: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    pub created_at: String,
}

/// `MarketplaceListingStats` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarketplaceListingStats {
    pub total_runs: i64,
    pub avg_rating: f64,
    pub total_ratings: i64,
    pub avg_latency_ms: f64,
    pub success_rate: f64,
}

/// `MarketplaceListingStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MarketplaceListingStatus {
    #[default]
    #[serde(rename = "draft")]
    Draft,
    #[serde(rename = "published")]
    Published,
    #[serde(rename = "suspended")]
    Suspended,
    #[serde(rename = "archived")]
    Archived,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MarketplaceListingStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Draft => "draft",
            Self::Published => "published",
            Self::Suspended => "suspended",
            Self::Archived => "archived",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MarketplaceListingStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MarketplaceListingStatus {
    fn from(value: &str) -> Self {
        match value {
            "draft" => Self::Draft,
            "published" => Self::Published,
            "suspended" => Self::Suspended,
            "archived" => Self::Archived,
            other => Self::Other(other.to_string()),
        }
    }
}

/// marketplace/listing-store.ts MarketplaceSubscription — on subscribe, `status` is `active`,
/// `stripe_subscription_id` is always present (the route rejects a body without it) and
/// `created_at` equals `updated_at`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarketplaceSubscription {
    pub listing_id: String,
    pub status: MarketplaceSubscriptionStatus,
    /// The Stripe subscription (`sub_…`) the tenant pays through. Written by the bootstrap path and
    /// — since 2026-09-11 — by the subscription webhook (created/updated); cleared when the
    /// subscription is deleted. Absent while the tenant has none, and on tenants whose subscription
    /// arrived before the webhook stored it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_subscription_id: Option<String>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `MarketplaceSubscriptionStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MarketplaceSubscriptionStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "cancelled")]
    Cancelled,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MarketplaceSubscriptionStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Cancelled => "cancelled",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MarketplaceSubscriptionStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MarketplaceSubscriptionStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "cancelled" => Self::Cancelled,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `MarkNotificationReadResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MarkNotificationReadResponse {
    pub ok: bool,
}

/// `MaterializeCanvasSquadRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MaterializeCanvasSquadRequest {
    pub supervisor_agent_id: String,
    /// Defaults to the saved layout's outgoing edges.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub worker_ids: Option<Vec<String>>,
}

/// `MaterializeCanvasSquadResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MaterializeCanvasSquadResponse {
    pub team_id: String,
    pub created: bool,
    pub worker_count: i64,
}

/// `McpjsonRpcRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct McpjsonRpcRequest {
    /// Always `2.0`.
    pub jsonrpc: String,
    pub method: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub params: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<serde_json::Value>,
}

/// An MCP server as returned. `env` and `env_encrypted` are stripped; only the COUNT is
/// disclosed.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MCPServer {
    pub id: String,
    pub name: String,
    pub transport: MCPTransport,
    /// stdio only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// http / streamable_http only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api_key_ref: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth: Option<MCPServerAuth>,
    /// Agents allowed to use this server's tools. Absent or empty means no agent sees them —
    /// installing a server does not connect it. Set it with PUT
    /// /api/v1/agents/{agentId}/mcp-servers, or pass it when installing.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_ids: Option<Vec<String>>,
    /// How many env vars are set. The values are never returned.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub egress_allowlist: Option<Vec<EgressRule>>,
    pub enabled: bool,
    /// Tool names and resource URIs discovered from the server.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<MCPServerStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_synced: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// How an http / streamable_http server is authenticated. The secret itself travels in `env`
/// under `env_key` and is encrypted at rest; it is never returned. Query-string placement is
/// not offered: a key in a URL lands in every proxy log on the way.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MCPServerAuth {
    pub r#type: MCPServerAuthType,
    /// Header carrying the secret. Default `Authorization`. Must be an RFC 9110 field name, and may
    /// not be one the platform sets itself (`Origin`, `Host`, `Content-Type`, `Accept`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub header: Option<String>,
    /// Value prefix. Defaults to `Bearer ` for `Authorization`, empty for any other header.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prefix: Option<String>,
    /// Key inside `env` holding the secret. Default `MCP_API_KEY`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env_key: Option<String>,
}

/// `MCPServerAuthType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MCPServerAuthType {
    #[default]
    #[serde(rename = "none")]
    None,
    #[serde(rename = "api_key")]
    APIKey,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MCPServerAuthType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::None => "none",
            Self::APIKey => "api_key",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MCPServerAuthType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MCPServerAuthType {
    fn from(value: &str) -> Self {
        match value {
            "none" => Self::None,
            "api_key" => Self::APIKey,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `MCPServerStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MCPServerStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "error")]
    Error,
    #[serde(rename = "disabled")]
    Disabled,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MCPServerStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Error => "error",
            Self::Disabled => "disabled",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MCPServerStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MCPServerStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "error" => Self::Error,
            "disabled" => Self::Disabled,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `MCPServerTestResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MCPServerTestResult {
    pub ok: bool,
    /// The MCP session status on success; the literal `error` when the probe failed.
    pub status: String,
    /// Present only when `ok` is true.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_count: Option<i64>,
    /// Present only when `ok` is true.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<MCPTestTool>>,
    /// Present only when `ok` is false.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    pub latency_ms: i64,
}

/// `MCPServerWithConnectResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MCPServerWithConnectResult {
    pub id: String,
    pub name: String,
    pub transport: MCPTransport,
    /// stdio only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// http / streamable_http only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api_key_ref: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth: Option<MCPServerAuth>,
    /// Agents allowed to use this server's tools. Absent or empty means no agent sees them —
    /// installing a server does not connect it. Set it with PUT
    /// /api/v1/agents/{agentId}/mcp-servers, or pass it when installing.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_ids: Option<Vec<String>>,
    /// How many env vars are set. The values are never returned.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub egress_allowlist: Option<Vec<EgressRule>>,
    pub enabled: bool,
    /// Tool names and resource URIs discovered from the server.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<MCPServerStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_synced: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    /// Set when the record saved but the session could not be reconnected. This is the only field
    /// distinguishing 'saved' from 'saved and working', and it arrives on a 200.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub connect_error: Option<String>,
}

/// `MCPTestTool` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MCPTestTool {
    pub name: String,
    pub description: String,
}

/// `stdio` is blocked in production unless UARP_ALLOW_MCP_STDIO=true.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MCPTransport {
    #[default]
    #[serde(rename = "stdio")]
    Stdio,
    #[serde(rename = "http")]
    HTTP,
    #[serde(rename = "streamable_http")]
    StreamableHTTP,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MCPTransport {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Stdio => "stdio",
            Self::HTTP => "http",
            Self::StreamableHTTP => "streamable_http",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MCPTransport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MCPTransport {
    fn from(value: &str) -> Self {
        match value {
            "stdio" => Self::Stdio,
            "http" => Self::HTTP,
            "streamable_http" => Self::StreamableHTTP,
            other => Self::Other(other.to_string()),
        }
    }
}

/// providers.ts listMediaProviders — image and video providers.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MediaProvider {
    pub id: String,
    pub name: String,
    pub configured: bool,
    pub local: bool,
    pub models: Vec<ModelInfo>,
}

/// `MemoryEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MemoryEntry {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub access_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_accessed_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    /// Present on entries written from a run (seen on some e2e-canon entries, absent on others).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_outcome: Option<String>,
    /// Present on entity entries only (e2e-canon).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entity_name: Option<String>,
    /// Present on entity entries only (e2e-canon).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entity_type: Option<String>,
    pub entry_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<MemoryEntryType>,
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub relevance_score: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source_run_id: Option<String>,
}

/// `MemoryEntryType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MemoryEntryType {
    #[default]
    #[serde(rename = "episodic")]
    Episodic,
    #[serde(rename = "semantic")]
    Semantic,
    #[serde(rename = "procedural")]
    Procedural,
    #[serde(rename = "note")]
    Note,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MemoryEntryType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Episodic => "episodic",
            Self::Semantic => "semantic",
            Self::Procedural => "procedural",
            Self::Note => "note",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MemoryEntryType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MemoryEntryType {
    fn from(value: &str) -> Self {
        match value {
            "episodic" => Self::Episodic,
            "semantic" => Self::Semantic,
            "procedural" => Self::Procedural,
            "note" => Self::Note,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `MemoryImportEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MemoryImportEntry {
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

/// POST /auth/mfa/enrol (mfa.ts): the TOTP secret, its otpauth URL and the one-time recovery
/// codes — shown once.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MfaEnrolment {
    pub otpauth_url: String,
    pub secret: String,
    pub recovery_codes: Vec<String>,
}

/// `MintLoginNonceResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MintLoginNonceResponse {
    /// Embed verbatim as the OIDC `nonce` of the next sign-in attempt.
    pub nonce: String,
    /// Seconds the nonce stays valid if unused.
    pub expires_in_s: i64,
}

/// `MintSSETokenResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MintSSETokenResponse {
    /// Bearer-shape API key. Pass as `?token=\<token\>` on SSE/WS endpoints.
    pub token: String,
    pub expires_at: String,
}

/// A Mission Execution Framework run: a goal decomposed into objectives, executed under an
/// authorization gate with checkpoints and an after-action review. Sent by every mission
/// endpoint that answers with the record itself.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Mission {
    pub mission_id: String,
    pub tenant_id: String,
    /// Chat session the mission was started from.
    pub session_id: String,
    /// User id, or an agent id when a sub-mission was spawned by an agent.
    pub created_by: String,
    /// The requester's goal, verbatim.
    pub goal: String,
    /// Why MEF took the request. `quick_reply` never reaches execution.
    pub classification: MissionClassification,
    /// Lifecycle state. `completed`, `failed` and `aborted` are terminal.
    pub status: MissionStatus,
    /// Root objective ids in plan order.
    pub objective_ids: Vec<String>,
    /// Appended chronologically as objectives verify; a resume replays from the last one.
    pub checkpoint_ids: Vec<String>,
    /// Set once the after-action review is finalized — see GET /missions/{missionId}/aar.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub aar_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<MissionMetrics>,
    /// Terminal outcome. `partial` means some objectives verified and some did not.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub outcome: Option<MissionOutcome>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result_summary: Option<String>,
    /// Subset of objective_ids that failed verification.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failed_objective_ids: Option<Vec<String>>,
    /// ISO 8601 hard deadline the runtime enforces against.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
    pub created_at: String,
    pub updated_at: String,
    /// Set when the status first leaves `draft`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub started_at: Option<String>,
    /// Set when the status becomes terminal.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
}

/// Why MEF took the request. `quick_reply` never reaches execution.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MissionClassification {
    #[default]
    #[serde(rename = "quick_reply")]
    QuickReply,
    #[serde(rename = "mission")]
    Mission,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MissionClassification {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::QuickReply => "quick_reply",
            Self::Mission => "mission",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MissionClassification {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MissionClassification {
    fn from(value: &str) -> Self {
        match value {
            "quick_reply" => Self::QuickReply,
            "mission" => Self::Mission,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Aggregated spend for the whole mission. Written on the terminal transition, so it is absent
/// while the mission is still running.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MissionMetrics {
    pub total_cost_usd: f64,
    pub total_tokens: i64,
    pub total_duration_ms: i64,
    pub llm_calls: i64,
    /// Objective retries across the mission — a strike counter, not an HTTP retry count.
    pub retries: i64,
}

/// Terminal outcome. `partial` means some objectives verified and some did not.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MissionOutcome {
    #[default]
    #[serde(rename = "success")]
    Success,
    #[serde(rename = "partial")]
    Partial,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "aborted")]
    Aborted,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MissionOutcome {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Success => "success",
            Self::Partial => "partial",
            Self::Failed => "failed",
            Self::Aborted => "aborted",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MissionOutcome {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MissionOutcome {
    fn from(value: &str) -> Self {
        match value {
            "success" => Self::Success,
            "partial" => Self::Partial,
            "failed" => Self::Failed,
            "aborted" => Self::Aborted,
            other => Self::Other(other.to_string()),
        }
    }
}

/// What POST /missions answers. `plan` is echoed back only when the server planned the mission
/// from a goal.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MissionStartResponse {
    pub mission_id: String,
    /// Persisted objective ids, in plan order.
    pub objective_ids: Vec<String>,
    /// The intake decision. A `quick_reply` mission is recorded but is not mission work.
    pub classification: MissionStartResponseClassification,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<PlannedMission>,
    /// Whether this request also started executing the mission. `true` when planning put it in
    /// `executing` (the plan needed no authorization) and a walk began — progress then arrives on
    /// `/missions/{missionId}/events`, and a later `POST /run` answers `already_running` while it
    /// is in flight. `false` when the mission is `awaiting_authorization` (authorize, then `POST
    /// /run`) or when the tenant is at its concurrent-mission ceiling (the mission stays
    /// `executing`; `POST /run` starts it). Added 2026-09-22: before it, a mission reported
    /// `executing` and dispatched nothing until a separate `POST /run`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_started: Option<bool>,
}

/// The intake decision. A `quick_reply` mission is recorded but is not mission work.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MissionStartResponseClassification {
    pub classification: MissionClassification,
    pub score: f64,
    pub confidence: f64,
}

/// Lifecycle state. `completed`, `failed` and `aborted` are terminal.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MissionStatus {
    #[default]
    #[serde(rename = "draft")]
    Draft,
    #[serde(rename = "planning")]
    Planning,
    #[serde(rename = "awaiting_authorization")]
    AwaitingAuthorization,
    #[serde(rename = "executing")]
    Executing,
    #[serde(rename = "paused")]
    Paused,
    #[serde(rename = "verifying")]
    Verifying,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "aborted")]
    Aborted,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl MissionStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Draft => "draft",
            Self::Planning => "planning",
            Self::AwaitingAuthorization => "awaiting_authorization",
            Self::Executing => "executing",
            Self::Paused => "paused",
            Self::Verifying => "verifying",
            Self::Completed => "completed",
            Self::Failed => "failed",
            Self::Aborted => "aborted",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for MissionStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for MissionStatus {
    fn from(value: &str) -> Self {
        match value {
            "draft" => Self::Draft,
            "planning" => Self::Planning,
            "awaiting_authorization" => Self::AwaitingAuthorization,
            "executing" => Self::Executing,
            "paused" => Self::Paused,
            "verifying" => Self::Verifying,
            "completed" => Self::Completed,
            "failed" => Self::Failed,
            "aborted" => Self::Aborted,
            other => Self::Other(other.to_string()),
        }
    }
}

/// providers.ts ModelInfo — only id and name are populated for media providers.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ModelInfo {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context_window: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_tools: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supports_vision: Option<bool>,
    /// TTS models only, when an admin preset names voices.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub voices: Option<Vec<String>>,
}

/// `MoveWorkspaceFileRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct MoveWorkspaceFileRequest {
    pub from_path: String,
    pub to_path: String,
}

/// `Notification` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Notification {
    pub id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    pub r#type: String,
    pub title: String,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_json::Map<String, serde_json::Value>>,
    pub read: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action_url: Option<String>,
    pub created_at: String,
    /// UI surface routing; defaults to `info` when omitted.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority: Option<NotificationPriority>,
    /// Notifications sharing a dedup_key collapse in the bell with a count badge.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dedup_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<NotificationSource>,
}

/// Delivery channel. `in_app` is always-on (bell drawer + SSE) and cannot be opted out of;
/// `telegram`/`whatsapp` are reserved and have no adapter yet.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationChannel {
    #[default]
    #[serde(rename = "in_app")]
    InApp,
    #[serde(rename = "email")]
    Email,
    #[serde(rename = "webhook")]
    Webhook,
    #[serde(rename = "push")]
    Push,
    #[serde(rename = "web_push")]
    WebPush,
    #[serde(rename = "telegram")]
    Telegram,
    #[serde(rename = "whatsapp")]
    Whatsapp,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationChannel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::InApp => "in_app",
            Self::Email => "email",
            Self::Webhook => "webhook",
            Self::Push => "push",
            Self::WebPush => "web_push",
            Self::Telegram => "telegram",
            Self::Whatsapp => "whatsapp",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationChannel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationChannel {
    fn from(value: &str) -> Self {
        match value {
            "in_app" => Self::InApp,
            "email" => Self::Email,
            "webhook" => Self::Webhook,
            "push" => Self::Push,
            "web_push" => Self::WebPush,
            "telegram" => Self::Telegram,
            "whatsapp" => Self::Whatsapp,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationPreferences` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreferences {
    /// Default channel routing keyed by severity. Server default: critical → \[in_app, email\];
    /// warning/info/success → \[in_app\].
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority_channels: Option<NotificationPreferencesPriorityChannels>,
    /// Per-event-type channel list. When present for a type it REPLACES the priority-level default
    /// for that type. Keys are NotificationType values.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub type_overrides: Option<HashMap<String, Vec<NotificationChannel>>>,
    /// Event types muted for OUTBOUND delivery (email/webhook/push). The in-app bell still receives
    /// them — muting does not hide an event from the bell drawer, it only stops the outbound
    /// channels.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub muted_types: Option<Vec<NotificationType>>,
    /// Window during which non-critical messages are suppressed; critical always bypasses. Set both
    /// start_local and end_local to enable, empty disables.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quiet_hours: Option<NotificationPreferencesQuietHours>,
    pub tenant_id: String,
    pub updated_at: String,
}

/// Per-TENANT notification routing. Sent to PUT /notifications/prefs, which REPLACES the stored
/// value — an omitted field is stored as omitted (that is how a client clears `muted_types` or
/// drops `quiet_hours`). `tenant_id` and `updated_at` are ignored if sent: the server derives
/// them.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreferencesInput {
    /// Default channel routing keyed by severity. Server default: critical → \[in_app, email\];
    /// warning/info/success → \[in_app\].
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority_channels: Option<NotificationPreferencesInputPriorityChannels>,
    /// Per-event-type channel list. When present for a type it REPLACES the priority-level default
    /// for that type. Keys are NotificationType values.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub type_overrides: Option<HashMap<String, Vec<NotificationChannel>>>,
    /// Event types muted for OUTBOUND delivery (email/webhook/push). The in-app bell still receives
    /// them — muting does not hide an event from the bell drawer, it only stops the outbound
    /// channels.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub muted_types: Option<Vec<NotificationType>>,
    /// Window during which non-critical messages are suppressed; critical always bypasses. Set both
    /// start_local and end_local to enable, empty disables.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quiet_hours: Option<NotificationPreferencesInputQuietHours>,
}

/// Default channel routing keyed by severity. Server default: critical → \[in_app, email\];
/// warning/info/success → \[in_app\].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreferencesInputPriorityChannels {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub critical: Option<Vec<NotificationChannel>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub warning: Option<Vec<NotificationChannel>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub info: Option<Vec<NotificationChannel>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<Vec<NotificationChannel>>,
}

/// Window during which non-critical messages are suppressed; critical always bypasses. Set both
/// start_local and end_local to enable, empty disables.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreferencesInputQuietHours {
    /// Local-time start "HH:mm".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_local: Option<String>,
    /// Local-time end "HH:mm".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end_local: Option<String>,
    /// IANA timezone (e.g. "Europe/Kyiv"). Defaults to UTC when absent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    /// Legacy — use start_local + timezone.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_utc: Option<String>,
    /// Legacy — use end_local + timezone.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end_utc: Option<String>,
}

/// Default channel routing keyed by severity. Server default: critical → \[in_app, email\];
/// warning/info/success → \[in_app\].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreferencesPriorityChannels {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub critical: Option<Vec<NotificationChannel>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub warning: Option<Vec<NotificationChannel>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub info: Option<Vec<NotificationChannel>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<Vec<NotificationChannel>>,
}

/// Window during which non-critical messages are suppressed; critical always bypasses. Set both
/// start_local and end_local to enable, empty disables.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreferencesQuietHours {
    /// Local-time start "HH:mm".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_local: Option<String>,
    /// Local-time end "HH:mm".
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end_local: Option<String>,
    /// IANA timezone (e.g. "Europe/Kyiv"). Defaults to UTC when absent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    /// Legacy — use start_local + timezone.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_utc: Option<String>,
    /// Legacy — use end_local + timezone.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end_utc: Option<String>,
}

/// UI surface routing; defaults to `info` when omitted.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationPriority {
    #[default]
    #[serde(rename = "critical")]
    Critical,
    #[serde(rename = "warning")]
    Warning,
    #[serde(rename = "info")]
    Info,
    #[serde(rename = "success")]
    Success,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationPriority {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Critical => "critical",
            Self::Warning => "warning",
            Self::Info => "info",
            Self::Success => "success",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationPriority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationPriority {
    fn from(value: &str) -> Self {
        match value {
            "critical" => Self::Critical,
            "warning" => Self::Warning,
            "info" => Self::Info,
            "success" => Self::Success,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationSource` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationSource {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<NotificationSourceKind>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}

/// `NotificationSourceKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationSourceKind {
    #[default]
    #[serde(rename = "run")]
    Run,
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "bridge")]
    Bridge,
    #[serde(rename = "budget")]
    Budget,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "task")]
    Task,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationSourceKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Run => "run",
            Self::Agent => "agent",
            Self::Bridge => "bridge",
            Self::Budget => "budget",
            Self::Team => "team",
            Self::Task => "task",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationSourceKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationSourceKind {
    fn from(value: &str) -> Self {
        match value {
            "run" => Self::Run,
            "agent" => Self::Agent,
            "bridge" => Self::Bridge,
            "budget" => Self::Budget,
            "team" => Self::Team,
            "task" => Self::Task,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Where outbound notifications go. **Secrets never leave the server**: a webhook's signing
/// secret is reported only as `has_signing_secret`, a device token only by its last four
/// characters, and a Web Push endpoint only by host — the path carries a subscription
/// identifier.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationTarget {
    pub id: String,
    pub tenant_id: String,
    pub channel: NotificationTargetChannel,
    /// Operator's own label — “Slack #ops”, “iPhone 15”.
    pub label: String,
    /// A disabled target is kept for audit and skipped at fan-out.
    pub enabled: bool,
    pub created_at: String,
    /// Last success — the field that tells a dead webhook from a quiet one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_delivered_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_error: Option<String>,
    pub config: serde_json::Value,
}

/// `NotificationTargetChannel` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationTargetChannel {
    #[default]
    #[serde(rename = "email")]
    Email,
    #[serde(rename = "webhook")]
    Webhook,
    #[serde(rename = "push")]
    Push,
    #[serde(rename = "web_push")]
    WebPush,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationTargetChannel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Email => "email",
            Self::Webhook => "webhook",
            Self::Push => "push",
            Self::WebPush => "web_push",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationTargetChannel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationTargetChannel {
    fn from(value: &str) -> Self {
        match value {
            "email" => Self::Email,
            "webhook" => Self::Webhook,
            "push" => Self::Push,
            "web_push" => Self::WebPush,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationTargetConfigVariant1` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationTargetConfigVariant1 {
    pub kind: NotificationTargetConfigVariant1kind,
    pub address: String,
}

/// `NotificationTargetConfigVariant1kind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationTargetConfigVariant1kind {
    #[default]
    #[serde(rename = "email")]
    Email,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationTargetConfigVariant1kind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Email => "email",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationTargetConfigVariant1kind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationTargetConfigVariant1kind {
    fn from(value: &str) -> Self {
        match value {
            "email" => Self::Email,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationTargetConfigVariant2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationTargetConfigVariant2 {
    pub kind: AgentScorerConfigType,
    pub url: String,
    pub format: NotificationTargetConfigVariant2format,
    /// Whether a secret is configured. The secret itself is never returned.
    pub has_signing_secret: bool,
}

/// `NotificationTargetConfigVariant2format` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationTargetConfigVariant2format {
    #[default]
    #[serde(rename = "generic")]
    Generic,
    #[serde(rename = "slack")]
    Slack,
    #[serde(rename = "discord")]
    Discord,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationTargetConfigVariant2format {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Generic => "generic",
            Self::Slack => "slack",
            Self::Discord => "discord",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationTargetConfigVariant2format {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationTargetConfigVariant2format {
    fn from(value: &str) -> Self {
        match value {
            "generic" => Self::Generic,
            "slack" => Self::Slack,
            "discord" => Self::Discord,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationTargetConfigVariant3` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationTargetConfigVariant3 {
    pub kind: NotificationTargetConfigVariant3kind,
    pub platform: NotificationTargetConfigVariant3platform,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_label: Option<String>,
    /// Last four characters of the device token, for visual identification only.
    pub device_token_suffix: String,
}

/// `NotificationTargetConfigVariant3kind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationTargetConfigVariant3kind {
    #[default]
    #[serde(rename = "push")]
    Push,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationTargetConfigVariant3kind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Push => "push",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationTargetConfigVariant3kind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationTargetConfigVariant3kind {
    fn from(value: &str) -> Self {
        match value {
            "push" => Self::Push,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationTargetConfigVariant3platform` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationTargetConfigVariant3platform {
    #[default]
    #[serde(rename = "apns")]
    Apns,
    #[serde(rename = "fcm")]
    Fcm,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationTargetConfigVariant3platform {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Apns => "apns",
            Self::Fcm => "fcm",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationTargetConfigVariant3platform {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationTargetConfigVariant3platform {
    fn from(value: &str) -> Self {
        match value {
            "apns" => Self::Apns,
            "fcm" => Self::Fcm,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `NotificationTargetConfigVariant4` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NotificationTargetConfigVariant4 {
    pub kind: NotificationTargetConfigVariant4kind,
    /// Host only — `(invalid endpoint)` when the stored URL will not parse.
    pub endpoint_host: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_label: Option<String>,
    /// Browser-supplied expiry, ms since epoch.
    #[serde(default)]
    pub expiration_time: Option<i64>,
}

/// `NotificationTargetConfigVariant4kind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationTargetConfigVariant4kind {
    #[default]
    #[serde(rename = "web_push")]
    WebPush,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationTargetConfigVariant4kind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::WebPush => "web_push",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationTargetConfigVariant4kind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationTargetConfigVariant4kind {
    fn from(value: &str) -> Self {
        match value {
            "web_push" => Self::WebPush,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Fine-grained event type. There are no coarse buckets on the server — a UI that groups events
/// (e.g. "agents / failures / system") maps its groups onto these types itself.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum NotificationType {
    #[default]
    #[serde(rename = "run.started")]
    RunStarted,
    #[serde(rename = "run.failed")]
    RunFailed,
    #[serde(rename = "run.completed")]
    RunCompleted,
    #[serde(rename = "run.awaiting_approval")]
    RunAwaitingApproval,
    #[serde(rename = "run.awaiting_input")]
    RunAwaitingInput,
    #[serde(rename = "approval.requested")]
    ApprovalRequested,
    #[serde(rename = "budget.warning")]
    BudgetWarning,
    #[serde(rename = "budget.exceeded")]
    BudgetExceeded,
    #[serde(rename = "bridge.online")]
    BridgeOnline,
    #[serde(rename = "bridge.offline")]
    BridgeOffline,
    #[serde(rename = "invite.accepted")]
    InviteAccepted,
    #[serde(rename = "marketplace.review")]
    MarketplaceReview,
    #[serde(rename = "workflow.triggered")]
    WorkflowTriggered,
    #[serde(rename = "system.alert")]
    SystemAlert,
    #[serde(rename = "task.completed")]
    TaskCompleted,
    #[serde(rename = "task.confirmation_required")]
    TaskConfirmationRequired,
    #[serde(rename = "agent.suspended")]
    AgentSuspended,
    #[serde(rename = "agent.terminated")]
    AgentTerminated,
    #[serde(rename = "billing.payment_failed")]
    BillingPaymentFailed,
    #[serde(rename = "billing.subscription_paused")]
    BillingSubscriptionPaused,
    #[serde(rename = "billing.subscription_cancelled")]
    BillingSubscriptionCancelled,
    #[serde(rename = "billing.dispute_opened")]
    BillingDisputeOpened,
    #[serde(rename = "domain.dns_drift")]
    DomainDnsDrift,
    #[serde(rename = "domain.cert_failed")]
    DomainCertFailed,
    #[serde(rename = "domain.cert_renewal_due")]
    DomainCertRenewalDue,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl NotificationType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::RunStarted => "run.started",
            Self::RunFailed => "run.failed",
            Self::RunCompleted => "run.completed",
            Self::RunAwaitingApproval => "run.awaiting_approval",
            Self::RunAwaitingInput => "run.awaiting_input",
            Self::ApprovalRequested => "approval.requested",
            Self::BudgetWarning => "budget.warning",
            Self::BudgetExceeded => "budget.exceeded",
            Self::BridgeOnline => "bridge.online",
            Self::BridgeOffline => "bridge.offline",
            Self::InviteAccepted => "invite.accepted",
            Self::MarketplaceReview => "marketplace.review",
            Self::WorkflowTriggered => "workflow.triggered",
            Self::SystemAlert => "system.alert",
            Self::TaskCompleted => "task.completed",
            Self::TaskConfirmationRequired => "task.confirmation_required",
            Self::AgentSuspended => "agent.suspended",
            Self::AgentTerminated => "agent.terminated",
            Self::BillingPaymentFailed => "billing.payment_failed",
            Self::BillingSubscriptionPaused => "billing.subscription_paused",
            Self::BillingSubscriptionCancelled => "billing.subscription_cancelled",
            Self::BillingDisputeOpened => "billing.dispute_opened",
            Self::DomainDnsDrift => "domain.dns_drift",
            Self::DomainCertFailed => "domain.cert_failed",
            Self::DomainCertRenewalDue => "domain.cert_renewal_due",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for NotificationType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for NotificationType {
    fn from(value: &str) -> Self {
        match value {
            "run.started" => Self::RunStarted,
            "run.failed" => Self::RunFailed,
            "run.completed" => Self::RunCompleted,
            "run.awaiting_approval" => Self::RunAwaitingApproval,
            "run.awaiting_input" => Self::RunAwaitingInput,
            "approval.requested" => Self::ApprovalRequested,
            "budget.warning" => Self::BudgetWarning,
            "budget.exceeded" => Self::BudgetExceeded,
            "bridge.online" => Self::BridgeOnline,
            "bridge.offline" => Self::BridgeOffline,
            "invite.accepted" => Self::InviteAccepted,
            "marketplace.review" => Self::MarketplaceReview,
            "workflow.triggered" => Self::WorkflowTriggered,
            "system.alert" => Self::SystemAlert,
            "task.completed" => Self::TaskCompleted,
            "task.confirmation_required" => Self::TaskConfirmationRequired,
            "agent.suspended" => Self::AgentSuspended,
            "agent.terminated" => Self::AgentTerminated,
            "billing.payment_failed" => Self::BillingPaymentFailed,
            "billing.subscription_paused" => Self::BillingSubscriptionPaused,
            "billing.subscription_cancelled" => Self::BillingSubscriptionCancelled,
            "billing.dispute_opened" => Self::BillingDisputeOpened,
            "domain.dns_drift" => Self::DomainDnsDrift,
            "domain.cert_failed" => Self::DomainCertFailed,
            "domain.cert_renewal_due" => Self::DomainCertRenewalDue,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `OAuthAppExchangeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthAppExchangeRequest {
    /// The value delivered in the callback fragment.
    pub code: String,
    /// The secret whose SHA-256, base64url-encoded, was sent as `app_code_challenge` when the flow
    /// started. It never leaves the app, which is what makes an intercepted code worthless.
    pub code_verifier: String,
}

/// `OAuthAppExchangeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthAppExchangeResponse {
    pub api_key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
}

/// Body to complete OAuth after callback
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthCompleteRequest {
    pub state: String,
    pub code: String,
    pub agent_id: String,
    /// Display name for this connection
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `OAuthIdentityConfig` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthIdentityConfig {
    pub apple_services_id: String,
    pub apple_team_id: String,
    pub apple_bundle_id: String,
    /// Lower-cased hostnames. Empty means nothing is allowlisted.
    pub oauth_return_to_hosts: Vec<String>,
}

/// Result after DELETE — record removed from admin KV
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProviderConfigDeleted {
    pub provider: OAuthLoginProviderConfigStatusProvider,
    /// Always false after a successful DELETE
    pub configured: bool,
}

/// Admin view of one provider's current config. client_secret is never echoed;
/// client_secret_hint shows the last 4 chars so the operator can confirm storage.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProviderConfigStatus {
    pub provider: OAuthLoginProviderConfigStatusProvider,
    pub enabled: bool,
    /// false when no record exists yet; remaining fields are absent in that case
    pub configured: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    /// Masked tail of the stored secret (e.g. "••••a1b2"). null if no secret on file.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_secret_hint: Option<String>,
    /// null when no override; provider defaults apply
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
}

/// `OAuthLoginProviderConfigStatusProvider` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum OAuthLoginProviderConfigStatusProvider {
    #[default]
    #[serde(rename = "github")]
    Github,
    #[serde(rename = "google")]
    Google,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl OAuthLoginProviderConfigStatusProvider {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Github => "github",
            Self::Google => "google",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for OAuthLoginProviderConfigStatusProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for OAuthLoginProviderConfigStatusProvider {
    fn from(value: &str) -> Self {
        match value {
            "github" => Self::Github,
            "google" => Self::Google,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Body for PUT /api/v1/admin/oauth-login-providers/{provider}. Merges with existing record: an
/// operator flipping `enabled` or rotating `scopes` does not need to re-paste the secret. The
/// first-time PUT (no existing record) requires both client_id and client_secret.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProviderConfigUpdate {
    /// OAuth app client ID issued by the provider
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    /// OAuth app client secret. Stored verbatim in admin KV; never echoed back.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_secret: Option<String>,
    /// Defaults to existing value, or true on first write if omitted
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    /// Optional override of the provider's default scope list. Omit to inherit defaults.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
}

/// Result after PUT — confirms the persisted state
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProviderConfigUpdateResponse {
    pub provider: OAuthLoginProviderConfigStatusProvider,
    pub enabled: bool,
    pub configured: bool,
}

/// Public-safe descriptor for an OAuth login (identity) provider. Surfaces only what the login
/// page needs to decide which buttons to render — never exposes client_secret.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProviderItem {
    /// Provider identifier used in /auth/oauth/{provider}/start path
    pub id: OAuthLoginProviderItemId,
    /// Human-readable provider name (e.g. "GitHub", "Google")
    pub name: String,
    /// true when the operator has configured client_id+client_secret AND set enabled=true. False
    /// values mean clicking the button would 404.
    pub enabled: bool,
}

/// Provider identifier used in /auth/oauth/{provider}/start path
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum OAuthLoginProviderItemId {
    #[default]
    #[serde(rename = "github")]
    Github,
    #[serde(rename = "google")]
    Google,
    #[serde(rename = "apple")]
    Apple,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl OAuthLoginProviderItemId {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Github => "github",
            Self::Google => "google",
            Self::Apple => "apple",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for OAuthLoginProviderItemId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for OAuthLoginProviderItemId {
    fn from(value: &str) -> Self {
        match value {
            "github" => Self::Github,
            "google" => Self::Google,
            "apple" => Self::Apple,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Response from GET /api/v1/auth/oauth/providers
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProvidersList {
    pub providers: Vec<OAuthLoginProviderItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub google_one_tap_client_id: Option<String>,
}

/// Response for starting OAuth flow
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthStartResponse {
    pub auth_url: String,
    pub state: String,
}

/// One unit of mission work. Sent in full by GET /missions/{missionId}/objectives and by the
/// PATCH that edits one.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Objective {
    pub objective_id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub company_id: Option<String>,
    /// Parent objective, or null for a root objective of the mission.
    #[serde(default)]
    pub parent_id: Option<String>,
    pub title: String,
    pub description: String,
    /// What the verifier checks before the objective counts as done.
    pub success_criteria: Vec<String>,
    /// Lifecycle, owned by the executor — PATCH cannot set it.
    pub status: ObjectiveStatus,
    pub priority: ObjectivePriority,
    /// Agent that executes this objective. Mutually exclusive with assigned_team_id in practice.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_team_id: Option<String>,
    /// Objective ids that must verify first. The plan is a DAG.
    pub dependencies: Vec<String>,
    pub budget: ObjectiveBudget,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_summary: Option<String>,
    pub progress_notes: Vec<String>,
    pub created_at: String,
    pub updated_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
    /// The end state to preserve when the literal instruction stops fitting.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commanders_intent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub roe: Option<ObjectiveRoE>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decision_points: Option<Vec<ObjectiveDecisionPoint>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
    /// Why the executor stopped on this objective: `exhausted_strikes_\<n\>`, `budget_exhausted`,
    /// `dependency_failed`, or `verifier_error` — the verifier could not reach a verdict (its judge
    /// errored or kept answering in an unparseable shape), which is the platform failing, not the
    /// agent's work; no strike is charged for it and the agent is not re-run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub abort_reason: Option<String>,
    /// Strikes the mission executor spent on this objective, written when it settles. Absent on
    /// objectives that never ran under a mission and on those settled before 2026-09-22.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strikes_used: Option<i64>,
}

/// Per-objective ceiling and what has been spent against it. The executor stops an objective
/// that would cross a max.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ObjectiveBudget {
    pub max_runs: i64,
    pub max_tokens: i64,
    pub max_cost_usd: f64,
    pub spent_runs: i64,
    pub spent_tokens: i64,
    pub spent_cost_usd: f64,
}

/// A branch in the plan: when `condition` holds, execution continues at the matching branch's
/// objective instead of the next one in order.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ObjectiveDecisionPoint {
    pub condition: String,
    pub branches: Vec<ObjectiveDecisionPointBranch>,
    /// Taken when no branch matches.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_objective_id: Option<String>,
}

/// `ObjectiveDecisionPointBranch` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ObjectiveDecisionPointBranch {
    pub when: String,
    pub objective_id: String,
}

/// `ObjectivePriority` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ObjectivePriority {
    #[default]
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "critical")]
    Critical,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ObjectivePriority {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Low => "low",
            Self::Medium => "medium",
            Self::High => "high",
            Self::Critical => "critical",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ObjectivePriority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ObjectivePriority {
    fn from(value: &str) -> Self {
        match value {
            "low" => Self::Low,
            "medium" => Self::Medium,
            "high" => Self::High,
            "critical" => Self::Critical,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Rules of engagement: what the objective may do alone, what needs a human, and what it must
/// never do.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ObjectiveRoE {
    pub autonomous_actions: Vec<String>,
    pub requires_approval: Vec<String>,
    pub prohibited: Vec<String>,
}

/// Lifecycle, owned by the executor — PATCH cannot set it.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ObjectiveStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "blocked")]
    Blocked,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ObjectiveStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::InProgress => "in_progress",
            Self::Blocked => "blocked",
            Self::Completed => "completed",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ObjectiveStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ObjectiveStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "in_progress" => Self::InProgress,
            "blocked" => Self::Blocked,
            "completed" => Self::Completed,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// agent-teams/objective-tracker.ts ObjectiveTree — recursive.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ObjectiveTree {
    pub objective: Objective,
    pub children: Vec<ObjectiveTree>,
}

/// An OpenAI Chat Completions object. `/v1/chat/completions` builds it (openai-compat.ts:
/// exactly one choice, no `logprobs`, no `system_fingerprint`); `/api/v1/llm/chat/completions`
/// passes the provider's body through (llm-proxy.ts) — `model` is then the provider's id, and a
/// reasoning-only reply has its reasoning copied into `content`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiChatCompletion {
    pub id: String,
    pub object: OpenAiChatCompletionObject,
    /// Unix seconds.
    pub created: i64,
    pub model: String,
    pub choices: Vec<OpenAiChatCompletionChoice>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<OpenAiChatCompletionUsage>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `OpenAiChatCompletionChoice` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiChatCompletionChoice {
    pub index: i64,
    pub message: OpenAiChatCompletionChoiceMessage,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub finish_reason: Option<String>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `OpenAiChatCompletionChoiceMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiChatCompletionChoiceMessage {
    pub role: OpenAiChatCompletionChoiceMessageRole,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<OpenAiToolCall>>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `OpenAiChatCompletionChoiceMessageRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum OpenAiChatCompletionChoiceMessageRole {
    #[default]
    #[serde(rename = "assistant")]
    Assistant,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl OpenAiChatCompletionChoiceMessageRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Assistant => "assistant",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for OpenAiChatCompletionChoiceMessageRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for OpenAiChatCompletionChoiceMessageRole {
    fn from(value: &str) -> Self {
        match value {
            "assistant" => Self::Assistant,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `OpenAiChatCompletionObject` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum OpenAiChatCompletionObject {
    #[default]
    #[serde(rename = "chat.completion")]
    ChatCompletion,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl OpenAiChatCompletionObject {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::ChatCompletion => "chat.completion",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for OpenAiChatCompletionObject {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for OpenAiChatCompletionObject {
    fn from(value: &str) -> Self {
        match value {
            "chat.completion" => Self::ChatCompletion,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `OpenAiChatCompletionUsage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiChatCompletionUsage {
    pub prompt_tokens: i64,
    pub completion_tokens: i64,
    pub total_tokens: i64,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// Error envelope used by the OpenAI-compatible surface (`/v1/*`). Deliberately NOT RFC 9457:
/// callers here are OpenAI SDKs pointed at this base URL, and they decode this shape.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiError {
    pub error: OpenAiErrorError,
}

/// `OpenAiErrorError` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiErrorError {
    /// Human-readable cause, including where an operator fixes it.
    pub message: String,
    pub r#type: String,
    /// Machine-readable code. `embedding_unavailable` = no provider configured (501, permanent).
    /// `embedding_failed` = the configured provider did not answer (503, retryable).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
}

/// The OpenAI tool-call object as passed through from the provider (llm-proxy.ts);
/// /v1/chat/completions itself emits tool calls only as streaming deltas.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiToolCall {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<OpenAiToolCallType>,
    pub function: OpenAiToolCallFunction,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `OpenAiToolCallFunction` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OpenAiToolCallFunction {
    pub name: String,
    pub arguments: String,
}

/// `OpenAiToolCallType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum OpenAiToolCallType {
    #[default]
    #[serde(rename = "function")]
    Function,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl OpenAiToolCallType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Function => "function",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for OpenAiToolCallType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for OpenAiToolCallType {
    fn from(value: &str) -> Self {
        match value {
            "function" => Self::Function,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PatchMeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PatchMeRequest {
    /// `/api/v1/files/\<file_id\>/content` of an image uploaded with `POST /files`, or `null` to
    /// clear.
    #[serde(default)]
    pub avatar_url: Option<String>,
}

/// `PatchMeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PatchMeResponse {
    pub user: PatchMeResponseUser,
    pub updated_rows: i64,
}

/// `PatchMeResponseUser` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PatchMeResponseUser {
    pub user_id: String,
    pub email: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub role: String,
    pub status: String,
    #[serde(default)]
    pub avatar_url: Option<String>,
}

/// A partial tenant. Fields not named are left alone — except `social_links`, which is REPLACED
/// wholesale rather than merged, so a PATCH carrying one platform leaves the tenant with that
/// one platform and nothing else. Send every link you want to keep, `custom` included.
///
/// `social_links` values are filtered, not rejected: a url that does not match
/// `^https?://.{3,500}$` is dropped and the request still answers 200. Length is applied BEFORE
/// the pattern, which is the case worth knowing about — a url longer than 500 characters is CUT
/// to 500 and the cut value then matches, so it is STORED TRUNCATED rather than refused. A
/// working-looking link that goes somewhere else is worse than a missing one, and a client
/// checking only whether the key came back cannot see it.
///
/// Nothing here is hidden: the response is the tenant AS STORED, so compare what you sent
/// against what came back — values and lengths, not just which keys are present. No second GET
/// is needed. See `Tenant.social_links` for the field-by-field shape.
///
/// Documented 2026-09-18. The 2026-09-17 pass wrote this onto the Tenant RESPONSE schema and
/// left the request body an untyped `object`: right words, wrong end of the call. Caught by the
/// SDK lane, whose generator produced a typed `Tenant.social_links` beside a `patch(body:
/// JsonObject)` that could not describe what to send.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PatchTenantRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub social_links: Option<TenantSocialLinks>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `PauseCompanyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PauseCompanyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `PauseMissionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PauseMissionResponse {
    pub pausing: bool,
    pub mission: Mission,
}

/// `PauseRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PauseRunResponse {
    pub paused: bool,
    pub run_id: String,
}

/// runs.ts — the tool calls of the newest run.awaiting_approval event (agent-runtime.ts /
/// bridge.ts); `options`/`kind` only from the bridge.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PendingApproval {
    pub id: String,
    pub name: String,
    pub args: serde_json::Map<String, serde_json::Value>,
    /// Choices the bridge reported for the approval, when any.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
}

/// `PermissionCheckResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PermissionCheckResult {
    pub allowed: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub denied_permissions: Option<Vec<String>>,
}

/// Per-agent capability envelope. Invariant: PermissionSet(child) ⊆ PermissionSet(parent).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PermissionSet {
    pub agent_id: String,
    pub tenant_id: String,
    pub allowed_tools: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_roles: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_permissions: Option<Vec<ResourcePermission>>,
    /// Hard cap (USD) on the cost of each of this agent's own runs, and the ceiling a spawned
    /// child's budget may not exceed. The run's effective cost ceiling is the smaller positive of
    /// this and resource_limits.max_cost_usd (or the platform ceiling); a run that crosses it fails
    /// with error_code BUDGET_EXCEEDED and error_details.cap_source "permission_set" or
    /// "resource_limits". 0 means no cap from this field.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_budget_per_run_usd: Option<f64>,
    pub max_spawn_depth: i64,
    pub can_spawn: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub can_self_modify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// Body of PUT /governance/permissions/{agentId}. Every field optional: a field the body omits
/// keeps its stored value (mergePermissionSet), and only a first write falls back to the
/// defaults. `agent_id`, `tenant_id`, `created_at`, `updated_at` are set by the server and
/// ignored in the body.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PermissionSetUpdate {
    /// Sending this field REPLACES the stored list (the handler stores the array as sent, it does
    /// not merge).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_tools: Option<Vec<String>>,
    /// Sending this field REPLACES the stored list (the handler stores the array as sent, it does
    /// not merge).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_roles: Option<Vec<String>>,
    /// Sending this field REPLACES the stored list (the handler stores the array as sent, it does
    /// not merge).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_permissions: Option<Vec<ResourcePermission>>,
    /// Hard cap (USD) on the cost of each of this agent's own runs, and the ceiling a spawned
    /// child's budget may not exceed. The run's effective cost ceiling is the smaller positive of
    /// this and resource_limits.max_cost_usd (or the platform ceiling); a run that crosses it fails
    /// with error_code BUDGET_EXCEEDED and error_details.cap_source "permission_set" or
    /// "resource_limits". 0 means no cap from this field.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_budget_per_run_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_spawn_depth: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub can_spawn: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub can_self_modify: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_agent_id: Option<String>,
}

/// `PlanLLMLimits` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlanLLMLimits {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tier_access: Option<Vec<PlanLLMLimitsTierAccessItem>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens_per_month: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_per_minute: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_per_hour: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requests_per_day: Option<i64>,
}

/// `PlanLLMLimitsTierAccessItem` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum PlanLLMLimitsTierAccessItem {
    #[default]
    #[serde(rename = "starter")]
    Starter,
    #[serde(rename = "pro")]
    Pro,
    #[serde(rename = "enterprise")]
    Enterprise,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl PlanLLMLimitsTierAccessItem {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Starter => "starter",
            Self::Pro => "pro",
            Self::Enterprise => "enterprise",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for PlanLLMLimitsTierAccessItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for PlanLLMLimitsTierAccessItem {
    fn from(value: &str) -> Self {
        match value {
            "starter" => Self::Starter,
            "pro" => Self::Pro,
            "enterprise" => Self::Enterprise,
            other => Self::Other(other.to_string()),
        }
    }
}

/// A fully decomposed plan. Supplying one skips the LLM planner entirely.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlannedMission {
    pub goal: String,
    pub classification: MissionClassification,
    pub objectives: Vec<PlannedObjective>,
    /// When true the mission stops at `awaiting_authorization` instead of executing — the gate for
    /// destructive or externally visible plans.
    pub requires_authorization: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
}

/// An objective as supplied in a caller-written plan. Dependencies are INDICES into
/// `objectives`, because ids do not exist until the plan is persisted.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlannedObjective {
    pub title: String,
    pub description: String,
    pub success_criteria: Vec<String>,
    pub priority: ObjectivePriority,
    /// Indices into `objectives`; must form a DAG or the plan is rejected.
    pub depends_on_indices: Vec<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_team_id: Option<String>,
    /// Ceilings only — the spent_* counters are created by the server.
    pub budget: PlannedObjectiveBudget,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commanders_intent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub roe: Option<ObjectiveRoE>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decision_points: Option<Vec<ObjectiveDecisionPoint>>,
}

/// Ceilings only — the spent_* counters are created by the server.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlannedObjectiveBudget {
    pub max_runs: i64,
    pub max_tokens: i64,
    pub max_cost_usd: f64,
}

/// Platform profit and loss: Stripe revenue against real host spend and the LLM provider bill.
/// Super-admin only. Served from a short-lived cache — `cache` says which.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomics {
    pub revenue: PlatformEconomicsRevenue,
    pub costs: PlatformEconomicsCosts,
    /// What the platform paid model providers for tokens, from the usage shards' pre-markup
    /// `provider_cost` summed over every tenant. The largest variable cost; absent from this report
    /// until 2026-09-02.
    pub llm: PlatformEconomicsLLM,
    pub economics: PlatformEconomicsEconomics,
    pub generated_at: String,
    /// `hit` — served from cache; `miss` — computed and cached; `bypass` — recomputed because
    /// `refresh=1`.
    pub cache: PlatformEconomicsCache,
}

/// `hit` — served from cache; `miss` — computed and cached; `bypass` — recomputed because
/// `refresh=1`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum PlatformEconomicsCache {
    #[default]
    #[serde(rename = "hit")]
    Hit,
    #[serde(rename = "miss")]
    Miss,
    #[serde(rename = "bypass")]
    Bypass,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl PlatformEconomicsCache {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Hit => "hit",
            Self::Miss => "miss",
            Self::Bypass => "bypass",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for PlatformEconomicsCache {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for PlatformEconomicsCache {
    fn from(value: &str) -> Self {
        match value {
            "hit" => Self::Hit,
            "miss" => Self::Miss,
            "bypass" => Self::Bypass,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PlatformEconomicsCosts` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomicsCosts {
    pub provider: PlatformEconomicsCostsProvider,
    pub configured: bool,
    /// Real accrued spend from the provider's own meter.
    #[serde(default)]
    pub month_to_date_usd: Option<f64>,
    /// Negative means credit.
    #[serde(default)]
    pub account_balance_usd: Option<f64>,
    #[serde(default)]
    pub balance_generated_at: Option<String>,
    pub droplets: Vec<HostDroplet>,
    /// Sum of droplet list prices — steady state, not accrued.
    pub monthly_run_rate_usd: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `PlatformEconomicsCostsProvider` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum PlatformEconomicsCostsProvider {
    #[default]
    #[serde(rename = "digitalocean")]
    Digitalocean,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl PlatformEconomicsCostsProvider {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Digitalocean => "digitalocean",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for PlatformEconomicsCostsProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for PlatformEconomicsCostsProvider {
    fn from(value: &str) -> Self {
        match value {
            "digitalocean" => Self::Digitalocean,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PlatformEconomicsEconomics` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomicsEconomics {
    pub monthly_revenue_usd: f64,
    pub monthly_infra_usd: f64,
    /// `llm.monthly_run_rate_usd` — see `llm.run_rate_basis` for how it was reached.
    pub monthly_llm_usd: f64,
    /// MRR − infra run rate − LLM run rate.
    pub monthly_margin_usd: f64,
    /// Null when there is no revenue to divide by — not zero, which would read as a 0% margin.
    #[serde(default)]
    pub margin_percent: Option<f64>,
    #[serde(default)]
    pub month_to_date_infra_usd: Option<f64>,
    #[serde(default)]
    pub markup_percent: Option<f64>,
    #[serde(default)]
    pub pricing_tiers: Option<serde_json::Map<String, serde_json::Value>>,
}

/// What the platform paid model providers for tokens, from the usage shards' pre-markup
/// `provider_cost` summed over every tenant. The largest variable cost; absent from this report
/// until 2026-09-02.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomicsLLM {
    /// YYYY-MM, UTC — the period the usage shards are keyed by.
    pub period: String,
    pub month_to_date_provider_usd: f64,
    /// What tenants were billed for the same usage (provider × markup).
    pub month_to_date_billed_usd: f64,
    pub previous_period: String,
    pub previous_period_provider_usd: f64,
    pub previous_period_billed_usd: f64,
    /// The figure folded into `economics.monthly_llm_usd`.
    pub monthly_run_rate_usd: f64,
    /// `previous_period` — last month's full bill; `month_to_date_extrapolated` — this month's
    /// spend scaled to a full month, a guess that is loudest on the 1st; `none` — nothing recorded
    /// yet.
    pub run_rate_basis: PlatformEconomicsLLMRunRateBasis,
    pub tenants_with_usage: i64,
    pub by_model: Vec<PlatformEconomicsLLMByModelItem>,
    /// What the number does not know: own-key proxy traffic is counted although the tenant paid it;
    /// shards older than the field count 0.
    pub caveats: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `PlatformEconomicsLLMByModelItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomicsLLMByModelItem {
    pub model: String,
    pub provider_usd: f64,
    pub billed_usd: f64,
    pub tokens: i64,
}

/// `previous_period` — last month's full bill; `month_to_date_extrapolated` — this month's
/// spend scaled to a full month, a guess that is loudest on the 1st; `none` — nothing recorded
/// yet.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum PlatformEconomicsLLMRunRateBasis {
    #[default]
    #[serde(rename = "previous_period")]
    PreviousPeriod,
    #[serde(rename = "month_to_date_extrapolated")]
    MonthToDateExtrapolated,
    #[serde(rename = "none")]
    None,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl PlatformEconomicsLLMRunRateBasis {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::PreviousPeriod => "previous_period",
            Self::MonthToDateExtrapolated => "month_to_date_extrapolated",
            Self::None => "none",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for PlatformEconomicsLLMRunRateBasis {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for PlatformEconomicsLLMRunRateBasis {
    fn from(value: &str) -> Self {
        match value {
            "previous_period" => Self::PreviousPeriod,
            "month_to_date_extrapolated" => Self::MonthToDateExtrapolated,
            "none" => Self::None,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PlatformEconomicsRevenue` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomicsRevenue {
    /// False on a deployment with no Stripe key; the figures are then zeros, not an error.
    pub stripe_configured: bool,
    pub mrr_usd: f64,
    pub arr_usd: f64,
    pub subscriptions: Vec<PlatformEconomicsRevenueSubscription>,
    pub by_status: serde_json::Map<String, serde_json::Value>,
    /// Present when Stripe could not be reached; the rest of the payload is still served.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `PlatformEconomicsRevenueSubscription` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformEconomicsRevenueSubscription {
    pub subscription_id: String,
    pub customer_id: String,
    #[serde(default)]
    pub tenant_id: Option<String>,
    #[serde(default)]
    pub tenant_name: Option<String>,
    #[serde(default)]
    pub plan: Option<String>,
    #[serde(default)]
    pub billing_status: Option<String>,
    pub status: String,
    pub monthly_usd: f64,
    pub currency: String,
    pub interval: String,
    #[serde(default)]
    pub current_period_end: Option<String>,
    pub cancel_at_period_end: bool,
}

/// What an unauthenticated page may know about this deployment. Deliberately minimal — no
/// secrets and no wizard step names, so a probe cannot enumerate what setup still has pending.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformInfo {
    /// The platform's own base URL, so a client need not bake it into its bundle.
    pub public_base_url: String,
    /// Role → address. Always an object, possibly empty — a client gates each link on presence
    /// rather than handling nulls.
    pub contact_emails: serde_json::Map<String, serde_json::Value>,
    /// True once the platform is live.
    pub setup_complete: bool,
    pub registration_open: bool,
}

/// `PlatformLLMDefaults` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlatformLLMDefaults {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_endpoint: Option<String>,
    /// Stored model half. May be bare (`minimax-m3`) or already provider-qualified
    /// (`ollama/glm-5.2`) — production holds both shapes. Dial `default_model_ref` instead of
    /// joining this yourself.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_provider: Option<String>,
    /// Stored model half of the fallback. A vendor path (`MiniMaxAI/MiniMax-M3`) carries a slash
    /// while naming no provider, so this string is NOT dialable on its own — use
    /// `fallback_model_ref`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_provider: Option<String>,
    /// The default as the chat surface accepts it: `provider/model`, already de-duplicated against
    /// a model half that carries the provider head. Null when no default model is configured.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_model_ref: Option<String>,
    /// Same for the fallback. Null when no fallback model is configured.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fallback_model_ref: Option<String>,
}

/// The visual-builder canvas of an agent as GET /playground/agents/{agentId} serves it
/// (measured 2026-09-10 on e2e-canon); PUT returns the same shape after the write.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaygroundAgentState {
    pub agent_id: String,
    pub tenant_id: String,
    pub nodes: Vec<CanvasNode>,
    pub edges: Vec<CanvasEdge>,
    pub metadata: serde_json::Map<String, serde_json::Value>,
    pub updated_at: String,
}

/// One starter template from GET /playground/templates (element keys measured 2026-09-10).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PlaygroundTemplate {
    pub id: String,
    pub name: String,
    pub description: String,
    pub category: String,
    pub nodes: Vec<CanvasNode>,
    pub edges: Vec<CanvasEdge>,
}

/// An ordered curriculum an agent delivers.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Program {
    pub program_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub listing_id: Option<String>,
    pub steps: Vec<ProgramStep>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `ProgramStep` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProgramStep {
    /// Generated by the server.
    pub step_id: String,
    pub title: String,
    pub order_index: i64,
}

/// A named body of work that chats belong to: standing instructions, the knowledge bases its
/// chats may search, and the files they can read. An agent is *who* answers; a project is *what
/// about*.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Project {
    pub project_id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Injected into the system prompt below the agent's own prompt and above personal preferences.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_ids: Option<Vec<String>>,
    /// Ids that no longer resolve to a file in this tenant are dropped on write — an attachment
    /// that lies is worse than a rejected one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_ids: Option<Vec<String>>,
    /// Owns a private project outright.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_by: Option<String>,
    /// `tenant` (the default, and what every pre-existing project is) or `private`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<ProjectVisibility>,
    /// Ignored while `visibility` is `tenant`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<ProjectGrant>>,
    /// Absent or null when the project is live. Archiving hides it from the default list and loses
    /// nothing.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

/// A project with its chats and the caller's own access level.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProjectDetail {
    pub project_id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Injected into the system prompt below the agent's own prompt and above personal preferences.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_ids: Option<Vec<String>>,
    /// Ids that no longer resolve to a file in this tenant are dropped on write — an attachment
    /// that lies is worse than a rejected one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_ids: Option<Vec<String>>,
    /// Owns a private project outright.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_by: Option<String>,
    /// `tenant` (the default, and what every pre-existing project is) or `private`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<ProjectVisibility>,
    /// Ignored while `visibility` is `tenant`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<ProjectGrant>>,
    /// Absent or null when the project is live. Archiving hides it from the default list and loses
    /// nothing.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<String>,
    pub created_at: String,
    pub updated_at: String,
    /// The chats filed under this project, most recently updated first.
    pub sessions: Vec<ProjectDetailSession>,
    pub session_count: i64,
    /// What THIS caller may do. `none` never reaches a client — it is answered as 404.
    pub access: ProjectGrantAccess,
}

/// `ProjectDetailSession` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProjectDetailSession {
    pub session_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

/// One person's access to a private project.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProjectGrant {
    pub user_id: String,
    /// `view` opens the chats and the brief; `edit` also rewrites them.
    pub access: ProjectGrantAccess,
}

/// `view` opens the chats and the brief; `edit` also rewrites them.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ProjectGrantAccess {
    #[default]
    #[serde(rename = "view")]
    View,
    #[serde(rename = "edit")]
    Edit,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ProjectGrantAccess {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::View => "view",
            Self::Edit => "edit",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ProjectGrantAccess {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ProjectGrantAccess {
    fn from(value: &str) -> Self {
        match value {
            "view" => Self::View,
            "edit" => Self::Edit,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `tenant` (the default, and what every pre-existing project is) or `private`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ProjectVisibility {
    #[default]
    #[serde(rename = "tenant")]
    Tenant,
    #[serde(rename = "private")]
    Private,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ProjectVisibility {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Tenant => "tenant",
            Self::Private => "private",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ProjectVisibility {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ProjectVisibility {
    fn from(value: &str) -> Self {
        match value {
            "tenant" => Self::Tenant,
            "private" => Self::Private,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PromoCode` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PromoCode {
    /// Upper-cased.
    pub code: String,
    /// Absent when unset.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<String>,
    /// The tenant that earns the reward.
    pub owner_tenant_id: String,
    pub reward_tokens_per_subscription: i64,
    /// Welcome grant to the redeeming tenant. Absent when unset.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subscriber_bonus_tokens: Option<i64>,
    /// Absent when unset.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discount_percent: Option<f64>,
    /// Scopes the code to ONE plan: the reward is skipped when it is set and does not match the
    /// plan being paid for. Absent means the code pays out on every plan.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_plan_id: Option<String>,
    /// Absent means unlimited.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_uses: Option<i64>,
    /// Server-maintained; carried across a replacing write.
    pub uses: i64,
    pub active: bool,
    /// Carried across a replacing write.
    pub created_at: String,
    pub updated_at: String,
}

/// `PromoCodeInput` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PromoCodeInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<String>,
    pub owner_tenant_id: String,
    pub reward_tokens_per_subscription: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subscriber_bonus_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discount_percent: Option<f64>,
    /// Resend this on every update — the write replaces, so omitting it unscopes the code.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target_plan_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_uses: Option<i64>,
    /// Omitting this on an update REACTIVATES a deactivated code.
    ///
    /// Server default: `true`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
}

/// public.ts GET /public/agents/{agentId} — a hand-built projection, not the Agent record. Keys
/// whose value is undefined are dropped from the JSON, so everything but `agent_id`, `name` and
/// `icon` is conditional; `specs` is omitted entirely when empty.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicAgentCard {
    pub agent_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// `metadata.icon`, `""` when unset.
    pub icon: serde_json::Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub greeting: Option<String>,
    /// `"N tools available"`, only when `public_config.allowed_tools` is set.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub specs: Option<Vec<PublicAgentCardSpec>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ui_avatar: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ui_drop_genome: Option<serde_json::Map<String, serde_json::Value>>,
    /// The tenant that owns the agent — the same value as `PublicTenant.slug`. The
    /// `/c/{slug}/{agentId}` path segment is NOT authoritative (nothing checks it against the
    /// agent); compare it with this and build the way back from here. Present when the owner record
    /// has a slug.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_slug: Option<String>,
    /// The owning tenant's display name. Present when the owner record has one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_name: Option<String>,
}

/// `PublicAgentCardSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicAgentCardSpec {
    pub spec_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
}

/// `PublicBlogPost` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicBlogPost {
    pub slug: String,
    pub title: String,
    /// Markdown.
    pub body: String,
    pub tags: Vec<String>,
    pub published_at: String,
    pub created_at: String,
    pub updated_at: String,
}

/// `PublicBlogPostSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicBlogPostSummary {
    pub slug: String,
    pub title: String,
    pub tags: Vec<String>,
    /// Body with its leading heading and markdown punctuation stripped, first 240 characters.
    pub excerpt: String,
    pub published_at: String,
}

/// Funnel for public (unauthenticated) chat surfaces: visits, engagement, messages, with the
/// usual breakdowns.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalytics {
    pub range: PublicChatAnalyticsRange,
    pub totals: PublicChatAnalyticsTotals,
    /// Ratios, not percentages: 0.25 means a quarter.
    pub conversion: PublicChatAnalyticsConversion,
    pub timeseries: Vec<PublicChatAnalyticsTimesery>,
    pub by_country: Vec<PublicChatAnalyticsByCountryItem>,
    pub by_device: Vec<PublicChatAnalyticsByDeviceItem>,
    pub by_browser: Vec<PublicChatAnalyticsByBrowserItem>,
    pub by_os: Vec<PublicChatAnalyticsByO>,
    pub by_referrer: Vec<PublicChatAnalyticsByReferrerItem>,
    pub by_utm_source: Vec<PublicChatAnalyticsByUtmSourceItem>,
    pub by_agent: Vec<PublicChatAnalyticsByAgentItem>,
}

/// `PublicChatAnalyticsByAgentItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByAgentItem {
    pub agent_id: String,
    pub visits: i64,
    pub engaged: i64,
    pub messages: i64,
}

/// `PublicChatAnalyticsByBrowserItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByBrowserItem {
    pub value: String,
    pub count: i64,
}

/// `PublicChatAnalyticsByCountryItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByCountryItem {
    pub value: String,
    pub count: i64,
}

/// `PublicChatAnalyticsByDeviceItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByDeviceItem {
    pub value: String,
    pub count: i64,
}

/// `PublicChatAnalyticsByO` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByO {
    pub value: String,
    pub count: i64,
}

/// `PublicChatAnalyticsByReferrerItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByReferrerItem {
    pub value: String,
    pub count: i64,
}

/// `PublicChatAnalyticsByUtmSourceItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsByUtmSourceItem {
    pub value: String,
    pub count: i64,
}

/// Ratios, not percentages: 0.25 means a quarter.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsConversion {
    /// engaged / visit.
    pub engagement_rate: f64,
    /// message / visit.
    pub message_rate: f64,
    /// message / engaged.
    pub engaged_to_message_rate: f64,
}

/// `PublicChatAnalyticsRange` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsRange {
    pub from: String,
    pub to: String,
    pub days: i64,
}

/// `PublicChatAnalyticsTimesery` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsTimesery {
    pub date: String,
    pub visits: i64,
    pub engaged: i64,
    pub messages: i64,
}

/// `PublicChatAnalyticsTotals` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicChatAnalyticsTotals {
    pub public_chat_visit: i64,
    pub public_chat_engaged: i64,
    pub public_chat_message: i64,
}

/// `PublicDomainLookupResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicDomainLookupResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub found: Option<bool>,
}

/// `PublicPlan` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicPlan {
    pub id: String,
    pub name: String,
    pub price_amount_cents: i64,
    pub price_currency: String,
    pub quotas: serde_json::Map<String, serde_json::Value>,
}

/// public.ts GET /public/sessions/{sessionId} — every field always present; compacted entries
/// are filtered out and non-string content is JSON-stringified.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicSessionView {
    pub session_id: String,
    pub agent_name: String,
    pub greeting: String,
    pub description: String,
    pub messages: Vec<PublicSessionViewMessage>,
    pub message_count: i64,
    pub messages_remaining: i64,
    pub status: PublicSessionViewStatus,
}

/// `PublicSessionViewMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicSessionViewMessage {
    /// The same derived id the authenticated transcript carries (ConversationEntry.message_id).
    pub message_id: String,
    pub role: PublicSessionViewMessageRole,
    pub content: String,
    pub timestamp: String,
    pub run_id: String,
}

/// `PublicSessionViewMessageRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum PublicSessionViewMessageRole {
    #[default]
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "tool_result")]
    ToolResult,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl PublicSessionViewMessageRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::User => "user",
            Self::Assistant => "assistant",
            Self::System => "system",
            Self::ToolResult => "tool_result",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for PublicSessionViewMessageRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for PublicSessionViewMessageRole {
    fn from(value: &str) -> Self {
        match value {
            "user" => Self::User,
            "assistant" => Self::Assistant,
            "system" => Self::System,
            "tool_result" => Self::ToolResult,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PublicSessionViewStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum PublicSessionViewStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "closed")]
    Closed,
    #[serde(rename = "expired")]
    Expired,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl PublicSessionViewStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Closed => "closed",
            Self::Expired => "expired",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for PublicSessionViewStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for PublicSessionViewStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "closed" => Self::Closed,
            "expired" => Self::Expired,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `PublicState` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicState {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marketplace: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub governance: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branding: Option<serde_json::Map<String, serde_json::Value>>,
    pub category: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
    pub short_description: String,
    pub slug: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub social_links: Option<TenantSocialLinks>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stats: Option<serde_json::Map<String, serde_json::Value>>,
    pub tags: Vec<String>,
    pub tenant_id: String,
}

/// public.ts — keys always present, values may be absent when the index row lacks them.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicStateAgent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub greeting: Option<String>,
}

/// `PublicTenant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicTenant {
    /// Served 2026-09-10; contents not asserted.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marketplace: Option<serde_json::Map<String, serde_json::Value>>,
    pub tenant_id: String,
    pub slug: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    pub tags: Vec<String>,
    pub agents_count: i64,
    pub agents: Vec<PublicTenantAgent>,
    pub stats: PublicTenantStats,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub social_links: Option<TenantSocialLinks>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branding: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
}

/// `PublicTenantAgent` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicTenantAgent {
    pub agent_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub greeting: Option<String>,
}

/// `PublicTenantStats` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicTenantStats {
    pub total_runs: i64,
    pub total_agents: i64,
    pub avg_rating: f64,
}

/// `PublicTrackEventRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublicTrackEventRequest {
    pub event: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `PublishListingRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublishListingRequest {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_version: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub category: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub readme: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pricing: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub a2a_enabled: Option<bool>,
}

/// `PublishWorkspaceSnapshotRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublishWorkspaceSnapshotRequest {
    /// Self-contained HTML, ≤3 MB.
    pub html: String,
    /// Defaults to `Shared page`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

/// `PublishWorkspaceSnapshotResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PublishWorkspaceSnapshotResponse {
    pub token: String,
    pub expires_at: String,
}

/// `PurgeAdminTenantResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PurgeAdminTenantResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub purged: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// `PushBridgeTaskEventsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PushBridgeTaskEventsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub events_stored: Option<i64>,
}

/// `RateListingRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RateListingRequest {
    pub rating: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
}

/// `ReactivateTenantResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReactivateTenantResponse {
    pub reactivated: bool,
    pub tenant_id: String,
}

/// GET /health/ready and GET /readyz (measured 2026-09-10): overall status, the check's
/// timestamp, and one entry per component — cron, events, kv, mcp, workers.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReadinessReport {
    pub status: String,
    pub timestamp: String,
    pub components: serde_json::Map<String, serde_json::Value>,
}

/// `RedeemPromoCodeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RedeemPromoCodeRequest {
    pub code: String,
}

/// `RedeemPromoCodeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RedeemPromoCodeResponse {
    pub redeemed: bool,
    pub code: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discount_percent: Option<f64>,
    pub subscriber_bonus_tokens: i64,
}

/// `RegisterAmbassadorRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegisterAmbassadorRequest {
    pub ambassador_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permissions: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `RegisterAmbassadorResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegisterAmbassadorResponse {
    pub ok: bool,
}

/// `RegisterResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegisterResponse {
    pub message: String,
}

/// `RegistryAdminListSpecsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryAdminListSpecsResponse {
    pub specs: Vec<RegistryAdminListSpecsResponseSpec>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
}

/// `RegistryAdminListSpecsResponseSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryAdminListSpecsResponseSpec {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub owner_tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<SetRegistrySpecVisibilityRequestVisibility>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub latest_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub yanked: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub categories: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub keywords: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// `RegistryGetFileResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetFileResponse {
    pub path: String,
    pub size: i64,
    pub binary: bool,
    pub truncated: bool,
    /// UTF-8 text body. `null` when `binary: true`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
}

/// `RegistryGetReadmeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetReadmeResponse {
    pub readme: String,
}

/// `RegistryGetShareResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetShareResponse {
    pub scope: String,
    pub name: String,
    pub shared_with: Vec<String>,
    pub owner_tenant_id: String,
    pub updated_at: String,
}

/// `RegistryGetSparseIndexResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetSparseIndexResponse {
    pub scope: String,
    pub name: String,
    pub versions: Vec<RegistryGetSparseIndexResponseVersion>,
}

/// `RegistryGetSparseIndexResponseVersion` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetSparseIndexResponseVersion {
    pub version: String,
    pub sha256: String,
    pub dependencies: Vec<ResolvedDep>,
    pub yanked: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub yank_reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
    pub published_at: String,
}

/// `RegistryGetSpecMetadataResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetSpecMetadataResponse {
    pub scope: String,
    pub name: String,
    pub description: String,
    pub license: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub repository: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub homepage: Option<String>,
    pub categories: Vec<String>,
    pub keywords: Vec<String>,
    pub visibility: SetRegistrySpecVisibilityRequestVisibility,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<String>>,
    pub owner_tenant_id: String,
    pub latest_version: String,
    pub versions: Vec<RegistryVersionEntry>,
    pub created_at: String,
    pub updated_at: String,
    pub tool_count: i64,
    pub skill_count: i64,
    pub capabilities: Vec<String>,
    /// The canvas this SPEC's output belongs on. Absent when it names none; a client treats absent
    /// and unknown the same way — chat.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub canvas: Option<RegistryGetSpecMetadataResponseCanvas>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema_version: Option<String>,
}

/// The canvas this SPEC's output belongs on. Absent when it names none; a client treats absent
/// and unknown the same way — chat.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RegistryGetSpecMetadataResponseCanvas {
    #[default]
    #[serde(rename = "document")]
    Document,
    #[serde(rename = "code")]
    Code,
    #[serde(rename = "image")]
    Image,
    #[serde(rename = "drawing")]
    Drawing,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RegistryGetSpecMetadataResponseCanvas {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Document => "document",
            Self::Code => "code",
            Self::Image => "image",
            Self::Drawing => "drawing",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RegistryGetSpecMetadataResponseCanvas {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RegistryGetSpecMetadataResponseCanvas {
    fn from(value: &str) -> Self {
        match value {
            "document" => Self::Document,
            "code" => Self::Code,
            "image" => Self::Image,
            "drawing" => Self::Drawing,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RegistryGetSpecVersionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetSpecVersionResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub manifest: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dependencies: Option<Vec<ResolvedDep>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub yanked: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<SetRegistrySpecVisibilityRequestVisibility>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub download_url: Option<String>,
}

/// `RegistryListFilesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryListFilesResponse {
    pub files: Vec<RegistryListFilesResponseFile>,
}

/// `RegistryListFilesResponseFile` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryListFilesResponseFile {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub binary: Option<bool>,
}

/// `RegistryPublishRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryPublishRequest {
    /// JSON-stringified SpecManifest, validated server-side.
    pub manifest: String,
    /// Spec bundle (.tar.zst). Size capped per platform config.
    pub artifact: FilePart,
    /// Lowercase hex sha256; verified if provided.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,
    /// Optional JSON-stringified SLSA provenance envelope. Shape-checked on publish (object with
    /// non-empty `predicate_type`, `signature`, `public_key` and an object `predicate`) and NOT
    /// verified: artifact signing is off by default (`spec_registry.signing_mode`), `GET
    /// /registry/keys` answers 501, and the loader's signature gate is skipped. Reads that carry an
    /// attestation also carry `attestation_verified: false` — see the version response.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attestation: Option<String>,
}

/// `RegistryPublishResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryPublishResponse {
    pub scope: String,
    pub name: String,
    pub version: String,
    pub publisher_tenant_id: String,
    pub manifest: serde_json::Map<String, serde_json::Value>,
    pub sha256: String,
    pub size_bytes: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub artifact_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dependencies: Option<Vec<ResolvedDep>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub yanked: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub yanked_reason: Option<String>,
    pub visibility: SetRegistrySpecVisibilityRequestVisibility,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attestation: Option<serde_json::Map<String, serde_json::Value>>,
    pub published_at: String,
}

/// `RegistrySearchResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistrySearchResponse {
    pub hits: Vec<RegistrySearchResponseHit>,
    pub total: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
}

/// `RegistrySearchResponseHit` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistrySearchResponseHit {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub categories: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub keywords: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub publisher_tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
}

/// `RegistrySetShareRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistrySetShareRequest {
    /// Tenant IDs allowed to read this private spec.
    pub shared_with: Vec<String>,
}

/// `RegistrySetShareResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistrySetShareResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub owner_tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `RegistrySpecFeatureState` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistrySpecFeatureState {
    pub scope: String,
    pub name: String,
    /// True after a POST, false after a DELETE.
    pub featured: bool,
}

/// `RegistryVersionEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryVersionEntry {
    pub version: String,
    pub sha256: String,
    pub dependencies: Vec<ResolvedDep>,
    pub yanked: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub yank_reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
    pub published_at: String,
}

/// `RegistryYankVersionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryYankVersionRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `ReindexKnowledgeBaseResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReindexKnowledgeBaseResponse {
    pub reindexed: bool,
    pub total_chunks: i64,
    /// Chunks that came back with a vector. Lower than `total_chunks` means some failed.
    pub embedded: i64,
    pub documents: i64,
    pub embedding_model: String,
    pub embedding_dimensions: i64,
}

/// `RejectRunRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RejectRunRequest {
    /// Why the tool was refused; recorded on the run and shown to the agent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `RejectRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RejectRunResponse {
    pub rejected: bool,
    pub run_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `RemoveScheduleResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RemoveScheduleResponse {
    pub removed: bool,
    pub agent_id: String,
}

/// `ReplaceConstitutionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReplaceConstitutionRequest {
    pub rules: Vec<ConstitutionRule>,
    /// Why the constitution is being replaced. Recorded in the immutable ledger and on the
    /// amendment record; defaults to a generic string when omitted.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
}

/// runtime/execution/replay-executor.ts ReplayResult. camelCase on the wire, unlike the rest of
/// the API; `divergencePoint`, `divergenceReason` and `stepComparisons` (execute mode only) are
/// conditional.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReplayResult {
    pub deterministic: bool,
    pub verified: ReplayResultVerified,
    /// Deprecated spelling of `events_replayed` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `events_replayed`.
    #[serde(rename = "eventsReplayed")]
    pub events_replayed: i64,
    /// Deprecated spelling of `run_id` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `run_id`.
    #[serde(rename = "runId")]
    pub run_id: String,
    pub mode: ReplayResultMode,
    /// Deprecated spelling of `divergence_point` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `divergence_point`.
    #[serde(rename = "divergencePoint", default, skip_serializing_if = "Option::is_none")]
    pub divergence_point: Option<i64>,
    /// Deprecated spelling of `divergence_reason` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `divergence_reason`.
    #[serde(rename = "divergenceReason", default, skip_serializing_if = "Option::is_none")]
    pub divergence_reason: Option<String>,
    /// Deprecated spelling of `step_comparisons` — the same value, kept for the compatibility
    /// window and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `step_comparisons`.
    #[serde(rename = "stepComparisons", default, skip_serializing_if = "Option::is_none")]
    pub step_comparisons: Option<Vec<ReplayResultStepComparison>>,
    #[serde(rename = "events_replayed")]
    pub events_replayed_: i64,
    #[serde(rename = "run_id")]
    pub run_id_: String,
    #[serde(rename = "divergence_point", default, skip_serializing_if = "Option::is_none")]
    pub divergence_point_: Option<i64>,
    #[serde(rename = "divergence_reason", default, skip_serializing_if = "Option::is_none")]
    pub divergence_reason_: Option<String>,
    #[serde(rename = "step_comparisons", default, skip_serializing_if = "Option::is_none")]
    pub step_comparisons_: Option<Vec<ReplayResultStepComparison2>>,
}

/// `ReplayResultMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ReplayResultMode {
    #[default]
    #[serde(rename = "verify")]
    Verify,
    #[serde(rename = "execute")]
    Execute,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ReplayResultMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Verify => "verify",
            Self::Execute => "execute",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ReplayResultMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ReplayResultMode {
    fn from(value: &str) -> Self {
        match value {
            "verify" => Self::Verify,
            "execute" => Self::Execute,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ReplayResultStepComparison` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReplayResultStepComparison {
    pub seq: i64,
    pub r#type: String,
    pub matches: bool,
    /// Deprecated spelling of `mismatch_detail` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `mismatch_detail`.
    #[serde(rename = "mismatchDetail", default, skip_serializing_if = "Option::is_none")]
    pub mismatch_detail: Option<String>,
    #[serde(rename = "mismatch_detail", default, skip_serializing_if = "Option::is_none")]
    pub mismatch_detail_: Option<String>,
}

/// `ReplayResultStepComparison2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ReplayResultStepComparison2 {
    pub seq: i64,
    pub r#type: String,
    pub matches: bool,
    /// Deprecated spelling of `mismatch_detail` — the same value, kept for the compatibility window
    /// and removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `mismatch_detail`.
    #[serde(rename = "mismatchDetail", default, skip_serializing_if = "Option::is_none")]
    pub mismatch_detail: Option<String>,
    #[serde(rename = "mismatch_detail", default, skip_serializing_if = "Option::is_none")]
    pub mismatch_detail_: Option<String>,
}

/// `ReplayResultVerified` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ReplayResultVerified {
    #[default]
    #[serde(rename = "recorded_log")]
    RecordedLog,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ReplayResultVerified {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::RecordedLog => "recorded_log",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ReplayResultVerified {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ReplayResultVerified {
    fn from(value: &str) -> Self {
        match value {
            "recorded_log" => Self::RecordedLog,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RequestOtpCodeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RequestOtpCodeResponse {
    pub ok: bool,
    pub message: String,
}

/// `ResendInviteResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResendInviteResponse {
    pub resent: bool,
    pub email_sent: bool,
    pub invite: serde_json::Map<String, serde_json::Value>,
}

/// `ResetAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResetAgentResponse {
    pub ok: bool,
    /// Sessions deleted
    pub sessions: i64,
    /// Runs deleted
    pub runs: i64,
}

/// `ResolveAmbassadorRequestRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResolveAmbassadorRequestRequest {
    pub response: String,
}

/// `ResolvedDep` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResolvedDep {
    pub scope: String,
    pub name: String,
    pub version_req: String,
}

/// `ResolveSharedSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResolveSharedSessionResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<CreateSessionShareRequestRole>,
}

/// Accepted, stored, and enforced by nothing (GOV-D01). The subset check that governs
/// agent-to-agent spawn examines tools, roles, budget, spawn depth and self-modify, and never
/// this field; no reader anywhere consults it to gate access to a resource. Granting or
/// revoking it changes what an operator sees stored and nothing about what an agent may do.
/// Documented rather than removed or enforced: removing it would break a field tenants may
/// already have populated, and enforcing it would invent an authorisation rule the platform has
/// never applied.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResourcePermission {
    pub resource: String,
    pub actions: Vec<ResourcePermissionAction>,
}

/// `ResourcePermissionAction` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ResourcePermissionAction {
    #[default]
    #[serde(rename = "read")]
    Read,
    #[serde(rename = "write")]
    Write,
    #[serde(rename = "delete")]
    Delete,
    #[serde(rename = "execute")]
    Execute,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ResourcePermissionAction {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Read => "read",
            Self::Write => "write",
            Self::Delete => "delete",
            Self::Execute => "execute",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ResourcePermissionAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ResourcePermissionAction {
    fn from(value: &str) -> Self {
        match value {
            "read" => Self::Read,
            "write" => Self::Write,
            "delete" => Self::Delete,
            "execute" => Self::Execute,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ResourceUsageEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResourceUsageEntry {
    pub count: f64,
    pub limit: f64,
    pub over_by: f64,
}

/// `RespondToPublicHitlRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RespondToPublicHitlRequest {
    pub response: String,
}

/// `RespondToPublicHitlResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RespondToPublicHitlResponse {
    pub status: RespondToPublicHitlResponseStatus,
    /// The resumed run, not a new one (public.ts handlePublicRespond).
    pub run_id: String,
}

/// `RespondToPublicHitlResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RespondToPublicHitlResponseStatus {
    #[default]
    #[serde(rename = "ok")]
    Ok,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RespondToPublicHitlResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Ok => "ok",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RespondToPublicHitlResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RespondToPublicHitlResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "ok" => Self::Ok,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RespondToRunRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RespondToRunRequest {
    pub response: String,
}

/// `RespondToRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RespondToRunResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepted: Option<bool>,
}

/// openai-responses.ts — always exactly one message with one output_text part.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResponsesOutputItem {
    pub r#type: ResponsesOutputItemType,
    pub role: OpenAiChatCompletionChoiceMessageRole,
    pub content: Vec<ResponsesOutputItemContentItem>,
}

/// `ResponsesOutputItemContentItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResponsesOutputItemContentItem {
    pub r#type: ResponsesOutputItemContentItemType,
    pub text: String,
}

/// `ResponsesOutputItemContentItemType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ResponsesOutputItemContentItemType {
    #[default]
    #[serde(rename = "output_text")]
    OutputText,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ResponsesOutputItemContentItemType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::OutputText => "output_text",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ResponsesOutputItemContentItemType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ResponsesOutputItemContentItemType {
    fn from(value: &str) -> Self {
        match value {
            "output_text" => Self::OutputText,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ResponsesOutputItemType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ResponsesOutputItemType {
    #[default]
    #[serde(rename = "message")]
    Message,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ResponsesOutputItemType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Message => "message",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ResponsesOutputItemType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ResponsesOutputItemType {
    fn from(value: &str) -> Self {
        match value {
            "message" => Self::Message,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RestoreWorkspaceTrashRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RestoreWorkspaceTrashRequest {
    /// The `.trash/…` path from a trash listing or a soft-delete response.
    pub trash_path: String,
}

/// `RestoreWorkspaceTrashResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RestoreWorkspaceTrashResponse {
    pub restored: bool,
    pub original_path: String,
    pub original_workspace_id: String,
}

/// `ResumeCompanyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResumeCompanyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// `ResumeMissionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResumeMissionResponse {
    pub accepted: bool,
    pub mission: Mission,
}

/// `ResumeRunRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResumeRunRequest {
    /// Stored on the run as `_resume_input`. A string `note` (or `message`) is handed to the model
    /// as a user turn when the run continues.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<ResumeRunRequestInput>,
    /// Accepted and ignored; kept so existing callers are not refused.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: Option<serde_json::Value>,
}

/// Stored on the run as `_resume_input`. A string `note` (or `message`) is handed to the model
/// as a user turn when the run continues.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResumeRunRequestInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `ResumeRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ResumeRunResponse {
    pub resumed: bool,
    pub run_id: String,
}

/// `RevokeAPIKeyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RevokeAPIKeyResponse {
    pub revoked: bool,
    pub key_id: String,
}

/// `RevokeMeSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RevokeMeSessionResponse {
    pub ok: bool,
    pub key_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub already_revoked: Option<bool>,
}

/// EU AI Act (Article 9) classification for an agent.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RiskClassification {
    pub level: RiskClassificationUpdateLevel,
    /// Set when level is `high`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annex_iii_category: Option<RiskClassificationUpdateAnnexIiiCategory>,
    pub justification: String,
    /// Key ID or user ID of whoever classified.
    pub assessor: String,
    pub assessed_at: String,
    pub review_due_at: String,
}

/// Body for `PATCH /api/v1/agents/{agentId}/risk-classification`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RiskClassificationUpdate {
    pub level: RiskClassificationUpdateLevel,
    /// Set when level is `high`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annex_iii_category: Option<RiskClassificationUpdateAnnexIiiCategory>,
    pub justification: String,
    pub assessor: String,
    /// Defaults to now when omitted.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assessed_at: Option<String>,
    pub review_due_at: String,
}

/// Set when level is `high`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RiskClassificationUpdateAnnexIiiCategory {
    #[default]
    #[serde(rename = "biometric")]
    Biometric,
    #[serde(rename = "critical-infrastructure")]
    CriticalInfrastructure,
    #[serde(rename = "education")]
    Education,
    #[serde(rename = "employment")]
    Employment,
    #[serde(rename = "essential-services")]
    EssentialServices,
    #[serde(rename = "law-enforcement")]
    LawEnforcement,
    #[serde(rename = "migration")]
    Migration,
    #[serde(rename = "democratic-processes")]
    DemocraticProcesses,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RiskClassificationUpdateAnnexIiiCategory {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Biometric => "biometric",
            Self::CriticalInfrastructure => "critical-infrastructure",
            Self::Education => "education",
            Self::Employment => "employment",
            Self::EssentialServices => "essential-services",
            Self::LawEnforcement => "law-enforcement",
            Self::Migration => "migration",
            Self::DemocraticProcesses => "democratic-processes",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RiskClassificationUpdateAnnexIiiCategory {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RiskClassificationUpdateAnnexIiiCategory {
    fn from(value: &str) -> Self {
        match value {
            "biometric" => Self::Biometric,
            "critical-infrastructure" => Self::CriticalInfrastructure,
            "education" => Self::Education,
            "employment" => Self::Employment,
            "essential-services" => Self::EssentialServices,
            "law-enforcement" => Self::LawEnforcement,
            "migration" => Self::Migration,
            "democratic-processes" => Self::DemocraticProcesses,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RiskClassificationUpdateLevel` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RiskClassificationUpdateLevel {
    #[default]
    #[serde(rename = "minimal")]
    Minimal,
    #[serde(rename = "limited")]
    Limited,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "unacceptable")]
    Unacceptable,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RiskClassificationUpdateLevel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Minimal => "minimal",
            Self::Limited => "limited",
            Self::High => "high",
            Self::Unacceptable => "unacceptable",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RiskClassificationUpdateLevel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RiskClassificationUpdateLevel {
    fn from(value: &str) -> Self {
        match value {
            "minimal" => Self::Minimal,
            "limited" => Self::Limited,
            "high" => Self::High,
            "unacceptable" => Self::Unacceptable,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RollbackAgentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RollbackAgentRequest {
    /// Version number to rollback to
    pub version: i64,
}

/// governance/emergency.ts RootAttestation — the KV record, unsanitized.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RootAttestation {
    pub root_agent_id: String,
    pub founder_id: String,
    pub founder_signature: String,
    pub constitution_hash: String,
    pub created_at: String,
}

/// `RotateAgentIdentityResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RotateAgentIdentityResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rotated_at: Option<String>,
}

/// `Run` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Run {
    /// Absent for platform-dispatched cloud runs. `bridge` is written by the platform when a local
    /// agent takes the run (run-dispatch.ts, bridge.ts); `async` is only ever an echo of a
    /// client-supplied value and has never been stored on production (measured 2026-09-10 over 8605
    /// run records: absent 7738, bridge 867, async 0).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_mode: Option<RunExecutionMode>,
    pub run_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    pub status: RunStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    /// Run output — the same object rides in run events and in a public session's stream
    /// (RunOutput). When a run is truncated by its step-budget cutoff (output.truncated === true)
    /// AND the platform has UARP_CONTINUATION_TOKEN_KEY configured, output.continuation_token
    /// carries an opaque HMAC-signed token that resumes the run via POST /runs/{id}/continue. With
    /// no key configured no token is minted and the field is absent; the token is an opaque string
    /// to every client.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<RunOutput>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<RunMetrics>,
    /// The sentence a person reads. English on every deployment — nothing here varies by
    /// `Accept-Language` — so branch on `error_code`, not on this.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /// Why the run failed, as a value from the `code` dictionary (see the `Error` schema's enum).
    /// Absent when the failure carries nothing a client can branch on — which is deliberate: a code
    /// meaning "something went wrong" would be worse than none. Populated since 2026-09-21; before
    /// that a client had to regex-test `error`. `approval_rejected` (since 2026-09-22) means a
    /// person refused the tool call the run was waiting on — `status` is still `failed`, and
    /// `error` is the reviewer's own reason.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_code: Option<String>,
    /// Numbers the code cannot carry: `retry_after_ms` with `provider_circuit_open`,
    /// `quota_exhausted` with `provider_rate_limited`, `stale_seconds` with `run_input_timeout`.
    /// Never a provider id — this reaches a screen, and the product does not name the model it
    /// picked.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_details: Option<serde_json::Map<String, serde_json::Value>>,
    /// Every human decision on a tool approval this run waited for, oldest first. Absent when the
    /// run never waited for one. Recorded since 2026-09-22; before that an approved call left no
    /// trace on the run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approvals: Option<Vec<RunApproval>>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub started_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
    /// Team run ID if part of a team execution
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_run_id: Option<String>,
    /// User-supplied metadata
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    /// Current step sequence number
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub step_seq: Option<i64>,
    /// Run artifacts
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub artifacts: Option<Vec<Artifact>>,
    /// Resource limits for the run
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource_limits: Option<RunResourceLimits>,
}

/// `RunApproval` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunApproval {
    pub decision: RunApprovalDecision,
    /// Tools the run was waiting on when the decision was made.
    pub tools: Vec<String>,
    pub decided_at: String,
    /// User id of the person who decided; the credential id when no person stands behind it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decided_by: Option<String>,
    /// The reviewer's reason, on a rejection.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `RunApprovalDecision` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunApprovalDecision {
    #[default]
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "rejected")]
    Rejected,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunApprovalDecision {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Approved => "approved",
            Self::Rejected => "rejected",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunApprovalDecision {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunApprovalDecision {
    fn from(value: &str) -> Self {
        match value {
            "approved" => Self::Approved,
            "rejected" => Self::Rejected,
            other => Self::Other(other.to_string()),
        }
    }
}

/// The body is optional and carries at most a `response` for the agent. An unknown field is
/// REFUSED, not ignored: `{"approved": false}` sent here used to be stripped in silence while
/// the endpoint approved anyway and answered `{"approved": true}`. To refuse a tool call, POST
/// /runs/{runId}/reject.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunApproveRequest {
    /// Optional message passed back to the agent alongside the approval.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: Option<String>,
}

/// `RunCanvasLoopRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCanvasLoopRequest {
    pub supervisor_agent_id: String,
    /// The agents drawn inside the loop. An empty array is 400 ("this loop has no worker agents
    /// inside it"), so it is required in practice and declared so here.
    pub worker_ids: Vec<String>,
    /// Which drawn loop to run. Required — the handler 400s without it, and it is the key the
    /// persisted layout is looked up by.
    pub loop_id: String,
    /// Overrides the exit condition stored on the drawn loop for this run only. Read at
    /// canvas.ts:234; was undocumented, so a client generated from this document could not send it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub condition: Option<String>,
    /// Overrides the loop's stored instruction for this run only. Read at canvas.ts:238.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompt: Option<String>,
}

/// `RunCanvasLoopResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCanvasLoopResponse {
    pub mission_id: String,
    pub team_id: String,
    pub worker_count: i64,
    pub max_passes: i64,
    pub budget_usd: f64,
    pub time_minutes: f64,
}

/// `RunCanvasWorkflowRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCanvasWorkflowRequest {
    /// The agent steps, in graph order. Fewer than two is 400 — a canvas of unconnected agents has
    /// no order to execute in. This was the whole body and the document did not carry it:
    /// `entry_agent_id` and `max_passes_per_step` were declared instead, and neither is read by any
    /// handler in the platform.
    pub steps: Vec<CanvasWorkflowStep>,
    /// Mission goal. Defaults to the literal "Workflow" when omitted (canvas.ts:313).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget_usd_per_step: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub time_minutes: Option<f64>,
    /// Free text passed into the run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub feedback: Option<String>,
}

/// `RunCanvasWorkflowResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCanvasWorkflowResponse {
    pub mission_id: String,
    /// Objectives created — one per agent step.
    pub step_count: i64,
    /// Workflow edges the plan was built from.
    pub edge_count: i64,
}

/// `RunCheckpoint` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCheckpoint {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub step: Option<i64>,
    /// The conversation as it stood at this checkpoint — the model-facing ChatMessage list the
    /// runtime stores (checkpoint-manager.ts CheckpointData / continuation.ts); a manual checkpoint
    /// row carries none.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub messages: Option<Vec<ChatMessage>>,
    /// Accumulated run metrics — `RunMetricsAccumulator` (`runtime/core/step-executor.ts:156`):
    /// step and token counters, optionally provider cache hits.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<serde_json::Map<String, serde_json::Value>>,
}

/// What a run is likely to cost before it is started. Nothing is dispatched and nothing is
/// stored — this is a read.
///
/// The numbers are an estimate built from the agent's own recent runs, and the `basis` block
/// says what they rest on so a client can present them honestly instead of showing every figure
/// with the same confidence.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCostEstimate {
    /// The model the estimate was priced against, after any per-session override.
    pub model: String,
    pub estimate: RunCostEstimateEstimate,
    /// What the estimate was computed from. A zero sample is not an error — it means the agent has
    /// no history yet and the defaults were used.
    pub basis: RunCostEstimateBasis,
}

/// What the estimate was computed from. A zero sample is not an error — it means the agent has
/// no history yet and the defaults were used.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCostEstimateBasis {
    /// Every cost in this response is at this rate. `user` — what the run will be billed (provider
    /// × markup); never the provider's own rate.
    pub rate: RunCostEstimateBasisRate,
    pub runs_sampled: i64,
    #[serde(default)]
    pub avg_steps: Option<i64>,
    #[serde(default)]
    pub avg_output_tokens_per_step: Option<i64>,
    /// Median of the sampled runs' actual cost.
    #[serde(default)]
    pub median_cost_usd: Option<f64>,
    /// What a bad run looked like — the number worth showing next to the estimate.
    #[serde(default)]
    pub p90_cost_usd: Option<f64>,
    /// `model` — a real per-model rate; `fallback` — the configured tier rate, i.e. a number with a
    /// shrug behind it; `unknown` — no rate at all, and the estimate is zero.
    pub pricing: RunCostEstimateBasisPricing,
}

/// `model` — a real per-model rate; `fallback` — the configured tier rate, i.e. a number with a
/// shrug behind it; `unknown` — no rate at all, and the estimate is zero.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunCostEstimateBasisPricing {
    #[default]
    #[serde(rename = "model")]
    Model,
    #[serde(rename = "fallback")]
    Fallback,
    #[serde(rename = "unknown")]
    Unknown,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunCostEstimateBasisPricing {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Model => "model",
            Self::Fallback => "fallback",
            Self::Unknown => "unknown",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunCostEstimateBasisPricing {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunCostEstimateBasisPricing {
    fn from(value: &str) -> Self {
        match value {
            "model" => Self::Model,
            "fallback" => Self::Fallback,
            "unknown" => Self::Unknown,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Every cost in this response is at this rate. `user` — what the run will be billed (provider
/// × markup); never the provider's own rate.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunCostEstimateBasisRate {
    #[default]
    #[serde(rename = "user")]
    User,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunCostEstimateBasisRate {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::User => "user",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunCostEstimateBasisRate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunCostEstimateBasisRate {
    fn from(value: &str) -> Self {
        match value {
            "user" => Self::User,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RunCostEstimateEstimate` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCostEstimateEstimate {
    /// At the user rate — the provider rate times the platform markup, the same rate
    /// `metrics.total_cost_usd` is written at — so it is comparable with `basis.median_cost_usd`
    /// and `basis.p90_cost_usd`.
    pub estimated_cost_usd: f64,
    /// `medium` only when past runs supplied a step count; `low` otherwise, including when no rate
    /// is known at all.
    pub confidence: RunCostEstimateEstimateConfidence,
    pub breakdown: RunCostEstimateEstimateBreakdown,
}

/// `RunCostEstimateEstimateBreakdown` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunCostEstimateEstimateBreakdown {
    pub input_tokens_est: i64,
    pub output_tokens_est: i64,
    pub input_cost_est: f64,
    pub output_cost_est: f64,
}

/// `medium` only when past runs supplied a step count; `low` otherwise, including when no rate
/// is known at all.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunCostEstimateEstimateConfidence {
    #[default]
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunCostEstimateEstimateConfidence {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Low => "low",
            Self::Medium => "medium",
            Self::High => "high",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunCostEstimateEstimateConfidence {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunCostEstimateEstimateConfidence {
    fn from(value: &str) -> Self {
        match value {
            "low" => Self::Low,
            "medium" => Self::Medium,
            "high" => Self::High,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RunEvaluationRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunEvaluationRequest {
    pub dataset_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_version: Option<String>,
}

/// Absent for platform-dispatched cloud runs. `bridge` is written by the platform when a local
/// agent takes the run (run-dispatch.ts, bridge.ts); `async` is only ever an echo of a
/// client-supplied value and has never been stored on production (measured 2026-09-10 over 8605
/// run records: absent 7738, bridge 867, async 0).
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunExecutionMode {
    #[default]
    #[serde(rename = "async")]
    Async,
    #[serde(rename = "bridge")]
    Bridge,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunExecutionMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Async => "async",
            Self::Bridge => "bridge",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunExecutionMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunExecutionMode {
    fn from(value: &str) -> Self {
        match value {
            "async" => Self::Async,
            "bridge" => Self::Bridge,
            other => Self::Other(other.to_string()),
        }
    }
}

/// GET …/feedback without `message_id`: every reaction the caller stored on the run (measured
/// 2026-09-10: `{"feedbacks":\[\]}` on a run with none).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunFeedbackList {
    pub feedbacks: Vec<RunFeedbackListFeedback>,
}

/// `RunFeedbackListFeedback` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunFeedbackListFeedback {
    /// The entry's `message_id` from GET /sessions/{sessionId}/messages
    /// (ConversationEntry.message_id) — the canonical key; any string is stored as sent.
    pub message_id: String,
    pub reaction: RunFeedbackListFeedbackReaction,
    /// Present only when the reader gave one with the reaction.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `RunFeedbackListFeedbackReaction` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunFeedbackListFeedbackReaction {
    #[default]
    #[serde(rename = "up")]
    Up,
    #[serde(rename = "down")]
    Down,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunFeedbackListFeedbackReaction {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Up => "up",
            Self::Down => "down",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunFeedbackListFeedbackReaction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunFeedbackListFeedbackReaction {
    fn from(value: &str) -> Self {
        match value {
            "up" => Self::Up,
            "down" => Self::Down,
            other => Self::Other(other.to_string()),
        }
    }
}

/// GET …/feedback with `message_id`: that one reaction, `null` when the caller has not reacted.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunFeedbackOne {
    #[serde(default)]
    pub reaction: Option<String>,
    /// Present only when the reader gave one with the reaction.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// PUT …/feedback: the stored reaction, echoed (runs.ts putRunFeedback, sessions.ts
/// putSessionFeedback — the same literal).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunFeedbackSet {
    pub reaction: RunFeedbackListFeedbackReaction,
    pub message_id: String,
    /// Echoed only when the caller sent one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `RunMetrics` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunMetrics {
    /// How the cost was priced (measured 2026-09-10 on e2e-canon; billing/cost-estimator.ts).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pricing_confidence: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub steps_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm_calls_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrail_checks: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrail_violations: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_retrievals: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub memory_extractions: Option<i64>,
    /// Estimated total cost in USD
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_cost_usd: Option<f64>,
}

/// `RunMissionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunMissionResponse {
    pub accepted: bool,
    pub already_running: bool,
    pub mission: Mission,
}

/// What the runtime writes as a run's `output` (agent-runtime.ts, the normal completion and the
/// max-steps cutoff). Measured 2026-09-10 on production, 8 640 stored runs: `{ response }` 6
/// 722; `{ response, search_sources }` 334; `{ response, output_truncated }` 23; `{ response,
/// search_sources, output_truncated }` 3; `{ response, truncated, continuation_token }` 3; `{
/// response, truncated }` 2; `{}` 3. A bridge agent (execution_mode bridge) reports its own
/// output — `{ response: "" }` is what it has been sending. Additional keys are possible from
/// that path; the five below are the platform's own.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunOutput {
    /// The final assistant text.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: Option<String>,
    /// URLs a real `web_search` tool call returned during this run — read back out of the tool
    /// results (`URL:` lines, response-postprocessing.ts extractSearchSources, deduplicated, at
    /// most 8), NOT out of the model's text. Present only when non-empty. Provenance is the point:
    /// a chat surface unfurls only these into preview cards, so a URL the model wrote from memory
    /// is never dressed up as a verified source. Witness: run 019faf2c… on tenant 019d9364…
    /// (2026-07-29) carries 8, the first on en.wikipedia.org.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub search_sources: Option<Vec<String>>,
    /// The model stopped because it ran out of OUTPUT tokens (`finish_reason: length`), not because
    /// it was finished — the answer ends mid-sentence. Present only when true; the chat offers
    /// "Continue generating" on this flag alone. Distinct from `truncated` (step budget). 26 stored
    /// runs carry it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_truncated: Option<bool>,
    /// The run hit its step budget (max_steps) before finishing. Present only when true.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub truncated: Option<bool>,
    /// Opaque HMAC-signed token minted with `truncated` when UARP_CONTINUATION_TOKEN_KEY is
    /// configured; resumes the run via POST /runs/{id}/continue.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub continuation_token: Option<String>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

/// `RunReconciliationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunReconciliationResponse {
    pub reconciliation: CostReconciliationResult,
}

/// Resource limits for the run
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunResourceLimits {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_steps: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tool_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens_per_run: Option<i64>,
}

/// `RunStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunStatus {
    #[default]
    #[serde(rename = "queued")]
    Queued,
    #[serde(rename = "running")]
    Running,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "cancelled")]
    Cancelled,
    #[serde(rename = "timeout")]
    Timeout,
    #[serde(rename = "guardrail_blocked")]
    GuardrailBlocked,
    #[serde(rename = "paused")]
    Paused,
    #[serde(rename = "awaiting_approval")]
    AwaitingApproval,
    #[serde(rename = "awaiting_input")]
    AwaitingInput,
    #[serde(rename = "auth_required")]
    AuthRequired,
    #[serde(rename = "rejected")]
    Rejected,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Queued => "queued",
            Self::Running => "running",
            Self::Completed => "completed",
            Self::Failed => "failed",
            Self::Cancelled => "cancelled",
            Self::Timeout => "timeout",
            Self::GuardrailBlocked => "guardrail_blocked",
            Self::Paused => "paused",
            Self::AwaitingApproval => "awaiting_approval",
            Self::AwaitingInput => "awaiting_input",
            Self::AuthRequired => "auth_required",
            Self::Rejected => "rejected",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunStatus {
    fn from(value: &str) -> Self {
        match value {
            "queued" => Self::Queued,
            "running" => Self::Running,
            "completed" => Self::Completed,
            "failed" => Self::Failed,
            "cancelled" => Self::Cancelled,
            "timeout" => Self::Timeout,
            "guardrail_blocked" => Self::GuardrailBlocked,
            "paused" => Self::Paused,
            "awaiting_approval" => Self::AwaitingApproval,
            "awaiting_input" => Self::AwaitingInput,
            "auth_required" => Self::AuthRequired,
            "rejected" => Self::Rejected,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RunStep` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunStep {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub step_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub step_index: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<RunStepStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<RunStepMetrics>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub started_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
}

/// `RunStepMetrics` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunStepMetrics {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub llm_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_usd: Option<f64>,
}

/// `RunStepStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RunStepStatus {
    #[default]
    #[serde(rename = "running")]
    Running,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RunStepStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Running => "running",
            Self::Completed => "completed",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for RunStepStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for RunStepStatus {
    fn from(value: &str) -> Self {
        match value {
            "running" => Self::Running,
            "completed" => Self::Completed,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RunWorkspaceCommandRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunWorkspaceCommandRequest {
    pub command: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workdir: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_sec: Option<i64>,
}

/// `RunWorkspaceCommandResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunWorkspaceCommandResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<String>,
}

/// What `GET /agents/{agentId}/schedule` returns: `agent_id`, the config fields flattened, and
/// the runtime state. Keys as served 2026-09-10; `last_fired_at`, `autonomous_mode` and
/// `reflection_prompt` appear only when set.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Schedule {
    pub agent_id: String,
    pub cron: String,
    pub enabled: bool,
    pub timezone: String,
    pub input: serde_json::Map<String, serde_json::Value>,
    pub max_concurrent_scheduled: i64,
    pub on_failure: AgentScheduleConfigOnFailure,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub autonomous_mode: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reflection_prompt: Option<String>,
    /// State of the scheduler ENTRY (ScheduleEntry.status in @uarp/scheduler), not whether the
    /// schedule is switched on: measured 2026-09-10, `active` on every live entry, including two
    /// with `enabled: false`. The human-facing on/off is `enabled`.
    pub status: ScheduleEntryStatus,
    /// The next fire when `enabled` is true. On a disabled schedule the server keeps the last
    /// computed instant, so it can lie in the past (measured 2026-09-10 on two disabled entries).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_fire_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_fired_at: Option<String>,
    pub consecutive_failures: i64,
}

/// `ScheduleCanvasWorkflowRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ScheduleCanvasWorkflowRequest {
    /// The trigger node's id on the canvas.
    pub trigger_id: String,
    pub cron: String,
    /// The agent steps the schedule fires, in graph order. Fewer than two is 400. Undeclared until
    /// now, alongside `goal` — while `entry_agent_id`, which WAS declared, is read by nothing: a
    /// client built from this document sent the one field the handler ignores and omitted the two
    /// it requires.
    pub steps: Vec<CanvasWorkflowStep>,
    /// Goal recorded on the schedule. Defaults to the literal "Workflow" (canvas.ts:415).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal: Option<String>,
    /// Persisted on the schedule. Omitted, every scheduled fire silently reverts to the default
    /// per-step budget rather than the one the operator set for the run.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget_usd_per_step: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub time_minutes: Option<f64>,
}

/// `ScheduleCanvasWorkflowResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ScheduleCanvasWorkflowResponse {
    pub trigger_id: String,
    pub cron: String,
    pub next_fire_at: String,
    pub status: ScheduleCanvasWorkflowResponseStatus,
}

/// `ScheduleCanvasWorkflowResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ScheduleCanvasWorkflowResponseStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ScheduleCanvasWorkflowResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ScheduleCanvasWorkflowResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ScheduleCanvasWorkflowResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            other => Self::Other(other.to_string()),
        }
    }
}

/// What `PUT /agents/{agentId}/schedule` returns: the stored entry with its `config` nested
/// (ScheduleEntry in @uarp/scheduler). `GET` returns the flattened `Schedule` instead.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ScheduleEntry {
    pub tenant_id: String,
    pub agent_id: String,
    pub config: AgentScheduleConfig,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_fired_at: Option<String>,
    /// The next fire when `enabled` is true. On a disabled schedule the server keeps the last
    /// computed instant, so it can lie in the past (measured 2026-09-10 on two disabled entries).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_fire_at: Option<String>,
    pub consecutive_failures: i64,
    /// State of the scheduler ENTRY (ScheduleEntry.status in @uarp/scheduler), not whether the
    /// schedule is switched on: measured 2026-09-10, `active` on every live entry, including two
    /// with `enabled: false`. The human-facing on/off is `enabled`.
    pub status: ScheduleEntryStatus,
}

/// State of the scheduler ENTRY (ScheduleEntry.status in @uarp/scheduler), not whether the
/// schedule is switched on: measured 2026-09-10, `active` on every live entry, including two
/// with `enabled: false`. The human-facing on/off is `enabled`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ScheduleEntryStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "paused")]
    Paused,
    #[serde(rename = "error")]
    Error,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ScheduleEntryStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Paused => "paused",
            Self::Error => "error",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for ScheduleEntryStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ScheduleEntryStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "paused" => Self::Paused,
            "error" => Self::Error,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ScheduleSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ScheduleSummary {
    pub agent_id: String,
    /// Resolved for display; absent if the agent record is gone.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    pub cron: String,
    pub enabled: bool,
    /// `paused` or `error`, or accumulated failures, is what a “silently dead cron” looks like.
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_fire_at: Option<String>,
}

/// `SearchKnowledgeBaseRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchKnowledgeBaseRequest {
    pub query: String,
    /// Maximum chunks to return.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

/// `SearchMarketplaceResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchMarketplaceResponse {
    pub items: Vec<MarketplaceListing>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub listings: Option<Vec<MarketplaceListing>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `SearchMarketplaceSort` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SearchMarketplaceSort {
    #[default]
    #[serde(rename = "rating")]
    Rating,
    #[serde(rename = "popularity")]
    Popularity,
    #[serde(rename = "recency")]
    Recency,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SearchMarketplaceSort {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Rating => "rating",
            Self::Popularity => "popularity",
            Self::Recency => "recency",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SearchMarketplaceSort {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SearchMarketplaceSort {
    fn from(value: &str) -> Self {
        match value {
            "rating" => Self::Rating,
            "popularity" => Self::Popularity,
            "recency" => Self::Recency,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SearchMemoryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchMemoryResponse {
    pub memories: Vec<MemoryEntry>,
    pub total: i64,
}

/// `SearchResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchResponse {
    pub results: Vec<SearchResult>,
}

/// search.ts SearchResult — `subtitle` is omitted for some result kinds.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchResult {
    pub r#type: SearchResultType,
    pub id: String,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subtitle: Option<String>,
    pub href: String,
    pub icon: String,
}

/// `SearchResultType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SearchResultType {
    #[default]
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "run")]
    Run,
    #[serde(rename = "session")]
    Session,
    #[serde(rename = "file")]
    File,
    #[serde(rename = "image")]
    Image,
    #[serde(rename = "project")]
    Project,
    #[serde(rename = "memory")]
    Memory,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SearchResultType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Agent => "agent",
            Self::Run => "run",
            Self::Session => "session",
            Self::File => "file",
            Self::Image => "image",
            Self::Project => "project",
            Self::Memory => "memory",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SearchResultType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SearchResultType {
    fn from(value: &str) -> Self {
        match value {
            "agent" => Self::Agent,
            "run" => Self::Run,
            "session" => Self::Session,
            "file" => Self::File,
            "image" => Self::Image,
            "project" => Self::Project,
            "memory" => Self::Memory,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SearchType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SearchType {
    #[default]
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "session")]
    Session,
    #[serde(rename = "run")]
    Run,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SearchType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Agent => "agent",
            Self::Session => "session",
            Self::Run => "run",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SearchType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SearchType {
    fn from(value: &str) -> Self {
        match value {
            "agent" => Self::Agent,
            "session" => Self::Session,
            "run" => Self::Run,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SearchWorkspaceFilesRegex` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SearchWorkspaceFilesRegex {
    #[default]
    #[serde(rename = "true")]
    True,
    #[serde(rename = "1")]
    V1,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SearchWorkspaceFilesRegex {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::True => "true",
            Self::V1 => "1",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SearchWorkspaceFilesRegex {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SearchWorkspaceFilesRegex {
    fn from(value: &str) -> Self {
        match value {
            "true" => Self::True,
            "1" => Self::V1,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SearchWorkspaceFilesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchWorkspaceFilesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub results: Option<Vec<SearchWorkspaceFilesResponseResult>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `SearchWorkspaceFilesResponseResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchWorkspaceFilesResponseResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// Deprecated spelling of `line_number` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `line_number`.
    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
    pub line_number: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub line: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#match: Option<String>,
    #[serde(rename = "line_number", default, skip_serializing_if = "Option::is_none")]
    pub line_number_: Option<i64>,
}

/// `SeedStarterSpecsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SeedStarterSpecsResponse {
    /// Newly published.
    pub added: i64,
    /// Already present at the bundled version.
    pub skipped: i64,
    /// How many starter SPECs the build ships. `added + skipped` reaching this is the completion
    /// signal.
    pub total_starter: i64,
    /// Absent when nothing failed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub errors: Option<Vec<SeedStarterSpecsResponseError>>,
}

/// `SeedStarterSpecsResponseError` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SeedStarterSpecsResponseError {
    pub name: String,
    pub error: String,
}

/// `SendPublicMessageRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SendPublicMessageRequest {
    pub content: String,
}

/// `SendPublicMessageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SendPublicMessageResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub messages_remaining: Option<i64>,
}

/// `content` is always present in the body; it may be the empty string when `file_ids` carries
/// at least one id.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SendSessionMessageRequest {
    /// Message body. May be empty when `file_ids` is non-empty — a photo with no caption is an
    /// ordinary message. A message with neither text nor files is refused.
    pub content: String,
    /// Optional slash-command string when the message is a builtin command.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    /// Optional attached file ids previously uploaded via /api/v1/files.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_ids: Option<Vec<String>>,
    /// Workspace override for this message; defaults to the agent's workspace.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
}

/// `SendSessionMessageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SendSessionMessageResponse {
    pub run_id: String,
}

/// `SensorWebhookResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SensorWebhookResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepted: Option<bool>,
}

/// `Session` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Session {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_by: Option<String>,
    pub session_id: String,
    pub tenant_id: String,
    pub agent_id: String,
    pub status: PublicSessionViewStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conversation_history: Option<Vec<ConversationEntry>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub runs: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    /// Team ID if session belongs to a team
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    /// Session branches for conversation forking
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branches: Option<Vec<SessionBranch>>,
    /// Currently active branch ID
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_branch: Option<String>,
    /// How to handle concurrent runs in this session
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub queue_mode: Option<SessionQueueMode>,
    /// Per-conversation model override (in-chat model switcher). When set, runs in this session
    /// resolve their LLM from this config instead of the agent's default. Absent → agent default.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_override: Option<SessionModelOverride>,
}

/// sessions.ts AnnotationRecord — the six-field projection create, list and PATCH all answer
/// with.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionAnnotation {
    pub id: String,
    pub message_id: String,
    pub content: String,
    pub author: String,
    pub created_at: String,
    pub resolved: bool,
}

/// `SessionBranch` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionBranch {
    pub branch_id: String,
    /// Absent on the main branch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_branch_id: Option<String>,
    pub name: String,
    /// The run this branch forked after. Empty when the session had no runs yet.
    pub fork_point_run_id: String,
    pub fork_point_step_seq: i64,
    pub runs: Vec<String>,
    pub status: SessionBranchStatus,
    pub created_at: String,
}

/// `SessionBranchStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SessionBranchStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "abandoned")]
    Abandoned,
    #[serde(rename = "merged")]
    Merged,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SessionBranchStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Abandoned => "abandoned",
            Self::Merged => "merged",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SessionBranchStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SessionBranchStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "abandoned" => Self::Abandoned,
            "merged" => Self::Merged,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SessionExport` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionExport {
    pub exported_at: String,
    /// Always `snaga.chat.v1`.
    pub format: String,
    pub session_id: String,
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    pub messages: Vec<SessionExportMessage>,
}

/// `SessionExportMessage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionExportMessage {
    pub role: String,
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<SessionExportMessageToolCall>>,
}

/// `SessionExportMessageToolCall` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionExportMessageToolCall {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Per-conversation model override (in-chat model switcher). When set, runs in this session
/// resolve their LLM from this config instead of the agent's default. Absent → agent default.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionModelOverride {
    pub provider: String,
    pub model_ref: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
}

/// How to handle concurrent runs in this session
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SessionQueueMode {
    #[default]
    #[serde(rename = "allow")]
    Allow,
    #[serde(rename = "reject")]
    Reject,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SessionQueueMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Allow => "allow",
            Self::Reject => "reject",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SessionQueueMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SessionQueueMode {
    fn from(value: &str) -> Self {
        match value {
            "allow" => Self::Allow,
            "reject" => Self::Reject,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SetAdminIntegrationOAuthProviderRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAdminIntegrationOAuthProviderRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    /// Never returned by any read. Omit to keep the stored one.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_secret: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
}

/// `SetAdminIntegrationOAuthProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAdminIntegrationOAuthProviderResponse {
    pub provider: String,
    pub enabled: bool,
    pub configured: bool,
}

/// `SetAdminLLMDefaultRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAdminLLMDefaultRequest {
    pub api_key: String,
}

/// `SetAdminLLMDefaultResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAdminLLMDefaultResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated: Option<bool>,
}

/// `SetAdminModelConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAdminModelConfigResponse {
    #[serde(default)]
    pub default_provider: Option<String>,
    #[serde(default)]
    pub default_model: Option<String>,
    #[serde(default)]
    pub default_endpoint: Option<String>,
    #[serde(default)]
    pub fallback_provider: Option<String>,
    #[serde(default)]
    pub fallback_model: Option<String>,
    #[serde(default)]
    pub fallback_endpoint: Option<String>,
}

/// `SetAgentCapabilitiesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentCapabilitiesResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// `SetAgentIntegrationsRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentIntegrationsRequest {
    /// The COMPLETE set after the call. Non-string members are ignored; ids the tenant does not own
    /// come back under `diff.unknown` rather than failing the call.
    pub integration_ids: Vec<String>,
}

/// `SetAgentIntegrationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentIntegrationsResponse {
    pub integrations: Vec<AgentIntegration>,
    pub total: i64,
    pub diff: SetAgentIntegrationsResponseDiff,
}

/// `SetAgentIntegrationsResponseDiff` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentIntegrationsResponseDiff {
    pub assigned: Vec<String>,
    pub unassigned: Vec<String>,
    pub unknown: Vec<String>,
}

/// `SetAgentMCPServersRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentMCPServersRequest {
    /// The complete set after the call. An empty array disconnects every server from this agent.
    pub server_ids: Vec<String>,
}

/// `SetAgentMCPServersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentMCPServersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    /// Server ids that gained this agent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub connected: Option<Vec<String>>,
    /// Server ids that lost it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disconnected: Option<Vec<String>>,
}

/// `SetAgentPermissionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentPermissionsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// `SetAgentTrafficRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentTrafficRequest {
    pub entries: Vec<SetAgentTrafficRequestEntry>,
}

/// `SetAgentTrafficRequestEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentTrafficRequestEntry {
    pub version: i64,
    pub weight: f64,
}

/// `SetAgentTrafficResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetAgentTrafficResponse {
    pub agent_id: String,
    pub entries: Vec<TrafficSplitEntry>,
    #[serde(default)]
    pub updated_at: Option<String>,
}

/// `SetArbiterRegistryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetArbiterRegistryResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// `SetBillingBudgetRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetBillingBudgetRequest {
    pub limit_usd: f64,
    /// Server default: `0.8`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub soft_threshold: Option<f64>,
    /// Server default: `1`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hard_threshold: Option<f64>,
    /// Server default: `"monthly"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub period: Option<GetBillingBudgetResponseBudgetPeriod>,
}

/// `SetBillingBudgetResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetBillingBudgetResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `SetBillingOverageRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetBillingOverageRequest {
    pub enabled: bool,
}

/// `SetBillingOverageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetBillingOverageResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requires_cap: Option<bool>,
}

/// `SetDataExplorerValueRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetDataExplorerValueRequest {
    pub namespace: String,
    pub key: Vec<serde_json::Value>,
    pub value: serde_json::Value,
}

/// `SetDataExplorerValueResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetDataExplorerValueResponse {
    pub success: bool,
    pub size_bytes: i64,
}

/// `SetFeatureFlagsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetFeatureFlagsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub flags: Option<Vec<FeatureFlag>>,
    pub updated: bool,
}

/// `SetLLMProviderKeyProvider` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SetLLMProviderKeyProvider {
    #[default]
    #[serde(rename = "openai_compat")]
    OpenaiCompat,
    #[serde(rename = "custom")]
    Custom,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SetLLMProviderKeyProvider {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::OpenaiCompat => "openai_compat",
            Self::Custom => "custom",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SetLLMProviderKeyProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SetLLMProviderKeyProvider {
    fn from(value: &str) -> Self {
        match value {
            "openai_compat" => Self::OpenaiCompat,
            "custom" => Self::Custom,
            other => Self::Other(other.to_string()),
        }
    }
}

/// WRITE SEMANTICS: mixed. `api_key` REPLACES on every call. `shared` MERGES — omit it and the
/// stored consent flag is kept. Verified against the handler and the store (ITG-05): omission
/// used to drop the flag, and since absent means shareable, a rotation silently returned an
/// opted-out personal key to the tenant-wide pool. Sending `shared: true` is the only way to
/// clear an opt-out.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetLLMProviderKeyRequest {
    /// Provider API key (stored encrypted)
    pub api_key: String,
    /// Consent for the tenant-wide fallback tier. `false` keeps this personal key out of other
    /// users' runs. Absent on a first write means shareable; absent on a later write means
    /// unchanged.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared: Option<bool>,
}

/// `SetLLMProviderKeyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetLLMProviderKeyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    /// Effective consent flag after the write. Absent when never set. Returned so a client can send
    /// back what it read — before ITG-05 no read path exposed it, which is why every rotation
    /// cleared it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `SetMaintenanceStateRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetMaintenanceStateRequest {
    /// Strictly a boolean — the string "true" is 400, not coerced.
    pub enabled: bool,
    /// Plain text shown on the blocked page; the API does not render HTML. Trimmed, and one that
    /// trims to empty is stored as no message at all. Over 500 characters is 400 — the cap exists
    /// so a misconfigured value cannot become an unbounded payload served at the edge.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `SetModelPricingOverrideRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetModelPricingOverrideRequest {
    pub input_per_million: f64,
    pub output_per_million: f64,
    /// Discounted rate for provider prefix-cache hits. Absent means cached tokens bill at the full
    /// input rate.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cached_input_per_million: Option<f64>,
}

/// `SetModelPricingOverrideResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetModelPricingOverrideResponse {
    /// Deprecated spelling of `model_ref` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read `model_ref`.
    #[serde(rename = "modelRef")]
    pub model_ref: String,
    pub input_per_million: f64,
    pub output_per_million: f64,
    /// Absent when not set.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cached_input_per_million: Option<f64>,
    #[serde(rename = "model_ref")]
    pub model_ref_: String,
}

/// `SetRateLimitsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRateLimitsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoints: Option<Vec<EndpointRateLimit>>,
    pub updated: bool,
}

/// `SetRegistrySpecVisibilityRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRegistrySpecVisibilityRequest {
    pub visibility: SetRegistrySpecVisibilityRequestVisibility,
}

/// `SetRegistrySpecVisibilityRequestVisibility` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SetRegistrySpecVisibilityRequestVisibility {
    #[default]
    #[serde(rename = "public")]
    Public,
    #[serde(rename = "private")]
    Private,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SetRegistrySpecVisibilityRequestVisibility {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Public => "public",
            Self::Private => "private",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SetRegistrySpecVisibilityRequestVisibility {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SetRegistrySpecVisibilityRequestVisibility {
    fn from(value: &str) -> Self {
        match value {
            "public" => Self::Public,
            "private" => Self::Private,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SetRegistrySpecVisibilityResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRegistrySpecVisibilityResponse {
    pub scope: String,
    pub name: String,
    pub visibility: SetRegistrySpecVisibilityRequestVisibility,
}

/// `SetRootAgentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRootAgentRequest {
    pub agent_id: String,
}

/// `SetRootAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRootAgentResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub root_agent_id: Option<String>,
}

/// `SetRootAttestationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRootAttestationResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// `SetRunFeedbackRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetRunFeedbackRequest {
    pub message_id: String,
    pub reaction: RunFeedbackListFeedbackReaction,
    /// Why the answer was bad, in the reader's own words or one of the chat's chips. Optional and
    /// only meaningful with `reaction: "down"`. Sent by the web chat since the chips shipped and
    /// dropped by the server until 2026-09-13; it is stored and echoed now.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `SetScheduleRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetScheduleRequest {
    pub cron: String,
    /// Server default: `true`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    /// Server default: `{}`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    /// Server default: `"UTC"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    /// Server default: `"retry_next"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub on_failure: Option<AgentScheduleConfigOnFailure>,
    /// Server default: `1`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_scheduled: Option<f64>,
    /// When true, schedule is fired by autonomous tick with reflection prompt instead of cron run
    /// with input.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub autonomous_mode: Option<bool>,
    /// Prompt injected into run input when autonomous_mode is true (e.g. review pending work, plan
    /// next steps).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reflection_prompt: Option<String>,
}

/// `SetSessionRunFeedbackRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetSessionRunFeedbackRequest {
    pub message_id: String,
    pub reaction: RunFeedbackListFeedbackReaction,
    /// Why the answer was bad, in the reader's own words or one of the chat's chips. Optional and
    /// only meaningful with `reaction: "down"`. Sent by the web chat since the chips shipped and
    /// dropped by the server until 2026-09-13; it is stored and echoed now.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `SetSpawnPolicyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetSpawnPolicyResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// `SetupStateResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetupStateResponse {
    pub state: SetupStateResponseState,
    /// The subset that gates going live. Read it rather than hard-coding it.
    pub required_steps: Vec<String>,
    /// Every known step id, required and optional.
    pub all_steps: Vec<String>,
    /// Required steps still outstanding. Non-empty means an attempt to open registration is refused
    /// and will name this list.
    pub missing_required: Vec<String>,
}

/// `SetupStateResponseState` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetupStateResponseState {
    /// `live` is a one-way latch; closing registration afterwards does not undo it.
    pub status: AdminRegistrationConfigSetupStatus,
    pub completed_steps: Vec<String>,
    pub registration_open: bool,
    pub started_at: String,
    /// Set once setup first completed. Its presence is what makes the latch one-way.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_at: Option<String>,
    pub version: i64,
}

/// `SetUserRoleRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetUserRoleRequest {
    pub role: String,
}

/// `SetUserRoleResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetUserRoleResponse {
    pub updated: bool,
    pub user_id: String,
    pub role: String,
}

/// `SharePublicSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SharePublicSessionResponse {
    pub token: String,
}

/// `ShareWorkspaceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ShareWorkspaceRequest {
    pub agent_id: String,
}

/// `SignUpForAndroidTestingRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SignUpForAndroidTestingRequest {
    pub email: String,
    /// Where the sign-up came from, e.g. `landing`. Truncated to 40 chars.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
}

/// `SpawnPolicy` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpawnPolicy {
    pub tenant_id: String,
    /// Child agent gets at most this fraction of parent's budget.
    pub child_budget_ratio: f64,
    pub max_depth: i64,
    pub allowed_roles: Vec<String>,
    pub require_approval_above_depth: i64,
    pub max_children_per_agent: i64,
}

/// Body of PUT /governance/permissions/spawn-policy. The handler requires the whole record
/// (requireWholeRecord): all five fields, every time; `tenant_id` is the caller's and is not
/// accepted in the body.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpawnPolicyUpdate {
    /// Child agent gets at most this fraction of parent's budget.
    pub child_budget_ratio: f64,
    pub max_depth: i64,
    /// Whole-record write: the array is stored as sent, REPLACING the stored list.
    pub allowed_roles: Vec<String>,
    pub require_approval_above_depth: i64,
    pub max_children_per_agent: i64,
}

/// Which SPEC output view renders each tool's result, for the builder UI. Keyed by tool name;
/// the first view claiming a tool wins, and a view whose JSON will not parse is skipped rather
/// than failing the call.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecToolCatalog {
    pub agent_id: String,
    /// Which of the agent's installed SPECs are waiting on a connection. `status` is
    /// `needs_connection` when the SPEC declares tools routed through a connector (manifest
    /// `delivered_by = { mode = "integration", connector = … }`) that this agent cannot currently
    /// see an ACTIVE connection of — visibility, not ownership: the assignment rule is
    /// `canAgentUseIntegration`. `action` is the runtime's own sentence, the same one a run injects
    /// when the SPEC's tools resolve to nothing, so a badge and a run cannot teach two vocabularies
    /// for one fact.
    ///
    /// `ready` means NO UNMET CONNECTOR REQUIREMENT — not that every tool dispatches. A full
    /// verdict needs the bundle's SDK export names, which only the runtime's loader has. A SPEC
    /// that cannot be resolved is reported `ready` rather than badged, because a badge is worse
    /// wrong than absent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub specs: Option<Vec<SpecToolCatalogSpec>>,
    /// The canvases this agent's SPECs put their output on (docs/DESIGNER-CANVAS.md §5.1) — today
    /// only `drawing`. Always present: empty means no drawing canvas, absence means an older
    /// server, and a client must not confuse the two.
    pub drawings: Vec<SpecToolCatalogDrawing>,
    /// Tool name → the SPEC that owns it and the view to render its output with. Integration
    /// aliases map onto their base tool's view.
    pub tools: HashMap<String, Value2>,
}

/// `SpecToolCatalogDrawing` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecToolCatalogDrawing {
    pub spec_id: String,
    pub canvas: SpecToolCatalogDrawingCanvas,
}

/// `SpecToolCatalogDrawingCanvas` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SpecToolCatalogDrawingCanvas {
    #[default]
    #[serde(rename = "drawing")]
    Drawing,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SpecToolCatalogDrawingCanvas {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Drawing => "drawing",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SpecToolCatalogDrawingCanvas {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SpecToolCatalogDrawingCanvas {
    fn from(value: &str) -> Self {
        match value {
            "drawing" => Self::Drawing,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SpecToolCatalogSpec` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecToolCatalogSpec {
    pub spec_id: String,
    pub status: SpecToolCatalogSpecStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requires: Option<SpecToolCatalogSpecRequires>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    pub tools_total: f64,
    pub tools_waiting: f64,
}

/// `SpecToolCatalogSpecRequires` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecToolCatalogSpecRequires {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<SpecToolCatalogSpecRequiresMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub connector: Option<String>,
}

/// `SpecToolCatalogSpecRequiresMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SpecToolCatalogSpecRequiresMode {
    #[default]
    #[serde(rename = "integration")]
    Integration,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SpecToolCatalogSpecRequiresMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Integration => "integration",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SpecToolCatalogSpecRequiresMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SpecToolCatalogSpecRequiresMode {
    fn from(value: &str) -> Self {
        match value {
            "integration" => Self::Integration,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SpecToolCatalogSpecStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SpecToolCatalogSpecStatus {
    #[default]
    #[serde(rename = "ready")]
    Ready,
    #[serde(rename = "needs_connection")]
    NeedsConnection,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl SpecToolCatalogSpecStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Ready => "ready",
            Self::NeedsConnection => "needs_connection",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for SpecToolCatalogSpecStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SpecToolCatalogSpecStatus {
    fn from(value: &str) -> Self {
        match value {
            "ready" => Self::Ready,
            "needs_connection" => Self::NeedsConnection,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `StartMissionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartMissionRequest {
    /// Chat session the mission belongs to.
    pub session_id: String,
    /// What the mission is for, in the requester's words.
    pub goal: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<PlannedMission>,
    /// Required when `plan` is omitted: the agents the planner may assign objectives to.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub available_agents: Option<Vec<StartMissionRequestAvailableAgent>>,
    /// Skip the intake classifier and treat the request as mission work.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub skip_classification: Option<bool>,
    /// ISO 8601. Honoured on the goal-only path.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
}

/// `StartMissionRequestAvailableAgent` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartMissionRequestAvailableAgent {
    pub agent_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

/// `StartOAuthProvider` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum StartOAuthProvider {
    #[default]
    #[serde(rename = "github")]
    Github,
    #[serde(rename = "stripe")]
    Stripe,
    #[serde(rename = "notion")]
    Notion,
    #[serde(rename = "slack")]
    Slack,
    #[serde(rename = "x_twitter")]
    XTwitter,
    #[serde(rename = "linkedin")]
    Linkedin,
    #[serde(rename = "youtube")]
    Youtube,
    #[serde(rename = "instagram")]
    Instagram,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl StartOAuthProvider {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Github => "github",
            Self::Stripe => "stripe",
            Self::Notion => "notion",
            Self::Slack => "slack",
            Self::XTwitter => "x_twitter",
            Self::Linkedin => "linkedin",
            Self::Youtube => "youtube",
            Self::Instagram => "instagram",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for StartOAuthProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for StartOAuthProvider {
    fn from(value: &str) -> Self {
        match value {
            "github" => Self::Github,
            "stripe" => Self::Stripe,
            "notion" => Self::Notion,
            "slack" => Self::Slack,
            "x_twitter" => Self::XTwitter,
            "linkedin" => Self::Linkedin,
            "youtube" => Self::Youtube,
            "instagram" => Self::Instagram,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `StartOAuthRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartOAuthRequest {
    /// Optional. Was declared REQUIRED here while the route has treated it as optional
    /// (`routes/integrations.ts`: "agent_id is now optional — if provided, validate it exists"), so
    /// a generated client had to invent one to connect an integration that belongs to no agent.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
    /// The destination connector when it differs from the OAuth provider in the path —
    /// `google_calendar` through `google`, for example. The route reads it and resolves scopes from
    /// it; the document did not declare it, so a client generated from this document could not send
    /// it and multi-connector OAuth silently asked for the provider's scopes instead of the
    /// connector's. Wrong scopes, no error.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub connector_id: Option<String>,
    /// Provider-specific parameters the authorize URL needs, e.g. `{ "subdomain": "acme" }` for
    /// Zendesk. Read by the route, previously undeclared.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `StartSquadRunRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartSquadRunRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub addressed_to: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chat_mode: Option<StartTeamRunRequestInputVariant2chatMode>,
}

/// `StartSquadRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartSquadRunResponse {
    pub team_run_id: String,
}

/// `addressed_to`, `message` and `chat_mode` were declared at the TOP level here and the
/// handler's schema accepts only `input` and `metadata`, with `.strip()`. So a client written
/// from this document had its addressing and its chat mode dropped with no error at all: the
/// run started, it just was not the run that was asked for. They belong inside `input`, which
/// is where the handler reads them.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartTeamRunRequest {
    /// The turn. A bare string is expanded to `{ message }`. `addressed_to` selects who answers;
    /// absent, @mentions in `message` are parsed for the same purpose.
    pub input: serde_json::Value,
    /// Accepted by the handler and undeclared here until now — the drift ran both ways.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `StartTeamRunRequestInputVariant2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartTeamRunRequestInputVariant2 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub addressed_to: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chat_mode: Option<StartTeamRunRequestInputVariant2chatMode>,
}

/// `StartTeamRunRequestInputVariant2chatMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum StartTeamRunRequestInputVariant2chatMode {
    #[default]
    #[serde(rename = "plan")]
    Plan,
    #[serde(rename = "chat")]
    Chat,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl StartTeamRunRequestInputVariant2chatMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Plan => "plan",
            Self::Chat => "chat",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for StartTeamRunRequestInputVariant2chatMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for StartTeamRunRequestInputVariant2chatMode {
    fn from(value: &str) -> Self {
        match value {
            "plan" => Self::Plan,
            "chat" => Self::Chat,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `StartTeamRunResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StartTeamRunResponse {
    pub team_run_id: String,
}

/// types/company.ts StrategicGoal — as stored; the create/update body is looser (goal_id
/// assigned by the server).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StrategicGoal {
    pub goal_id: String,
    pub title: String,
    pub description: String,
    pub kpis: Vec<StrategicGoalKpisItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub root_objective_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
}

/// `StrategicGoalKpisItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct StrategicGoalKpisItem {
    pub name: String,
    pub target: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current: Option<String>,
}

/// What the scan actually looked at, on every access and erasure answer. A count of zero is
/// otherwise unreadable: until 2026-09-16 every one of these counts was zero on every request
/// ever made, and the reason was the matcher rather than the data.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SubjectSweep {
    /// How many identifiers the subject was matched on — the subject id plus the id of every
    /// api-key credential that acted for them. Never the identifiers themselves: a key id is a
    /// credential reference and this payload goes to the requester.
    pub identifiers_matched: i64,
    /// KV prefixes walked to exhaustion in this tenant.
    pub prefixes_scanned: Vec<String>,
    /// Record fields compared against the identifier set.
    pub fields_matched: Vec<String>,
    /// True when nothing matched, so a zero can be read as a zero.
    pub no_records_matched: bool,
}

/// `SubmitFeedbackRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SubmitFeedbackRequest {
    /// Clipped at 8000 characters.
    pub message: String,
    /// Clipped at 300.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    /// Clipped at 2000.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context: Option<String>,
    /// Clipped at 1000.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    /// Anything other than `feedback` is filed as an error.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<ErrorReportKind>,
}

/// `SubmitFeedbackResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SubmitFeedbackResponse {
    pub ok: bool,
    pub id: String,
}

/// `SubscribeToListingRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SubscribeToListingRequest {
    /// Required: the handler answers 403 without one. The block carried no `required` until
    /// 2026-09-18.
    pub stripe_subscription_id: String,
}

/// `SuspendAgentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SuspendAgentRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `SuspendTenantRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SuspendTenantRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `SuspendTenantResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SuspendTenantResponse {
    pub suspended: bool,
    pub tenant_id: String,
    pub reason: String,
}

/// `SuspendUserResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SuspendUserResponse {
    pub suspended: bool,
    pub user_id: String,
}

/// `SwitchTenantRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SwitchTenantRequest {
    pub tenant_id: String,
}

/// `SwitchTenantResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SwitchTenantResponse {
    pub switched: bool,
    pub tenant_id: String,
    pub user_id: String,
    pub role: String,
}

/// `SyncProviderModelsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SyncProviderModelsResponse {
    /// New catalogue entries.
    pub added: i64,
    /// Ids of the added entries; capped. Deprecated spelling of `added_ids` — the same value, kept
    /// for the compatibility window and removed in the next breaking release (the one that moves
    /// `X-API-Version`). Read `added_ids`.
    #[serde(rename = "addedIds")]
    pub added_ids: Vec<String>,
    /// Catalogue size after the merge.
    pub total: i64,
    /// Models the provider reported.
    pub scanned: i64,
    /// Present when the run was scoped to one provider, as it is here.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    /// Ids of the added entries; capped.
    #[serde(rename = "added_ids")]
    pub added_ids_: Vec<String>,
}

/// Multi-agent collaboration unit (tenant-scoped).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Team {
    pub team_id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub topology: TeamTopology,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delegation_strategy: Option<TeamDelegationStrategy>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub merge_strategy: Option<TeamMergeStrategy>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message_protocol: Option<TeamMessageProtocol>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub orchestration_mode: Option<TeamOrchestrationMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supervisor_mode: Option<TeamSupervisorMode>,
    pub supervisor_agent_id: String,
    pub workers: Vec<TeamWorker>,
    pub policies: TeamPolicies,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal_config: Option<TeamGoalConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub swarm_config: Option<TeamSwarmConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `TeamChatTurn` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamChatTurn {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub addressed_to: Option<Vec<String>>,
    pub content: String,
    pub from_task: bool,
    pub role: String,
    pub run_meta: serde_json::Map<String, serde_json::Value>,
    pub run_pending: bool,
    pub team_run_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
    pub timestamp: String,
}

/// Body for `POST /api/v1/teams` (`CreateTeamSchema`).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamCreate {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub topology: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supervisor_agent_id: Option<String>,
    /// Each entry REQUIRES `agent_id` — omitting it answers `422 workers.0.agent_id: Required`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workers: Option<Vec<TeamCreateWorker>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delegation_strategy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub merge_strategy: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub orchestration_mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
}

/// `TeamCreateWorker` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamCreateWorker {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
}

/// `TeamDelegationStrategy` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamDelegationStrategy {
    #[default]
    #[serde(rename = "supervisor_decides")]
    SupervisorDecides,
    #[serde(rename = "round_robin")]
    RoundRobin,
    #[serde(rename = "capability_match")]
    CapabilityMatch,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamDelegationStrategy {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::SupervisorDecides => "supervisor_decides",
            Self::RoundRobin => "round_robin",
            Self::CapabilityMatch => "capability_match",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamDelegationStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamDelegationStrategy {
    fn from(value: &str) -> Self {
        match value {
            "supervisor_decides" => Self::SupervisorDecides,
            "round_robin" => Self::RoundRobin,
            "capability_match" => Self::CapabilityMatch,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Goal-driven topology: the objective, the review cadence, the budget.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamGoalConfig {
    pub root_objective_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub review_interval_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_iterations: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget: Option<TeamObjectiveBudget>,
}

/// `TeamGraphEdge` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamGraphEdge {
    pub edge_id: String,
    pub from: String,
    pub to: String,
    pub r#type: TeamGraphEdgeType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task_id: Option<String>,
    pub created_at: String,
}

/// `TeamGraphEdgeType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamGraphEdgeType {
    #[default]
    #[serde(rename = "delegation")]
    Delegation,
    #[serde(rename = "supervision")]
    Supervision,
    #[serde(rename = "peer")]
    Peer,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamGraphEdgeType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Delegation => "delegation",
            Self::Supervision => "supervision",
            Self::Peer => "peer",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamGraphEdgeType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamGraphEdgeType {
    fn from(value: &str) -> Self {
        match value {
            "delegation" => Self::Delegation,
            "supervision" => Self::Supervision,
            "peer" => Self::Peer,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TeamGraphNode` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamGraphNode {
    pub agent_id: String,
    pub role: TeamGraphNodeRole,
    pub status: TeamGraphNodeStatus,
    pub spawned_by: String,
    pub spawned_at: String,
    pub goal_summary: String,
}

/// `TeamGraphNodeRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamGraphNodeRole {
    #[default]
    #[serde(rename = "orchestrator")]
    Orchestrator,
    #[serde(rename = "worker")]
    Worker,
    #[serde(rename = "arbiter")]
    Arbiter,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamGraphNodeRole {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Orchestrator => "orchestrator",
            Self::Worker => "worker",
            Self::Arbiter => "arbiter",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamGraphNodeRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamGraphNodeRole {
    fn from(value: &str) -> Self {
        match value {
            "orchestrator" => Self::Orchestrator,
            "worker" => Self::Worker,
            "arbiter" => Self::Arbiter,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TeamGraphNodeStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamGraphNodeStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "idle")]
    Idle,
    #[serde(rename = "terminated")]
    Terminated,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamGraphNodeStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Idle => "idle",
            Self::Terminated => "terminated",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamGraphNodeStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamGraphNodeStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "idle" => Self::Idle,
            "terminated" => Self::Terminated,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TeamMergeStrategy` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamMergeStrategy {
    #[default]
    #[serde(rename = "supervisor_merges")]
    SupervisorMerges,
    #[serde(rename = "concatenate")]
    Concatenate,
    #[serde(rename = "vote")]
    Vote,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamMergeStrategy {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::SupervisorMerges => "supervisor_merges",
            Self::Concatenate => "concatenate",
            Self::Vote => "vote",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamMergeStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamMergeStrategy {
    fn from(value: &str) -> Self {
        match value {
            "supervisor_merges" => Self::SupervisorMerges,
            "concatenate" => Self::Concatenate,
            "vote" => Self::Vote,
            other => Self::Other(other.to_string()),
        }
    }
}

/// types/team.ts TeamMessage — one protocol message between team agents.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamMessage {
    pub message_id: String,
    pub team_run_id: String,
    pub from_agent_id: String,
    pub to_agent_id: String,
    pub r#type: TeamMessageType,
    pub content: String,
    pub round: i64,
    pub timestamp: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_message_id: Option<String>,
}

/// `TeamMessageProtocol` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamMessageProtocol {
    #[default]
    #[serde(rename = "shared_context")]
    SharedContext,
    #[serde(rename = "message_passing")]
    MessagePassing,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamMessageProtocol {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::SharedContext => "shared_context",
            Self::MessagePassing => "message_passing",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamMessageProtocol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamMessageProtocol {
    fn from(value: &str) -> Self {
        match value {
            "shared_context" => Self::SharedContext,
            "message_passing" => Self::MessagePassing,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TeamMessageType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamMessageType {
    #[default]
    #[serde(rename = "delegation")]
    Delegation,
    #[serde(rename = "result")]
    Result,
    #[serde(rename = "question")]
    Question,
    #[serde(rename = "status_update")]
    StatusUpdate,
    #[serde(rename = "merge_request")]
    MergeRequest,
    #[serde(rename = "validation")]
    Validation,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamMessageType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Delegation => "delegation",
            Self::Result => "result",
            Self::Question => "question",
            Self::StatusUpdate => "status_update",
            Self::MergeRequest => "merge_request",
            Self::Validation => "validation",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamMessageType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamMessageType {
    fn from(value: &str) -> Self {
        match value {
            "delegation" => Self::Delegation,
            "result" => Self::Result,
            "question" => Self::Question,
            "status_update" => Self::StatusUpdate,
            "merge_request" => Self::MergeRequest,
            "validation" => Self::Validation,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Ceiling for a goal-driven team's pursuit of its objective.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamObjectiveBudget {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_cost_usd: Option<f64>,
}

/// `TeamOrchestrationMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamOrchestrationMode {
    #[default]
    #[serde(rename = "strict_addressed")]
    StrictAddressed,
    #[serde(rename = "peer_collab")]
    PeerCollab,
    #[serde(rename = "vote_based")]
    VoteBased,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamOrchestrationMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::StrictAddressed => "strict_addressed",
            Self::PeerCollab => "peer_collab",
            Self::VoteBased => "vote_based",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamOrchestrationMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamOrchestrationMode {
    fn from(value: &str) -> Self {
        match value {
            "strict_addressed" => Self::StrictAddressed,
            "peer_collab" => Self::PeerCollab,
            "vote_based" => Self::VoteBased,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Limits and failure handling for a team run.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamPolicies {
    pub max_rounds: i64,
    /// Total team run timeout. Accepted at any value but only ever RAISED: anything below 3600000
    /// (1 hour) is enforced as 3600000, so that slow local models are not killed mid-run. 0 or
    /// absent means uncapped.
    pub timeout_ms: i64,
    pub early_termination: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub consensus_threshold: Option<f64>,
    pub effort: TeamPoliciesEffort,
    /// supervisor -\> worker -\> sub-worker.
    pub max_delegation_depth: i64,
    pub subtask_timeout_ms: i64,
    /// Applied by the auto_dispatch supervisor. Under tool_driven the failure is returned to the
    /// supervisor as a tool result instead, and this policy does not run.
    pub on_worker_failure: TeamPoliciesOnWorkerFailure,
    pub max_worker_retries: i64,
    pub require_all_workers: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub validation: Option<ValidationPolicy>,
    /// Default 50.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_graph_nodes: Option<i64>,
    /// Concurrent worker runs in a fan-out (default 8).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrency: Option<i64>,
}

/// `TeamPoliciesEffort` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamPoliciesEffort {
    #[default]
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "max")]
    Max,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamPoliciesEffort {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Low => "low",
            Self::Medium => "medium",
            Self::High => "high",
            Self::Max => "max",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamPoliciesEffort {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamPoliciesEffort {
    fn from(value: &str) -> Self {
        match value {
            "low" => Self::Low,
            "medium" => Self::Medium,
            "high" => Self::High,
            "max" => Self::Max,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Applied by the auto_dispatch supervisor. Under tool_driven the failure is returned to the
/// supervisor as a tool result instead, and this policy does not run.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamPoliciesOnWorkerFailure {
    #[default]
    #[serde(rename = "retry")]
    Retry,
    #[serde(rename = "skip")]
    Skip,
    #[serde(rename = "abort_team")]
    AbortTeam,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamPoliciesOnWorkerFailure {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Retry => "retry",
            Self::Skip => "skip",
            Self::AbortTeam => "abort_team",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamPoliciesOnWorkerFailure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamPoliciesOnWorkerFailure {
    fn from(value: &str) -> Self {
        match value {
            "retry" => Self::Retry,
            "skip" => Self::Skip,
            "abort_team" => Self::AbortTeam,
            other => Self::Other(other.to_string()),
        }
    }
}

/// teams.ts — the chat turn of a team run; at most one element.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamRunChatTurn {
    pub user_message: String,
    pub assistant_message: String,
}

/// GET /teams/{teamId}/runs/{teamRunId} and GET /squads/{squadId}/runs/{teamRunId} (measured
/// 2026-09-10 on e2e-canon, identical on both routes): the team run and the member runs it
/// spawned.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamRunDetail {
    pub team_run_id: String,
    pub team_id: String,
    pub status: String,
    pub runs: Vec<Run>,
    pub total_runs: i64,
}

/// `TeamRunSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamRunSummary {
    pub team_run_id: String,
    pub run_id: String,
    pub agent_id: String,
    pub status: String,
    pub created_at: String,
}

/// `TeamSupervisorMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamSupervisorMode {
    #[default]
    #[serde(rename = "auto_dispatch")]
    AutoDispatch,
    #[serde(rename = "tool_driven")]
    ToolDriven,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamSupervisorMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::AutoDispatch => "auto_dispatch",
            Self::ToolDriven => "tool_driven",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamSupervisorMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamSupervisorMode {
    fn from(value: &str) -> Self {
        match value {
            "auto_dispatch" => Self::AutoDispatch,
            "tool_driven" => Self::ToolDriven,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Swarm topology: who starts, and how context travels on handoff.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamSwarmConfig {
    pub initial_agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_handoffs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub handoff_context_strategy: Option<TeamSwarmConfigHandoffContextStrategy>,
}

/// `TeamSwarmConfigHandoffContextStrategy` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamSwarmConfigHandoffContextStrategy {
    #[default]
    #[serde(rename = "full")]
    Full,
    #[serde(rename = "summary")]
    Summary,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamSwarmConfigHandoffContextStrategy {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Full => "full",
            Self::Summary => "summary",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamSwarmConfigHandoffContextStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamSwarmConfigHandoffContextStrategy {
    fn from(value: &str) -> Self {
        match value {
            "full" => Self::Full,
            "summary" => Self::Summary,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TeamTopology` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TeamTopology {
    #[default]
    #[serde(rename = "supervisor")]
    Supervisor,
    #[serde(rename = "round_robin")]
    RoundRobin,
    #[serde(rename = "pipeline")]
    Pipeline,
    #[serde(rename = "goal_driven")]
    GoalDriven,
    #[serde(rename = "swarm")]
    Swarm,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TeamTopology {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Supervisor => "supervisor",
            Self::RoundRobin => "round_robin",
            Self::Pipeline => "pipeline",
            Self::GoalDriven => "goal_driven",
            Self::Swarm => "swarm",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TeamTopology {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TeamTopology {
    fn from(value: &str) -> Self {
        match value {
            "supervisor" => Self::Supervisor,
            "round_robin" => Self::RoundRobin,
            "pipeline" => Self::Pipeline,
            "goal_driven" => Self::GoalDriven,
            "swarm" => Self::Swarm,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Body for `PUT /api/v1/teams/{teamId}`. Every field optional — send only what changes.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub topology: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub supervisor_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workers: Option<Vec<TeamUpdateWorker>>,
}

/// `TeamUpdateWorker` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamUpdateWorker {
    pub agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
}

/// An agent acting in a team, with a role and permissions.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamWorker {
    pub agent_id: String,
    pub role: String,
    pub permissions: TeamWorkerPermissions,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub external_a2a: Option<TeamWorkerExternalA2A>,
}

/// Delegate this worker to another platform over the A2A protocol.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamWorkerExternalA2A {
    pub endpoint: String,
    pub agent_card_url: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth: Option<TeamWorkerExternalA2AAuth>,
}

/// `TeamWorkerExternalA2AAuth` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamWorkerExternalA2AAuth {
    pub r#type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub token_ref: Option<String>,
}

/// What a worker may do inside a team run.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TeamWorkerPermissions {
    /// Tool names this worker may invoke. Defaults to the agent's own allowed_tools.
    pub tools: Vec<String>,
    pub can_read_other_results: bool,
    pub can_delegate: bool,
    pub can_abort: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_steps_per_subtask: Option<i64>,
}

/// `Tenant` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Tenant {
    pub tenant_id: String,
    pub name: String,
    pub slug: String,
    pub status: TenantStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<String>,
    /// Resolved plan id — present on the normal answer, absent on the bootstrap branch.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quotas: Option<TenantQuotas>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quota_overrides: Option<TenantQuotaOverrides>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub settings: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub billing: Option<TenantBilling>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub billing_status: Option<TenantBillingStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub trial: Option<TenantTrial>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub trial_ends_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub trial_recommended_plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub trial_resolved: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub onboarding_completed: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub is_super_admin: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub is_platform_admin: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub head_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_workspace_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom_domain: Option<TenantCustomDomain>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branding: Option<TenantBranding>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub social_links: Option<TenantSocialLinks>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marketplace_listing: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_agent_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_settings: Option<TenantPublicSettings>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entitled_spec_packages: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legal_hold: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub suspension_reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub suspended_at: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

/// `TenantBilling` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantBilling {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_customer_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_subscription_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cancel_at_period_end: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub current_period_end_ms: Option<i64>,
}

/// `TenantBillingStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TenantBillingStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "past_due")]
    PastDue,
    #[serde(rename = "disputed")]
    Disputed,
    #[serde(rename = "cancelled")]
    Cancelled,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TenantBillingStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::PastDue => "past_due",
            Self::Disputed => "disputed",
            Self::Cancelled => "cancelled",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TenantBillingStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TenantBillingStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "past_due" => Self::PastDue,
            "disputed" => Self::Disputed,
            "cancelled" => Self::Cancelled,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TenantBranding` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantBranding {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub primary_color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accent_color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub background_color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub foreground_color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub card_color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub border_color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub favicon_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom_css: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub font_family: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub site_title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub seo_description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub og_image_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dark_mode: Option<bool>,
}

/// `TenantCustomDomain` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantCustomDomain {
    pub domain: String,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<TenantCustomDomainStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verification_method: Option<TenantCustomDomainVerificationMethod>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verification_value: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_checked_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verified_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dns: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cert: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `TenantCustomDomainStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TenantCustomDomainStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "verified")]
    Verified,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "deactivated")]
    Deactivated,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TenantCustomDomainStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Verified => "verified",
            Self::Failed => "failed",
            Self::Deactivated => "deactivated",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TenantCustomDomainStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TenantCustomDomainStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "verified" => Self::Verified,
            "failed" => Self::Failed,
            "deactivated" => Self::Deactivated,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TenantCustomDomainVerificationMethod` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TenantCustomDomainVerificationMethod {
    #[default]
    #[serde(rename = "cname")]
    Cname,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TenantCustomDomainVerificationMethod {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Cname => "cname",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TenantCustomDomainVerificationMethod {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TenantCustomDomainVerificationMethod {
    fn from(value: &str) -> Self {
        match value {
            "cname" => Self::Cname,
            other => Self::Other(other.to_string()),
        }
    }
}

/// The “what needs a human” queue. The overview answers how many; this answers which, and what
/// they are asking.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantInbox {
    pub generated_at: String,
    /// Counted over the whole scan, NOT over `items` — so `limit` truncating the list does not move
    /// them. The SCAN is capped too, though, and that cap they cannot see past: when `truncated` is
    /// true these are a floor, not a total.
    pub counts: TenantInboxCounts,
    pub items: Vec<InboxItem>,
    /// Run records inspected; the scan is capped.
    pub scanned: i64,
    /// The scan hit its cap, so `counts` is a floor rather than a total. `scanned` alone cannot
    /// tell you this — the number only means something to a caller who already knows what the cap
    /// is.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub truncated: Option<bool>,
}

/// Counted over the whole scan, NOT over `items` — so `limit` truncating the list does not move
/// them. The SCAN is capped too, though, and that cap they cannot see past: when `truncated` is
/// true these are a floor, not a total.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantInboxCounts {
    pub total: i64,
    pub approval: i64,
    pub input: i64,
    pub paused: i64,
    pub failed: i64,
}

/// `TenantMefConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantMefConfigResponse {
    pub tenant_id: String,
    /// What an operator stored. Null when nothing is overridden — never an empty object.
    #[serde(default)]
    pub mef_config: Option<TenantMefConfigResponseMefConfig>,
    /// What the runtime will do. All false when the mission service is absent platform-wide,
    /// whatever the overrides say.
    pub effective: TenantMefConfigResponseEffective,
}

/// What the runtime will do. All false when the mission service is absent platform-wide,
/// whatever the overrides say.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantMefConfigResponseEffective {
    pub enabled: bool,
    pub planner_enabled: bool,
    pub judge_enabled: bool,
    pub auto_classify: bool,
}

/// What an operator stored. Null when nothing is overridden — never an empty object.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantMefConfigResponseMefConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub planner_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub judge_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_classify: Option<bool>,
}

/// The single aggregate behind Mission Control: fleet, run buckets, approvals, quota, worker
/// health and schedule risk in one call instead of N.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverview {
    pub generated_at: String,
    pub fleet: TenantOverviewFleet,
    pub runs: TenantOverviewRuns,
    pub approvals: TenantOverviewApprovals,
    /// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
    /// health); clients must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<TenantOverviewUsage>,
    /// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
    /// health); clients must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost: Option<TenantOverviewCost>,
    /// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
    /// health); clients must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system: Option<TenantOverviewSystem>,
    pub schedules: TenantOverviewSchedules,
}

/// `TenantOverviewApprovals` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewApprovals {
    pub pending_count: i64,
}

/// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
/// health); clients must tolerate absence. v1 serves it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewCost {
    pub total_usd: f64,
    pub range_days: i64,
}

/// `TenantOverviewFleet` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewFleet {
    pub total: i64,
    pub active_agents: i64,
    pub suspended: i64,
    pub terminated: i64,
    /// Optional: absent when the server does not track it (no such field on v2's record); clients
    /// must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub by_execution_mode: Option<TenantOverviewFleetByExecutionMode>,
    /// Optional: absent on a server without the bridge concept (v2 has none); clients must tolerate
    /// absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge: Option<TenantOverviewFleetBridge>,
    /// Optional: absent when the server does not track it (no such field on v2's record); clients
    /// must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub head_agent_id: Option<String>,
    pub top_by_runs: Vec<AgentAnalyticsRow>,
    /// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
    /// health); clients must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_by_cost: Option<Vec<AgentAnalyticsRow>>,
    /// Agent id → the timestamp of its most recent run in the scanned window.
    pub last_run_at: serde_json::Map<String, serde_json::Value>,
}

/// Optional: absent on a server without the bridge concept (v2 has none); clients must tolerate
/// absence. v1 serves it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewFleetBridge {
    pub online: i64,
    pub stale: i64,
    pub offline: i64,
    pub machines_total: i64,
}

/// Optional: absent when the server does not track it (no such field on v2's record); clients
/// must tolerate absence. v1 serves it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewFleetByExecutionMode {
    pub cloud: i64,
    pub bridge: i64,
}

/// `TenantOverviewRuns` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewRuns {
    pub by_status: serde_json::Map<String, serde_json::Value>,
    /// Queued, running, paused, awaiting approval or awaiting input.
    pub active_count: i64,
    pub failed_24h: i64,
    /// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
    /// health); clients must tolerate absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_24h_usd: Option<f64>,
    pub recent: Vec<TenantOverviewRunsRecentItem>,
    /// How many run records the aggregate actually looked at. The scan is capped, so a busy
    /// tenant's numbers describe the scanned window, not all history.
    pub scanned: i64,
}

/// `TenantOverviewRunsRecentItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewRunsRecentItem {
    pub run_id: String,
    pub agent_id: String,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost_usd: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration_ms: Option<i64>,
    /// The sentence a person reads, English on every deployment. Branch on `error_code`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /// The failed run's code, passed through from the run record — a value from the `Error`
    /// schema's `code` enum. Absent when the failure carries nothing to branch on. This board is
    /// the only surface that renders a failed run's cause, and until 2026-09-21 it chose what to
    /// say by matching English in `error`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_code: Option<String>,
    /// Numbers the code cannot carry — `retry_after_ms`, `quota_exhausted`, `stale_seconds`. See
    /// `Run.error_details`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_details: Option<serde_json::Map<String, serde_json::Value>>,
    /// Passed through from the run record. Absent for platform-dispatched cloud runs; `bridge` is
    /// the only value the platform writes (run-dispatch.ts, bridge.ts); `async` only echoes what a
    /// client supplied at run creation and has never been stored on production (measured 2026-09-10
    /// over 8605 run records: absent 7738, bridge 867, async 0).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_mode: Option<RunExecutionMode>,
}

/// `TenantOverviewSchedules` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewSchedules {
    pub total: i64,
    /// Paused, errored, or carrying consecutive failures — a silently dead cron. Optional: absent
    /// when the server does not track it (no such field on v2's record); clients must tolerate
    /// absence. v1 serves it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub at_risk: Option<i64>,
    pub paused: i64,
}

/// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
/// health); clients must tolerate absence. v1 serves it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewSystem {
    /// False when no cron job is registered — the signal that scheduled work has stopped.
    pub healthy: bool,
    pub kv: bool,
    pub workers_active: i64,
    pub workers_queued: i64,
    pub cron_registered: i64,
}

/// Optional: absent when the server does not track it (v2 measures no cost, tokens or system
/// health); clients must tolerate absence. v1 serves it.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewUsage {
    pub tokens_used: i64,
    pub runs_used: i64,
    pub cost_mtd_usd: f64,
}

/// `TenantPublicSettings` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantPublicSettings {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_messages_per_session: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens_per_session: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allow_tool_calls: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allow_file_uploads: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rate_limit_per_ip_per_hour: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub require_auth: Option<bool>,
}

/// Per-tenant overrides applied on top of the plan's quotas. Partial by nature: only the keys
/// actually overridden are present.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantQuotaOverrides {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_agents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_teams: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_workers_per_team: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_team_runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_active_sessions: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_tool_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_mcp_servers: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_storage_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_memory_entries_per_agent: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_memory_storage_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_agent_versions: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_knowledge_bases: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_workspaces: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_daily_tool_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_images: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_daily_images: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_videos: Option<i64>,
}

/// `TenantQuotas` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantQuotas {
    pub max_agents: i64,
    pub max_teams: i64,
    pub max_workers_per_team: i64,
    pub max_concurrent_runs: i64,
    pub max_concurrent_team_runs: i64,
    pub max_active_sessions: i64,
    pub max_monthly_tokens: i64,
    pub max_monthly_tool_calls: i64,
    pub max_monthly_runs: i64,
    pub max_mcp_servers: i64,
    pub max_storage_bytes: i64,
    pub max_memory_entries_per_agent: i64,
    pub max_memory_storage_bytes: i64,
    pub max_agent_versions: i64,
    pub max_knowledge_bases: i64,
    pub max_workspaces: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_daily_tool_calls: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_images: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_daily_images: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_monthly_videos: Option<i64>,
}

/// REPLACES the stored object; it is not merged. A PATCH carrying one platform leaves the
/// tenant with that one platform and nothing else, so read-modify-write is the only safe shape
/// — send every link you want to keep, `custom` included.
///
/// Values are filtered, not rejected: a URL that does not match `^https?://.{3,500}$` is
/// dropped and the request still answers 200. Nothing is hidden by this — the response body
/// carries the tenant as STORED, so the saved `social_links` is in the answer and a second GET
/// is not needed to see what survived. Compare what you sent against what came back; a key
/// missing from the answer was refused.
///
/// Length is applied BEFORE the pattern, which matters: a url longer than 500 characters is CUT
/// to 500 and then matches, so it is stored TRUNCATED rather than refused — a different link
/// that still looks like one. Compare lengths too, not just presence. `custom` takes at most 5
/// entries, each with a label and a url; labels are stripped of angle brackets and cut to 50,
/// urls to 500, on the same before-validation order. Documented 2026-09-17 after the web lane
/// measured the filtering and could not find it described anywhere.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantSocialLinks {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub twitter: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub github: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub linkedin: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discord: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub telegram: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub youtube: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instagram: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub facebook: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tiktok: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom: Option<Vec<TenantSocialLinksCustomItem>>,
}

/// `TenantSocialLinksCustomItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantSocialLinksCustomItem {
    pub label: String,
    pub url: String,
}

/// `TenantStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TenantStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "suspended")]
    Suspended,
    #[serde(rename = "trial")]
    Trial,
    #[serde(rename = "deleted")]
    Deleted,
    #[serde(rename = "waitlisted")]
    Waitlisted,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TenantStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Suspended => "suspended",
            Self::Trial => "trial",
            Self::Deleted => "deleted",
            Self::Waitlisted => "waitlisted",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TenantStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TenantStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "suspended" => Self::Suspended,
            "trial" => Self::Trial,
            "deleted" => Self::Deleted,
            "waitlisted" => Self::Waitlisted,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TenantTrial` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantTrial {
    pub active: bool,
    #[serde(default)]
    pub ends_at: Option<String>,
    pub days_left: i64,
    #[serde(default)]
    pub recommended_plan: Option<String>,
}

/// `TenantUser` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantUser {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub avatar_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_login_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `TerminateAgentResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TerminateAgentResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deleted: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
}

/// `TestAdminSmtpConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestAdminSmtpConfigRequest {
    pub to: String,
}

/// `TestAdminSmtpConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestAdminSmtpConfigResponse {
    pub ok: bool,
    pub sent_to: String,
}

/// `TestAdminStripeConfigResponseVariant1` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestAdminStripeConfigResponseVariant1 {
    pub ok: bool,
    /// The Stripe account (`acct_…`) the key belongs to — the one fact that says which company
    /// receives the money.
    pub account_id: String,
    /// Whether the key is a live one — derived from the key prefix (`sk_live_`/`rk_live_`), because
    /// Stripe's Account object carries no `livemode`; until 2026-09-11 the field was absent and the
    /// panel showed TEST for a live key.
    pub livemode: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub business_name: Option<String>,
    pub country: String,
    pub default_currency: String,
    /// Whether the billing manager that serves checkout and the portal holds the same key as the
    /// one stored here. Until 2026-09-11 this check read the stored key on its own and could say
    /// LIVE while the running manager still held the environment's key of the previous company —
    /// green in the panel, "No such price" at checkout.
    pub active_key_matches: bool,
    /// Only when `active_key_matches` is false: what to do (save the panel, which rebuilds the
    /// manager from the stored key; boot does the same since 2026-09-11).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub warning: Option<String>,
}

/// `TestAdminStripeConfigResponseVariant2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestAdminStripeConfigResponseVariant2 {
    pub ok: bool,
    pub error: String,
    /// Stripe's HTTP status, when it answered.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<i64>,
}

/// `TestAgentIntegrationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestAgentIntegrationResponse {
    /// False when the connector could not reach the remote or the credentials were refused. This is
    /// the only field that says so; the status will be 200 either way.
    pub success: bool,
    /// Why it failed. Absent on success.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `TestIntegrationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestIntegrationResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `TestLLMProviderKeyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestLLMProviderKeyResponse {
    /// False when the connector could not reach the remote or the credentials were refused. This is
    /// the only field that says so; the status will be 200 either way.
    pub success: bool,
    /// Why it failed. Absent on success.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// `TestNotificationTargetResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestNotificationTargetResponse {
    pub ok: bool,
    pub message: String,
}

/// `TestWebhookResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TestWebhookResponse {
    pub test_sent: bool,
    pub webhook_id: String,
    /// The subscription's first configured event, or `run.completed` when it has none.
    pub event_type: String,
}

/// `Todo` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Todo {
    pub todo_id: String,
    pub session_id: String,
    pub tenant_id: String,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub due_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assign_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assign_team_id: Option<String>,
    pub status: TodoStatus,
    pub created_at: String,
    pub updated_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub recurrence: Option<TodoRecurrence>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_fire_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_fired_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_run_status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub require_confirmation: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delivery: Option<TodoDelivery>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub order_index: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_task_id: Option<String>,
    /// Present only on the session-scoped list; absent from GET /todos.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_name: Option<String>,
}

/// `TodoDelivery` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TodoDelivery {
    pub channels: Vec<TodoDeliveryChannel>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
}

/// `TodoDeliveryChannel` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TodoDeliveryChannel {
    #[default]
    #[serde(rename = "email")]
    Email,
    #[serde(rename = "telegram")]
    Telegram,
    #[serde(rename = "whatsapp")]
    Whatsapp,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TodoDeliveryChannel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Email => "email",
            Self::Telegram => "telegram",
            Self::Whatsapp => "whatsapp",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TodoDeliveryChannel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TodoDeliveryChannel {
    fn from(value: &str) -> Self {
        match value {
            "email" => Self::Email,
            "telegram" => Self::Telegram,
            "whatsapp" => Self::Whatsapp,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `TodoRecurrence` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TodoRecurrence {
    pub cron: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}

/// `TodoStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TodoStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "pending_confirmation")]
    PendingConfirmation,
    #[serde(rename = "in_progress")]
    InProgress,
    #[serde(rename = "done")]
    Done,
    #[serde(rename = "cancelled")]
    Cancelled,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TodoStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::PendingConfirmation => "pending_confirmation",
            Self::InProgress => "in_progress",
            Self::Done => "done",
            Self::Cancelled => "cancelled",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for TodoStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for TodoStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "pending_confirmation" => Self::PendingConfirmation,
            "in_progress" => Self::InProgress,
            "done" => Self::Done,
            "cancelled" => Self::Cancelled,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `ToolBreakdownEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ToolBreakdownEntry {
    pub name: String,
    pub count: i64,
}

/// `ToolOverride` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ToolOverride {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Hides the catalogue row. Presentation only — the runtime still serves the tool. Stored only
    /// when true.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
}

/// agent-versioning.ts TrafficSplitEntry; weights sum to 100.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TrafficSplitEntry {
    pub version: i64,
    pub weight: f64,
}

/// `TransferTenantOwnershipResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TransferTenantOwnershipResponse {
    pub transferred: bool,
    pub new_owner: String,
    pub previous_owner: String,
}

/// persistence/workspace-store.ts TrashManifestEntry — read back from .trash/_manifest.json as
/// written.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TrashManifestEntry {
    pub trash_path: String,
    pub original_path: String,
    pub original_workspace_id: String,
    pub original_agent_id: String,
    pub trashed_by: String,
    pub trashed_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// Exactly one of the three. The handler trims each and acts on the first non-empty one.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UnassignWorkspaceRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub company_id: Option<String>,
}

/// `UnlinkAuthProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UnlinkAuthProviderResponse {
    pub ok: bool,
    pub provider: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub remaining_factors: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub already_unlinked: Option<bool>,
}

/// `UnscheduleCanvasWorkflowResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UnscheduleCanvasWorkflowResponse {
    pub trigger_id: String,
    pub status: UnscheduleCanvasWorkflowResponseStatus,
}

/// `UnscheduleCanvasWorkflowResponseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum UnscheduleCanvasWorkflowResponseStatus {
    #[default]
    #[serde(rename = "removed")]
    Removed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl UnscheduleCanvasWorkflowResponseStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Removed => "removed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for UnscheduleCanvasWorkflowResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for UnscheduleCanvasWorkflowResponseStatus {
    fn from(value: &str) -> Self {
        match value {
            "removed" => Self::Removed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `UnsubscribeFromListingResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UnsubscribeFromListingResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unsubscribed: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub listing_id: Option<String>,
}

/// `UnsuspendUserResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UnsuspendUserResponse {
    pub unsuspended: bool,
    pub user_id: String,
}

/// `UpdateACPSessionResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateACPSessionResponse {
    pub saved: bool,
    /// Deprecated spelling of `session_id` — the same value, kept for the compatibility window and
    /// removed in the next breaking release (the one that moves `X-API-Version`). Read
    /// `session_id`.
    #[serde(rename = "sessionId")]
    pub session_id: String,
    #[serde(rename = "session_id")]
    pub session_id_: String,
}

/// `UpdateAdminAgentMemoryConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminAgentMemoryConfigResponse {
    pub agent_memory: UpdateAdminAgentMemoryConfigResponseAgentMemory,
    pub updated: bool,
}

/// `UpdateAdminAgentMemoryConfigResponseAgentMemory` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminAgentMemoryConfigResponseAgentMemory {
    pub enabled: bool,
    pub use_shared_store: bool,
    pub default_max_entries: i64,
    pub default_retrieval_limit: i64,
    pub default_retrieval_strategy: String,
    pub decay_enabled: bool,
    pub decay_half_life_days: i64,
    pub decay_job_interval_ms: i64,
    pub extraction_max_tokens: i64,
    pub extraction_model: String,
    pub eviction_threshold: i64,
    pub embedding_dimensions: i64,
    pub embedding_provider: String,
    pub embedding_model: String,
    pub compression_model: String,
}

/// `UpdateAdminAuthConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminAuthConfigResponse {
    pub auth: UpdateAdminAuthConfigResponseAuth,
    pub updated: bool,
}

/// `UpdateAdminAuthConfigResponseAuth` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminAuthConfigResponseAuth {
    pub super_admin_email: String,
    pub otp_ttl_ms: i64,
    pub verification_ttl_ms: i64,
    pub jwks_cache_ttl_ms: i64,
    pub jwks_grace_ttl_ms: i64,
    pub api_key_cache_ttl_s: i64,
    pub api_key_rotation_grace_period_h: i64,
}

/// `UpdateAdminBackpressureConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminBackpressureConfigResponse {
    pub backpressure: UpdateAdminBackpressureConfigResponseBackpressure,
    pub updated: bool,
}

/// `UpdateAdminBackpressureConfigResponseBackpressure` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminBackpressureConfigResponseBackpressure {
    pub sse_buffer_max: i64,
    pub sse_high_watermark: i64,
    pub sse_low_watermark: i64,
    pub tool_queue_max_depth: i64,
    pub tool_queue_high_watermark: i64,
}

/// `UpdateAdminBlogConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminBlogConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Null detaches the author and clears the pinned tenant.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    /// `manual` never auto-generates.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub frequency: Option<BlogConfigFrequency>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schedule_hour: Option<i64>,
    /// 0 = Sunday, UTC.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schedule_weekday: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub topic_prompt: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub conditions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_publish: Option<bool>,
}

/// `UpdateAdminBlogConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminBlogConfigResponse {
    pub config: BlogConfig,
}

/// `UpdateAdminBlogPostRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminBlogPostRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub body: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<BlogPostStatus>,
}

/// `UpdateAdminBlogPostResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminBlogPostResponse {
    pub post: BlogPost,
}

/// `UpdateAdminCodeInterpreterConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminCodeInterpreterConfigResponse {
    pub code_interpreter: UpdateAdminCodeInterpreterConfigResponseCodeInterpreter,
    pub updated: bool,
}

/// `UpdateAdminCodeInterpreterConfigResponseCodeInterpreter` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminCodeInterpreterConfigResponseCodeInterpreter {
    pub isolation: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_memory_mb: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub container_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub python_container_image: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub python_sandbox_host_dir: Option<String>,
}

/// `UpdateAdminDisabledToolsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminDisabledToolsResponse {
    pub ok: bool,
    pub disabled_tools: Vec<String>,
}

/// `UpdateAdminEvaluationConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminEvaluationConfigResponse {
    pub evaluation: UpdateAdminEvaluationConfigResponseEvaluation,
    pub updated: bool,
}

/// `UpdateAdminEvaluationConfigResponseEvaluation` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminEvaluationConfigResponseEvaluation {
    pub enabled: bool,
    pub max_concurrent_eval_cases: i64,
    pub regression_threshold: f64,
    pub default_scorers: Vec<String>,
    pub max_cases_per_dataset: i64,
    pub eval_run_timeout_ms: i64,
    pub auto_rollback_enabled: bool,
}

/// `UpdateAdminFounderConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminFounderConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub founder_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub founder_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub founder_public_key: Option<String>,
}

/// `UpdateAdminGuardrailsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminGuardrailsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub guardrails: Option<Vec<GuardrailConfigItem>>,
    pub updated: bool,
}

/// `UpdateAdminIdempotencyConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminIdempotencyConfigResponse {
    pub idempotency: UpdateAdminIdempotencyConfigResponseIdempotency,
    pub updated: bool,
}

/// `UpdateAdminIdempotencyConfigResponseIdempotency` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminIdempotencyConfigResponseIdempotency {
    pub enabled: bool,
    pub ttl_hours: i64,
    pub max_response_cache_bytes: i64,
}

/// `UpdateAdminIntegrationsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminIntegrationsResponse {
    pub integrations: Vec<UpdateAdminIntegrationsResponseIntegration>,
    pub updated: bool,
}

/// `UpdateAdminIntegrationsResponseIntegration` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminIntegrationsResponseIntegration {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auth_type: Option<AdminIntegrationsConfigIntegrationAuthType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub beta: Option<bool>,
    /// `kv` when an operator overrode the shipped default, `default` otherwise.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
}

/// `UpdateAdminLLMAdaptersConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLLMAdaptersConfigResponse {
    pub llm_adapters: UpdateAdminLLMAdaptersConfigResponseLLMAdapters,
    pub updated: bool,
}

/// `UpdateAdminLLMAdaptersConfigResponseLLMAdapters` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLLMAdaptersConfigResponseLLMAdapters {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_retries: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retry_base_delay_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub retry_max_delay_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stream_empty_timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub circuit_breaker: Option<UpdateAdminLLMAdaptersConfigResponseLLMAdaptersCircuitBreaker>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider_rate_limits: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `UpdateAdminLLMAdaptersConfigResponseLLMAdaptersCircuitBreaker` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLLMAdaptersConfigResponseLLMAdaptersCircuitBreaker {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub failure_threshold: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reset_timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub half_open_max_requests: Option<i64>,
}

/// `UpdateAdminLoggingConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLoggingConfigResponse {
    pub logging: UpdateAdminLoggingConfigResponseLogging,
    pub updated: bool,
}

/// `UpdateAdminLoggingConfigResponseLogging` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLoggingConfigResponseLogging {
    pub pii_mode: String,
    pub log_agent_responses: bool,
    pub file_enabled: bool,
    pub file_max_size_mb: i64,
    pub file_retention_days: i64,
    pub file_level: String,
    pub file_separate_error: bool,
    pub activity_log_verbosity: String,
}

/// `UpdateAdminLongRunningConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLongRunningConfigResponse {
    pub long_running: UpdateAdminLongRunningConfigResponseLongRunning,
    pub updated: bool,
}

/// `UpdateAdminLongRunningConfigResponseLongRunning` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminLongRunningConfigResponseLongRunning {
    pub enabled: bool,
    pub max_duration_ms: i64,
    pub checkpoint_interval_ms: i64,
    pub idle_timeout_ms: i64,
    pub continuation_token_ttl_days: i64,
    pub max_background_runs_per_tenant: i64,
}

/// `UpdateAdminMCPConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminMCPConfigResponse {
    pub mcp: UpdateAdminMCPConfigResponseMCP,
    pub updated: bool,
}

/// `UpdateAdminMCPConfigResponseMCP` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminMCPConfigResponseMCP {
    pub max_sessions_per_server: i64,
    pub max_total_stdio_sessions: i64,
    pub session_idle_timeout_ms: i64,
}

/// `UpdateAdminMultimodalConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminMultimodalConfigResponse {
    pub multimodal: UpdateAdminMultimodalConfigResponseMultimodal,
    pub updated: bool,
}

/// `UpdateAdminMultimodalConfigResponseMultimodal` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminMultimodalConfigResponseMultimodal {
    pub enabled: bool,
    pub max_image_size_bytes: i64,
    pub max_audio_duration_s: i64,
    pub max_video_duration_s: i64,
    pub auto_resize_images: bool,
    pub supported_image_formats: Vec<String>,
    pub supported_audio_formats: Vec<String>,
}

/// `UpdateAdminOAuthIdentityConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminOAuthIdentityConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub apple_services_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub apple_team_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub apple_bundle_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oauth_return_to_hosts: Option<Vec<String>>,
}

/// `UpdateAdminPersistenceConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminPersistenceConfigResponse {
    pub persistence: UpdateAdminPersistenceConfigResponsePersistence,
    pub updated: bool,
}

/// `UpdateAdminPersistenceConfigResponsePersistence` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminPersistenceConfigResponsePersistence {
    pub snapshot_every_n_events: i64,
    pub checkpoint_after_tool_calls: bool,
    pub usage_shards: i64,
    pub auto_cap_kv_values: bool,
}

/// `UpdateAdminPlansRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminPlansRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plans: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `UpdateAdminPlansResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminPlansResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plans: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated: Option<bool>,
}

/// `UpdateAdminPricingResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminPricingResponse {
    pub pricing: UpdateAdminPricingResponsePricing,
    pub updated: bool,
}

/// `UpdateAdminPricingResponsePricing` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminPricingResponsePricing {
    pub openai_compat_input: f64,
    pub openai_compat_output: f64,
    pub anthropic_input: i64,
    pub anthropic_output: f64,
    pub anthropic_thinking: f64,
}

/// `UpdateAdminProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminProviderResponse {
    pub id: String,
    pub enabled: bool,
    pub model_allowlist: Vec<String>,
}

/// `UpdateAdminRegistrationConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminRegistrationConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub registration_open: Option<bool>,
    /// Required alongside `registration_open: true` when registration is currently closed. Ignored
    /// otherwise.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub confirm_open: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_signup_plan: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_email_domains: Option<Vec<String>>,
}

/// `UpdateAdminRetentionConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminRetentionConfigResponse {
    pub retention: UpdateAdminRetentionConfigResponseRetention,
    pub updated: bool,
}

/// `UpdateAdminRetentionConfigResponseRetention` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminRetentionConfigResponseRetention {
    pub completed_run_ttl_days: i64,
    pub event_ttl_days: i64,
    pub archive_to_sqlite: bool,
    pub audit_log_ttl_days: i64,
    pub archive_job_interval_ms: i64,
    pub archive_batch_size: i64,
    pub feed_ttl_days: i64,
    pub artifact_ttl_days: i64,
    /// Notification retention in days. 0 (the default) means no expiry. Applies to rows written
    /// after the setting changes.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub notification_ttl_days: Option<i64>,
    pub checkpoint_ttl_hours: i64,
}

/// `UpdateAdminRunCommandConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminRunCommandConfigResponse {
    pub run_command: UpdateAdminRunCommandConfigResponseRunCommand,
    pub updated: bool,
}

/// `UpdateAdminRunCommandConfigResponseRunCommand` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminRunCommandConfigResponseRunCommand {
    pub enabled: bool,
    pub isolation: String,
    pub timeout_ms: i64,
    pub max_output_bytes: i64,
    pub allowed_commands: Vec<String>,
    pub deno_allow: Vec<String>,
}

/// `UpdateAdminServerConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminServerConfigResponse {
    pub server: UpdateAdminServerConfigResponseServer,
    pub updated: bool,
}

/// `UpdateAdminServerConfigResponseServer` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminServerConfigResponseServer {
    pub trust_proxy: bool,
    pub max_body_bytes: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub graceful_shutdown_timeout_ms: Option<i64>,
}

/// `UpdateAdminSetupStateRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminSetupStateRequest {
    /// Unioned with what is stored. Unknown ids are rejected.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_steps: Option<Vec<UpdateAdminSetupStateRequestCompletedStep>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub registration_open: Option<bool>,
    /// Required alongside `registration_open: true` when registration is currently closed.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub confirm_open: Option<bool>,
}

/// `UpdateAdminSetupStateRequestCompletedStep` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum UpdateAdminSetupStateRequestCompletedStep {
    #[default]
    #[serde(rename = "super_admin_login")]
    SuperAdminLogin,
    #[serde(rename = "platform_identity")]
    PlatformIdentity,
    #[serde(rename = "public_url")]
    PublicURL,
    #[serde(rename = "llm_provider")]
    LLMProvider,
    #[serde(rename = "registration_open")]
    RegistrationOpen,
    #[serde(rename = "smtp")]
    Smtp,
    #[serde(rename = "oauth_login")]
    OauthLogin,
    #[serde(rename = "stripe")]
    Stripe,
    #[serde(rename = "spec_seed")]
    SpecSeed,
    #[serde(rename = "custom_domain")]
    CustomDomain,
    #[serde(rename = "integrations")]
    Integrations,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl UpdateAdminSetupStateRequestCompletedStep {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::SuperAdminLogin => "super_admin_login",
            Self::PlatformIdentity => "platform_identity",
            Self::PublicURL => "public_url",
            Self::LLMProvider => "llm_provider",
            Self::RegistrationOpen => "registration_open",
            Self::Smtp => "smtp",
            Self::OauthLogin => "oauth_login",
            Self::Stripe => "stripe",
            Self::SpecSeed => "spec_seed",
            Self::CustomDomain => "custom_domain",
            Self::Integrations => "integrations",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for UpdateAdminSetupStateRequestCompletedStep {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for UpdateAdminSetupStateRequestCompletedStep {
    fn from(value: &str) -> Self {
        match value {
            "super_admin_login" => Self::SuperAdminLogin,
            "platform_identity" => Self::PlatformIdentity,
            "public_url" => Self::PublicURL,
            "llm_provider" => Self::LLMProvider,
            "registration_open" => Self::RegistrationOpen,
            "smtp" => Self::Smtp,
            "oauth_login" => Self::OauthLogin,
            "stripe" => Self::Stripe,
            "spec_seed" => Self::SpecSeed,
            "custom_domain" => Self::CustomDomain,
            "integrations" => Self::Integrations,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `UpdateAdminSmtpConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminSmtpConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub host: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
    /// Empty string clears the stored credential.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from_name: Option<String>,
}

/// `UpdateAdminSSEConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminSSEConfigResponse {
    pub sse: UpdateAdminSSEConfigResponseSSE,
    pub updated: bool,
}

/// `UpdateAdminSSEConfigResponseSSE` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminSSEConfigResponseSSE {
    pub heartbeat_interval_ms: i64,
    pub watch_timeout_ms: i64,
    pub poll_interval_ms: i64,
    pub max_poll_interval_ms: i64,
    pub reconnect_hint_ms: i64,
    pub run_wait_timeout_sec: i64,
}

/// `UpdateAdminStripeConfigRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminStripeConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<UpdateAdminStripeConfigRequestMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secret_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webhook_secret: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub publishable_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_id_starter: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_id_pro: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price_id_enterprise: Option<String>,
}

/// `UpdateAdminStripeConfigRequestMode` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum UpdateAdminStripeConfigRequestMode {
    #[default]
    #[serde(rename = "test")]
    Test,
    #[serde(rename = "live")]
    Live,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl UpdateAdminStripeConfigRequestMode {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Test => "test",
            Self::Live => "live",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for UpdateAdminStripeConfigRequestMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for UpdateAdminStripeConfigRequestMode {
    fn from(value: &str) -> Self {
        match value {
            "test" => Self::Test,
            "live" => Self::Live,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `UpdateAdminStripeConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminStripeConfigResponse {
    pub stripe: UpdateAdminStripeConfigResponseStripe,
    pub updated: bool,
}

/// `UpdateAdminStripeConfigResponseStripe` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminStripeConfigResponseStripe {
    pub enabled: bool,
    pub mode: String,
    pub secret_key: String,
    pub webhook_secret: String,
    pub publishable_key: String,
    pub price_id_starter: String,
    pub price_id_pro: String,
    pub price_id_enterprise: String,
}

/// `UpdateAdminTenantSettingsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminTenantSettingsResponse {
    pub tenant_id: String,
    /// types/tenant.ts TenantSettings as stored — legacy records may lack fields.
    pub settings: serde_json::Map<String, serde_json::Value>,
    /// Only when ever set.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub legal_hold: Option<bool>,
}

/// `UpdateAdminToolOverridesRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminToolOverridesRequest {
    pub overrides: HashMap<String, ToolOverride>,
}

/// `UpdateAdminToolOverridesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminToolOverridesResponse {
    pub ok: bool,
    pub overrides: HashMap<String, ToolOverride>,
}

/// `UpdateAdminToolSecurityConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminToolSecurityConfigResponse {
    pub tool_security: UpdateAdminToolSecurityConfigResponseToolSecurity,
    pub updated: bool,
}

/// `UpdateAdminToolSecurityConfigResponseToolSecurity` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminToolSecurityConfigResponseToolSecurity {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub egress_allowlist_per_tenant: Option<Vec<String>>,
    pub default_tool_timeout_ms: i64,
    pub default_tool_max_payload_bytes: i64,
    pub default_tool_max_concurrency: i64,
    pub stdio_inherit_env: bool,
}

/// `UpdateAdminWebhooksConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminWebhooksConfigResponse {
    pub webhooks: UpdateAdminWebhooksConfigResponseWebhooks,
    pub updated: bool,
}

/// `UpdateAdminWebhooksConfigResponseWebhooks` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminWebhooksConfigResponseWebhooks {
    pub enabled: bool,
    pub max_subscriptions_per_tenant: i64,
    pub delivery_timeout_ms: i64,
    pub max_retry_attempts: i64,
    pub require_https: bool,
    pub max_payload_bytes: i64,
}

/// `UpdateAdminWorkerPoolConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminWorkerPoolConfigResponse {
    pub worker_pool: UpdateAdminWorkerPoolConfigResponseWorkerPool,
    pub updated: bool,
}

/// `UpdateAdminWorkerPoolConfigResponseWorkerPool` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminWorkerPoolConfigResponseWorkerPool {
    pub max_workers: i64,
    pub default_mode: String,
    pub max_run_duration_ms: i64,
    pub reconciliation_interval_ms: i64,
    pub schedule_max_retries: i64,
    pub schedule_base_delay_ms: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_queue_size: Option<i64>,
}

/// `UpdateAgentIntegrationRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAgentIntegrationRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `UpdateBridgeAgentCapabilityRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateBridgeAgentCapabilityRequest {
    pub capabilities: Vec<String>,
    /// Where the bridge process is running. Stored on the connection record and shown to the
    /// operator; read at bridge.ts:3479.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub working_directory: Option<String>,
    /// The reporting machine's hostname; read at bridge.ts:3480.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hostname: Option<String>,
    /// Outcome of the local spec sync, feeding the web drawer's "Installed locally" badges. Bounded
    /// server-side: at most 100 entries, 200 tool names each, errors truncated to 500 characters.
    /// Entries without a string `spec_id` are dropped, and `reported_at` is ignored on input — the
    /// server stamps its own.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub installed_specs: Option<Vec<BridgeInstalledSpec>>,
}

/// `UpdateBridgeAgentCapabilityResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateBridgeAgentCapabilityResponse {
    pub status: RespondToPublicHitlResponseStatus,
}

/// `UpdateBuilderRequestStatusRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateBuilderRequestStatusRequest {
    pub status: DesignRequestStatus,
}

/// `UpdateCoreMemoryBlockRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateCoreMemoryBlockRequest {
    pub content: String,
    /// Values outside 1..32000 are clamped to the range, not refused.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i64>,
}

/// `UpdateFeedbackReportStatusRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateFeedbackReportStatusRequest {
    /// Anything other than the exact string `resolved` — including an absent body — results in
    /// `new`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<UpdateFeedbackReportStatusRequestStatus>,
}

/// Anything other than the exact string `resolved` — including an absent body — results in
/// `new`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum UpdateFeedbackReportStatusRequestStatus {
    #[default]
    #[serde(rename = "resolved")]
    Resolved,
    #[serde(rename = "new")]
    New,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl UpdateFeedbackReportStatusRequestStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Resolved => "resolved",
            Self::New => "new",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for UpdateFeedbackReportStatusRequestStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for UpdateFeedbackReportStatusRequestStatus {
    fn from(value: &str) -> Self {
        match value {
            "resolved" => Self::Resolved,
            "new" => Self::New,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `UpdateFeedbackReportStatusResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateFeedbackReportStatusResponse {
    pub ok: bool,
    /// Read this back — it is how a caller learns its value was not understood.
    pub status: UpdateFeedbackReportStatusRequestStatus,
}

/// `UpdateGoalStatusRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateGoalStatusRequest {
    pub status: String,
}

/// `UpdateImprovementStatusRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateImprovementStatusRequest {
    pub status: ImprovementProposalStatus,
}

/// `UpdateIntegrationRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateIntegrationRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `UpdateMarkupConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateMarkupConfigResponse {
    pub markup: UpdateMarkupConfigResponseMarkup,
    pub updated: bool,
}

/// `UpdateMarkupConfigResponseMarkup` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateMarkupConfigResponseMarkup {
    pub platform_markup_percent: f64,
    pub model_markup_overrides: serde_json::Map<String, serde_json::Value>,
}

/// `UpdateMCPServerRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateMCPServerRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    /// Re-encrypted on write. `{}` clears it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<MCPServerStatus>,
    /// Names an environment variable of the API process whose value is sent to this server as a
    /// bearer token. It MUST begin `MCP_` — 422 otherwise. The namespace is the whole security
    /// boundary: before it existed, the HTTP transport read ANY variable of the API process, so a
    /// tenant admin registering `{url: \<their server\>, api_key_ref: "UARP_ENCRYPTION_KEY"}` was
    /// mailed the platform's at-rest key on the first connect (found 2026-09-15). The variable is
    /// never echoed back; only the ref is stored.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api_key_ref: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub egress_allowlist: Option<Vec<String>>,
}

/// At least one editable field.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateMissionObjectiveRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success_criteria: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub priority: Option<ObjectivePriority>,
    /// Empty string clears the assignment.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agent_id: Option<String>,
    /// Empty string clears the assignment.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_team_id: Option<String>,
    /// Ceilings only; the spent counters are not writable.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub budget: Option<UpdateMissionObjectiveRequestBudget>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub deadline: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commanders_intent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub roe: Option<ObjectiveRoE>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decision_points: Option<Vec<ObjectiveDecisionPoint>>,
}

/// Ceilings only; the spent counters are not writable.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateMissionObjectiveRequestBudget {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_runs: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_cost_usd: Option<f64>,
}

/// `UpdateMyPreferencesRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateMyPreferencesRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `UpdatePlatformURLSRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdatePlatformURLSRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_base_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webhook_base_url: Option<String>,
}

/// `UpdatePlatformURLSResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdatePlatformURLSResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub urls: Option<UpdatePlatformURLSResponseURLS>,
    pub updated: bool,
}

/// `UpdatePlatformURLSResponseURLS` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdatePlatformURLSResponseURLS {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub public_base_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webhook_base_url: Option<String>,
}

/// `UpdateProjectRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateProjectRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_base_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub visibility: Option<ProjectVisibility>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<ProjectGrant>>,
    /// Timestamp to archive, null to restore.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived_at: Option<String>,
}

/// `UpdateRuntimeConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateRuntimeConfigResponse {
    /// The effective runtime config — sparse: only keys present in the platform config or the
    /// stored override (RuntimeConfig, every field optional).
    pub runtime: serde_json::Map<String, serde_json::Value>,
    pub updated: bool,
    /// Only when the body carried keys the schema does not declare.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ignored_keys: Option<Vec<String>>,
}

/// `UpdateSecurityPoliciesRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSecurityPoliciesRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cors_allowed_origins: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webhook_url_denylist: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_upload_max_size_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_upload_allowed_mime_types: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub admin_provider_settings_require_super_admin: Option<bool>,
}

/// `UpdateSecurityPoliciesResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSecurityPoliciesResponse {
    pub policies: UpdateSecurityPoliciesResponsePolicies,
    pub updated: bool,
}

/// `UpdateSecurityPoliciesResponsePolicies` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSecurityPoliciesResponsePolicies {
    pub cors_allowed_origins: Vec<String>,
    pub webhook_url_denylist: Vec<String>,
    pub file_upload_max_size_bytes: i64,
    pub file_upload_allowed_mime_types: Vec<String>,
    pub admin_provider_settings_require_super_admin: bool,
}

/// `UpdateSessionAnnotationRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSessionAnnotationRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolved: Option<bool>,
}

/// `UpdateSessionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSessionRequest {
    /// MERGED into the stored bag, not replaced — a key this body omits keeps its value, and a key
    /// it names is overwritten. The platform writes its own keys here (`project_id`, `_public`,
    /// `temporary`, `_todo_id`, the preview fields), which is why replace semantics would be wrong.
    /// Because it merges, the limits are measured on the RESULT and so accumulate across calls: at
    /// most 100 keys, at most 64 KiB of JSON, and at most 8 levels of nesting. Past any of them the
    /// request is refused with 422 and a `detail` naming the number reached. Remove keys you no
    /// longer need; this is a label bag, not content.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    /// Per-conversation model override. Send null to clear (revert to agent default), or {
    /// provider, model_ref, endpoint_url?, capabilities? } to set. The runtime governance allowlist
    /// is still enforced at run time.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_override: Option<UpdateSessionRequestModelOverride>,
}

/// Per-conversation model override. Send null to clear (revert to agent default), or {
/// provider, model_ref, endpoint_url?, capabilities? } to set. The runtime governance allowlist
/// is still enforced at run time.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSessionRequestModelOverride {
    pub provider: String,
    pub model_ref: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `UpdateSquadGraphNodeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateSquadGraphNodeRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<TeamGraphNodeStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal_summary: Option<String>,
}

/// `UpdateTeamGraphNodeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateTeamGraphNodeRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<TeamGraphNodeStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub goal_summary: Option<String>,
}

/// Null clears an override. Any other non-boolean is 422.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateTenantMefConfigRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub planner_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub judge_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_classify: Option<bool>,
}

/// `UpdateTenantPlanRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateTenantPlanRequest {
    /// A built-in plan (`free`, `starter`, `pro`, `enterprise`) or the id of an ACTIVE custom plan
    /// from `/admin/config/custom-plans`. Matched case-insensitively and trimmed. Anything else is
    /// 400 rather than a silently stored value.
    pub plan: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quotas: Option<TenantQuotas>,
    /// Partial quota grant that outlives subscription changes — only the dimensions being raised
    /// need be present.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quota_overrides: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Lowercase letters, numbers and hyphens. Changing it re-points the public tenant index.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
}

/// `UpdateTenantPlanResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateTenantPlanResponse {
    pub tenant_id: String,
    /// The RESOLVED plan id, which may differ in case from what was sent.
    pub plan: String,
    pub quotas: TenantQuotas,
}

/// `UpdateTenantRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateTenantRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub settings: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub head_agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_workspace_id: Option<String>,
}

/// `UpdateWebhooksPolicyRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateWebhooksPolicyRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ssrf_check_at_subscription: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_signature_tolerance_sec: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delivery_max_retries: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delivery_backoff_base_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delivery_max_window_hours: Option<i64>,
}

/// `UpdateWebhooksPolicyResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateWebhooksPolicyResponse {
    pub policy: UpdateWebhooksPolicyResponsePolicy,
    pub updated: bool,
}

/// `UpdateWebhooksPolicyResponsePolicy` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateWebhooksPolicyResponsePolicy {
    pub ssrf_check_at_subscription: bool,
    pub stripe_signature_tolerance_sec: i64,
    pub delivery_max_retries: i64,
    pub delivery_backoff_base_ms: i64,
    pub delivery_max_window_hours: i64,
}

/// `UpdateWorkspaceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateWorkspaceRequest {
    pub name: String,
}

/// `UploadFileRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UploadFileRequest {
    /// Base64-encoded file content
    pub data: FilePart,
    pub mime_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
}

/// `UploadFileResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UploadFileResponse {
    pub file_id: String,
    pub tenant_id: String,
    pub filename: String,
    pub mime_type: String,
    pub size_bytes: i64,
    pub sha256: String,
    pub created_at: String,
    pub url: String,
}

/// `UploadPublicSessionImageResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UploadPublicSessionImageResponse {
    pub file_id: String,
    pub mime_type: String,
    /// Bytes stored.
    pub size: i64,
}

/// `UploadWorkspaceFileIfNoneMatch` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum UploadWorkspaceFileIfNoneMatch {
    #[default]
    #[serde(rename = "*")]
    Empty,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl UploadWorkspaceFileIfNoneMatch {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Empty => "*",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for UploadWorkspaceFileIfNoneMatch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for UploadWorkspaceFileIfNoneMatch {
    fn from(value: &str) -> Self {
        match value {
            "*" => Self::Empty,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `UploadWorkspaceFileRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UploadWorkspaceFileRequest {
    pub file: FilePart,
}

/// `UpsertAgentToolOverrideResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertAgentToolOverrideResponse {
    pub tool_overrides: Vec<AgentToolOverride>,
}

/// `UpsertCustomPlanResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertCustomPlanResponse {
    pub plan: CustomPlan,
}

/// `UpsertNotificationTargetRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertNotificationTargetRequest {
    /// Rewrites this target when it exists.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    /// Defaults to something channel-specific when omitted.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    /// Defaults to true; only an explicit `false` disables.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    pub config: serde_json::Value,
}

/// `UpsertNotificationTargetRequestConfigVariant1` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertNotificationTargetRequestConfigVariant1 {
    pub kind: NotificationTargetConfigVariant1kind,
    pub address: String,
}

/// `UpsertNotificationTargetRequestConfigVariant2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertNotificationTargetRequestConfigVariant2 {
    pub kind: AgentScorerConfigType,
    /// Must be https.
    pub url: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub signing_secret: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<NotificationTargetConfigVariant2format>,
}

/// `UpsertNotificationTargetRequestConfigVariant3` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertNotificationTargetRequestConfigVariant3 {
    pub kind: NotificationTargetConfigVariant3kind,
    pub platform: NotificationTargetConfigVariant3platform,
    pub device_token: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_label: Option<String>,
}

/// `UpsertNotificationTargetRequestConfigVariant4` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertNotificationTargetRequestConfigVariant4 {
    pub kind: NotificationTargetConfigVariant4kind,
    pub endpoint: String,
    pub keys: UpsertNotificationTargetRequestConfigVariant4keys,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub device_label: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expiration_time: Option<i64>,
}

/// `UpsertNotificationTargetRequestConfigVariant4keys` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertNotificationTargetRequestConfigVariant4keys {
    pub p256dh: String,
    pub auth: String,
}

/// `UpsertPromoCodeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpsertPromoCodeResponse {
    pub promo_code: PromoCode,
}

/// `UsageMarginSummary` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageMarginSummary {
    pub platform_markup_percent: f64,
    pub provider_cost_usd: f64,
    pub user_cost_usd: f64,
    pub margin_usd: f64,
    pub effective_margin_percent: f64,
}

/// billing.ts GET /usage/quota. `reason` only when `allowed` is false (billing/usage-tracker.ts
/// checkQuota).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuota {
    pub plan: String,
    pub allowed: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    /// billing/usage-tracker.ts AggregatedUsage for the current month.
    pub usage: UsageQuotaUsage,
    pub daily: UsageQuotaDaily,
    pub resets_at: UsageQuotaResetsAt,
    pub limits: UsageQuotaLimits,
    /// Every plan-capped counter in one list, joined server-side: `{kind, used, limit, period,
    /// resets_at}`. The same facts as `usage`, `limits`, `daily` and `resource_usage`, which stay
    /// exactly as they were — this is the shape a meter renders without doing the join itself (four
    /// client surfaces were doing it). `limit: null` means unlimited; a sentinel would render as "0
    /// of 0". `period`/`resets_at` are null for standing counts like agents, which do not reset at
    /// midnight.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub counters: Option<Vec<UsageQuotaCounter>>,
    /// api/lib/resource-usage.ts TenantResourceUsage.
    pub resource_usage: UsageQuotaResourceUsage,
}

/// `UsageQuotaCounter` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuotaCounter {
    pub kind: UsageQuotaCounterKind,
    pub used: f64,
    #[serde(default)]
    pub limit: Option<f64>,
    #[serde(default)]
    pub period: Option<String>,
    #[serde(default)]
    pub resets_at: Option<String>,
}

/// `UsageQuotaCounterKind` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum UsageQuotaCounterKind {
    #[default]
    #[serde(rename = "runs")]
    Runs,
    #[serde(rename = "tokens")]
    Tokens,
    #[serde(rename = "tokens_daily")]
    TokensDaily,
    #[serde(rename = "tool_calls")]
    ToolCalls,
    #[serde(rename = "agents")]
    Agents,
    #[serde(rename = "teams")]
    Teams,
    #[serde(rename = "knowledge_bases")]
    KnowledgeBases,
    #[serde(rename = "workspaces")]
    Workspaces,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl UsageQuotaCounterKind {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Runs => "runs",
            Self::Tokens => "tokens",
            Self::TokensDaily => "tokens_daily",
            Self::ToolCalls => "tool_calls",
            Self::Agents => "agents",
            Self::Teams => "teams",
            Self::KnowledgeBases => "knowledge_bases",
            Self::Workspaces => "workspaces",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for UsageQuotaCounterKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for UsageQuotaCounterKind {
    fn from(value: &str) -> Self {
        match value {
            "runs" => Self::Runs,
            "tokens" => Self::Tokens,
            "tokens_daily" => Self::TokensDaily,
            "tool_calls" => Self::ToolCalls,
            "agents" => Self::Agents,
            "teams" => Self::Teams,
            "knowledge_bases" => Self::KnowledgeBases,
            "workspaces" => Self::Workspaces,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `UsageQuotaDaily` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuotaDaily {
    pub used: f64,
    pub limit: f64,
    #[serde(default)]
    pub remaining: Option<f64>,
    pub resets_at: String,
}

/// `UsageQuotaLimits` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuotaLimits {
    pub max_monthly_tokens: f64,
    pub max_monthly_runs: f64,
    pub max_daily_tokens: f64,
    pub max_agents: f64,
    pub max_teams: f64,
    pub max_knowledge_bases: f64,
    pub max_workspaces: f64,
}

/// `UsageQuotaResetsAt` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuotaResetsAt {
    pub day: String,
    pub month: String,
}

/// api/lib/resource-usage.ts TenantResourceUsage.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuotaResourceUsage {
    pub agents: ResourceUsageEntry,
    pub workspaces: ResourceUsageEntry,
    pub knowledge_bases: ResourceUsageEntry,
    pub teams: ResourceUsageEntry,
    pub any_over_tier: bool,
}

/// billing/usage-tracker.ts AggregatedUsage for the current month.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageQuotaUsage {
    pub input_tokens: f64,
    pub output_tokens: f64,
    pub thinking_tokens: f64,
    pub total_tokens: f64,
    pub runs_count: f64,
    pub tool_calls_count: f64,
    pub storage_bytes: f64,
    pub total_cost: f64,
    pub provider_cost: f64,
    pub non_run_cost: f64,
    pub period: String,
}

/// Tenant usage for one billing period. Flat — the counters are top-level, not nested under a
/// `usage` object.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UsageSummary {
    pub plan: String,
    /// `YYYY-MM`.
    pub period: String,
    pub period_days: i64,
    pub input_tokens: i64,
    pub output_tokens: i64,
    pub thinking_tokens: i64,
    pub total_tokens: i64,
    pub runs_count: i64,
    pub tool_calls_count: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bridge_tasks: Option<i64>,
    pub storage_bytes: i64,
    /// What the tenant is billed, in USD.
    pub total_cost: f64,
    /// What the upstream providers charged, in USD.
    pub provider_cost: f64,
    pub non_run_cost: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub margin_summary: Option<UsageMarginSummary>,
}

/// Personal instructions that apply to every conversation this person has, whichever agent
/// answers.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UserPreferences {
    pub custom_instructions: String,
    /// Off keeps the text but stops it reaching any run — the switch people actually want when an
    /// instruction misfires.
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    /// Server-enforced ceiling for `custom_instructions`. Sent on every response so a client does
    /// not hard-code it.
    pub max_chars: i64,
}

/// One rubric line for LLM-as-judge validation.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ValidationCriterion {
    pub name: String,
    pub description: String,
    /// 0.0-1.0; weights should sum to ~1.0.
    pub weight: f64,
}

/// Optional gate scoring worker outputs before synthesis.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ValidationPolicy {
    pub enabled: bool,
    pub criteria: Vec<ValidationCriterion>,
    /// Pass threshold 0.0-1.0 (default 0.7).
    pub min_score: f64,
    pub max_revision_rounds: i64,
    /// Dedicated validator; omitted means the supervisor judges its own workers.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub validator_agent_id: Option<String>,
    /// Re-run the workers with the validator's feedback when a round fails, up to
    /// `max_revision_rounds`. Defaults to true — the server treats only an explicit `false` as off.
    pub auto_revise: bool,
    /// Re-run only the workers whose output failed, rather than the whole round. Defaults to false.
    pub selective: bool,
}

/// `Value` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Value {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub en: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uk: Option<String>,
}

/// `Value2` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Value2 {
    pub spec_id: String,
    /// The parsed view document, or null when the stored view was unparseable.
    pub output_view: serde_json::Value,
}

/// `Value3` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Value3 {
    pub x: f64,
    pub y: f64,
}

/// `Value4` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Value4 {
    pub x: f64,
    pub y: f64,
}

/// `Value5` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Value5 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub from: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub to: Option<serde_json::Value>,
}

/// The API key is e-mailed, never returned here (register.ts handleVerifyEmail).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VerifyEmailResponse {
    pub tenant_id: String,
    pub message: String,
}

/// `VerifyMfaRecoveryRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VerifyMfaRecoveryRequest {
    pub code: String,
}

/// `VerifyMfaRecoveryResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VerifyMfaRecoveryResponse {
    pub verified: bool,
    pub recovery_remaining: i64,
}

/// `VerifyMfaRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VerifyMfaRequest {
    /// 6-digit TOTP code.
    pub code: String,
}

/// `VerifyMfaResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VerifyMfaResponse {
    pub verified: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub recovery_remaining: Option<i64>,
}

/// `VerifyTenantDomainResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VerifyTenantDomainResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verified: Option<bool>,
}

/// `VetoProposalRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VetoProposalRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub founder_id: Option<String>,
}

/// `VetoProposalResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VetoProposalResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<bool>,
}

/// A veto as issued and listed (VetoRecord in @uarp/governance). Shape from the store's record;
/// no tenant in reach had a veto to measure on 2026-09-10.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VetoRecord {
    pub veto_id: String,
    pub issued_by: String,
    pub target_type: VetoRecordTargetType,
    pub target_id: String,
    pub reason: String,
    pub issued_at: String,
}

/// `VetoRecordTargetType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum VetoRecordTargetType {
    #[default]
    #[serde(rename = "proposal")]
    Proposal,
    #[serde(rename = "action")]
    Action,
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "case")]
    Case,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl VetoRecordTargetType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Proposal => "proposal",
            Self::Action => "action",
            Self::Agent => "agent",
            Self::Case => "case",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for VetoRecordTargetType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for VetoRecordTargetType {
    fn from(value: &str) -> Self {
        match value {
            "proposal" => Self::Proposal,
            "action" => Self::Action,
            "agent" => Self::Agent,
            "case" => Self::Case,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `VideoProvider` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VideoProvider {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub local: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub models: Option<Vec<ModelInfo>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `VoiceConfig` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VoiceConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stt: Option<VoiceConfigStt>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tts: Option<VoiceConfigTts>,
}

/// `VoiceConfigStt` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VoiceConfigStt {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
}

/// `VoiceConfigTts` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VoiceConfigTts {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub configured: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub voice: Option<String>,
}

/// providers.ts voice-providers — STT and TTS models split.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VoiceProvider {
    pub id: String,
    pub name: String,
    pub configured: bool,
    pub stt_models: Vec<ModelInfo>,
    pub tts_models: Vec<ModelInfo>,
}

/// `VoiceProviderList` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VoiceProviderList {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub providers: Option<Vec<VoiceProvider>>,
}

/// `VoteResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VoteResult {
    pub proposal_id: String,
    pub status: VoteResultStatus,
    pub total_votes: i64,
    pub approve_weight: f64,
    pub reject_weight: f64,
    pub abstain_weight: f64,
    pub quorum_met: bool,
    pub tallied_at: String,
}

/// `VoteResultStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum VoteResultStatus {
    #[default]
    #[serde(rename = "passed")]
    Passed,
    #[serde(rename = "rejected")]
    Rejected,
    #[serde(rename = "expired")]
    Expired,
    #[serde(rename = "vetoed")]
    Vetoed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl VoteResultStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Passed => "passed",
            Self::Rejected => "rejected",
            Self::Expired => "expired",
            Self::Vetoed => "vetoed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for VoteResultStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for VoteResultStatus {
    fn from(value: &str) -> Self {
        match value {
            "passed" => Self::Passed,
            "rejected" => Self::Rejected,
            "expired" => Self::Expired,
            "vetoed" => Self::Vetoed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `VotingProposal` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VotingProposal {
    pub proposal_id: String,
    pub tenant_id: String,
    pub r#type: String,
    pub title: String,
    pub description: String,
    pub proposed_by: String,
    pub payload: serde_json::Map<String, serde_json::Value>,
    pub quorum: f64,
    pub status: VotingProposalStatus,
    pub deadline: String,
    pub created_at: String,
    pub updated_at: String,
}

/// `VotingProposalStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum VotingProposalStatus {
    #[default]
    #[serde(rename = "open")]
    Open,
    #[serde(rename = "passed")]
    Passed,
    #[serde(rename = "rejected")]
    Rejected,
    #[serde(rename = "expired")]
    Expired,
    #[serde(rename = "vetoed")]
    Vetoed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl VotingProposalStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Open => "open",
            Self::Passed => "passed",
            Self::Rejected => "rejected",
            Self::Expired => "expired",
            Self::Vetoed => "vetoed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for VotingProposalStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for VotingProposalStatus {
    fn from(value: &str) -> Self {
        match value {
            "open" => Self::Open,
            "passed" => Self::Passed,
            "rejected" => Self::Rejected,
            "expired" => Self::Expired,
            "vetoed" => Self::Vetoed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// webhooks/webhook-manager.ts DeliveryAttempt (7-day TTL).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WebhookDeliveryAttempt {
    pub delivery_id: String,
    pub webhook_id: String,
    pub tenant_id: String,
    pub event_type: WebhookDeliveryAttemptEventType,
    pub attempt_number: i64,
    pub status: WebhookDeliveryAttemptStatus,
    pub request_body: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response_status: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub latency_ms: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_retry_at: Option<String>,
    pub created_at: String,
}

/// `WebhookDeliveryAttemptEventType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum WebhookDeliveryAttemptEventType {
    #[default]
    #[serde(rename = "run.completed")]
    RunCompleted,
    #[serde(rename = "run.failed")]
    RunFailed,
    #[serde(rename = "run.cancelled")]
    RunCancelled,
    #[serde(rename = "agent.created")]
    AgentCreated,
    #[serde(rename = "agent.updated")]
    AgentUpdated,
    #[serde(rename = "agent.deleted")]
    AgentDeleted,
    #[serde(rename = "quota.threshold")]
    QuotaThreshold,
    #[serde(rename = "quota.exceeded")]
    QuotaExceeded,
    #[serde(rename = "guardrail.violated")]
    GuardrailViolated,
    #[serde(rename = "billing.invoice.created")]
    BillingInvoiceCreated,
    #[serde(rename = "billing.payment.failed")]
    BillingPaymentFailed,
    #[serde(rename = "eval.auto_rollback")]
    EvalAutoRollback,
    #[serde(rename = "company.budget_alert")]
    CompanyBudgetAlert,
    #[serde(rename = "company.budget_exceeded")]
    CompanyBudgetExceeded,
    #[serde(rename = "company.objective_failed")]
    CompanyObjectiveFailed,
    #[serde(rename = "company.goal_completed")]
    CompanyGoalCompleted,
    #[serde(rename = "company.paused")]
    CompanyPaused,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl WebhookDeliveryAttemptEventType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::RunCompleted => "run.completed",
            Self::RunFailed => "run.failed",
            Self::RunCancelled => "run.cancelled",
            Self::AgentCreated => "agent.created",
            Self::AgentUpdated => "agent.updated",
            Self::AgentDeleted => "agent.deleted",
            Self::QuotaThreshold => "quota.threshold",
            Self::QuotaExceeded => "quota.exceeded",
            Self::GuardrailViolated => "guardrail.violated",
            Self::BillingInvoiceCreated => "billing.invoice.created",
            Self::BillingPaymentFailed => "billing.payment.failed",
            Self::EvalAutoRollback => "eval.auto_rollback",
            Self::CompanyBudgetAlert => "company.budget_alert",
            Self::CompanyBudgetExceeded => "company.budget_exceeded",
            Self::CompanyObjectiveFailed => "company.objective_failed",
            Self::CompanyGoalCompleted => "company.goal_completed",
            Self::CompanyPaused => "company.paused",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for WebhookDeliveryAttemptEventType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for WebhookDeliveryAttemptEventType {
    fn from(value: &str) -> Self {
        match value {
            "run.completed" => Self::RunCompleted,
            "run.failed" => Self::RunFailed,
            "run.cancelled" => Self::RunCancelled,
            "agent.created" => Self::AgentCreated,
            "agent.updated" => Self::AgentUpdated,
            "agent.deleted" => Self::AgentDeleted,
            "quota.threshold" => Self::QuotaThreshold,
            "quota.exceeded" => Self::QuotaExceeded,
            "guardrail.violated" => Self::GuardrailViolated,
            "billing.invoice.created" => Self::BillingInvoiceCreated,
            "billing.payment.failed" => Self::BillingPaymentFailed,
            "eval.auto_rollback" => Self::EvalAutoRollback,
            "company.budget_alert" => Self::CompanyBudgetAlert,
            "company.budget_exceeded" => Self::CompanyBudgetExceeded,
            "company.objective_failed" => Self::CompanyObjectiveFailed,
            "company.goal_completed" => Self::CompanyGoalCompleted,
            "company.paused" => Self::CompanyPaused,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `WebhookDeliveryAttemptStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum WebhookDeliveryAttemptStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "success")]
    Success,
    #[serde(rename = "failed")]
    Failed,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl WebhookDeliveryAttemptStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Success => "success",
            Self::Failed => "failed",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for WebhookDeliveryAttemptStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for WebhookDeliveryAttemptStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "success" => Self::Success,
            "failed" => Self::Failed,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `WebhookSubscription` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WebhookSubscription {
    pub webhook_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub url: String,
    pub events: Vec<String>,
    pub status: WebhookSubscriptionStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

/// `WebhookSubscriptionStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum WebhookSubscriptionStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "disabled")]
    Disabled,
    #[serde(rename = "failing")]
    Failing,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl WebhookSubscriptionStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Disabled => "disabled",
            Self::Failing => "failing",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for WebhookSubscriptionStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for WebhookSubscriptionStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "disabled" => Self::Disabled,
            "failing" => Self::Failing,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `Workspace` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Workspace {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_size_bytes: Option<i64>,
    pub workspace_id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub owner_type: Option<WorkspaceOwnerType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub owner_id: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<String>>,
    pub assigned_agents: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_teams: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_companies: Option<Vec<String>>,
    pub created_at: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `WorkspaceFile` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceFile {
    /// Lowercase hex sha256 of the content; absent on records written before 2026-09-03
    /// (workspace-store.ts).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub etag: Option<String>,
    pub file_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    pub workspace_id: String,
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_path: Option<String>,
    pub filename: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    pub size_bytes: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// One kept version of a workspace file. Keys as served 2026-09-10.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceFileVersion {
    pub file_id: String,
    pub tenant_id: String,
    pub workspace_id: String,
    pub path: String,
    pub parent_path: String,
    pub filename: String,
    pub mime_type: String,
    pub size_bytes: i64,
    pub created_at: String,
}

/// `WorkspaceOwnerType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum WorkspaceOwnerType {
    #[default]
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "standalone")]
    Standalone,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl WorkspaceOwnerType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Agent => "agent",
            Self::Team => "team",
            Self::Standalone => "standalone",
            Self::Other(value) => value.as_str(),
        }
    }
}

impl std::fmt::Display for WorkspaceOwnerType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for WorkspaceOwnerType {
    fn from(value: &str) -> Self {
        match value {
            "agent" => Self::Agent,
            "team" => Self::Team,
            "standalone" => Self::Standalone,
            other => Self::Other(other.to_string()),
        }
    }
}