uarp-sdk 0.5.6

// Code generated by @uarp/codegen from spec/openapi.json. DO NOT EDIT.
//!
//! Data models for UARP — Universal Agent Runtime Platform (spec version 0.2.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()),
        }
    }
}

/// Agent-to-Agent Protocol task (A2A spec compliant).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct A2ATask {
    pub task_id: String,
    pub agent_id: String,
    pub status: A2ATaskStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    /// Message history per A2A spec.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub history: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub artifacts: Option<Vec<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>>,
    #[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>,
}

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

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

/// `AddTeamGraphEdgeRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AddTeamGraphEdgeRequest {
    pub from: String,
    pub to: String,
    pub r#type: String,
    #[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: String,
    #[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()),
        }
    }
}

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

/// `AdminGetOAuthProviderResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminGetOAuthProviderResponse {
    pub provider: String,
    pub enabled: bool,
    pub configured: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    /// `••••XXXX` form — last 4 chars only.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_secret_hint: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<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>,
}

/// `AdminPutOAuthProviderRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AdminPutOAuthProviderRequest {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub client_secret: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
}

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

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

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

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

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

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

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

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

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

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

/// `AmbassadorRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct AmbassadorRequest {
    pub id: String,
    pub from_agent_id: String,
    pub r#type: String,
    pub subject: String,
    pub body: String,
    pub status: AmbassadorRequestStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: 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_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()),
        }
    }
}

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

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

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

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

/// `ArbiterCase` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ArbiterCase {
    pub id: String,
    pub filed_by: String,
    pub against_agent_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    pub status: ArbiterCaseStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ruling: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filed_at: Option<String>,
}

/// `ArbiterCaseStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ArbiterCaseStatus {
    #[default]
    #[serde(rename = "filed")]
    Filed,
    #[serde(rename = "in_review")]
    InReview,
    #[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::Filed => "filed",
            Self::InReview => "in_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 {
            "filed" => Self::Filed,
            "in_review" => Self::InReview,
            "ruled" => Self::Ruled,
            "appealed" => Self::Appealed,
            "closed" => Self::Closed,
            other => Self::Other(other.to_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>,
}

/// 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 id: String,
    pub proposal_id: String,
    pub agent_id: String,
    pub vote: BallotVote,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub weight: Option<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 = "yes")]
    Yes,
    #[serde(rename = "no")]
    No,
    #[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::Yes => "yes",
            Self::No => "no",
            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 {
            "yes" => Self::Yes,
            "no" => Self::No,
            "abstain" => Self::Abstain,
            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>,
}

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

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

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

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

/// `BridgeTaskEvent` model.
#[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<BridgeTaskEventStatus>,
    #[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 content: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metrics: Option<BridgeTaskEventMetrics>,
}

/// `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>,
    /// Any additional properties the server returned.
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

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

impl BridgeTaskEventStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Working => "working",
            Self::Completed => "completed",
            Self::Failed => "failed",
            Self::ApprovalDenied => "approval_denied",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for BridgeTaskEventStatus {
    fn from(value: &str) -> Self {
        match value {
            "working" => Self::Working,
            "completed" => Self::Completed,
            "failed" => Self::Failed,
            "approval_denied" => Self::ApprovalDenied,
            other => Self::Other(other.to_string()),
        }
    }
}

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

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

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

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

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

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

/// 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 in USD.
    pub budget: 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>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
}

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

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

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

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

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

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

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

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

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

/// `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 skills: Option<Vec<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 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>>,
}

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

/// `CreateCommerceProductRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateCommerceProductRequest {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub r#type: ProductType,
    pub price_cents: i64,
    pub currency: 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 agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub course_structure: 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>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vendor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub images: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variants: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compare_at_price_cents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub body_html: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shopify_product_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

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

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

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

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

impl From<&str> for CreateGuardrailRequestPhase {
    fn from(value: &str) -> Self {
        match value {
            "input" => Self::Input,
            "output" => Self::Output,
            "both" => Self::Both,
            other => Self::Other(other.to_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: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub args: Option<Vec<String>>,
    #[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,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `CreateTaskRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateTaskRequest {
    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 recurrence: Option<CreateTaskRequestRecurrence>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub require_confirmation: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delivery: Option<CreateTaskRequestDelivery>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_ids: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub team_id: Option<String>,
}

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

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

impl From<&str> for CreateTaskRequestDeliveryChannel {
    fn from(value: &str) -> Self {
        match value {
            "email" => Self::Email,
            "telegram" => Self::Telegram,
            "whatsapp" => Self::Whatsapp,
            other => Self::Other(other.to_string()),
        }
    }
}

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

/// Commerce customer record.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Customer {
    pub id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub phone: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub addresses: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepts_marketing: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verified_email: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tax_exempt: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub locale: 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>,
}

/// Body for `PATCH /api/v1/commerce/customers/{id}`. Only the listed fields are applied;
/// anything else in the body is ignored.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CustomerUpdate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub last_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub phone: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub addresses: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepts_marketing: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub verified_email: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tax_exempt: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub locale: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `EnforcementResult` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResult {
    pub allowed: bool,
    pub violations: Vec<EnforcementResultViolation>,
}

/// `EnforcementResultViolation` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnforcementResultViolation {
    pub rule_id: String,
    pub severity: EnforcementResultViolationSeverity,
    pub message: String,
}

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

