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;

/// `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()),
        }
    }
}

/// `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<serde_json::Map<String, serde_json::Value>>,
    pub index: i64,
}

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

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

impl A2ATaskMessageRole {
    /// 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 A2ATaskMessageRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `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.
    pub strikes_used: i64,
    #[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,
    pub category: AarRootCauseCategory,
    pub details: String,
}

/// `AarRootCauseCategory` enumeration.
#[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<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_countries: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_devices: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_browsers: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_referrers: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_utm_sources: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

/// `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>,
}

/// `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()),
        }
    }
}

/// `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>,
}

/// `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 {
    #[serde(rename = "eventId")]
    pub event_id: String,
    #[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>>,
    #[serde(rename = "errorMessage")]
    pub error_message: String,
    pub timestamp: String,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
}

/// `AdminReplayWebhookDLQResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminReplayWebhookDLQResponse {
    pub success: bool,
    #[serde(rename = "eventId")]
    pub event_id: String,
    pub action: String,
    pub message: 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.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    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 skills: Option<Vec<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.
    #[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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status_reason: Option<String>,
    #[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<serde_json::Value>,
    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()),
        }
    }
}

/// 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 {
    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()),
        }
    }
}

/// `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>,
    #[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>,
}

/// `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,
    #[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>,
}

/// `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()),
        }
    }
}

/// `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,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start_date: Option<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()),
        }
    }
}

/// `BootstrapAmbassadorResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct BootstrapAmbassadorResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ambassador_id: Option<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>,
}

/// `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 {
    pub agent_id: String,
    pub context: 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.
    #[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,
}

/// `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.
    #[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,
}

/// `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 ≤ 100.
    #[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>,
    #[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: ChatCompletionRequestToolType,
    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>>,
}

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

impl ChatCompletionRequestToolType {
    /// 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 ChatCompletionRequestToolType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `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,
}

/// `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<serde_json::Map<String, serde_json::Value>>>,
    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>,
}

/// 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/{id}`. 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,
}

/// `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>,
}

/// `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>,
}

/// `ConversationEntry` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ConversationEntry {
    pub role: ConversationEntryRole,
    /// Message content
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<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>,
}

/// `ConversationEntryRole` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ConversationEntryRole {
    #[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 ConversationEntryRole {
    /// 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 ConversationEntryRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for ConversationEntryRole {
    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()),
        }
    }
}

/// `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>,
}

/// `CreateA2ATaskRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateA2ATaskRequest {
    pub agent_id: String,
    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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parts: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

/// `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,
}

/// `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>,
    #[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 {
    /// Same-origin URL to return to after the portal session ends.
    #[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,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success_url: Option<String>,
    #[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>>,
}

/// `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 {
    pub agent_id: String,
}

/// `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: GuardrailPhase,
    #[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 {
    pub r#type: String,
}

/// `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>>,
    #[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>,
}

/// `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<SpecPackagePricingBillingInterval>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub product_name: Option<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<serde_json::Map<String, serde_json::Value>>,
    #[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>,
}

/// `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>,
}

/// `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>,
}

/// `CreateSpecPackageCheckoutSessionRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateSpecPackageCheckoutSessionRequest {
    /// Same-origin. Defaults to the billing settings page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub success_url: Option<String>,
    /// Same-origin. Defaults to the billing settings page.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cancel_url: Option<String>,
}

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

/// `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<CreateWebhookRequestEvent>,
}

/// `CreateWebhookRequestEvent` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum CreateWebhookRequestEvent {
    #[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 CreateWebhookRequestEvent {
    /// 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 CreateWebhookRequestEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for CreateWebhookRequestEvent {
    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()),
        }
    }
}

/// `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: SpecPackageIncludedInPlan,
    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,
}

/// `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: SpecPackageIncludedInPlan,
    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()),
        }
    }
}

/// `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>,
}

/// `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,
}

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

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

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

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

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

impl DeleteCustomPlanForce {
    /// 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 DeleteCustomPlanForce {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `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>,
}

/// `DeleteFileResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteFileResponse {
    pub error: RevokeSessionShareResponseError,
    pub message: String,
    pub retry_after_seconds: 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>,
}

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

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

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

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

/// `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>,
}

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

/// `DeleteMeResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteMeResponse {
    pub deleted: bool,
    pub tenants: Vec<DeleteMeResponseTenant>,
    pub sessions_revoked: 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 {
    #[serde(rename = "modelRef")]
    pub model_ref: String,
    pub deleted: bool,
}

/// `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,
}

/// `DeleteSessionAnnotationResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DeleteSessionAnnotationResponse {
    pub error: RevokeSessionShareResponseError,
    pub message: String,
    pub retry_after_seconds: 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()),
        }
    }
}

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

/// 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`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DesignRequestCreate {
    #[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>,
}

/// `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()),
        }
    }
}

/// `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,
}

/// `EnforcementResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResult {
    /// False when any matched rule carries a blocking penalty.
    pub allowed: bool,
    #[serde(rename = "checkResult")]
    pub check_result: EnforcementResultCheckResult,
    /// What the matched rules call for. Empty when nothing matched.
    pub penalties: Vec<EnforcementResultPenalty>,
}

/// `EnforcementResultCheckResult` model.
#[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,
}

/// `EnforcementResultPenalty` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResultPenalty {
    #[serde(rename = "ruleId")]
    pub rule_id: String,
    pub penalty: ConstitutionRulePenalty,
}

/// `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+json style error; correlationId for request tracing.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Error {
    pub r#type: String,
    pub title: String,
    pub status: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub detail: Option<String>,
    /// Request ID for tracing
    #[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>>,
}

/// `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()),
        }
    }
}

/// `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>,
}

/// `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>,
}

/// `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()),
        }
    }
}

/// `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,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `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, Value3>,
    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, Value2>,
    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>,
}

/// `GetAdminFounderConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminFounderConfigResponse {
    pub kv: FounderIdentity,
    pub env: FounderIdentity,
    pub effective: FounderIdentity,
}

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

/// `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>>,
}

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

/// `GetAdminIntegrationsResponseIntegration` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminIntegrationsResponseIntegration {
    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<GetAdminIntegrationsResponseIntegrationAuthType>,
    #[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>,
}

/// `GetAdminIntegrationsResponseIntegrationAuthType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GetAdminIntegrationsResponseIntegrationAuthType {
    #[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 GetAdminIntegrationsResponseIntegrationAuthType {
    /// 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 GetAdminIntegrationsResponseIntegrationAuthType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GetAdminIntegrationsResponseIntegrationAuthType {
    fn from(value: &str) -> Self {
        match value {
            "oauth2" => Self::Oauth2,
            "api_key" => Self::APIKey,
            "none" => Self::None,
            other => Self::Other(other.to_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,
}

/// `GetAdminOAuthIdentityConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminOAuthIdentityConfigResponse {
    pub kv: OAuthIdentityConfig,
    pub env: OAuthIdentityConfig,
    pub effective: OAuthIdentityConfig,
}

/// `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>,
}

/// `GetAdminRegistrationConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminRegistrationConfigResponse {
    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: SetupStateResponseStateStatus,
    /// 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<GetAdminRegistrationConfigResponseWaitlistItem>,
}

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

/// `GetAdminSmtpConfigResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminSmtpConfigResponse {
    /// What is stored. Empty strings and a `port` of 0 mean nothing has been saved for that field.
    pub kv: GetAdminSmtpConfigResponseKv,
    /// What the environment supplies. `port` defaults to 465 when unset or unparseable.
    pub env: GetAdminSmtpConfigResponseEnv,
    /// 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: GetAdminSmtpConfigResponseSource,
}

/// What the environment supplies. `port` defaults to 465 when unset or unparseable.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminSmtpConfigResponseEnv {
    #[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 GetAdminSmtpConfigResponseKv {
    #[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 GetAdminSmtpConfigResponseSource {
    #[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 GetAdminSmtpConfigResponseSource {
    /// 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 GetAdminSmtpConfigResponseSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

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

