opencode-codes 1.18.5

// AUTO-GENERATED by scripts/codegen_opencode.py — DO NOT EDIT BY HAND.
// Source: opencode-codes/tests/schemas/opencode_openapi.json (opencode 1.18.5).
// Run `python3 scripts/codegen_opencode.py` to regenerate.
//
// Every schema in components.schemas is emitted, plus synthesized named types
// for the six hand-wrapped endpoints' inline request/response bodies and for
// inline object / union field shapes. Discriminated unions become internally-
// tagged serde enums; all-string unions become open enums with Unknown(String);
// remaining unions are #[serde(untagged)] with branch order preserved. Inline
// string-enum fields are represented as String.

#![allow(
    clippy::large_enum_variant,
    clippy::enum_variant_names,
    clippy::doc_markdown,
    clippy::doc_lazy_continuation
)]

use serde::{Deserialize, Deserializer, Serialize, Serializer};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct APIError {
    pub data: APIErrorData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct APIErrorData {
    #[serde(rename = "isRetryable")]
    pub is_retryable: bool,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<std::collections::BTreeMap<String, String>>,
    #[serde(
        rename = "responseBody",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_body: Option<String>,
    #[serde(
        rename = "responseHeaders",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_headers: Option<std::collections::BTreeMap<String, String>>,
    #[serde(
        rename = "statusCode",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_code: Option<u64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Agent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    pub mode: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<AgentModel>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub native: Option<bool>,
    pub options: serde_json::Map<String, serde_json::Value>,
    pub permission: PermissionRuleset,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompt: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub steps: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
    #[serde(rename = "topP", default, skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AgentColor {
    Primary,
    Secondary,
    Accent,
    Success,
    Warning,
    Error,
    Info,
    Unknown(String),
}

impl AgentColor {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Primary => "primary",
            Self::Secondary => "secondary",
            Self::Accent => "accent",
            Self::Success => "success",
            Self::Warning => "warning",
            Self::Error => "error",
            Self::Info => "info",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for AgentColor {
    fn from(s: &str) -> Self {
        match s {
            "primary" => Self::Primary,
            "secondary" => Self::Secondary,
            "accent" => Self::Accent,
            "success" => Self::Success,
            "warning" => Self::Warning,
            "error" => Self::Error,
            "info" => Self::Info,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for AgentColor {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for AgentColor {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AgentConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<AgentConfigColor>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disable: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    #[serde(rename = "maxSteps", default, skip_serializing_if = "Option::is_none")]
    pub max_steps: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permission: Option<PermissionConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompt: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub steps: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<std::collections::BTreeMap<String, bool>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

/// Hex color code (e.g., #FF5733) or theme color (e.g., primary)
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AgentConfigColor {
    Primary,
    Secondary,
    Accent,
    Success,
    Warning,
    Error,
    Info,
    Unknown(String),
}

impl AgentConfigColor {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Primary => "primary",
            Self::Secondary => "secondary",
            Self::Accent => "accent",
            Self::Success => "success",
            Self::Warning => "warning",
            Self::Error => "error",
            Self::Info => "info",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for AgentConfigColor {
    fn from(s: &str) -> Self {
        match s {
            "primary" => Self::Primary,
            "secondary" => Self::Secondary,
            "accent" => Self::Accent,
            "success" => Self::Success,
            "warning" => Self::Warning,
            "error" => Self::Error,
            "info" => Self::Info,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for AgentConfigColor {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for AgentConfigColor {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AgentModel {
    #[serde(rename = "modelID")]
    pub model_id: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AgentPart {
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub name: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<AgentPartInputSource>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AgentPartInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<AgentPartInputSource>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AgentPartInputSource {
    pub end: u64,
    pub start: u64,
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AgentV2Info {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<AgentColor>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub hidden: bool,
    pub id: String,
    pub mode: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<ModelRef>,
    pub permissions: PermissionV2Ruleset,
    pub request: ProviderRequest,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub steps: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ApiAuth {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<std::collections::BTreeMap<String, String>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssistantMessage {
    pub agent: String,
    pub cost: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<SessionErrorDataError>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub finish: Option<String>,
    pub id: String,
    pub mode: String,
    #[serde(rename = "modelID")]
    pub model_id: String,
    #[serde(rename = "parentID")]
    pub parent_id: String,
    pub path: AssistantMessagePath,
    #[serde(rename = "providerID")]
    pub provider_id: String,
    #[serde(default, skip_serializing)]
    pub role: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub structured: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<bool>,
    pub time: AssistantMessageTime,
    pub tokens: StepFinishPartTokens,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssistantMessagePath {
    pub cwd: String,
    pub root: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AssistantMessageTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed: Option<u64>,
    pub created: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AttachmentConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<ImageAttachmentConfig>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Auth {
    #[serde(rename = "oauth")]
    Oauth(OAuth),
    #[serde(rename = "api")]
    Api(ApiAuth),
    #[serde(rename = "wellknown")]
    Wellknown(WellKnownAuth),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BadRequestError {
    pub data: BadRequestErrorData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BadRequestErrorData {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CatalogUpdated {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Command {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub hints: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subtask: Option<bool>,
    pub template: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CommandExecuted {
    pub data: CommandExecutedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CommandExecutedData {
    pub arguments: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub name: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CommandV2Info {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<ModelRef>,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subtask: Option<bool>,
    pub template: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CompactionPart {
    pub auto: bool,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub overflow: Option<bool>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tail_start_id: Option<String>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Config {
    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
    pub schema: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<ConfigAgent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attachment: Option<AttachmentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub autoshare: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub autoupdate: Option<ConfigAutoupdate>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<std::collections::BTreeMap<String, ConfigCommandValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compaction: Option<ConfigCompaction>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled_providers: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled_providers: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enterprise: Option<ConfigEnterprise>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub experimental: Option<ConfigExperimental>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub formatter: Option<ConfigFormatter>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub layout: Option<LayoutConfig>,
    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
    pub log_level: Option<LogLevel>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lsp: Option<ConfigLsp>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mcp: Option<std::collections::BTreeMap<String, ConfigMcpValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mode: Option<ConfigMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permission: Option<PermissionConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plugin: Option<Vec<ConfigPluginItem>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<std::collections::BTreeMap<String, ProviderConfig>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reference: Option<std::collections::BTreeMap<String, ConfigReferencesValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub references: Option<std::collections::BTreeMap<String, ConfigReferencesValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub server: Option<ServerConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub share: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub shell: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub skills: Option<ConfigSkills>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub small_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subagent_depth: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_output: Option<ConfigToolOutput>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<std::collections::BTreeMap<String, bool>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub watcher: Option<ConfigWatcher>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigAgent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub build: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compaction: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub explore: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub general: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<AgentConfig>,
}

/// Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications
/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigAutoupdate {
    Variant0(bool),
    Variant1(String),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigCommandValue {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subtask: Option<bool>,
    pub template: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigCompaction {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preserve_recent_tokens: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prune: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reserved: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tail_turns: Option<u64>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigExperimental {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub batch_tool: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub continue_loop_on_deny: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disable_paste_summary: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mcp_timeout: Option<i64>,
    #[serde(
        rename = "openTelemetry",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub open_telemetry: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub policies: Option<Vec<ConfigV2ExperimentalPolicy>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub primary_tools: Option<Vec<String>>,
}

/// Enable or configure formatters. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides.
/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigFormatter {
    Variant0(bool),
    Variant1(std::collections::BTreeMap<String, ConfigFormatterVariant1Value>),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigFormatterVariant1Value {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub environment: Option<std::collections::BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub extensions: Option<Vec<String>>,
}

/// Enable or configure LSP servers. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides.
/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigLsp {
    Variant0(bool),
    Variant1(std::collections::BTreeMap<String, ConfigLspVariant1Value>),
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigLspVariant1Value {
    Variant0(ConfigLspVariant1ValueVariant0),
    Variant1(ConfigLspVariant1ValueVariant1),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigLspVariant1ValueVariant0 {
    pub disabled: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigLspVariant1ValueVariant1 {
    pub command: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<std::collections::BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub extensions: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub initialization: Option<serde_json::Map<String, serde_json::Value>>,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigMcpValue {
    McpLocalConfig(McpLocalConfig),
    McpRemoteConfig(McpRemoteConfig),
    Variant2(ConfigMcpValueVariant2),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigMcpValueVariant2 {
    pub enabled: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigMode {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub build: Option<AgentConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plan: Option<AgentConfig>,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigPluginItem {
    Variant0(String),
    Variant1(Vec<serde_json::Value>),
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConfigReferencesValue {
    Variant0(String),
    ConfigV2ReferenceGit(ConfigV2ReferenceGit),
    ConfigV2ReferenceLocal(ConfigV2ReferenceLocal),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigSkills {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub paths: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub urls: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigToolOutput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_lines: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigV2ExperimentalPolicy {
    pub action: String,
    pub effect: PolicyEffect,
    pub resource: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigV2ReferenceGit {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    pub repository: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigV2ReferenceLocal {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    pub path: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigWatcher {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ignore: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConflictError {
    pub _tag: String,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConnectionCredentialInfo {
    pub id: String,
    pub label: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConnectionEnvInfo {
    pub name: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ConnectionInfo {
    #[serde(rename = "credential")]
    Credential(ConnectionCredentialInfo),
    #[serde(rename = "env")]
    Env(ConnectionEnvInfo),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConsoleState {
    #[serde(
        rename = "activeOrgName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub active_org_name: Option<String>,
    #[serde(rename = "consoleManagedProviders")]
    pub console_managed_providers: Vec<String>,
    #[serde(rename = "switchableOrgCount")]
    pub switchable_org_count: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ContentFilterError {
    pub data: WorktreeFailedData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ContextOverflowError {
    pub data: ContextOverflowErrorData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ContextOverflowErrorData {
    pub message: String,
    #[serde(
        rename = "responseBody",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_body: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CredentialKey {
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CredentialOAuth {
    pub access: String,
    pub expires: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "methodID")]
    pub method_id: String,
    pub refresh: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum CredentialValue {
    #[serde(rename = "oauth")]
    Oauth(CredentialOAuth),
    #[serde(rename = "key")]
    Key(CredentialKey),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Event {
    #[serde(rename = "models-dev.refreshed")]
    ModelsDevRefreshed(EventModelsDevRefreshed),
    #[serde(rename = "integration.updated")]
    IntegrationUpdated(EventIntegrationUpdated),
    #[serde(rename = "integration.connection.updated")]
    IntegrationConnectionUpdated(EventIntegrationConnectionUpdated),
    #[serde(rename = "catalog.updated")]
    CatalogUpdated(EventCatalogUpdated),
    #[serde(rename = "session.created")]
    SessionCreated(EventSessionCreated),
    #[serde(rename = "session.updated")]
    SessionUpdated(EventSessionUpdated),
    #[serde(rename = "session.deleted")]
    SessionDeleted(EventSessionDeleted),
    #[serde(rename = "message.updated")]
    MessageUpdated(EventMessageUpdated),
    #[serde(rename = "message.removed")]
    MessageRemoved(EventMessageRemoved),
    #[serde(rename = "message.part.updated")]
    MessagePartUpdated(EventMessagePartUpdated),
    #[serde(rename = "message.part.removed")]
    MessagePartRemoved(EventMessagePartRemoved),
    #[serde(rename = "session.next.agent.switched")]
    SessionNextAgentSwitched(EventSessionNextAgentSwitched),
    #[serde(rename = "session.next.model.switched")]
    SessionNextModelSwitched(EventSessionNextModelSwitched),
    #[serde(rename = "session.next.moved")]
    SessionNextMoved(EventSessionNextMoved),
    #[serde(rename = "session.next.prompted")]
    SessionNextPrompted(EventSessionNextPrompted),
    #[serde(rename = "session.next.prompt.admitted")]
    SessionNextPromptAdmitted(EventSessionNextPromptAdmitted),
    #[serde(rename = "session.next.context.updated")]
    SessionNextContextUpdated(EventSessionNextContextUpdated),
    #[serde(rename = "session.next.synthetic")]
    SessionNextSynthetic(EventSessionNextSynthetic),
    #[serde(rename = "session.next.shell.started")]
    SessionNextShellStarted(EventSessionNextShellStarted),
    #[serde(rename = "session.next.shell.ended")]
    SessionNextShellEnded(EventSessionNextShellEnded),
    #[serde(rename = "session.next.step.started")]
    SessionNextStepStarted(EventSessionNextStepStarted),
    #[serde(rename = "session.next.step.ended")]
    SessionNextStepEnded(EventSessionNextStepEnded),
    #[serde(rename = "session.next.step.failed")]
    SessionNextStepFailed(EventSessionNextStepFailed),
    #[serde(rename = "session.next.text.started")]
    SessionNextTextStarted(EventSessionNextTextStarted),
    #[serde(rename = "session.next.text.delta")]
    SessionNextTextDelta(EventSessionNextTextDelta),
    #[serde(rename = "session.next.text.ended")]
    SessionNextTextEnded(EventSessionNextTextEnded),
    #[serde(rename = "session.next.reasoning.started")]
    SessionNextReasoningStarted(EventSessionNextReasoningStarted),
    #[serde(rename = "session.next.reasoning.delta")]
    SessionNextReasoningDelta(EventSessionNextReasoningDelta),
    #[serde(rename = "session.next.reasoning.ended")]
    SessionNextReasoningEnded(EventSessionNextReasoningEnded),
    #[serde(rename = "session.next.tool.input.started")]
    SessionNextToolInputStarted(EventSessionNextToolInputStarted),
    #[serde(rename = "session.next.tool.input.delta")]
    SessionNextToolInputDelta(EventSessionNextToolInputDelta),
    #[serde(rename = "session.next.tool.input.ended")]
    SessionNextToolInputEnded(EventSessionNextToolInputEnded),
    #[serde(rename = "session.next.tool.called")]
    SessionNextToolCalled(EventSessionNextToolCalled),
    #[serde(rename = "session.next.tool.progress")]
    SessionNextToolProgress(EventSessionNextToolProgress),
    #[serde(rename = "session.next.tool.success")]
    SessionNextToolSuccess(EventSessionNextToolSuccess),
    #[serde(rename = "session.next.tool.failed")]
    SessionNextToolFailed(EventSessionNextToolFailed),
    #[serde(rename = "session.next.retried")]
    SessionNextRetried(EventSessionNextRetried),
    #[serde(rename = "session.next.compaction.started")]
    SessionNextCompactionStarted(EventSessionNextCompactionStarted),
    #[serde(rename = "session.next.compaction.delta")]
    SessionNextCompactionDelta(EventSessionNextCompactionDelta),
    #[serde(rename = "session.next.compaction.ended")]
    SessionNextCompactionEnded(EventSessionNextCompactionEnded),
    #[serde(rename = "session.next.revert.staged")]
    SessionNextRevertStaged(EventSessionNextRevertStaged),
    #[serde(rename = "session.next.revert.cleared")]
    SessionNextRevertCleared(EventSessionNextRevertCleared),
    #[serde(rename = "session.next.revert.committed")]
    SessionNextRevertCommitted(EventSessionNextRevertCommitted),
    #[serde(rename = "message.part.delta")]
    MessagePartDelta(EventMessagePartDelta),
    #[serde(rename = "session.diff")]
    SessionDiff(EventSessionDiff),
    #[serde(rename = "session.error")]
    SessionError(EventSessionError),
    #[serde(rename = "installation.updated")]
    InstallationUpdated(EventInstallationUpdated),
    #[serde(rename = "installation.update-available")]
    InstallationUpdateAvailable(EventInstallationUpdateAvailable),
    #[serde(rename = "file.edited")]
    FileEdited(EventFileEdited),
    #[serde(rename = "reference.updated")]
    ReferenceUpdated(EventReferenceUpdated),
    #[serde(rename = "permission.v2.asked")]
    PermissionV2Asked(EventPermissionV2Asked),
    #[serde(rename = "permission.v2.replied")]
    PermissionV2Replied(EventPermissionV2Replied),
    #[serde(rename = "plugin.added")]
    PluginAdded(EventPluginAdded),
    #[serde(rename = "project.directories.updated")]
    ProjectDirectoriesUpdated(EventProjectDirectoriesUpdated),
    #[serde(rename = "file.watcher.updated")]
    FileWatcherUpdated(EventFileWatcherUpdated),
    #[serde(rename = "pty.created")]
    PtyCreated(EventPtyCreated),
    #[serde(rename = "pty.updated")]
    PtyUpdated(EventPtyUpdated),
    #[serde(rename = "pty.exited")]
    PtyExited(EventPtyExited),
    #[serde(rename = "pty.deleted")]
    PtyDeleted(EventPtyDeleted),
    #[serde(rename = "question.v2.asked")]
    QuestionV2Asked(EventQuestionV2Asked),
    #[serde(rename = "question.v2.replied")]
    QuestionV2Replied(EventQuestionV2Replied),
    #[serde(rename = "question.v2.rejected")]
    QuestionV2Rejected(EventQuestionV2Rejected),
    #[serde(rename = "todo.updated")]
    TodoUpdated(EventTodoUpdated),
    #[serde(rename = "lsp.updated")]
    LspUpdated(EventLspUpdated),
    #[serde(rename = "permission.asked")]
    PermissionAsked(EventPermissionAsked),
    #[serde(rename = "permission.replied")]
    PermissionReplied(EventPermissionReplied),
    #[serde(rename = "tui.prompt.append")]
    TuiPromptAppend(EventTuiPromptAppend),
    #[serde(rename = "tui.command.execute")]
    TuiCommandExecute(EventTuiCommandExecute),
    #[serde(rename = "tui.toast.show")]
    TuiToastShow(EventTuiToastShow),
    #[serde(rename = "tui.session.select")]
    TuiSessionSelect(EventTuiSessionSelect),
    #[serde(rename = "mcp.tools.changed")]
    McpToolsChanged(EventMcpToolsChanged),
    #[serde(rename = "mcp.browser.open.failed")]
    McpBrowserOpenFailed(EventMcpBrowserOpenFailed),
    #[serde(rename = "command.executed")]
    CommandExecuted(EventCommandExecuted),
    #[serde(rename = "project.updated")]
    ProjectUpdated(EventProjectUpdated),
    #[serde(rename = "session.status")]
    SessionStatus(EventSessionStatus),
    #[serde(rename = "session.idle")]
    SessionIdle(EventSessionIdle),
    #[serde(rename = "question.asked")]
    QuestionAsked(EventQuestionAsked),
    #[serde(rename = "question.replied")]
    QuestionReplied(EventQuestionReplied),
    #[serde(rename = "question.rejected")]
    QuestionRejected(EventQuestionRejected),
    #[serde(rename = "session.compacted")]
    SessionCompacted(EventSessionCompacted),
    #[serde(rename = "vcs.branch.updated")]
    VcsBranchUpdated(EventVcsBranchUpdated),
    #[serde(rename = "workspace.ready")]
    WorkspaceReady(EventWorkspaceReady),
    #[serde(rename = "workspace.failed")]
    WorkspaceFailed(EventWorkspaceFailed),
    #[serde(rename = "workspace.status")]
    WorkspaceStatus(EventWorkspaceStatus),
    #[serde(rename = "worktree.ready")]
    WorktreeReady(EventWorktreeReady),
    #[serde(rename = "worktree.failed")]
    WorktreeFailed(EventWorktreeFailed),
    #[serde(rename = "server.connected")]
    ServerConnected(EventServerConnected),
    #[serde(rename = "global.disposed")]
    GlobalDisposed(EventGlobalDisposed),
    #[serde(rename = "server.instance.disposed")]
    ServerInstanceDisposed(EventServerInstanceDisposed),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiCommandExecute {
    pub id: String,
    pub properties: TuiCommandExecuteData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiPromptAppend {
    pub id: String,
    pub properties: TuiPromptAppendData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiSessionSelect {
    pub id: String,
    pub properties: TuiSessionSelectData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiToastShow {
    pub id: String,
    pub properties: TuiToastShowData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventCatalogUpdated {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventCommandExecuted {
    pub id: String,
    pub properties: CommandExecutedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventFileEdited {
    pub id: String,
    pub properties: FileEditedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventFileWatcherUpdated {
    pub id: String,
    pub properties: FileWatcherUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventGlobalDisposed {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventInstallationUpdateAvailable {
    pub id: String,
    pub properties: InstallationUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventInstallationUpdated {
    pub id: String,
    pub properties: InstallationUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventIntegrationConnectionUpdated {
    pub id: String,
    pub properties: IntegrationConnectionUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventIntegrationUpdated {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventLspUpdated {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMcpBrowserOpenFailed {
    pub id: String,
    pub properties: McpBrowserOpenFailedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMcpToolsChanged {
    pub id: String,
    pub properties: McpToolsChangedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMessagePartDelta {
    pub id: String,
    pub properties: MessagePartDeltaData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMessagePartRemoved {
    pub id: String,
    pub properties: MessagePartRemovedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMessagePartUpdated {
    pub id: String,
    pub properties: MessagePartUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMessageRemoved {
    pub id: String,
    pub properties: MessageRemovedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventMessageUpdated {
    pub id: String,
    pub properties: MessageUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventModelsDevRefreshed {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPermissionAsked {
    pub id: String,
    pub properties: PermissionAskedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPermissionReplied {
    pub id: String,
    pub properties: PermissionRepliedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPermissionV2Asked {
    pub id: String,
    pub properties: PermissionV2AskedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPermissionV2Replied {
    pub id: String,
    pub properties: PermissionV2RepliedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPluginAdded {
    pub id: String,
    pub properties: PluginAddedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventProjectDirectoriesUpdated {
    pub id: String,
    pub properties: ProjectDirectoriesUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventProjectUpdated {
    pub id: String,
    pub properties: ProjectUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPtyCreated {
    pub id: String,
    pub properties: PtyCreatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPtyDeleted {
    pub id: String,
    pub properties: PtyDeletedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPtyExited {
    pub id: String,
    pub properties: PtyExitedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventPtyUpdated {
    pub id: String,
    pub properties: PtyCreatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventQuestionAsked {
    pub id: String,
    pub properties: QuestionAskedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventQuestionRejected {
    pub id: String,
    pub properties: QuestionRejected2Data,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventQuestionReplied {
    pub id: String,
    pub properties: QuestionReplied2Data,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventQuestionV2Asked {
    pub id: String,
    pub properties: QuestionV2AskedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventQuestionV2Rejected {
    pub id: String,
    pub properties: QuestionRejected2Data,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventQuestionV2Replied {
    pub id: String,
    pub properties: QuestionV2RepliedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventReferenceUpdated {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventServerConnected {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventServerInstanceDisposed {
    pub id: String,
    pub properties: EventServerInstanceDisposedProperties,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventServerInstanceDisposedProperties {
    pub directory: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionCompacted {
    pub id: String,
    pub properties: SessionIdleData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionCreated {
    pub id: String,
    pub properties: SessionCreatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionDeleted {
    pub id: String,
    pub properties: SessionCreatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionDiff {
    pub id: String,
    pub properties: SessionDiffData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionError {
    pub id: String,
    pub properties: SessionErrorData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionIdle {
    pub id: String,
    pub properties: SessionIdleData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextAgentSwitched {
    pub id: String,
    pub properties: SessionNextAgentSwitchedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextCompactionDelta {
    pub id: String,
    pub properties: SessionNextContextUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextCompactionEnded {
    pub id: String,
    pub properties: SessionNextCompactionEndedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextCompactionStarted {
    pub id: String,
    pub properties: SessionNextCompactionStartedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextContextUpdated {
    pub id: String,
    pub properties: SessionNextContextUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextModelSwitched {
    pub id: String,
    pub properties: SessionNextModelSwitchedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextMoved {
    pub id: String,
    pub properties: SessionNextMovedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextPromptAdmitted {
    pub id: String,
    pub properties: SessionNextPromptedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextPrompted {
    pub id: String,
    pub properties: SessionNextPromptedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextReasoningDelta {
    pub id: String,
    pub properties: SessionNextReasoningDeltaData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextReasoningEnded {
    pub id: String,
    pub properties: SessionNextReasoningEndedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextReasoningStarted {
    pub id: String,
    pub properties: SessionNextReasoningStartedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextRetried {
    pub id: String,
    pub properties: SessionNextRetriedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextRevertCleared {
    pub id: String,
    pub properties: SessionNextRevertClearedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextRevertCommitted {
    pub id: String,
    pub properties: SessionNextRevertCommittedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextRevertStaged {
    pub id: String,
    pub properties: SessionNextRevertStagedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextShellEnded {
    pub id: String,
    pub properties: SessionNextShellEndedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextShellStarted {
    pub id: String,
    pub properties: SessionNextShellStartedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextStepEnded {
    pub id: String,
    pub properties: SessionNextStepEndedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextStepFailed {
    pub id: String,
    pub properties: SessionNextStepFailedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextStepStarted {
    pub id: String,
    pub properties: SessionNextStepStartedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextSynthetic {
    pub id: String,
    pub properties: SessionNextContextUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextTextDelta {
    pub id: String,
    pub properties: SessionNextTextDeltaData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextTextEnded {
    pub id: String,
    pub properties: SessionNextTextEndedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextTextStarted {
    pub id: String,
    pub properties: SessionNextTextStartedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolCalled {
    pub id: String,
    pub properties: SessionNextToolCalledData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolFailed {
    pub id: String,
    pub properties: SessionNextToolFailedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolInputDelta {
    pub id: String,
    pub properties: SessionNextToolInputDeltaData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolInputEnded {
    pub id: String,
    pub properties: SessionNextToolInputEndedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolInputStarted {
    pub id: String,
    pub properties: SessionNextToolInputStartedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolProgress {
    pub id: String,
    pub properties: SessionNextToolProgressData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionNextToolSuccess {
    pub id: String,
    pub properties: SessionNextToolSuccessData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionStatus {
    pub id: String,
    pub properties: SessionStatus2Data,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventSessionUpdated {
    pub id: String,
    pub properties: SessionCreatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTodoUpdated {
    pub id: String,
    pub properties: TodoUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiCommandExecute2 {
    pub properties: TuiCommandExecuteData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiPromptAppend2 {
    pub properties: TuiPromptAppendData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiSessionSelect2 {
    pub properties: TuiSessionSelectData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTuiToastShow2 {
    pub properties: TuiToastShowData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventVcsBranchUpdated {
    pub id: String,
    pub properties: VcsBranchUpdatedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventWorkspaceFailed {
    pub id: String,
    pub properties: WorktreeFailedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventWorkspaceReady {
    pub id: String,
    pub properties: WorkspaceReadyData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventWorkspaceStatus {
    pub id: String,
    pub properties: WorkspaceStatusData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventWorktreeFailed {
    pub id: String,
    pub properties: WorktreeFailedData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventWorktreeReady {
    pub id: String,
    pub properties: WorktreeReadyData,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExperimentalCapabilities {
    #[serde(rename = "backgroundSubagents")]
    pub background_subagents: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct File {
    pub added: u64,
    pub path: String,
    pub removed: u64,
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileContent {
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub diff: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub encoding: Option<String>,
    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub patch: Option<FileContentPatch>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileContentPatch {
    pub hunks: Vec<FileContentPatchHunksItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub index: Option<String>,
    #[serde(rename = "newFileName")]
    pub new_file_name: String,
    #[serde(rename = "newHeader", default, skip_serializing_if = "Option::is_none")]
    pub new_header: Option<String>,
    #[serde(rename = "oldFileName")]
    pub old_file_name: String,
    #[serde(rename = "oldHeader", default, skip_serializing_if = "Option::is_none")]
    pub old_header: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileContentPatchHunksItem {
    pub lines: Vec<String>,
    #[serde(rename = "newLines")]
    pub new_lines: u64,
    #[serde(rename = "newStart")]
    pub new_start: u64,
    #[serde(rename = "oldLines")]
    pub old_lines: u64,
    #[serde(rename = "oldStart")]
    pub old_start: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileDiff {
    pub additions: u64,
    pub deletions: u64,
    pub patch: String,
    pub path: String,
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileEdited {
    pub data: FileEditedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileEditedData {
    pub file: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileNode {
    pub absolute: String,
    pub ignored: bool,
    pub name: String,
    pub path: String,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilePart {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub mime: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<FilePartSource>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilePartInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filename: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    pub mime: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<FilePartSource>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum FilePartSource {
    #[serde(rename = "file")]
    File(FileSource),
    #[serde(rename = "symbol")]
    Symbol(SymbolSource),
    #[serde(rename = "resource")]
    Resource(ResourceSource),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilePartSourceText {
    pub end: f64,
    pub start: f64,
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileSource {
    pub path: String,
    pub text: FilePartSourceText,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileSystemEntry {
    pub path: String,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileWatcherUpdated {
    pub data: FileWatcherUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileWatcherUpdatedData {
    pub event: String,
    pub file: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ForbiddenError {
    pub _tag: String,
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FormatterStatus {
    pub enabled: bool,
    pub extensions: Vec<String>,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalDisposed {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEvent {
    pub directory: String,
    pub payload: GlobalEventPayload,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub project: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub workspace: Option<String>,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GlobalEventPayload {
    Variant0(GlobalEventPayloadVariant0),
    Variant1(GlobalEventPayloadVariant1),
    Variant2(GlobalEventPayloadVariant2),
    Variant3(GlobalEventPayloadVariant3),
    Variant4(GlobalEventPayloadVariant4),
    Variant5(GlobalEventPayloadVariant5),
    Variant6(GlobalEventPayloadVariant6),
    Variant7(GlobalEventPayloadVariant7),
    Variant8(GlobalEventPayloadVariant8),
    Variant9(GlobalEventPayloadVariant9),
    Variant10(GlobalEventPayloadVariant10),
    Variant11(GlobalEventPayloadVariant11),
    Variant12(GlobalEventPayloadVariant12),
    Variant13(GlobalEventPayloadVariant13),
    Variant14(GlobalEventPayloadVariant14),
    Variant15(GlobalEventPayloadVariant15),
    Variant16(GlobalEventPayloadVariant16),
    Variant17(GlobalEventPayloadVariant17),
    Variant18(GlobalEventPayloadVariant18),
    Variant19(GlobalEventPayloadVariant19),
    Variant20(GlobalEventPayloadVariant20),
    Variant21(GlobalEventPayloadVariant21),
    Variant22(GlobalEventPayloadVariant22),
    Variant23(GlobalEventPayloadVariant23),
    Variant24(GlobalEventPayloadVariant24),
    Variant25(GlobalEventPayloadVariant25),
    Variant26(GlobalEventPayloadVariant26),
    Variant27(GlobalEventPayloadVariant27),
    Variant28(GlobalEventPayloadVariant28),
    Variant29(GlobalEventPayloadVariant29),
    Variant30(GlobalEventPayloadVariant30),
    Variant31(GlobalEventPayloadVariant31),
    Variant32(GlobalEventPayloadVariant32),
    Variant33(GlobalEventPayloadVariant33),
    Variant34(GlobalEventPayloadVariant34),
    Variant35(GlobalEventPayloadVariant35),
    Variant36(GlobalEventPayloadVariant36),
    Variant37(GlobalEventPayloadVariant37),
    Variant38(GlobalEventPayloadVariant38),
    Variant39(GlobalEventPayloadVariant39),
    Variant40(GlobalEventPayloadVariant40),
    Variant41(GlobalEventPayloadVariant41),
    Variant42(GlobalEventPayloadVariant42),
    Variant43(GlobalEventPayloadVariant43),
    Variant44(GlobalEventPayloadVariant44),
    Variant45(GlobalEventPayloadVariant45),
    Variant46(GlobalEventPayloadVariant46),
    Variant47(GlobalEventPayloadVariant47),
    Variant48(GlobalEventPayloadVariant48),
    Variant49(GlobalEventPayloadVariant49),
    Variant50(GlobalEventPayloadVariant50),
    Variant51(GlobalEventPayloadVariant51),
    Variant52(GlobalEventPayloadVariant52),
    Variant53(GlobalEventPayloadVariant53),
    Variant54(GlobalEventPayloadVariant54),
    Variant55(GlobalEventPayloadVariant55),
    Variant56(GlobalEventPayloadVariant56),
    Variant57(GlobalEventPayloadVariant57),
    Variant58(GlobalEventPayloadVariant58),
    Variant59(GlobalEventPayloadVariant59),
    Variant60(GlobalEventPayloadVariant60),
    Variant61(GlobalEventPayloadVariant61),
    Variant62(GlobalEventPayloadVariant62),
    Variant63(GlobalEventPayloadVariant63),
    Variant64(GlobalEventPayloadVariant64),
    Variant65(GlobalEventPayloadVariant65),
    Variant66(GlobalEventPayloadVariant66),
    Variant67(GlobalEventPayloadVariant67),
    Variant68(GlobalEventPayloadVariant68),
    Variant69(GlobalEventPayloadVariant69),
    Variant70(GlobalEventPayloadVariant70),
    Variant71(GlobalEventPayloadVariant71),
    Variant72(GlobalEventPayloadVariant72),
    Variant73(GlobalEventPayloadVariant73),
    Variant74(GlobalEventPayloadVariant74),
    Variant75(GlobalEventPayloadVariant75),
    Variant76(GlobalEventPayloadVariant76),
    Variant77(GlobalEventPayloadVariant77),
    Variant78(GlobalEventPayloadVariant78),
    Variant79(GlobalEventPayloadVariant79),
    Variant80(GlobalEventPayloadVariant80),
    Variant81(GlobalEventPayloadVariant81),
    Variant82(GlobalEventPayloadVariant82),
    Variant83(GlobalEventPayloadVariant83),
    Variant84(GlobalEventPayloadVariant84),
    Variant85(GlobalEventPayloadVariant85),
    Variant86(GlobalEventPayloadVariant86),
    Variant87(GlobalEventPayloadVariant87),
    EventServerInstanceDisposed(EventServerInstanceDisposed),
    SyncEventSessionCreated(SyncEventSessionCreated),
    SyncEventSessionUpdated(SyncEventSessionUpdated),
    SyncEventSessionDeleted(SyncEventSessionDeleted),
    SyncEventMessageUpdated(SyncEventMessageUpdated),
    SyncEventMessageRemoved(SyncEventMessageRemoved),
    SyncEventMessagePartUpdated(SyncEventMessagePartUpdated),
    SyncEventMessagePartRemoved(SyncEventMessagePartRemoved),
    SyncEventSessionNextAgentSwitched(SyncEventSessionNextAgentSwitched),
    SyncEventSessionNextModelSwitched(SyncEventSessionNextModelSwitched),
    SyncEventSessionNextMoved(SyncEventSessionNextMoved),
    SyncEventSessionNextPrompted(SyncEventSessionNextPrompted),
    SyncEventSessionNextPromptAdmitted(SyncEventSessionNextPromptAdmitted),
    SyncEventSessionNextContextUpdated(SyncEventSessionNextContextUpdated),
    SyncEventSessionNextSynthetic(SyncEventSessionNextSynthetic),
    SyncEventSessionNextShellStarted(SyncEventSessionNextShellStarted),
    SyncEventSessionNextShellEnded(SyncEventSessionNextShellEnded),
    SyncEventSessionNextStepStarted(SyncEventSessionNextStepStarted),
    SyncEventSessionNextStepEnded(SyncEventSessionNextStepEnded),
    SyncEventSessionNextStepFailed(SyncEventSessionNextStepFailed),
    SyncEventSessionNextTextStarted(SyncEventSessionNextTextStarted),
    SyncEventSessionNextTextEnded(SyncEventSessionNextTextEnded),
    SyncEventSessionNextReasoningStarted(SyncEventSessionNextReasoningStarted),
    SyncEventSessionNextReasoningEnded(SyncEventSessionNextReasoningEnded),
    SyncEventSessionNextToolInputStarted(SyncEventSessionNextToolInputStarted),
    SyncEventSessionNextToolInputEnded(SyncEventSessionNextToolInputEnded),
    SyncEventSessionNextToolCalled(SyncEventSessionNextToolCalled),
    SyncEventSessionNextToolProgress(SyncEventSessionNextToolProgress),
    SyncEventSessionNextToolSuccess(SyncEventSessionNextToolSuccess),
    SyncEventSessionNextToolFailed(SyncEventSessionNextToolFailed),
    SyncEventSessionNextRetried(SyncEventSessionNextRetried),
    SyncEventSessionNextCompactionStarted(SyncEventSessionNextCompactionStarted),
    SyncEventSessionNextCompactionEnded(SyncEventSessionNextCompactionEnded),
    SyncEventSessionNextRevertStaged(SyncEventSessionNextRevertStaged),
    SyncEventSessionNextRevertCleared(SyncEventSessionNextRevertCleared),
    SyncEventSessionNextRevertCommitted(SyncEventSessionNextRevertCommitted),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant0 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant1 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant10 {
    pub id: String,
    pub properties: MessagePartRemovedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant11 {
    pub id: String,
    pub properties: SessionNextAgentSwitchedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant12 {
    pub id: String,
    pub properties: SessionNextModelSwitchedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant13 {
    pub id: String,
    pub properties: SessionNextMovedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant14 {
    pub id: String,
    pub properties: SessionNextPromptedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant15 {
    pub id: String,
    pub properties: SessionNextPromptedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant16 {
    pub id: String,
    pub properties: SessionNextContextUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant17 {
    pub id: String,
    pub properties: SessionNextContextUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant18 {
    pub id: String,
    pub properties: SessionNextShellStartedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant19 {
    pub id: String,
    pub properties: SessionNextShellEndedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant2 {
    pub id: String,
    pub properties: IntegrationConnectionUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant20 {
    pub id: String,
    pub properties: SessionNextStepStartedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant21 {
    pub id: String,
    pub properties: SessionNextStepEndedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant22 {
    pub id: String,
    pub properties: SessionNextStepFailedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant23 {
    pub id: String,
    pub properties: SessionNextTextStartedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant24 {
    pub id: String,
    pub properties: SessionNextTextDeltaData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant25 {
    pub id: String,
    pub properties: SessionNextTextEndedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant26 {
    pub id: String,
    pub properties: SessionNextReasoningStartedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant27 {
    pub id: String,
    pub properties: SessionNextReasoningDeltaData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant28 {
    pub id: String,
    pub properties: SessionNextReasoningEndedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant29 {
    pub id: String,
    pub properties: SessionNextToolInputStartedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant3 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant30 {
    pub id: String,
    pub properties: SessionNextToolInputDeltaData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant31 {
    pub id: String,
    pub properties: SessionNextToolInputEndedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant32 {
    pub id: String,
    pub properties: SessionNextToolCalledData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant33 {
    pub id: String,
    pub properties: SessionNextToolProgressData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant34 {
    pub id: String,
    pub properties: SessionNextToolSuccessData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant35 {
    pub id: String,
    pub properties: SessionNextToolFailedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant36 {
    pub id: String,
    pub properties: SessionNextRetriedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant37 {
    pub id: String,
    pub properties: SessionNextCompactionStartedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant38 {
    pub id: String,
    pub properties: SessionNextContextUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant39 {
    pub id: String,
    pub properties: SessionNextCompactionEndedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant4 {
    pub id: String,
    pub properties: SessionCreatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant40 {
    pub id: String,
    pub properties: SessionNextRevertStagedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant41 {
    pub id: String,
    pub properties: SessionNextRevertClearedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant42 {
    pub id: String,
    pub properties: SessionNextRevertCommittedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant43 {
    pub id: String,
    pub properties: MessagePartDeltaData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant44 {
    pub id: String,
    pub properties: SessionDiffData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant45 {
    pub id: String,
    pub properties: SessionErrorData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant46 {
    pub id: String,
    pub properties: InstallationUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant47 {
    pub id: String,
    pub properties: InstallationUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant48 {
    pub id: String,
    pub properties: FileEditedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant49 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant5 {
    pub id: String,
    pub properties: SessionCreatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant50 {
    pub id: String,
    pub properties: PermissionV2AskedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant51 {
    pub id: String,
    pub properties: PermissionV2RepliedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant52 {
    pub id: String,
    pub properties: PluginAddedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant53 {
    pub id: String,
    pub properties: ProjectDirectoriesUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant54 {
    pub id: String,
    pub properties: FileWatcherUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant55 {
    pub id: String,
    pub properties: PtyCreatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant56 {
    pub id: String,
    pub properties: PtyCreatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant57 {
    pub id: String,
    pub properties: PtyExitedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant58 {
    pub id: String,
    pub properties: PtyDeletedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant59 {
    pub id: String,
    pub properties: QuestionV2AskedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant6 {
    pub id: String,
    pub properties: SessionCreatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant60 {
    pub id: String,
    pub properties: QuestionV2RepliedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant61 {
    pub id: String,
    pub properties: QuestionRejected2Data,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant62 {
    pub id: String,
    pub properties: TodoUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant63 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant64 {
    pub id: String,
    pub properties: PermissionAskedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant65 {
    pub id: String,
    pub properties: PermissionRepliedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant66 {
    pub id: String,
    pub properties: TuiPromptAppendData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant67 {
    pub id: String,
    pub properties: TuiCommandExecuteData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant68 {
    pub id: String,
    pub properties: TuiToastShowData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant69 {
    pub id: String,
    pub properties: TuiSessionSelectData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant7 {
    pub id: String,
    pub properties: MessageUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant70 {
    pub id: String,
    pub properties: McpToolsChangedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant71 {
    pub id: String,
    pub properties: McpBrowserOpenFailedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant72 {
    pub id: String,
    pub properties: CommandExecutedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant73 {
    pub id: String,
    pub properties: ProjectUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant74 {
    pub id: String,
    pub properties: SessionStatus2Data,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant75 {
    pub id: String,
    pub properties: SessionIdleData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant76 {
    pub id: String,
    pub properties: QuestionAskedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant77 {
    pub id: String,
    pub properties: QuestionReplied2Data,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant78 {
    pub id: String,
    pub properties: QuestionRejected2Data,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant79 {
    pub id: String,
    pub properties: SessionIdleData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant8 {
    pub id: String,
    pub properties: MessageRemovedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant80 {
    pub id: String,
    pub properties: VcsBranchUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant81 {
    pub id: String,
    pub properties: WorkspaceReadyData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant82 {
    pub id: String,
    pub properties: WorktreeFailedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant83 {
    pub id: String,
    pub properties: WorkspaceStatusData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant84 {
    pub id: String,
    pub properties: WorktreeReadyData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant85 {
    pub id: String,
    pub properties: WorktreeFailedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant86 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant87 {
    pub id: String,
    pub properties: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalEventPayloadVariant9 {
    pub id: String,
    pub properties: MessagePartUpdatedData,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GlobalSession {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost: Option<f64>,
    pub directory: String,
    pub id: 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 model: Option<SessionCreateParamsModel>,
    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
    pub parent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permission: Option<PermissionRuleset>,
    pub project: Option<ProjectSummary>,
    #[serde(rename = "projectID")]
    pub project_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revert: Option<SessionRevert>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub share: Option<SessionShare>,
    pub slug: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<SessionSummary>,
    pub time: SessionTime,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens: Option<SessionNextStepEndedDataTokens>,
    pub version: String,
    #[serde(
        rename = "workspaceID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub workspace_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImageAttachmentConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub auto_resize: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_base64_bytes: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_height: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max_width: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InstallationUpdateAvailable {
    pub data: InstallationUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InstallationUpdated {
    pub data: InstallationUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InstallationUpdatedData {
    pub version: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationAttempt {
    #[serde(rename = "attemptID")]
    pub attempt_id: String,
    pub instructions: String,
    pub mode: String,
    pub time: IntegrationAttemptStatusPendingTime,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum IntegrationAttemptStatus {
    #[serde(rename = "pending")]
    Pending {
        time: IntegrationAttemptStatusPendingTime,
    },
    #[serde(rename = "complete")]
    Complete {
        time: IntegrationAttemptStatusPendingTime,
    },
    #[serde(rename = "failed")]
    Failed {
        message: String,
        time: IntegrationAttemptStatusPendingTime,
    },
    #[serde(rename = "expired")]
    Expired {
        time: IntegrationAttemptStatusPendingTime,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationAttemptStatusPendingTime {
    pub created: WorkspaceTimeUsed,
    pub expires: WorkspaceTimeUsed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationConnectionUpdated {
    pub data: IntegrationConnectionUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationConnectionUpdatedData {
    #[serde(rename = "integrationID")]
    pub integration_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationEnvMethod {
    pub names: Vec<String>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationInfo {
    pub connections: Vec<ConnectionInfo>,
    pub id: String,
    pub methods: Vec<IntegrationMethod>,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationInputs {
    #[serde(flatten)]
    pub map: std::collections::BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationKeyMethod {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum IntegrationMethod {
    #[serde(rename = "oauth")]
    Oauth(IntegrationOAuthMethod),
    #[serde(rename = "key")]
    Key(IntegrationKeyMethod),
    #[serde(rename = "env")]
    Env(IntegrationEnvMethod),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationOAuthMethod {
    pub id: String,
    pub label: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompts: Option<Vec<IntegrationOAuthMethodPromptsItem>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum IntegrationOAuthMethodPromptsItem {
    #[serde(rename = "text")]
    Text(IntegrationTextPrompt),
    #[serde(rename = "select")]
    Select(IntegrationSelectPrompt),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationRef {
    pub id: String,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationSelectPrompt {
    pub key: String,
    pub message: String,
    pub options: Vec<ProviderAuthMethodPromptsItemSelectOptionsItem>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub when: Option<IntegrationWhen>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationTextPrompt {
    pub key: String,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub placeholder: Option<String>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub when: Option<IntegrationWhen>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationUpdated {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntegrationWhen {
    pub key: String,
    pub op: String,
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InvalidCursorError {
    pub _tag: String,
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InvalidRequestError {
    pub _tag: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub field: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JSONSchema {
    #[serde(flatten)]
    pub extra: serde_json::Map<String, serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LLMProviderMetadata {
    #[serde(flatten)]
    pub map: std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum LLMToolContent {
    #[serde(rename = "text")]
    Text(ToolTextContent),
    #[serde(rename = "file")]
    File(ToolFileContent),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LSPStatus {
    pub id: String,
    pub name: String,
    pub root: String,
    pub status: String,
}

/// @deprecated Always uses stretch layout.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum LayoutConfig {
    Auto,
    Stretch,
    Unknown(String),
}

impl LayoutConfig {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Auto => "auto",
            Self::Stretch => "stretch",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for LayoutConfig {
    fn from(s: &str) -> Self {
        match s {
            "auto" => Self::Auto,
            "stretch" => Self::Stretch,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for LayoutConfig {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for LayoutConfig {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LocationInfo {
    pub directory: String,
    pub project: LocationInfoProject,
    #[serde(
        rename = "workspaceID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub workspace_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LocationInfoProject {
    pub directory: String,
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LocationRef {
    pub directory: String,
    #[serde(
        rename = "workspaceID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub workspace_id: Option<String>,
}

/// Log level
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum LogLevel {
    DEBUG,
    INFO,
    WARN,
    ERROR,
    Unknown(String),
}

impl LogLevel {
    pub fn as_str(&self) -> &str {
        match self {
            Self::DEBUG => "DEBUG",
            Self::INFO => "INFO",
            Self::WARN => "WARN",
            Self::ERROR => "ERROR",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for LogLevel {
    fn from(s: &str) -> Self {
        match s {
            "DEBUG" => Self::DEBUG,
            "INFO" => Self::INFO,
            "WARN" => Self::WARN,
            "ERROR" => Self::ERROR,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for LogLevel {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for LogLevel {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LspUpdated {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum MCPStatus {
    #[serde(rename = "connected")]
    Connected(MCPStatusConnected),
    #[serde(rename = "disabled")]
    Disabled(MCPStatusDisabled),
    #[serde(rename = "failed")]
    Failed(MCPStatusFailed),
    #[serde(rename = "needs_auth")]
    NeedsAuth(MCPStatusNeedsAuth),
    #[serde(rename = "needs_client_registration")]
    NeedsClientRegistration(MCPStatusNeedsClientRegistration),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MCPStatusConnected {
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MCPStatusDisabled {
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MCPStatusFailed {
    pub error: String,
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MCPStatusNeedsAuth {
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MCPStatusNeedsClientRegistration {
    pub error: String,
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpBrowserOpenFailed {
    pub data: McpBrowserOpenFailedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpBrowserOpenFailedData {
    #[serde(rename = "mcpName")]
    pub mcp_name: String,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpLocalConfig {
    pub command: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub environment: Option<std::collections::BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout: Option<i64>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpOAuthConfig {
    #[serde(
        rename = "callbackPort",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub callback_port: Option<u64>,
    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
    #[serde(
        rename = "clientSecret",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub client_secret: Option<String>,
    #[serde(
        rename = "redirectUri",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub redirect_uri: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpRemoteConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<std::collections::BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub oauth: Option<McpRemoteConfigOauth>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout: Option<i64>,
    #[serde(rename = "type")]
    pub type_: String,
    pub url: String,
}

/// OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection.
/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpRemoteConfigOauth {
    McpOAuthConfig(McpOAuthConfig),
    Variant1(bool),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpResource {
    pub client: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    pub name: String,
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpServerNotFoundError {
    pub _tag: String,
    pub message: String,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpToolsChanged {
    pub data: McpToolsChangedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpToolsChangedData {
    pub server: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct McpUnsupportedOAuthError {
    pub error: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "role")]
pub enum Message {
    #[serde(rename = "user")]
    User(UserMessage),
    #[serde(rename = "assistant")]
    Assistant(AssistantMessage),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageAbortedError {
    pub data: WorktreeFailedData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageOutputLengthError {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagePartDelta {
    pub data: MessagePartDeltaData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagePartDeltaData {
    pub delta: String,
    pub field: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "partID")]
    pub part_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagePartRemoved {
    pub data: MessagePartRemovedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagePartRemovedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "partID")]
    pub part_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagePartUpdated {
    pub data: MessagePartUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessagePartUpdatedData {
    pub part: Part,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub time: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageRemoved {
    pub data: MessageRemovedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageRemovedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageUpdated {
    pub data: MessageUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageUpdatedData {
    pub info: Message,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MessageWithParts {
    pub info: Message,
    pub parts: Vec<Part>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Model {
    pub api: ModelApi2,
    pub capabilities: ModelCapabilities2,
    pub cost: ModelCost2,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub family: Option<String>,
    pub headers: std::collections::BTreeMap<String, String>,
    pub id: String,
    pub limit: ProviderConfigModelsValueLimit,
    pub name: String,
    pub options: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "providerID")]
    pub provider_id: String,
    pub release_date: String,
    pub status: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variants:
        Option<std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ModelApi {
    #[serde(rename = "aisdk")]
    Aisdk {
        id: String,
        package: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        settings: Option<serde_json::Map<String, serde_json::Value>>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        url: Option<String>,
    },
    #[serde(rename = "native")]
    Native {
        id: String,
        settings: serde_json::Map<String, serde_json::Value>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        url: Option<String>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelApi2 {
    pub id: String,
    pub npm: String,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCapabilities {
    pub input: Vec<String>,
    pub output: Vec<String>,
    pub tools: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCapabilities2 {
    pub attachment: bool,
    pub input: ModelCapabilities2Input,
    pub interleaved: ModelCapabilities2Interleaved,
    pub output: ModelCapabilities2Input,
    pub reasoning: bool,
    pub temperature: bool,
    pub toolcall: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCapabilities2Input {
    pub audio: bool,
    pub image: bool,
    pub pdf: bool,
    pub text: bool,
    pub video: bool,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ModelCapabilities2Interleaved {
    Variant0(bool),
    Variant1(ProviderConfigModelsValueInterleavedVariant1),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCost {
    pub cache: SessionNextStepEndedDataTokensCache,
    pub input: f64,
    pub output: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tier: Option<ModelCostTier>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCost2 {
    pub cache: SessionNextStepEndedDataTokensCache,
    #[serde(
        rename = "experimentalOver200K",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub experimental_over200_k: Option<ModelCost2ExperimentalOver200K>,
    pub input: f64,
    pub output: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tiers: Option<Vec<ModelCost2TiersItem>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCost2ExperimentalOver200K {
    pub cache: SessionNextStepEndedDataTokensCache,
    pub input: f64,
    pub output: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCost2TiersItem {
    pub cache: SessionNextStepEndedDataTokensCache,
    pub input: f64,
    pub output: f64,
    pub tier: ModelCost2TiersItemTier,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCost2TiersItemTier {
    pub size: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelCostTier {
    pub size: i64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelRef {
    pub id: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelV2Info {
    pub api: ModelApi,
    pub capabilities: ModelCapabilities,
    pub cost: Vec<ModelCost>,
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub family: Option<String>,
    pub id: String,
    pub limit: ModelV2InfoLimit,
    pub name: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
    pub request: ModelV2InfoRequest,
    pub status: String,
    pub time: ModelV2InfoTime,
    pub variants: Vec<ModelV2InfoVariantsItem>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelV2InfoLimit {
    pub context: i64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<i64>,
    pub output: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelV2InfoRequest {
    pub body: serde_json::Map<String, serde_json::Value>,
    pub headers: std::collections::BTreeMap<String, String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelV2InfoTime {
    pub released: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelV2InfoVariantsItem {
    pub body: serde_json::Map<String, serde_json::Value>,
    pub headers: std::collections::BTreeMap<String, String>,
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModelsDevRefreshed {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MoveSessionDestination {
    pub directory: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MoveSessionError {
    pub data: WorktreeFailedData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NotFoundError {
    pub data: NotFoundErrorData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NotFoundErrorData {
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OAuth {
    pub access: String,
    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[serde(
        rename = "enterpriseUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub enterprise_url: Option<String>,
    pub expires: u64,
    pub refresh: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum OutputFormat {
    #[serde(rename = "text")]
    Text(OutputFormatText),
    #[serde(rename = "json_schema")]
    JsonSchema(OutputFormatJsonSchema),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum OutputFormat1 {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "json_schema")]
    JsonSchema {
        #[serde(
            rename = "retryCount",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        retry_count: Option<u64>,
        schema: JSONSchema,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutputFormatJsonSchema {
    #[serde(
        rename = "retryCount",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_count: Option<u64>,
    pub schema: JSONSchema,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OutputFormatText {
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Part {
    #[serde(rename = "text")]
    Text(TextPart),
    #[serde(rename = "subtask")]
    Subtask(SubtaskPart),
    #[serde(rename = "reasoning")]
    Reasoning(ReasoningPart),
    #[serde(rename = "file")]
    File(FilePart),
    #[serde(rename = "tool")]
    Tool(ToolPart),
    #[serde(rename = "step-start")]
    StepStart(StepStartPart),
    #[serde(rename = "step-finish")]
    StepFinish(StepFinishPart),
    #[serde(rename = "snapshot")]
    Snapshot(SnapshotPart),
    #[serde(rename = "patch")]
    Patch(PatchPart),
    #[serde(rename = "agent")]
    Agent(AgentPart),
    #[serde(rename = "retry")]
    Retry(RetryPart),
    #[serde(rename = "compaction")]
    Compaction(CompactionPart),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PatchPart {
    pub files: Vec<String>,
    pub hash: String,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Path {
    pub config: String,
    pub directory: String,
    pub home: String,
    pub state: String,
    pub worktree: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PermissionAction {
    Allow,
    Deny,
    Ask,
    Unknown(String),
}

impl PermissionAction {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Allow => "allow",
            Self::Deny => "deny",
            Self::Ask => "ask",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for PermissionAction {
    fn from(s: &str) -> Self {
        match s {
            "allow" => Self::Allow,
            "deny" => Self::Deny,
            "ask" => Self::Ask,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for PermissionAction {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for PermissionAction {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PermissionActionConfig {
    Ask,
    Allow,
    Deny,
    Unknown(String),
}

impl PermissionActionConfig {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Ask => "ask",
            Self::Allow => "allow",
            Self::Deny => "deny",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for PermissionActionConfig {
    fn from(s: &str) -> Self {
        match s {
            "ask" => Self::Ask,
            "allow" => Self::Allow,
            "deny" => Self::Deny,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for PermissionActionConfig {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for PermissionActionConfig {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionAsked {
    pub data: PermissionAskedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionAskedData {
    pub always: Vec<String>,
    pub id: String,
    pub metadata: serde_json::Map<String, serde_json::Value>,
    pub patterns: Vec<String>,
    pub permission: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<PermissionAskedDataTool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionAskedDataTool {
    #[serde(rename = "callID")]
    pub call_id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PermissionConfig {
    PermissionActionConfig(PermissionActionConfig),
    Variant1(PermissionConfigVariant1),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionConfigVariant1 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub bash: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub doom_loop: Option<PermissionActionConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub edit: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub external_directory: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub glob: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub grep: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub list: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lsp: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub question: Option<PermissionActionConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub read: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub skill: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub task: Option<PermissionRuleConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub todowrite: Option<PermissionActionConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub webfetch: Option<PermissionActionConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub websearch: Option<PermissionActionConfig>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "requestID")]
    pub request_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionObjectConfig {
    #[serde(flatten)]
    pub map: std::collections::BTreeMap<String, PermissionActionConfig>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionReplied {
    pub data: PermissionRepliedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionRepliedData {
    pub reply: String,
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionReplyParams {
    pub response: PermissionReplyResponse,
}

/// Decision sent when replying to a permission request
/// (`POST /session/{sessionID}/permissions/{permissionID}`). The wire schema
/// pins this to `once` / `always` / `reject`; the [`Unknown`](Self::Unknown)
/// fallback preserves forward compatibility with newer server values.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PermissionReplyResponse {
    /// Grant the permission for this request only.
    Once,
    /// Grant the permission and remember the decision.
    Always,
    /// Deny the permission.
    Reject,
    /// A value not known to this crate version.
    Unknown(String),
}

impl PermissionReplyResponse {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Once => "once",
            Self::Always => "always",
            Self::Reject => "reject",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for PermissionReplyResponse {
    fn from(s: &str) -> Self {
        match s {
            "once" => Self::Once,
            "always" => Self::Always,
            "reject" => Self::Reject,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for PermissionReplyResponse {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for PermissionReplyResponse {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionRequest {
    pub always: Vec<String>,
    pub id: String,
    pub metadata: serde_json::Map<String, serde_json::Value>,
    pub patterns: Vec<String>,
    pub permission: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<PermissionAskedDataTool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionRule {
    pub action: PermissionAction,
    pub pattern: String,
    pub permission: String,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PermissionRuleConfig {
    PermissionActionConfig(PermissionActionConfig),
    PermissionObjectConfig(PermissionObjectConfig),
}

pub type PermissionRuleset = Vec<PermissionRule>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionSavedInfo {
    pub action: String,
    pub id: String,
    #[serde(rename = "projectID")]
    pub project_id: String,
    pub resource: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2Asked {
    pub data: PermissionV2AskedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2AskedData {
    pub action: String,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub resources: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub save: Option<Vec<String>>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<PermissionV2Source>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PermissionV2Effect {
    Allow,
    Deny,
    Ask,
    Unknown(String),
}

impl PermissionV2Effect {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Allow => "allow",
            Self::Deny => "deny",
            Self::Ask => "ask",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for PermissionV2Effect {
    fn from(s: &str) -> Self {
        match s {
            "allow" => Self::Allow,
            "deny" => Self::Deny,
            "ask" => Self::Ask,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for PermissionV2Effect {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for PermissionV2Effect {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2Replied {
    pub data: PermissionV2RepliedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2RepliedData {
    pub reply: PermissionV2Reply,
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PermissionV2Reply {
    Once,
    Always,
    Reject,
    Unknown(String),
}

impl PermissionV2Reply {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Once => "once",
            Self::Always => "always",
            Self::Reject => "reject",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for PermissionV2Reply {
    fn from(s: &str) -> Self {
        match s {
            "once" => Self::Once,
            "always" => Self::Always,
            "reject" => Self::Reject,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for PermissionV2Reply {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for PermissionV2Reply {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2Request {
    pub action: String,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub resources: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub save: Option<Vec<String>>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<PermissionV2Source>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2Rule {
    pub action: String,
    pub effect: PermissionV2Effect,
    pub resource: String,
}

pub type PermissionV2Ruleset = Vec<PermissionV2Rule>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PermissionV2Source {
    #[serde(rename = "callID")]
    pub call_id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PluginAdded {
    pub data: PluginAddedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PluginAddedData {
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PolicyEffect {
    Allow,
    Deny,
    Unknown(String),
}

impl PolicyEffect {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Allow => "allow",
            Self::Deny => "deny",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for PolicyEffect {
    fn from(s: &str) -> Self {
        match s {
            "allow" => Self::Allow,
            "deny" => Self::Deny,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for PolicyEffect {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for PolicyEffect {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Project {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commands: Option<ProjectCommands>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<ProjectIcon>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub sandboxes: Vec<String>,
    pub time: ProjectTime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vcs: Option<ProjectVcs>,
    pub worktree: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectCommands {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectCopyCopy {
    pub directory: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectCopyError {
    pub data: ProjectCopyErrorData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectCopyErrorData {
    #[serde(
        rename = "forceRequired",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub force_required: Option<bool>,
    pub message: String,
}

pub type ProjectDirectories = Vec<ProjectDirectoriesItem>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectDirectoriesItem {
    pub directory: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strategy: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectDirectoriesUpdated {
    pub data: ProjectDirectoriesUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectDirectoriesUpdatedData {
    #[serde(rename = "projectID")]
    pub project_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectIcon {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    #[serde(rename = "override", default, skip_serializing_if = "Option::is_none")]
    pub override_: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "projectID")]
    pub project_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectSummary {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub worktree: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectTime {
    pub created: u64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub initialized: Option<u64>,
    pub updated: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectUpdated {
    pub data: ProjectUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProjectUpdatedData {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commands: Option<ProjectCommands>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<ProjectIcon>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub sandboxes: Vec<String>,
    pub time: ProjectTime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub vcs: Option<ProjectVcs>,
    pub worktree: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ProjectVcs {
    Git,
    Unknown(String),
}

impl ProjectVcs {
    pub fn as_str(&self) -> &str {
        match self {
            Self::Git => "git",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for ProjectVcs {
    fn from(s: &str) -> Self {
        match s {
            "git" => Self::Git,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for ProjectVcs {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for ProjectVcs {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Prompt {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agents: Option<Vec<PromptAgentAttachment>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<PromptFileAttachment>>,
    pub text: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PromptAgentAttachment {
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<PromptSource>,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PromptAsyncParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<OutputFormat>,
    #[serde(rename = "messageID", default, skip_serializing_if = "Option::is_none")]
    pub message_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<SubtaskPartInputModel>,
    #[serde(rename = "noReply", default, skip_serializing_if = "Option::is_none")]
    pub no_reply: Option<bool>,
    pub parts: Vec<PromptAsyncParamsPartsItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<std::collections::BTreeMap<String, bool>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum PromptAsyncParamsPartsItem {
    #[serde(rename = "text")]
    Text(TextPartInput),
    #[serde(rename = "file")]
    File(FilePartInput),
    #[serde(rename = "agent")]
    Agent(AgentPartInput),
    #[serde(rename = "subtask")]
    Subtask(SubtaskPartInput),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PromptFileAttachment {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub mime: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<PromptSource>,
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PromptInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agents: Option<Vec<PromptAgentAttachment>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<PromptInputFileAttachment>>,
    pub text: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PromptInputFileAttachment {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<PromptSource>,
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PromptSource {
    pub end: f64,
    pub start: f64,
    pub text: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Provider {
    pub env: Vec<String>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,
    pub models: std::collections::BTreeMap<String, Model>,
    pub name: String,
    pub options: serde_json::Map<String, serde_json::Value>,
    pub source: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAISDK {
    pub package: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub settings: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ProviderApi {
    #[serde(rename = "aisdk")]
    Aisdk(ProviderAISDK),
    #[serde(rename = "native")]
    Native(ProviderNative),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthAuthorization {
    pub instructions: String,
    pub method: String,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthError {
    pub data: ProviderAuthErrorData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthError1 {
    pub data: ProviderAuthError1Data,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthError1Data {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub field: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(
        rename = "providerID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub provider_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthErrorData {
    pub message: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthMethod {
    pub label: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompts: Option<Vec<ProviderAuthMethodPromptsItem>>,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ProviderAuthMethodPromptsItem {
    #[serde(rename = "text")]
    Text {
        key: String,
        message: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        placeholder: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        when: Option<ProviderAuthMethodPromptsItemTextWhen>,
    },
    #[serde(rename = "select")]
    Select {
        key: String,
        message: String,
        options: Vec<ProviderAuthMethodPromptsItemSelectOptionsItem>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        when: Option<ProviderAuthMethodPromptsItemTextWhen>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthMethodPromptsItemSelectOptionsItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hint: Option<String>,
    pub label: String,
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderAuthMethodPromptsItemTextWhen {
    pub key: String,
    pub op: String,
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub blacklist: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub models: Option<std::collections::BTreeMap<String, ProviderConfigModelsValue>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub npm: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<ProviderConfigOptions>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub whitelist: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValue {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attachment: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost: Option<ProviderConfigModelsValueCost>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub experimental: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub family: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub headers: Option<std::collections::BTreeMap<String, String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interleaved: Option<ProviderConfigModelsValueInterleaved>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<ProviderConfigModelsValueLimit>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub modalities: Option<ProviderConfigModelsValueModalities>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<ProviderConfigModelsValueProvider>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reasoning: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub release_date: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub temperature: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool_call: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variants:
        Option<std::collections::BTreeMap<String, ProviderConfigModelsValueVariantsValue>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueCost {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_read: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_write: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context_over_200k: Option<ProviderConfigModelsValueCostContextOver200k>,
    pub input: f64,
    pub output: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueCostContextOver200k {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_read: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cache_write: Option<f64>,
    pub input: f64,
    pub output: f64,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ProviderConfigModelsValueInterleaved {
    Variant0(bool),
    Variant1(ProviderConfigModelsValueInterleavedVariant1),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueInterleavedVariant1 {
    pub field: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueLimit {
    pub context: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<f64>,
    pub output: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueModalities {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub input: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueProvider {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub api: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub npm: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigModelsValueVariantsValue {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderConfigOptions {
    #[serde(rename = "apiKey", default, skip_serializing_if = "Option::is_none")]
    pub api_key: Option<String>,
    #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
    pub base_url: Option<String>,
    #[serde(
        rename = "chunkTimeout",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub chunk_timeout: Option<i64>,
    #[serde(
        rename = "enterpriseUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub enterprise_url: Option<String>,
    #[serde(
        rename = "headerTimeout",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub header_timeout: Option<ProviderConfigOptionsHeaderTimeout>,
    #[serde(
        rename = "setCacheKey",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub set_cache_key: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timeout: Option<ProviderConfigOptionsTimeout>,
}

/// Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout.
/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ProviderConfigOptionsHeaderTimeout {
    Variant0(i64),
    Variant1(bool),
}

/// Timeout in milliseconds for full requests to this provider. Set to false to disable timeout.
/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ProviderConfigOptionsTimeout {
    Variant0(i64),
    Variant1(bool),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderNative {
    pub settings: serde_json::Map<String, serde_json::Value>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderRequest {
    pub body: serde_json::Map<String, serde_json::Value>,
    pub headers: std::collections::BTreeMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ProviderV2Info {
    pub api: ProviderApi,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub disabled: Option<bool>,
    pub id: String,
    #[serde(
        rename = "integrationID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub integration_id: Option<String>,
    pub name: String,
    pub request: ProviderRequest,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Pty {
    pub args: Vec<String>,
    pub command: String,
    pub cwd: String,
    #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
    pub exit_code: Option<u64>,
    pub id: String,
    pub pid: u64,
    pub status: String,
    pub title: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyCreated {
    pub data: PtyCreatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyCreatedData {
    pub info: Pty,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyDeleted {
    pub data: PtyDeletedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyDeletedData {
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyExited {
    pub data: PtyExitedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyExitedData {
    #[serde(rename = "exitCode")]
    pub exit_code: u64,
    pub id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyForbiddenError {
    pub _tag: String,
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "ptyID")]
    pub pty_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyTicketConnectToken {
    pub expires_in: i64,
    pub ticket: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PtyUpdated {
    pub data: PtyCreatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

pub type QuestionAnswer = Vec<String>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionAsked {
    pub data: QuestionAskedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionAskedData {
    pub id: String,
    pub questions: Vec<QuestionInfo>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<QuestionTool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom: Option<bool>,
    pub header: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub multiple: Option<bool>,
    pub options: Vec<QuestionOption>,
    pub question: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "requestID")]
    pub request_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionOption {
    pub description: String,
    pub label: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionRejected {
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionRejected2Data {
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionReplied {
    pub answers: Vec<QuestionAnswer>,
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionReplied2Data {
    pub answers: Vec<QuestionAnswer>,
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionRequest {
    pub id: String,
    pub questions: Vec<QuestionInfo>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<QuestionTool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionTool {
    #[serde(rename = "callID")]
    pub call_id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
}

pub type QuestionV2Answer = Vec<String>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Asked {
    pub data: QuestionV2AskedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2AskedData {
    pub id: String,
    pub questions: Vec<QuestionV2Info>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<QuestionV2Tool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Info {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom: Option<bool>,
    pub header: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub multiple: Option<bool>,
    pub options: Vec<QuestionV2Option>,
    pub question: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Option {
    pub description: String,
    pub label: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Rejected {
    pub data: QuestionRejected2Data,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Replied {
    pub data: QuestionV2RepliedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2RepliedData {
    pub answers: Vec<QuestionV2Answer>,
    #[serde(rename = "requestID")]
    pub request_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Reply {
    pub answers: Vec<QuestionV2Answer>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Request {
    pub id: String,
    pub questions: Vec<QuestionV2Info>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<QuestionV2Tool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionV2Tool {
    #[serde(rename = "callID")]
    pub call_id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Range {
    pub end: RangeStart,
    pub start: RangeStart,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RangeStart {
    pub character: u64,
    pub line: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReasoningPart {
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    pub time: TextPartInputTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReferenceGitSource {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    pub repository: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReferenceInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    pub name: String,
    pub path: String,
    pub source: ReferenceSource,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReferenceLocalSource {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hidden: Option<bool>,
    pub path: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ReferenceSource {
    #[serde(rename = "local")]
    Local(ReferenceLocalSource),
    #[serde(rename = "git")]
    Git(ReferenceGitSource),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReferenceUpdated {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceSource {
    #[serde(rename = "clientName")]
    pub client_name: String,
    pub text: FilePartSourceText,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RetryPart {
    pub attempt: u64,
    pub error: APIError,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub time: RetryPartTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RetryPartTime {
    pub created: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RevertState {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub diff: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<FileDiff>>,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "partID", default, skip_serializing_if = "Option::is_none")]
    pub part_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<String>,
}

/// Server configuration for opencode serve and web commands
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServerConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cors: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hostname: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mdns: Option<bool>,
    #[serde(
        rename = "mdnsDomain",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub mdns_domain: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServerConnected {
    pub data: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServiceUnavailableError {
    pub _tag: String,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Session {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost: Option<f64>,
    pub directory: String,
    pub id: 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 model: Option<SessionCreateParamsModel>,
    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
    pub parent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permission: Option<PermissionRuleset>,
    #[serde(rename = "projectID")]
    pub project_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revert: Option<SessionRevert>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub share: Option<SessionShare>,
    pub slug: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<SessionSummary>,
    pub time: SessionTime,
    pub title: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens: Option<SessionNextStepEndedDataTokens>,
    pub version: String,
    #[serde(
        rename = "workspaceID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub workspace_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionActive {
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionBusyError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionCompacted {
    pub data: SessionIdleData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SessionCreateParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: 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 model: Option<SessionCreateParamsModel>,
    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
    pub parent_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permission: Option<PermissionRuleset>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(
        rename = "workspaceID",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub workspace_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionCreateParamsModel {
    pub id: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionCreated {
    pub data: SessionCreatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionCreatedData {
    pub info: Session,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionDeleted {
    pub data: SessionCreatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionDiff {
    pub data: SessionDiffData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionDiffData {
    pub diff: Vec<SnapshotFileDiff>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SessionDurableEvent {
    #[serde(rename = "session.next.agent.switched")]
    SessionNextAgentSwitched(SessionNextAgentSwitched),
    #[serde(rename = "session.next.model.switched")]
    SessionNextModelSwitched(SessionNextModelSwitched),
    #[serde(rename = "session.next.moved")]
    SessionNextMoved(SessionNextMoved),
    #[serde(rename = "session.next.prompted")]
    SessionNextPrompted(SessionNextPrompted),
    #[serde(rename = "session.next.prompt.admitted")]
    SessionNextPromptAdmitted(SessionNextPromptAdmitted),
    #[serde(rename = "session.next.context.updated")]
    SessionNextContextUpdated(SessionNextContextUpdated),
    #[serde(rename = "session.next.synthetic")]
    SessionNextSynthetic(SessionNextSynthetic),
    #[serde(rename = "session.next.shell.started")]
    SessionNextShellStarted(SessionNextShellStarted),
    #[serde(rename = "session.next.shell.ended")]
    SessionNextShellEnded(SessionNextShellEnded),
    #[serde(rename = "session.next.step.started")]
    SessionNextStepStarted(SessionNextStepStarted),
    #[serde(rename = "session.next.step.ended")]
    SessionNextStepEnded(SessionNextStepEnded),
    #[serde(rename = "session.next.step.failed")]
    SessionNextStepFailed(SessionNextStepFailed),
    #[serde(rename = "session.next.text.started")]
    SessionNextTextStarted(SessionNextTextStarted),
    #[serde(rename = "session.next.text.ended")]
    SessionNextTextEnded(SessionNextTextEnded),
    #[serde(rename = "session.next.tool.input.started")]
    SessionNextToolInputStarted(SessionNextToolInputStarted),
    #[serde(rename = "session.next.tool.input.ended")]
    SessionNextToolInputEnded(SessionNextToolInputEnded),
    #[serde(rename = "session.next.tool.called")]
    SessionNextToolCalled(SessionNextToolCalled),
    #[serde(rename = "session.next.tool.progress")]
    SessionNextToolProgress(SessionNextToolProgress),
    #[serde(rename = "session.next.tool.success")]
    SessionNextToolSuccess(SessionNextToolSuccess),
    #[serde(rename = "session.next.tool.failed")]
    SessionNextToolFailed(SessionNextToolFailed),
    #[serde(rename = "session.next.reasoning.started")]
    SessionNextReasoningStarted(SessionNextReasoningStarted),
    #[serde(rename = "session.next.reasoning.ended")]
    SessionNextReasoningEnded(SessionNextReasoningEnded),
    #[serde(rename = "session.next.retried")]
    SessionNextRetried(SessionNextRetried),
    #[serde(rename = "session.next.compaction.started")]
    SessionNextCompactionStarted(SessionNextCompactionStarted),
    #[serde(rename = "session.next.compaction.ended")]
    SessionNextCompactionEnded(SessionNextCompactionEnded),
    #[serde(rename = "session.next.revert.staged")]
    SessionNextRevertStaged(SessionNextRevertStaged),
    #[serde(rename = "session.next.revert.cleared")]
    SessionNextRevertCleared(SessionNextRevertCleared),
    #[serde(rename = "session.next.revert.committed")]
    SessionNextRevertCommitted(SessionNextRevertCommitted),
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct SessionDurableEventStream(pub String);

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionError {
    pub data: SessionErrorData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionErrorData {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<SessionErrorDataError>,
    #[serde(rename = "sessionID", default, skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "name")]
pub enum SessionErrorDataError {
    ProviderAuthError(ProviderAuthError),
    UnknownError(UnknownError),
    MessageOutputLengthError(MessageOutputLengthError),
    MessageAbortedError(MessageAbortedError),
    StructuredOutputError(StructuredOutputError),
    ContextOverflowError(ContextOverflowError),
    ContentFilterError(ContentFilterError),
    APIError(APIError),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionErrorUnknown {
    pub message: String,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionHistory {
    pub data: Vec<SessionDurableEvent>,
    #[serde(rename = "hasMore")]
    pub has_more: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionIdle {
    pub data: SessionIdleData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionIdleData {
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionInputAdmitted {
    #[serde(rename = "admittedSeq")]
    pub admitted_seq: u64,
    pub delivery: String,
    pub id: String,
    #[serde(
        rename = "promotedSeq",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub promoted_seq: Option<u64>,
    pub prompt: Prompt,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(rename = "timeCreated")]
    pub time_created: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SessionMessage {
    #[serde(rename = "agent-switched")]
    AgentSwitched(SessionMessageAgentSwitched),
    #[serde(rename = "model-switched")]
    ModelSwitched(SessionMessageModelSwitched),
    #[serde(rename = "user")]
    User(SessionMessageUser),
    #[serde(rename = "synthetic")]
    Synthetic(SessionMessageSynthetic),
    #[serde(rename = "system")]
    System(SessionMessageSystem),
    #[serde(rename = "shell")]
    Shell(SessionMessageShell),
    #[serde(rename = "assistant")]
    Assistant(SessionMessageAssistant),
    #[serde(rename = "compaction")]
    Compaction(SessionMessageCompaction),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAgentSwitched {
    pub agent: String,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub time: SessionMessageUserTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistant {
    pub agent: String,
    pub content: Vec<SessionMessageAssistantContentItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cost: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<SessionErrorUnknown>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub finish: Option<String>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub model: ModelRef,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<SessionMessageAssistantSnapshot>,
    pub time: SessionMessageShellTime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tokens: Option<SessionNextStepEndedDataTokens>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SessionMessageAssistantContentItem {
    #[serde(rename = "text")]
    Text(SessionMessageAssistantText),
    #[serde(rename = "reasoning")]
    Reasoning(SessionMessageAssistantReasoning),
    #[serde(rename = "tool")]
    Tool(SessionMessageAssistantTool),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistantReasoning {
    pub id: String,
    #[serde(
        rename = "providerMetadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub provider_metadata: Option<LLMProviderMetadata>,
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub time: Option<SessionMessageShellTime>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistantSnapshot {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub start: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistantText {
    pub id: String,
    pub text: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistantTool {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<SessionMessageAssistantToolProvider>,
    pub state: SessionMessageAssistantToolState,
    pub time: SessionMessageAssistantToolTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistantToolProvider {
    pub executed: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<LLMProviderMetadata>,
    #[serde(
        rename = "resultMetadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub result_metadata: Option<LLMProviderMetadata>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum SessionMessageAssistantToolState {
    #[serde(rename = "pending")]
    Pending(SessionMessageToolStatePending),
    #[serde(rename = "running")]
    Running(SessionMessageToolStateRunning),
    #[serde(rename = "completed")]
    Completed(SessionMessageToolStateCompleted),
    #[serde(rename = "error")]
    Error(SessionMessageToolStateError),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageAssistantToolTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed: Option<f64>,
    pub created: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pruned: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ran: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageCompaction {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub reason: String,
    pub recent: String,
    pub summary: String,
    pub time: SessionMessageUserTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageModelSwitched {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub model: ModelRef,
    pub time: SessionMessageUserTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageShell {
    #[serde(rename = "callID")]
    pub call_id: String,
    pub command: String,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub output: String,
    pub time: SessionMessageShellTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageShellTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub completed: Option<f64>,
    pub created: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageSynthetic {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    pub time: SessionMessageUserTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageSystem {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub text: String,
    pub time: SessionMessageUserTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageToolStateCompleted {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attachments: Option<Vec<PromptFileAttachment>>,
    pub content: Vec<LLMToolContent>,
    pub input: serde_json::Map<String, serde_json::Value>,
    #[serde(
        rename = "outputPaths",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub output_paths: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Value>,
    #[serde(default, skip_serializing)]
    pub status: String,
    pub structured: serde_json::Map<String, serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageToolStateError {
    pub content: Vec<LLMToolContent>,
    pub error: SessionErrorUnknown,
    pub input: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Value>,
    #[serde(default, skip_serializing)]
    pub status: String,
    pub structured: serde_json::Map<String, serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageToolStatePending {
    pub input: String,
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageToolStateRunning {
    pub content: Vec<LLMToolContent>,
    pub input: serde_json::Map<String, serde_json::Value>,
    #[serde(default, skip_serializing)]
    pub status: String,
    pub structured: serde_json::Map<String, serde_json::Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageUser {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agents: Option<Vec<PromptAgentAttachment>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<PromptFileAttachment>>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    pub text: String,
    pub time: SessionMessageUserTime,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessageUserTime {
    pub created: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionMessagesResponse {
    pub cursor: SessionsResponseCursor,
    pub data: Vec<SessionMessage>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextAgentSwitched {
    pub data: SessionNextAgentSwitchedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextAgentSwitchedData {
    pub agent: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextCompactionDelta {
    pub data: SessionNextContextUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextCompactionEnded {
    pub data: SessionNextCompactionEndedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextCompactionEndedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub reason: String,
    pub recent: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextCompactionStarted {
    pub data: SessionNextCompactionStartedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextCompactionStartedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub reason: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextContextUpdated {
    pub data: SessionNextContextUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextContextUpdatedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextModelSwitched {
    pub data: SessionNextModelSwitchedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextModelSwitchedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub model: ModelRef,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextMoved {
    pub data: SessionNextMovedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextMovedData {
    pub location: LocationRef,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subdirectory: Option<String>,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextPromptAdmitted {
    pub data: SessionNextPromptedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextPrompted {
    pub data: SessionNextPromptedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextPromptedData {
    pub delivery: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub prompt: Prompt,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextReasoningDelta {
    pub data: SessionNextReasoningDeltaData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextReasoningDeltaData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    pub delta: String,
    #[serde(rename = "reasoningID")]
    pub reasoning_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextReasoningEnded {
    pub data: SessionNextReasoningEndedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextReasoningEndedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(
        rename = "providerMetadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub provider_metadata: Option<LLMProviderMetadata>,
    #[serde(rename = "reasoningID")]
    pub reasoning_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextReasoningStarted {
    pub data: SessionNextReasoningStartedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextReasoningStartedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(
        rename = "providerMetadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub provider_metadata: Option<LLMProviderMetadata>,
    #[serde(rename = "reasoningID")]
    pub reasoning_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRetried {
    pub data: SessionNextRetriedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRetriedData {
    pub attempt: f64,
    pub error: SessionNextRetryError,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRetryError {
    #[serde(rename = "isRetryable")]
    pub is_retryable: bool,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<std::collections::BTreeMap<String, String>>,
    #[serde(
        rename = "responseBody",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_body: Option<String>,
    #[serde(
        rename = "responseHeaders",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_headers: Option<std::collections::BTreeMap<String, String>>,
    #[serde(
        rename = "statusCode",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_code: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRevertCleared {
    pub data: SessionNextRevertClearedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRevertClearedData {
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRevertCommitted {
    pub data: SessionNextRevertCommittedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRevertCommittedData {
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRevertStaged {
    pub data: SessionNextRevertStagedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextRevertStagedData {
    pub revert: RevertState,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextShellEnded {
    pub data: SessionNextShellEndedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextShellEndedData {
    #[serde(rename = "callID")]
    pub call_id: String,
    pub output: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextShellStarted {
    pub data: SessionNextShellStartedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextShellStartedData {
    #[serde(rename = "callID")]
    pub call_id: String,
    pub command: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepEnded {
    pub data: SessionNextStepEndedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepEndedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    pub cost: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<String>>,
    pub finish: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<String>,
    pub timestamp: f64,
    pub tokens: SessionNextStepEndedDataTokens,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepEndedDataTokens {
    pub cache: SessionNextStepEndedDataTokensCache,
    pub input: f64,
    pub output: f64,
    pub reasoning: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepEndedDataTokensCache {
    pub read: f64,
    pub write: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepFailed {
    pub data: SessionNextStepFailedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepFailedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    pub error: SessionErrorUnknown,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepStarted {
    pub data: SessionNextStepStartedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextStepStartedData {
    pub agent: String,
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    pub model: ModelRef,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<String>,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextSynthetic {
    pub data: SessionNextContextUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextTextDelta {
    pub data: SessionNextTextDeltaData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextTextDeltaData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    pub delta: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(rename = "textID")]
    pub text_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextTextEnded {
    pub data: SessionNextTextEndedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextTextEndedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    #[serde(rename = "textID")]
    pub text_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextTextStarted {
    pub data: SessionNextTextStartedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextTextStartedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(rename = "textID")]
    pub text_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolCalled {
    pub data: SessionNextToolCalledData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolCalledData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    pub input: serde_json::Map<String, serde_json::Value>,
    pub provider: SessionNextToolFailedDataProvider,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
    pub tool: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolFailed {
    pub data: SessionNextToolFailedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolFailedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    pub error: SessionErrorUnknown,
    pub provider: SessionNextToolFailedDataProvider,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Value>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolFailedDataProvider {
    pub executed: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<LLMProviderMetadata>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolInputDelta {
    pub data: SessionNextToolInputDeltaData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolInputDeltaData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    pub delta: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolInputEnded {
    pub data: SessionNextToolInputEndedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolInputEndedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub text: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolInputStarted {
    pub data: SessionNextToolInputStartedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolInputStartedData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    pub name: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolProgress {
    pub data: SessionNextToolProgressData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolProgressData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    pub content: Vec<LLMToolContent>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub structured: serde_json::Map<String, serde_json::Value>,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolSuccess {
    pub data: SessionNextToolSuccessData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNextToolSuccessData {
    #[serde(rename = "assistantMessageID")]
    pub assistant_message_id: String,
    #[serde(rename = "callID")]
    pub call_id: String,
    pub content: Vec<LLMToolContent>,
    #[serde(
        rename = "outputPaths",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub output_paths: Option<Vec<String>>,
    pub provider: SessionNextToolFailedDataProvider,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<serde_json::Value>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub structured: serde_json::Map<String, serde_json::Value>,
    pub timestamp: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionNotFoundError {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionRevert {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub diff: Option<String>,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "partID", default, skip_serializing_if = "Option::is_none")]
    pub part_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionShare {
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SessionStatus {
    #[serde(rename = "idle")]
    Idle,
    #[serde(rename = "retry")]
    Retry {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        action: Option<SessionStatusRetryAction>,
        attempt: u64,
        message: String,
        next: u64,
    },
    #[serde(rename = "busy")]
    Busy,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionStatus2Data {
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub status: SessionStatus,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionStatus2Durable {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub seq: i64,
    pub version: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionStatusRetryAction {
    pub label: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    pub message: String,
    pub provider: String,
    pub reason: String,
    pub title: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionSummary {
    pub additions: f64,
    pub deletions: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub diffs: Option<Vec<SnapshotFileDiff>>,
    pub files: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compacting: Option<u64>,
    pub created: u64,
    pub updated: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionUpdated {
    pub data: SessionCreatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionV2Info {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,
    pub cost: f64,
    pub id: String,
    pub location: LocationRef,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<ModelRef>,
    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
    pub parent_id: Option<String>,
    #[serde(rename = "projectID")]
    pub project_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub revert: Option<RevertState>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subpath: Option<String>,
    pub time: SessionV2InfoTime,
    pub title: String,
    pub tokens: SessionNextStepEndedDataTokens,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionV2InfoTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived: Option<f64>,
    pub created: f64,
    pub updated: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionsResponse {
    pub cursor: SessionsResponseCursor,
    pub data: Vec<SessionV2Info>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionsResponseCursor {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub previous: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SkillV2DirectorySource {
    pub path: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SkillV2EmbeddedSource {
    pub skill: SkillV2Info,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SkillV2Info {
    pub content: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub location: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub slash: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum SkillV2Source {
    #[serde(rename = "directory")]
    Directory(SkillV2DirectorySource),
    #[serde(rename = "url")]
    Url(SkillV2UrlSource),
    #[serde(rename = "embedded")]
    Embedded(SkillV2EmbeddedSource),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SkillV2UrlSource {
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    pub url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotFileDiff {
    pub additions: f64,
    pub deletions: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub patch: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SnapshotPart {
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub snapshot: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StepFinishPart {
    pub cost: f64,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    pub reason: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<String>,
    pub tokens: StepFinishPartTokens,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StepFinishPartTokens {
    pub cache: SessionNextStepEndedDataTokensCache,
    pub input: f64,
    pub output: f64,
    pub reasoning: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StepStartPart {
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub snapshot: Option<String>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StructuredOutputError {
    pub data: StructuredOutputErrorData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StructuredOutputErrorData {
    pub message: String,
    pub retries: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SubtaskPart {
    pub agent: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    pub description: String,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<SubtaskPartInputModel>,
    pub prompt: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SubtaskPartInput {
    pub agent: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    pub description: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<SubtaskPartInputModel>,
    pub prompt: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SubtaskPartInputModel {
    #[serde(rename = "modelID")]
    pub model_id: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Symbol {
    pub kind: u64,
    pub location: SymbolLocation,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SymbolLocation {
    pub range: Range,
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SymbolSource {
    pub kind: u64,
    pub name: String,
    pub path: String,
    pub range: Range,
    pub text: FilePartSourceText,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessagePartRemoved {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventMessagePartRemovedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessagePartRemovedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: MessagePartRemovedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessagePartUpdated {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventMessagePartUpdatedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessagePartUpdatedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: MessagePartUpdatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessageRemoved {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventMessageRemovedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessageRemovedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: MessageRemovedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessageUpdated {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventMessageUpdatedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventMessageUpdatedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: MessageUpdatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionCreated {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionCreatedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionCreatedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionCreatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionDeleted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionDeletedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionDeletedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionCreatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextAgentSwitched {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextAgentSwitchedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextAgentSwitchedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextAgentSwitchedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextCompactionEnded {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextCompactionEndedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextCompactionEndedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextCompactionEndedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextCompactionStarted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextCompactionStartedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextCompactionStartedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextCompactionStartedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextContextUpdated {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextContextUpdatedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextContextUpdatedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextContextUpdatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextModelSwitched {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextModelSwitchedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextModelSwitchedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextModelSwitchedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextMoved {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextMovedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextMovedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextMovedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextPromptAdmitted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextPromptAdmittedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextPromptAdmittedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextPromptedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextPrompted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextPromptedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextPromptedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextPromptedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextReasoningEnded {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextReasoningEndedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextReasoningEndedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextReasoningEndedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextReasoningStarted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextReasoningStartedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextReasoningStartedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextReasoningStartedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRetried {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextRetriedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRetriedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextRetriedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRevertCleared {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextRevertClearedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRevertClearedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextRevertClearedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRevertCommitted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextRevertCommittedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRevertCommittedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextRevertCommittedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRevertStaged {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextRevertStagedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextRevertStagedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextRevertStagedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextShellEnded {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextShellEndedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextShellEndedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextShellEndedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextShellStarted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextShellStartedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextShellStartedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextShellStartedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextStepEnded {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextStepEndedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextStepEndedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextStepEndedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextStepFailed {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextStepFailedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextStepFailedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextStepFailedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextStepStarted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextStepStartedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextStepStartedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextStepStartedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextSynthetic {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextSyntheticSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextSyntheticSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextContextUpdatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextTextEnded {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextTextEndedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextTextEndedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextTextEndedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextTextStarted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextTextStartedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextTextStartedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextTextStartedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolCalled {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextToolCalledSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolCalledSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextToolCalledData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolFailed {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextToolFailedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolFailedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextToolFailedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolInputEnded {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextToolInputEndedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolInputEndedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextToolInputEndedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolInputStarted {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextToolInputStartedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolInputStartedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextToolInputStartedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolProgress {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextToolProgressSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolProgressSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextToolProgressData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolSuccess {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionNextToolSuccessSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionNextToolSuccessSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionNextToolSuccessData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionUpdated {
    pub id: String,
    #[serde(rename = "syncEvent")]
    pub sync_event: SyncEventSessionUpdatedSyncEvent,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SyncEventSessionUpdatedSyncEvent {
    #[serde(rename = "aggregateID")]
    pub aggregate_id: String,
    pub data: SessionCreatedData,
    pub id: String,
    pub seq: f64,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TextPart {
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ignored: Option<bool>,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub synthetic: Option<bool>,
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub time: Option<TextPartInputTime>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct TextPartInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ignored: Option<bool>,
    #[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 synthetic: Option<bool>,
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub time: Option<TextPartInputTime>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TextPartInputTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub end: Option<u64>,
    pub start: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Todo {
    pub content: String,
    pub priority: String,
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TodoUpdated {
    pub data: TodoUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TodoUpdatedData {
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub todos: Vec<Todo>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolFileContent {
    pub mime: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
    pub uri: String,
}

pub type ToolIDs = Vec<String>;

pub type ToolList = Vec<ToolListItem>;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolListItem {
    pub description: String,
    pub id: String,
    pub parameters: serde_json::Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolPart {
    #[serde(rename = "callID")]
    pub call_id: String,
    pub id: String,
    #[serde(rename = "messageID")]
    pub message_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    pub state: ToolState,
    pub tool: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum ToolState {
    #[serde(rename = "pending")]
    Pending(ToolStatePending),
    #[serde(rename = "running")]
    Running(ToolStateRunning),
    #[serde(rename = "completed")]
    Completed(ToolStateCompleted),
    #[serde(rename = "error")]
    Error(ToolStateError),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStateCompleted {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub attachments: Option<Vec<FilePart>>,
    pub input: serde_json::Map<String, serde_json::Value>,
    pub metadata: serde_json::Map<String, serde_json::Value>,
    pub output: String,
    #[serde(default, skip_serializing)]
    pub status: String,
    pub time: ToolStateCompletedTime,
    pub title: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStateCompletedTime {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compacted: Option<u64>,
    pub end: u64,
    pub start: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStateError {
    pub error: String,
    pub input: 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)]
    pub status: String,
    pub time: ToolStateErrorTime,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStateErrorTime {
    pub end: u64,
    pub start: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStatePending {
    pub input: serde_json::Map<String, serde_json::Value>,
    pub raw: String,
    #[serde(default, skip_serializing)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStateRunning {
    pub input: 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)]
    pub status: String,
    pub time: ToolStateRunningTime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolStateRunningTime {
    pub start: u64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolTextContent {
    pub text: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiCommandExecute {
    pub data: TuiCommandExecuteData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiCommandExecuteData {
    pub command: TuiCommandExecuteDataCommand,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TuiCommandExecuteDataCommand {
    SessionList,
    SessionNew,
    SessionShare,
    SessionInterrupt,
    SessionCompact,
    SessionPageUp,
    SessionPageDown,
    SessionLineUp,
    SessionLineDown,
    SessionHalfPageUp,
    SessionHalfPageDown,
    SessionFirst,
    SessionLast,
    PromptClear,
    PromptSubmit,
    AgentCycle,
    Unknown(String),
}

impl TuiCommandExecuteDataCommand {
    pub fn as_str(&self) -> &str {
        match self {
            Self::SessionList => "session.list",
            Self::SessionNew => "session.new",
            Self::SessionShare => "session.share",
            Self::SessionInterrupt => "session.interrupt",
            Self::SessionCompact => "session.compact",
            Self::SessionPageUp => "session.page.up",
            Self::SessionPageDown => "session.page.down",
            Self::SessionLineUp => "session.line.up",
            Self::SessionLineDown => "session.line.down",
            Self::SessionHalfPageUp => "session.half.page.up",
            Self::SessionHalfPageDown => "session.half.page.down",
            Self::SessionFirst => "session.first",
            Self::SessionLast => "session.last",
            Self::PromptClear => "prompt.clear",
            Self::PromptSubmit => "prompt.submit",
            Self::AgentCycle => "agent.cycle",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

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

impl From<&str> for TuiCommandExecuteDataCommand {
    fn from(s: &str) -> Self {
        match s {
            "session.list" => Self::SessionList,
            "session.new" => Self::SessionNew,
            "session.share" => Self::SessionShare,
            "session.interrupt" => Self::SessionInterrupt,
            "session.compact" => Self::SessionCompact,
            "session.page.up" => Self::SessionPageUp,
            "session.page.down" => Self::SessionPageDown,
            "session.line.up" => Self::SessionLineUp,
            "session.line.down" => Self::SessionLineDown,
            "session.half.page.up" => Self::SessionHalfPageUp,
            "session.half.page.down" => Self::SessionHalfPageDown,
            "session.first" => Self::SessionFirst,
            "session.last" => Self::SessionLast,
            "prompt.clear" => Self::PromptClear,
            "prompt.submit" => Self::PromptSubmit,
            "agent.cycle" => Self::AgentCycle,
            other => Self::Unknown(other.to_string()),
        }
    }
}

impl Serialize for TuiCommandExecuteDataCommand {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for TuiCommandExecuteDataCommand {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let s = String::deserialize(deserializer)?;
        Ok(Self::from(s.as_str()))
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiPromptAppend {
    pub data: TuiPromptAppendData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiPromptAppendData {
    pub text: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiSessionSelect {
    pub data: TuiSessionSelectData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiSessionSelectData {
    #[serde(rename = "sessionID")]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiToastShow {
    pub data: TuiToastShowData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TuiToastShowData {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub duration: Option<i64>,
    pub message: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    pub variant: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnauthorizedError {
    pub _tag: String,
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnknownError {
    pub data: UnknownErrorData,
    #[serde(default, skip_serializing)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnknownError1 {
    pub _tag: String,
    pub message: String,
    #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
    pub ref_: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UnknownErrorData {
    pub message: String,
    #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
    pub ref_: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserMessage {
    pub agent: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<OutputFormat>,
    pub id: String,
    pub model: UserMessageModel,
    #[serde(default, skip_serializing)]
    pub role: String,
    #[serde(rename = "sessionID")]
    pub session_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<UserMessageSummary>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub system: Option<String>,
    pub time: UserMessageTime,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<std::collections::BTreeMap<String, bool>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserMessageModel {
    #[serde(rename = "modelID")]
    pub model_id: String,
    #[serde(rename = "providerID")]
    pub provider_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub variant: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserMessageSummary {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub body: Option<String>,
    pub diffs: Vec<SnapshotFileDiff>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserMessageTime {
    pub created: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum V2Event {
    #[serde(rename = "models-dev.refreshed")]
    ModelsDevRefreshed(ModelsDevRefreshed),
    #[serde(rename = "integration.updated")]
    IntegrationUpdated(IntegrationUpdated),
    #[serde(rename = "integration.connection.updated")]
    IntegrationConnectionUpdated(IntegrationConnectionUpdated),
    #[serde(rename = "catalog.updated")]
    CatalogUpdated(CatalogUpdated),
    #[serde(rename = "session.created")]
    SessionCreated(SessionCreated),
    #[serde(rename = "session.updated")]
    SessionUpdated(SessionUpdated),
    #[serde(rename = "session.deleted")]
    SessionDeleted(SessionDeleted),
    #[serde(rename = "message.updated")]
    MessageUpdated(MessageUpdated),
    #[serde(rename = "message.removed")]
    MessageRemoved(MessageRemoved),
    #[serde(rename = "message.part.updated")]
    MessagePartUpdated(MessagePartUpdated),
    #[serde(rename = "message.part.removed")]
    MessagePartRemoved(MessagePartRemoved),
    #[serde(rename = "session.next.agent.switched")]
    SessionNextAgentSwitched(SessionNextAgentSwitched),
    #[serde(rename = "session.next.model.switched")]
    SessionNextModelSwitched(SessionNextModelSwitched),
    #[serde(rename = "session.next.moved")]
    SessionNextMoved(SessionNextMoved),
    #[serde(rename = "session.next.prompted")]
    SessionNextPrompted(SessionNextPrompted),
    #[serde(rename = "session.next.prompt.admitted")]
    SessionNextPromptAdmitted(SessionNextPromptAdmitted),
    #[serde(rename = "session.next.context.updated")]
    SessionNextContextUpdated(SessionNextContextUpdated),
    #[serde(rename = "session.next.synthetic")]
    SessionNextSynthetic(SessionNextSynthetic),
    #[serde(rename = "session.next.shell.started")]
    SessionNextShellStarted(SessionNextShellStarted),
    #[serde(rename = "session.next.shell.ended")]
    SessionNextShellEnded(SessionNextShellEnded),
    #[serde(rename = "session.next.step.started")]
    SessionNextStepStarted(SessionNextStepStarted),
    #[serde(rename = "session.next.step.ended")]
    SessionNextStepEnded(SessionNextStepEnded),
    #[serde(rename = "session.next.step.failed")]
    SessionNextStepFailed(SessionNextStepFailed),
    #[serde(rename = "session.next.text.started")]
    SessionNextTextStarted(SessionNextTextStarted),
    #[serde(rename = "session.next.text.delta")]
    SessionNextTextDelta(SessionNextTextDelta),
    #[serde(rename = "session.next.text.ended")]
    SessionNextTextEnded(SessionNextTextEnded),
    #[serde(rename = "session.next.reasoning.started")]
    SessionNextReasoningStarted(SessionNextReasoningStarted),
    #[serde(rename = "session.next.reasoning.delta")]
    SessionNextReasoningDelta(SessionNextReasoningDelta),
    #[serde(rename = "session.next.reasoning.ended")]
    SessionNextReasoningEnded(SessionNextReasoningEnded),
    #[serde(rename = "session.next.tool.input.started")]
    SessionNextToolInputStarted(SessionNextToolInputStarted),
    #[serde(rename = "session.next.tool.input.delta")]
    SessionNextToolInputDelta(SessionNextToolInputDelta),
    #[serde(rename = "session.next.tool.input.ended")]
    SessionNextToolInputEnded(SessionNextToolInputEnded),
    #[serde(rename = "session.next.tool.called")]
    SessionNextToolCalled(SessionNextToolCalled),
    #[serde(rename = "session.next.tool.progress")]
    SessionNextToolProgress(SessionNextToolProgress),
    #[serde(rename = "session.next.tool.success")]
    SessionNextToolSuccess(SessionNextToolSuccess),
    #[serde(rename = "session.next.tool.failed")]
    SessionNextToolFailed(SessionNextToolFailed),
    #[serde(rename = "session.next.retried")]
    SessionNextRetried(SessionNextRetried),
    #[serde(rename = "session.next.compaction.started")]
    SessionNextCompactionStarted(SessionNextCompactionStarted),
    #[serde(rename = "session.next.compaction.delta")]
    SessionNextCompactionDelta(SessionNextCompactionDelta),
    #[serde(rename = "session.next.compaction.ended")]
    SessionNextCompactionEnded(SessionNextCompactionEnded),
    #[serde(rename = "session.next.revert.staged")]
    SessionNextRevertStaged(SessionNextRevertStaged),
    #[serde(rename = "session.next.revert.cleared")]
    SessionNextRevertCleared(SessionNextRevertCleared),
    #[serde(rename = "session.next.revert.committed")]
    SessionNextRevertCommitted(SessionNextRevertCommitted),
    #[serde(rename = "message.part.delta")]
    MessagePartDelta(MessagePartDelta),
    #[serde(rename = "session.diff")]
    SessionDiff(SessionDiff),
    #[serde(rename = "session.error")]
    SessionError(SessionError),
    #[serde(rename = "installation.updated")]
    InstallationUpdated(InstallationUpdated),
    #[serde(rename = "installation.update-available")]
    InstallationUpdateAvailable(InstallationUpdateAvailable),
    #[serde(rename = "file.edited")]
    FileEdited(FileEdited),
    #[serde(rename = "reference.updated")]
    ReferenceUpdated(ReferenceUpdated),
    #[serde(rename = "permission.v2.asked")]
    PermissionV2Asked(PermissionV2Asked),
    #[serde(rename = "permission.v2.replied")]
    PermissionV2Replied(PermissionV2Replied),
    #[serde(rename = "plugin.added")]
    PluginAdded(PluginAdded),
    #[serde(rename = "project.directories.updated")]
    ProjectDirectoriesUpdated(ProjectDirectoriesUpdated),
    #[serde(rename = "file.watcher.updated")]
    FileWatcherUpdated(FileWatcherUpdated),
    #[serde(rename = "pty.created")]
    PtyCreated(PtyCreated),
    #[serde(rename = "pty.updated")]
    PtyUpdated(PtyUpdated),
    #[serde(rename = "pty.exited")]
    PtyExited(PtyExited),
    #[serde(rename = "pty.deleted")]
    PtyDeleted(PtyDeleted),
    #[serde(rename = "question.v2.asked")]
    QuestionV2Asked(QuestionV2Asked),
    #[serde(rename = "question.v2.replied")]
    QuestionV2Replied(QuestionV2Replied),
    #[serde(rename = "question.v2.rejected")]
    QuestionV2Rejected(QuestionV2Rejected),
    #[serde(rename = "todo.updated")]
    TodoUpdated(TodoUpdated),
    #[serde(rename = "lsp.updated")]
    LspUpdated(LspUpdated),
    #[serde(rename = "permission.asked")]
    PermissionAsked(PermissionAsked),
    #[serde(rename = "permission.replied")]
    PermissionReplied(PermissionReplied),
    #[serde(rename = "tui.prompt.append")]
    TuiPromptAppend(TuiPromptAppend),
    #[serde(rename = "tui.command.execute")]
    TuiCommandExecute(TuiCommandExecute),
    #[serde(rename = "tui.toast.show")]
    TuiToastShow(TuiToastShow),
    #[serde(rename = "tui.session.select")]
    TuiSessionSelect(TuiSessionSelect),
    #[serde(rename = "mcp.tools.changed")]
    McpToolsChanged(McpToolsChanged),
    #[serde(rename = "mcp.browser.open.failed")]
    McpBrowserOpenFailed(McpBrowserOpenFailed),
    #[serde(rename = "command.executed")]
    CommandExecuted(CommandExecuted),
    #[serde(rename = "project.updated")]
    ProjectUpdated(ProjectUpdated),
    #[serde(rename = "session.status")]
    SessionStatus(SessionStatus2),
    #[serde(rename = "session.idle")]
    SessionIdle(SessionIdle),
    #[serde(rename = "question.asked")]
    QuestionAsked(QuestionAsked),
    #[serde(rename = "question.replied")]
    QuestionReplied(QuestionReplied2),
    #[serde(rename = "question.rejected")]
    QuestionRejected(QuestionRejected2),
    #[serde(rename = "session.compacted")]
    SessionCompacted(SessionCompacted),
    #[serde(rename = "vcs.branch.updated")]
    VcsBranchUpdated(VcsBranchUpdated),
    #[serde(rename = "workspace.ready")]
    WorkspaceReady(WorkspaceReady),
    #[serde(rename = "workspace.failed")]
    WorkspaceFailed(WorkspaceFailed),
    #[serde(rename = "workspace.status")]
    WorkspaceStatus(WorkspaceStatus),
    #[serde(rename = "worktree.ready")]
    WorktreeReady(WorktreeReady),
    #[serde(rename = "worktree.failed")]
    WorktreeFailed(WorktreeFailed),
    #[serde(rename = "server.connected")]
    ServerConnected(ServerConnected),
    #[serde(rename = "global.disposed")]
    GlobalDisposed(GlobalDisposed),
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(transparent)]
pub struct V2EventStream(pub String);

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsApplyError {
    pub data: VcsApplyErrorData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsApplyErrorData {
    pub message: String,
    pub reason: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsBranchUpdated {
    pub data: VcsBranchUpdatedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsBranchUpdatedData {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsFileDiff {
    pub additions: f64,
    pub deletions: f64,
    pub file: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub patch: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsFileStatus {
    pub additions: f64,
    pub deletions: f64,
    pub file: String,
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VcsInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default_branch: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WellKnownAuth {
    pub key: String,
    pub token: String,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Workspace {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub directory: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,
    pub id: String,
    pub name: String,
    #[serde(rename = "projectID")]
    pub project_id: String,
    #[serde(rename = "timeUsed")]
    pub time_used: WorkspaceTimeUsed,
    #[serde(rename = "type")]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceCreateError {
    pub data: WorktreeFailedData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceEventConnectionStatus {
    pub status: String,
    #[serde(rename = "workspaceID")]
    pub workspace_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceFailed {
    pub data: WorktreeFailedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceReady {
    pub data: WorkspaceReadyData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceReadyData {
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceStatus {
    pub data: WorkspaceStatusData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceStatusData {
    pub status: String,
    #[serde(rename = "workspaceID")]
    pub workspace_id: String,
}

/// Untagged union: serde tries each variant in the order below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkspaceTimeUsed {
    Variant0(f64),
    Variant1(String),
    Variant2(String),
    Variant3(String),
    Variant4(String),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkspaceWarpError {
    pub data: WorktreeFailedData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Worktree {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    pub directory: String,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeCreateInput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        rename = "startCommand",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub start_command: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeError {
    pub data: WorktreeFailedData,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeFailed {
    pub data: WorktreeFailedData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeFailedData {
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeReady {
    pub data: WorktreeReadyData,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeReadyData {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeRemoveInput {
    pub directory: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorktreeResetInput {
    pub directory: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EffectHttpApiErrorBadRequest {
    pub _tag: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EffectHttpApiErrorForbidden {
    pub _tag: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EffectHttpApiErrorInternalServerError {
    pub _tag: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionRejected2 {
    pub data: QuestionRejected2Data,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuestionReplied2 {
    pub data: QuestionReplied2Data,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SessionStatus2 {
    pub data: SessionStatus2Data,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub durable: Option<SessionStatus2Durable>,
    pub id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<LocationRef>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
    #[serde(rename = "type", default, skip_serializing)]
    pub type_: String,
}