impl EnforcementResultViolationSeverity {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Info => "info",
            Self::Warning => "warning",
            Self::Error => "error",
            Self::Blocker => "blocker",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for EnforcementResultViolationSeverity {
    fn from(value: &str) -> Self {
        match value {
            "info" => Self::Info,
            "warning" => Self::Warning,
            "error" => Self::Error,
            "blocker" => Self::Blocker,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `Enrollment` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Enrollment {
    pub id: String,
    pub tenant_id: String,
    pub customer_id: String,
    pub product_id: String,
    pub status: EnrollmentStatus,
    #[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>,
}

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

impl EnrollmentStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Active => "active",
            Self::Paused => "paused",
            Self::Completed => "completed",
            Self::Cancelled => "cancelled",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for EnrollmentStatus {
    fn from(value: &str) -> Self {
        match value {
            "active" => Self::Active,
            "paused" => Self::Paused,
            "completed" => Self::Completed,
            "cancelled" => Self::Cancelled,
            other => Self::Other(other.to_string()),
        }
    }
}

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

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

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

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

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

/// `EnrolMfaResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct EnrolMfaResponse {
    pub otpauth_url: String,
    /// Base32 secret.
    pub secret: String,
    pub recovery_codes: Vec<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>,
}

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

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

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

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

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

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

/// `GetAdminPlansResponsePlan` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetAdminPlansResponsePlan {
    pub id: String,
    pub name: String,
    /// Per-plan limits (`max_agents`, `max_monthly_tokens`, …).
    pub quotas: serde_json::Map<String, serde_json::Value>,
}

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

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

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

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

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

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

/// `GetCommerceAnalyticsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct GetCommerceAnalyticsResponse {
    pub total_customers: i64,
    pub total_products: i64,
    pub total_orders: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub paid_orders: Option<i64>,
    pub total_revenue_cents: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub active_enrollments: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed_enrollments: Option<i64>,
}

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

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

/// `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>,
    /// Hash of the most recent ledger entry.
    pub head: String,
    pub 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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    /// Runs waiting to be resumed after a restart.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pending_resumes: 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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `GoalStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum GoalStatus {
    #[default]
    #[serde(rename = "draft")]
    Draft,
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "achieved")]
    Achieved,
    #[serde(rename = "abandoned")]
    Abandoned,
    #[serde(rename = "expired")]
    Expired,
    /// 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::Draft => "draft",
            Self::Active => "active",
            Self::Achieved => "achieved",
            Self::Abandoned => "abandoned",
            Self::Expired => "expired",
            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 {
            "draft" => Self::Draft,
            "active" => Self::Active,
            "achieved" => Self::Achieved,
            "abandoned" => Self::Abandoned,
            "expired" => Self::Expired,
            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 {
    /// Monotonic position in the tenant's chain.
    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,
}

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

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

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

/// 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 agent_id: String,
    pub version: String,
    pub r#type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub diff: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
    pub status: ImprovementProposalStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub submitted_by: 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>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `ListCommerceCustomersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListCommerceCustomersResponse {
    pub items: Vec<Customer>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub customers: Option<Vec<Customer>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
}

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

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

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

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

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

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

/// `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<serde_json::Map<String, serde_json::Value>>>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invites: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[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<serde_json::Map<String, serde_json::Value>>>,
    #[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<serde_json::Map<String, serde_json::Value>>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub knowledge_bases: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    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<serde_json::Map<String, serde_json::Value>>>,
}

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

/// `ListMeSessionsResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMeSessionsResponse {
    pub items: Vec<ListMeSessionsResponseItem>,
    /// Legacy alias for `items`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sessions: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    pub total: i64,
}