/// `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 {
    #[serde(rename = "totalRuns", default, skip_serializing_if = "Option::is_none")]
    pub total_runs: Option<i64>,
    #[serde(rename = "completedRuns", default, skip_serializing_if = "Option::is_none")]
    pub completed_runs: Option<i64>,
    #[serde(rename = "failedRuns", default, skip_serializing_if = "Option::is_none")]
    pub failed_runs: Option<i64>,
    #[serde(rename = "cancelledRuns", default, skip_serializing_if = "Option::is_none")]
    pub cancelled_runs: Option<i64>,
    #[serde(rename = "guardrailBlockedRuns", default, skip_serializing_if = "Option::is_none")]
    pub guardrail_blocked_runs: Option<i64>,
    #[serde(rename = "errorRatePercent", default, skip_serializing_if = "Option::is_none")]
    pub error_rate_percent: Option<f64>,
    #[serde(rename = "avgStepsPerRun", default, skip_serializing_if = "Option::is_none")]
    pub avg_steps_per_run: Option<f64>,
    #[serde(rename = "avgDurationMs", default, skip_serializing_if = "Option::is_none")]
    pub avg_duration_ms: Option<f64>,
    #[serde(rename = "avgInputTokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_input_tokens: Option<f64>,
    #[serde(rename = "avgOutputTokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_output_tokens: Option<f64>,
    #[serde(rename = "avgThinkingTokens", default, skip_serializing_if = "Option::is_none")]
    pub avg_thinking_tokens: Option<f64>,
    #[serde(rename = "toolBreakdown", default, skip_serializing_if = "Option::is_none")]
    pub tool_breakdown: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(rename = "topErrorMessages", default, skip_serializing_if = "Option::is_none")]
    pub top_error_messages: Option<Vec<GetAgentActivityStatsResponseTopErrorMessage>>,
    #[serde(rename = "runsByDay", default, skip_serializing_if = "Option::is_none")]
    pub runs_by_day: Option<Vec<GetAgentActivityStatsResponseRunsByDayItem>>,
}

/// `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>,
}

/// `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>,
}

/// `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, Value4>>,
    #[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>>,
}

/// `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>>,
}

/// `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 activity: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

/// `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<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub objectives: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

/// `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>,
}

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

/// `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<serde_json::Map<String, serde_json::Value>>,
    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<serde_json::Map<String, serde_json::Value>>>,
    #[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()),
        }
    }
}

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

/// `GetPlatformURLSResponseURLS` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetPlatformURLSResponseURLS {
    #[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>,
}

/// `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>>,
}

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

/// `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()),
        }
    }
}

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

/// `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 {
    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. 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<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<RunMetrics>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    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<serde_json::Map<String, serde_json::Value>>>,
    /// 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>,
}

/// 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<serde_json::Value>>,
}

/// 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 {
    pub messages: Vec<serde_json::Map<String, serde_json::Value>>,
    /// The same list as `messages`.
    pub items: Vec<serde_json::Map<String, serde_json::Value>>,
    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<serde_json::Map<String, serde_json::Value>>,
    pub protocol_messages: Vec<serde_json::Map<String, serde_json::Value>>,
    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<serde_json::Map<String, serde_json::Value>>,
    pub protocol_messages: Vec<serde_json::Map<String, serde_json::Value>>,
    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,
    #[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: GuardrailPhase,
    #[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()),
        }
    }
}

/// `GuardrailPhase` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GuardrailPhase {
    #[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 GuardrailPhase {
    /// 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 GuardrailPhase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for GuardrailPhase {
    fn from(value: &str) -> Self {
        match value {
            "input" => Self::Input,
            "output" => Self::Output,
            "both" => Self::Both,
            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<serde_json::Map<String, serde_json::Value>>>,
}

/// `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>,
}

/// `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,
}

/// 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>,
}

/// `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()),
        }
    }
}

/// `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>,
    #[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()),
        }
    }
}

/// `Invite` model.
#[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 secret: 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 secret: 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>,
}

/// `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>,
}

/// `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>,
    #[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>,
    #[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/{id}`. 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>,
}

/// 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<serde_json::Map<String, serde_json::Value>>>,
}

/// `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,
}

/// `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,
}

/// `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>>,
    pub total: i64,
}

/// `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<ListBillingSpecPackagesResponsePackage>,
}

/// `ListBillingSpecPackagesResponsePackage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListBillingSpecPackagesResponsePackage {
    pub package_id: String,
    pub name: String,
    pub description: String,
    pub category: String,
    pub included_specs: Vec<String>,
    pub included_in_plans: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<SpecPackageProgram>,
    #[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>,
    /// A Stripe price is wired. False means checkout will refuse with 400.
    pub checkout_available: bool,
    pub entitlement: ListBillingSpecPackagesResponsePackageEntitlement,
}

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

impl ListBillingSpecPackagesResponsePackageEntitlement {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::PlanIncluded => "plan_included",
            Self::Purchased => "purchased",
            Self::Available => "available",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for ListBillingSpecPackagesResponsePackageEntitlement {
    fn from(value: &str) -> Self {
        match value {
            "plan_included" => Self::PlanIncluded,
            "purchased" => Self::Purchased,
            "available" => Self::Available,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `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>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub companies: Option<Vec<Company>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<i64>,
}

/// `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,
}

/// `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<serde_json::Map<String, serde_json::Value>>>,
    /// 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<serde_json::Map<String, serde_json::Value>>>,
}

/// `ListDatasetsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListDatasetsResponse {
    pub datasets: Vec<serde_json::Map<String, serde_json::Value>>,
    pub total: i64,
}

/// `ListEvalRunsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListEvalRunsResponse {
    pub eval_runs: Vec<serde_json::Map<String, serde_json::Value>>,
    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,
}

/// `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: SessionStatus,
    #[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<serde_json::Map<String, serde_json::Value>>>,
    /// 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<serde_json::Map<String, serde_json::Value>>>,
}

/// `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<serde_json::Map<String, serde_json::Value>>,
    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<serde_json::Map<String, serde_json::Value>>>,
}

/// `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>,
}

/// `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()),
        }
    }
}

/// `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>,
    /// 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<serde_json::Map<String, serde_json::Value>>>,
    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>,
}

/// `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<serde_json::Map<String, serde_json::Value>>>,
    /// 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>,
    /// 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<serde_json::Map<String, serde_json::Value>>>,
    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>,
}

/// `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()),
        }
    }
}

/// `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>,
}

/// `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>,
}

/// 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()),
        }
    }
}

/// `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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub abort_reason: Option<String>,
}

/// 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()),
        }
    }
}

/// 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>,
}

/// `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>,
}

/// `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,
}

/// `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>>,
    #[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>>,
    #[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<serde_json::Map<String, serde_json::Value>>,
    pub edges: Vec<serde_json::Map<String, serde_json::Value>>,
    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<serde_json::Map<String, serde_json::Value>>,
    pub edges: Vec<serde_json::Map<String, serde_json::Value>>,
}

/// 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>,
}

/// `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>,
}

/// `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 agents: Option<Vec<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<serde_json::Map<String, serde_json::Value>>,
    #[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,
}

/// `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<serde_json::Map<String, serde_json::Value>>,
    #[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>,
}

/// 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>,
}

/// `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,
}

/// `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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub schema_version: Option<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<serde_json::Map<String, serde_json::Value>>>,
    #[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 attestation.
    #[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<serde_json::Map<String, serde_json::Value>>>,
    #[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,
}

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

/// `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>,
}

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

/// `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>,
}

/// `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()),
        }
    }
}

/// `RespondToPublicHitlRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RespondToPublicHitlRequest {
    pub response: 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>,
}

/// `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,
}

/// `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>,
}

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

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

impl RevokeSessionShareResponseError {
    /// 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 RevokeSessionShareResponseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// 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,
}

/// `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 {
    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. 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<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<RunMetrics>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    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>,
}

/// 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>,
    /// Conversation as it stood at this checkpoint. Left opaque: it mirrors the provider's message
    /// shape, which differs per adapter.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub messages: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    /// 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>,
}

/// 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 {
    pub message_id: String,
    pub reaction: RunFeedbackListFeedbackReaction,
}

/// `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>,
}

/// 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,
}

/// `RunMetrics` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RunMetrics {
    #[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,
}

/// 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,
}

/// `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>,
    #[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>,
}

/// `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,
    pub entitlement_updated: bool,
    /// 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: SessionStatus,
    #[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<serde_json::Map<String, serde_json::Value>>>,
    /// 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>,
}

/// `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()),
        }
    }
}

/// `SessionStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SessionStatus {
    #[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 SessionStatus {
    /// 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 SessionStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SessionStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "closed" => Self::Closed,
            "expired" => Self::Expired,
            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>,
}

/// `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>,
}

/// `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<serde_json::Map<String, serde_json::Value>>,
    #[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>,
}

/// `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,
}

/// `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 {
    #[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>,
}

/// `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,
}

/// `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>,
}

/// `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: SetupStateResponseStateStatus,
    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,
}

/// `live` is a one-way latch; closing registration afterwards does not undo it.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SetupStateResponseStateStatus {
    #[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 SetupStateResponseStateStatus {
    /// 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 SetupStateResponseStateStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `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,
}

/// `SpecPackage` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecPackage {
    /// Lowercase alphanumeric and hyphens, 1-64 characters. Also the map key.
    pub package_id: String,
    pub name: String,
    /// Server default: `""`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub category: String,
    /// SPEC refs. Only non-emptiness is checked here; the registry resolver enforces the
    /// `@scope/name\[@version\]` shape at run time, so a malformed ref is accepted by this write
    /// and fails later.
    pub included_specs: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub included_in_plans: Option<Vec<SpecPackageIncludedInPlan>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pricing: Option<SpecPackagePricing>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub display_order: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program: Option<SpecPackageProgram>,
    /// Stamped by the server on every write; not read from the body.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