/// `ListMeSessionsResponseItem` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListMeSessionsResponseItem {
    pub key_id: String,
    pub name: String,
    pub prefix: String,
    pub scopes: Vec<String>,
    pub status: ListMeSessionsResponseItemStatus,
    #[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>,
    pub is_current: bool,
}

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

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

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

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

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

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

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

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

impl From<&str> for ListOAuthLoginProvidersResponseProviderId {
    fn from(value: &str) -> Self {
        match value {
            "github" => Self::Github,
            "google" => Self::Google,
            "apple" => Self::Apple,
            other => Self::Other(other.to_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>>,
}

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

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

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

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

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

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

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

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

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

/// `ListUsersResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ListUsersResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub items: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    /// Legacy alias for `items`. Will be removed in API v1.x.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub users: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[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<serde_json::Map<String, serde_json::Value>>>,
}

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

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

/// Tenant-scoped LLM provider credential (masked secret).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct LLMCredential {
    pub id: String,
    pub tenant_id: String,
    pub provider: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    /// Last 4 chars only; full key never returned.
    pub key_preview: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub endpoint_url: 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>,
}

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

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

/// `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 listing_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub caller_tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<serde_json::Map<String, serde_json::Value>>,
    pub status: MarketplaceInvocationStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Map<String, serde_json::Value>>,
    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,
    #[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: MarketplaceListingCategory,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon_url: Option<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 stats: Option<MarketplaceListingStats>,
    pub status: MarketplaceListingStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub a2a_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub program_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>,
}

/// `MarketplaceListingCategory` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum MarketplaceListingCategory {
    #[default]
    #[serde(rename = "productivity")]
    Productivity,
    #[serde(rename = "engineering")]
    Engineering,
    #[serde(rename = "research")]
    Research,
    #[serde(rename = "creative")]
    Creative,
    #[serde(rename = "support")]
    Support,
    #[serde(rename = "operations")]
    Operations,
    #[serde(rename = "analytics")]
    Analytics,
    #[serde(rename = "education")]
    Education,
    #[serde(rename = "personal")]
    Personal,
    #[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::Productivity => "productivity",
            Self::Engineering => "engineering",
            Self::Research => "research",
            Self::Creative => "creative",
            Self::Support => "support",
            Self::Operations => "operations",
            Self::Analytics => "analytics",
            Self::Education => "education",
            Self::Personal => "personal",
            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 {
            "productivity" => Self::Productivity,
            "engineering" => Self::Engineering,
            "research" => Self::Research,
            "creative" => Self::Creative,
            "support" => Self::Support,
            "operations" => Self::Operations,
            "analytics" => Self::Analytics,
            "education" => Self::Education,
            "personal" => Self::Personal,
            "other" => Self::Other,
            other => Self::Unknown(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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rating_avg: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rating_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub invocation_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub favourite_count: Option<i64>,
}

/// `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 = "deprecated")]
    Deprecated,
    /// 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::Deprecated => "deprecated",
            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,
            "deprecated" => Self::Deprecated,
            other => Self::Other(other.to_string()),
        }
    }
}

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

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

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

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

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

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

/// Result after DELETE — record removed from admin KV
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthLoginProviderConfigDeleted {
    pub provider: OAuthLoginProviderItemId,
    /// 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: OAuthLoginProviderItemId,
    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>>,
}

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

/// Response for starting OAuth flow
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct OAuthStartResponse {
    pub auth_url: String,
    pub state: 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>,
}

/// `Order` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Order {
    pub id: String,
    pub tenant_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub customer_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub product_id: Option<String>,
    pub amount_cents: i64,
    pub currency: String,
    pub status: OrderStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_payment_intent_id: 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 paid_at: Option<String>,
}

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