/// `SpecPackageIncludedInPlan` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum SpecPackageIncludedInPlan {
    #[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 SpecPackageIncludedInPlan {
    /// 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 SpecPackageIncludedInPlan {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<&str> for SpecPackageIncludedInPlan {
    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()),
        }
    }
}

/// `SpecPackagePricing` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecPackagePricing {
    #[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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub billing_interval: Option<SpecPackagePricingBillingInterval>,
    /// Never returned by the tenant-facing read. Its presence is what protects the package from a
    /// silent drop.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_price_id: Option<String>,
}

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

impl SpecPackagePricingBillingInterval {
    /// 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 SpecPackagePricingBillingInterval {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `SpecPackageProgram` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SpecPackageProgram {
    pub nav: SpecPackageProgramNav,
    pub pages: Vec<SpecPackageProgramPage>,
}

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

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

/// 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,
    /// 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, Value>,
}

/// `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,
}

/// `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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_subscription_id: Option<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>,
}

/// `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.
    #[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>,
}

/// 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()),
        }
    }
}

/// `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()),
        }
    }
}

/// 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()),
        }
    }
}

/// 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<serde_json::Map<String, serde_json::Value>>,
    #[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,
    pub usage: TenantOverviewUsage,
    pub cost: TenantOverviewCost,
    pub system: TenantOverviewSystem,
    pub schedules: TenantOverviewSchedules,
}

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

/// `TenantOverviewCost` model.
#[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,
    pub by_execution_mode: TenantOverviewFleetByExecutionMode,
    pub bridge: TenantOverviewFleetBridge,
    #[serde(default)]
    pub head_agent_id: Option<String>,
    pub top_by_runs: Vec<AgentAnalyticsRow>,
    pub top_by_cost: 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>,
}

/// `TenantOverviewFleetBridge` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TenantOverviewFleetBridge {
    pub online: i64,
    pub stale: i64,
    pub offline: i64,
    pub machines_total: i64,
}

/// `TenantOverviewFleetByExecutionMode` model.
#[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,
    pub cost_24h_usd: 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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /// Passed through from the run record (same values as `Run.execution_mode`); absent when the
    /// record has none. `bridge` marks a report from a local agent, which may carry no transcript.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub execution_mode: Option<TenantOverviewRunsRecentItemExecutionMode>,
}

/// Passed through from the run record (same values as `Run.execution_mode`); absent when the
/// record has none. `bridge` marks a report from a local agent, which may carry no transcript.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum TenantOverviewRunsRecentItemExecutionMode {
    #[default]
    #[serde(rename = "async")]
    Async,
    #[serde(rename = "bridge")]
    Bridge,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl TenantOverviewRunsRecentItemExecutionMode {
    /// 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 TenantOverviewRunsRecentItemExecutionMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `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.
    pub at_risk: i64,
    pub paused: i64,
}

/// `TenantOverviewSystem` model.
#[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,
}

/// `TenantOverviewUsage` model.
#[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>,
}

/// `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 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,
}

/// `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()),
        }
    }
}

/// `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>,
}

/// `TransferTenantOwnershipResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TransferTenantOwnershipResponse {
    pub transferred: bool,
    pub new_owner: String,
    pub previous_owner: 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>,
}

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

/// `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,
}

/// `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,
}

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

/// `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>,
}

/// `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>>,
}

/// `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>,
}

/// `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>>,
}

/// `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>,
}

/// `UpdateAdminSpecPackagesRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateAdminSpecPackagesRequest {
    /// Keyed by `package_id`.
    pub packages: HashMap<String, SpecPackage>,
}

/// `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()),
        }
    }
}

/// `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>,
}

/// `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: UpdateBridgeAgentCapabilityResponseStatus,
}

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

impl UpdateBridgeAgentCapabilityResponseStatus {
    /// 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 UpdateBridgeAgentCapabilityResponseStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

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

/// `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,
    #[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>>,
}

/// 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>,
}

/// `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>,
}

/// `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>,
}

/// `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 {
    #[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>,
}

/// `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,
}

/// `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,
}

/// 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 {
    pub spec_id: String,
    /// The parsed view document, or null when the stored view was unparseable.
    pub output_view: serde_json::Value,
}

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

/// `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 {
    #[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>,
}

/// `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<serde_json::Map<String, serde_json::Value>>>,
    #[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>,
}

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

/// `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()),
        }
    }
}

/// `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 {
    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()),
        }
    }
}