impl OrderStatus {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Pending => "pending",
            Self::Paid => "paid",
            Self::Failed => "failed",
            Self::Refunded => "refunded",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for OrderStatus {
    fn from(value: &str) -> Self {
        match value {
            "pending" => Self::Pending,
            "paid" => Self::Paid,
            "failed" => Self::Failed,
            "refunded" => Self::Refunded,
            other => Self::Other(other.to_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>,
}

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

/// `Product` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Product {
    pub id: String,
    pub tenant_id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub r#type: ProductType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<ProductStatus>,
    pub price_cents: i64,
    pub currency: 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 agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub course_structure: 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>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vendor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub images: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variants: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compare_at_price_cents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub body_html: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shopify_product_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 created_at: Option<String>,
}

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

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

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

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

/// `ProductType` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum ProductType {
    #[default]
    #[serde(rename = "course")]
    Course,
    #[serde(rename = "service")]
    Service,
    #[serde(rename = "digital")]
    Digital,
    #[serde(rename = "subscription")]
    Subscription,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl ProductType {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Course => "course",
            Self::Service => "service",
            Self::Digital => "digital",
            Self::Subscription => "subscription",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for ProductType {
    fn from(value: &str) -> Self {
        match value {
            "course" => Self::Course,
            "service" => Self::Service,
            "digital" => Self::Digital,
            "subscription" => Self::Subscription,
            other => Self::Other(other.to_string()),
        }
    }
}

/// Body for `PATCH /api/v1/commerce/products/{id}`. Every field optional; unknown fields are
/// dropped without error, so a typo answers 200 and changes nothing.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProductUpdate {
    #[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 price_cents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: 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 agent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub course_structure: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stripe_price_id: 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 slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vendor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub images: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variants: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compare_at_price_cents: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub body_html: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<serde_json::Map<String, serde_json::Value>>>,
}

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

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

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

/// `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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ok: Option<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<RegistryPublishResponseVisibility>,
    #[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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha256: 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 yank_reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub published_at: Option<String>,
}

/// `RegistryGetSpecMetadataResponse` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RegistryGetSpecMetadataResponse {
    pub scope: 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 license: Option<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>,
    #[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>>,
    pub visibility: RegistryPublishResponseVisibility,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shared_with: Option<Vec<String>>,
    pub owner_tenant_id: String,
    pub latest_version: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub versions: Option<Vec<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 tool_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub skill_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<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<RegistryPublishResponseVisibility>,
    #[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: RegistryPublishResponseVisibility,
    #[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,
}

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

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

impl From<&str> for RegistryPublishResponseVisibility {
    fn from(value: &str) -> Self {
        match value {
            "public" => Self::Public,
            "private" => Self::Private,
            other => Self::Other(other.to_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>,
}

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

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

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

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

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

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

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

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

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

/// EU AI Act (Article 9) classification for an agent.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RiskClassification {
    pub level: RiskClassificationUpdateLevel,
    /// Set when level is `high`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annex_iii_category: Option<RiskClassificationUpdateAnnexIiiCategory>,
    pub justification: String,
    /// Key ID or user ID of whoever classified.
    pub assessor: String,
    pub assessed_at: String,
    pub review_due_at: String,
}

/// Body for `PATCH /api/v1/agents/{agentId}/risk-classification`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RiskClassificationUpdate {
    pub level: RiskClassificationUpdateLevel,
    /// Set when level is `high`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annex_iii_category: Option<RiskClassificationUpdateAnnexIiiCategory>,
    pub justification: String,
    pub assessor: String,
    /// Defaults to now when omitted.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assessed_at: Option<String>,
    pub review_due_at: String,
}

/// Set when level is `high`.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum RiskClassificationUpdateAnnexIiiCategory {
    #[default]
    #[serde(rename = "biometric")]
    Biometric,
    #[serde(rename = "critical-infrastructure")]
    CriticalInfrastructure,
    #[serde(rename = "education")]
    Education,
    #[serde(rename = "employment")]
    Employment,
    #[serde(rename = "essential-services")]
    EssentialServices,
    #[serde(rename = "law-enforcement")]
    LawEnforcement,
    #[serde(rename = "migration")]
    Migration,
    #[serde(rename = "democratic-processes")]
    DemocraticProcesses,
    /// A value the API introduced after this SDK was generated.
    #[serde(untagged)]
    Other(String),
}

impl RiskClassificationUpdateAnnexIiiCategory {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Biometric => "biometric",
            Self::CriticalInfrastructure => "critical-infrastructure",
            Self::Education => "education",
            Self::Employment => "employment",
            Self::EssentialServices => "essential-services",
            Self::LawEnforcement => "law-enforcement",
            Self::Migration => "migration",
            Self::DemocraticProcesses => "democratic-processes",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for RiskClassificationUpdateAnnexIiiCategory {
    fn from(value: &str) -> Self {
        match value {
            "biometric" => Self::Biometric,
            "critical-infrastructure" => Self::CriticalInfrastructure,
            "education" => Self::Education,
            "employment" => Self::Employment,
            "essential-services" => Self::EssentialServices,
            "law-enforcement" => Self::LawEnforcement,
            "migration" => Self::Migration,
            "democratic-processes" => Self::DemocraticProcesses,
            other => Self::Other(other.to_string()),
        }
    }
}

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

impl RiskClassificationUpdateLevel {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Minimal => "minimal",
            Self::Limited => "limited",
            Self::High => "high",
            Self::Unacceptable => "unacceptable",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for RiskClassificationUpdateLevel {
    fn from(value: &str) -> Self {
        match value {
            "minimal" => Self::Minimal,
            "limited" => Self::Limited,
            "high" => Self::High,
            "unacceptable" => Self::Unacceptable,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `RollbackAgentRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RollbackAgentRequest {
    /// Version number to rollback to
    pub version: i64,
}

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

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

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

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

/// Cron-driven recurring run config attached to an agent (PUT /agents/{id}/schedule).
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Schedule {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    pub cron: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[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 timezone: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_concurrent_scheduled: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub on_failure: Option<ScheduleOnFailure>,
    #[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>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_run_at: Option<String>,
}

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

impl ScheduleOnFailure {
    /// The value as it appears on the wire.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Continue => "continue",
            Self::Pause => "pause",
            Self::Alert => "alert",
            Self::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for ScheduleOnFailure {
    fn from(value: &str) -> Self {
        match value {
            "continue" => Self::Continue,
            "pause" => Self::Pause,
            "alert" => Self::Alert,
            other => Self::Other(other.to_string()),
        }
    }
}

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

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

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

/// `SearchMemoryRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SearchMemoryRequest {
    pub text: String,
    /// Server default: `"hybrid"`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategy: Option<SearchMemoryRequestStrategy>,
    /// Server default: `20`.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub types: Option<Vec<SearchMemoryRequestType>>,
}

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

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

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

impl From<&str> for SearchMemoryRequestStrategy {
    fn from(value: &str) -> Self {
        match value {
            "recency" => Self::Recency,
            "hybrid" => Self::Hybrid,
            other => Self::Other(other.to_string()),
        }
    }
}

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

impl SearchMemoryRequestType {
    /// 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::Other(value) => value.as_str(),
        }
    }
}

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

impl From<&str> for SearchMemoryRequestType {
    fn from(value: &str) -> Self {
        match value {
            "episodic" => Self::Episodic,
            "semantic" => Self::Semantic,
            "procedural" => Self::Procedural,
            other => Self::Other(other.to_string()),
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl From<&str> for SetLLMProviderKeyProvider {
    fn from(value: &str) -> Self {
        match value {
            "openai_compat" => Self::OpenaiCompat,
            "custom" => Self::Custom,
            other => Self::Other(other.to_string()),
        }
    }
}

/// `SetLLMProviderKeyRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SetLLMProviderKeyRequest {
    /// Provider API key (stored encrypted)
    pub api_key: String,
}

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

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

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

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

impl From<&str> for SetScheduleRequestOnFailure {
    fn from(value: &str) -> Self {
        match value {
            "retry_next" => Self::RetryNext,
            "pause_schedule" => Self::PauseSchedule,
            "notify" => Self::Notify,
            other => Self::Other(other.to_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>,
}

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

/// `ShareWorkspaceRequest` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ShareWorkspaceRequest {
    pub agent_id: 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,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_roles: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub require_approval_above_depth: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_children_per_agent: Option<i64>,
}

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

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

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

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

impl From<&str> for StartTeamRunRequestChatMode {
    fn from(value: &str) -> Self {
        match value {
            "plan" => Self::Plan,
            "chat" => Self::Chat,
            other => Self::Other(other.to_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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub suspended: Option<bool>,
}

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

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

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

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

/// `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 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<TenantStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<TenantPlan>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub quotas: Option<serde_json::Map<String, serde_json::Value>>,
    #[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 created_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

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

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

/// `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,
    /// 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::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,
            other => Self::Other(other.to_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>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// `Veto` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Veto {
    pub id: String,
    pub issued_by: String,
    pub target_type: String,
    pub target_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub issued_at: Option<String>,
}

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

/// `VotingProposal` model.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct VotingProposal {
    pub id: String,
    #[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 proposer_agent_id: Option<String>,
    pub status: VotingProposalStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub opens_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub closes_at: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Map<String, serde_json::Value>>,
}

/// `VotingProposalStatus` enumeration.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
pub enum VotingProposalStatus {
    #[default]
    #[serde(rename = "draft")]
    Draft,
    #[serde(rename = "open")]
    Open,
    #[serde(rename = "closed")]
    Closed,
    #[serde(rename = "vetoed")]
    Vetoed,
    #[serde(rename = "executed")]
    Executed,
    /// 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::Draft => "draft",
            Self::Open => "open",
            Self::Closed => "closed",
            Self::Vetoed => "vetoed",
            Self::Executed => "executed",
            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 {
            "draft" => Self::Draft,
            "open" => Self::Open,
            "closed" => Self::Closed,
            "vetoed" => Self::Vetoed,
            "executed" => Self::Executed,
            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 {
    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>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub assigned_agents: Option<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>>,
    #[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>,
}

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

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