antigravity_codes/protocol_generated/

types.rs

// AUTO-GENERATED by scripts/codegen_antigravity.py — DO NOT EDIT BY HAND.
// Run `python3 scripts/codegen_antigravity.py` to regenerate.
//
// Source: the `FileDescriptorProto` embedded in `localharness_pb2.py` from the
// `google-antigravity` wheel, snapshotted under `tests/schemas/`.
//
// The harness speaks protobuf-JSON over a WebSocket, so these are plain serde
// types shaped like that encoding: `camelCase` members, 64-bit integers as
// strings, `bytes` as base64, enums as their proto value names, and a protobuf
// `oneof` flattened into sibling `Option` members (with a generated view enum).

#![allow(clippy::large_enum_variant)]

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

/// `antigravity.localharness.ActionEditFile.DiffLine.LineAction`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum ActionEditFileDiffLineLineAction {
    #[default]
    Unspecified,
    Insert,
    Delete,
    None,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl ActionEditFileDiffLineLineAction {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "LINE_ACTION_UNSPECIFIED",
            Self::Insert => "LINE_ACTION_INSERT",
            Self::Delete => "LINE_ACTION_DELETE",
            Self::None => "LINE_ACTION_NONE",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for ActionEditFileDiffLineLineAction {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "LINE_ACTION_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "LINE_ACTION_INSERT" => Self::Insert,
            crate::wire::EnumRepr::Name(n) if n == "LINE_ACTION_DELETE" => Self::Delete,
            crate::wire::EnumRepr::Name(n) if n == "LINE_ACTION_NONE" => Self::None,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Insert,
            crate::wire::EnumRepr::Number(2) => Self::Delete,
            crate::wire::EnumRepr::Number(3) => Self::None,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.AudioContent.MimeType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum AudioContentMimeType {
    #[default]
    TypeUnspecified,
    TypeWav,
    TypeMp3,
    TypeAiff,
    TypeAac,
    TypeOgg,
    TypeFlac,
    TypeMpeg,
    TypeM4a,
    TypeL16,
    TypeS16le,
    TypeOpus,
    TypeAlaw,
    TypeMulaw,
    TypeVideoAudioS16le,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl AudioContentMimeType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
            Self::TypeWav => "TYPE_WAV",
            Self::TypeMp3 => "TYPE_MP3",
            Self::TypeAiff => "TYPE_AIFF",
            Self::TypeAac => "TYPE_AAC",
            Self::TypeOgg => "TYPE_OGG",
            Self::TypeFlac => "TYPE_FLAC",
            Self::TypeMpeg => "TYPE_MPEG",
            Self::TypeM4a => "TYPE_M4A",
            Self::TypeL16 => "TYPE_L16",
            Self::TypeS16le => "TYPE_S16LE",
            Self::TypeOpus => "TYPE_OPUS",
            Self::TypeAlaw => "TYPE_ALAW",
            Self::TypeMulaw => "TYPE_MULAW",
            Self::TypeVideoAudioS16le => "TYPE_VIDEO_AUDIO_S16LE",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for AudioContentMimeType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "TYPE_UNSPECIFIED" => Self::TypeUnspecified,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_WAV" => Self::TypeWav,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MP3" => Self::TypeMp3,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_AIFF" => Self::TypeAiff,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_AAC" => Self::TypeAac,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_OGG" => Self::TypeOgg,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_FLAC" => Self::TypeFlac,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MPEG" => Self::TypeMpeg,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_M4A" => Self::TypeM4a,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_L16" => Self::TypeL16,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_S16LE" => Self::TypeS16le,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_OPUS" => Self::TypeOpus,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_ALAW" => Self::TypeAlaw,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MULAW" => Self::TypeMulaw,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_VIDEO_AUDIO_S16LE" => {
                Self::TypeVideoAudioS16le
            }
            crate::wire::EnumRepr::Number(0) => Self::TypeUnspecified,
            crate::wire::EnumRepr::Number(1) => Self::TypeWav,
            crate::wire::EnumRepr::Number(2) => Self::TypeMp3,
            crate::wire::EnumRepr::Number(3) => Self::TypeAiff,
            crate::wire::EnumRepr::Number(4) => Self::TypeAac,
            crate::wire::EnumRepr::Number(5) => Self::TypeOgg,
            crate::wire::EnumRepr::Number(6) => Self::TypeFlac,
            crate::wire::EnumRepr::Number(7) => Self::TypeMpeg,
            crate::wire::EnumRepr::Number(8) => Self::TypeM4a,
            crate::wire::EnumRepr::Number(9) => Self::TypeL16,
            crate::wire::EnumRepr::Number(10) => Self::TypeS16le,
            crate::wire::EnumRepr::Number(11) => Self::TypeOpus,
            crate::wire::EnumRepr::Number(12) => Self::TypeAlaw,
            crate::wire::EnumRepr::Number(13) => Self::TypeMulaw,
            crate::wire::EnumRepr::Number(14) => Self::TypeVideoAudioS16le,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.CodeExecutionCallContent.CodeExecutionCallArguments.Language`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum CodeExecutionCallContentCodeExecutionCallArgumentsLanguage {
    #[default]
    Unspecified,
    Python,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl CodeExecutionCallContentCodeExecutionCallArgumentsLanguage {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "LANGUAGE_UNSPECIFIED",
            Self::Python => "PYTHON",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for CodeExecutionCallContentCodeExecutionCallArgumentsLanguage {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "LANGUAGE_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "PYTHON" => Self::Python,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Python,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.DocumentContent.MimeType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum DocumentContentMimeType {
    #[default]
    TypeUnspecified,
    TypePdf,
    TypeCsv,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl DocumentContentMimeType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
            Self::TypePdf => "TYPE_PDF",
            Self::TypeCsv => "TYPE_CSV",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for DocumentContentMimeType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "TYPE_UNSPECIFIED" => Self::TypeUnspecified,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_PDF" => Self::TypePdf,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_CSV" => Self::TypeCsv,
            crate::wire::EnumRepr::Number(0) => Self::TypeUnspecified,
            crate::wire::EnumRepr::Number(1) => Self::TypePdf,
            crate::wire::EnumRepr::Number(2) => Self::TypeCsv,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.GoogleSearch.SearchType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum GoogleSearchSearchType {
    #[default]
    Unspecified,
    WebSearch,
    ImageSearch,
    EnterpriseWebSearch,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl GoogleSearchSearchType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "SEARCH_TYPE_UNSPECIFIED",
            Self::WebSearch => "SEARCH_TYPE_WEB_SEARCH",
            Self::ImageSearch => "SEARCH_TYPE_IMAGE_SEARCH",
            Self::EnterpriseWebSearch => "SEARCH_TYPE_ENTERPRISE_WEB_SEARCH",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for GoogleSearchSearchType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "SEARCH_TYPE_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "SEARCH_TYPE_WEB_SEARCH" => Self::WebSearch,
            crate::wire::EnumRepr::Name(n) if n == "SEARCH_TYPE_IMAGE_SEARCH" => Self::ImageSearch,
            crate::wire::EnumRepr::Name(n) if n == "SEARCH_TYPE_ENTERPRISE_WEB_SEARCH" => {
                Self::EnterpriseWebSearch
            }
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::WebSearch,
            crate::wire::EnumRepr::Number(2) => Self::ImageSearch,
            crate::wire::EnumRepr::Number(3) => Self::EnterpriseWebSearch,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.HarnessConfig.SessionContinuationMode`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum HarnessConfigSessionContinuationMode {
    #[default]
    Unspecified,
    Resume,
    CreateOrResume,
    CreateOnly,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl HarnessConfigSessionContinuationMode {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "SESSION_CONTINUATION_MODE_UNSPECIFIED",
            Self::Resume => "RESUME",
            Self::CreateOrResume => "CREATE_OR_RESUME",
            Self::CreateOnly => "CREATE_ONLY",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for HarnessConfigSessionContinuationMode {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "SESSION_CONTINUATION_MODE_UNSPECIFIED" => {
                Self::Unspecified
            }
            crate::wire::EnumRepr::Name(n) if n == "RESUME" => Self::Resume,
            crate::wire::EnumRepr::Name(n) if n == "CREATE_OR_RESUME" => Self::CreateOrResume,
            crate::wire::EnumRepr::Name(n) if n == "CREATE_ONLY" => Self::CreateOnly,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Resume,
            crate::wire::EnumRepr::Number(2) => Self::CreateOrResume,
            crate::wire::EnumRepr::Number(3) => Self::CreateOnly,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.ImageContent.MimeType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum ImageContentMimeType {
    #[default]
    TypeUnspecified,
    TypePng,
    TypeJpeg,
    TypeWebp,
    TypeHeic,
    TypeHeif,
    TypeGif,
    TypeBmp,
    TypeTiff,
    TypeVideoFrameJpeg2000,
    TypeVideoJpeg2000,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl ImageContentMimeType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
            Self::TypePng => "TYPE_PNG",
            Self::TypeJpeg => "TYPE_JPEG",
            Self::TypeWebp => "TYPE_WEBP",
            Self::TypeHeic => "TYPE_HEIC",
            Self::TypeHeif => "TYPE_HEIF",
            Self::TypeGif => "TYPE_GIF",
            Self::TypeBmp => "TYPE_BMP",
            Self::TypeTiff => "TYPE_TIFF",
            Self::TypeVideoFrameJpeg2000 => "TYPE_VIDEO_FRAME_JPEG2000",
            Self::TypeVideoJpeg2000 => "TYPE_VIDEO_JPEG2000",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for ImageContentMimeType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "TYPE_UNSPECIFIED" => Self::TypeUnspecified,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_PNG" => Self::TypePng,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_JPEG" => Self::TypeJpeg,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_WEBP" => Self::TypeWebp,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_HEIC" => Self::TypeHeic,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_HEIF" => Self::TypeHeif,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_GIF" => Self::TypeGif,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_BMP" => Self::TypeBmp,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_TIFF" => Self::TypeTiff,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_VIDEO_FRAME_JPEG2000" => {
                Self::TypeVideoFrameJpeg2000
            }
            crate::wire::EnumRepr::Name(n) if n == "TYPE_VIDEO_JPEG2000" => Self::TypeVideoJpeg2000,
            crate::wire::EnumRepr::Number(0) => Self::TypeUnspecified,
            crate::wire::EnumRepr::Number(1) => Self::TypePng,
            crate::wire::EnumRepr::Number(2) => Self::TypeJpeg,
            crate::wire::EnumRepr::Number(3) => Self::TypeWebp,
            crate::wire::EnumRepr::Number(4) => Self::TypeHeic,
            crate::wire::EnumRepr::Number(5) => Self::TypeHeif,
            crate::wire::EnumRepr::Number(7) => Self::TypeGif,
            crate::wire::EnumRepr::Number(8) => Self::TypeBmp,
            crate::wire::EnumRepr::Number(9) => Self::TypeTiff,
            crate::wire::EnumRepr::Number(10) => Self::TypeVideoFrameJpeg2000,
            crate::wire::EnumRepr::Number(11) => Self::TypeVideoJpeg2000,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.LifecycleHook`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum LifecycleHook {
    #[default]
    Unspecified,
    OnSessionStart,
    OnSessionEnd,
    PreTurn,
    PostTurn,
    PreTool,
    PostTool,
    OnToolError,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl LifecycleHook {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "LIFECYCLE_HOOK_UNSPECIFIED",
            Self::OnSessionStart => "LIFECYCLE_HOOK_ON_SESSION_START",
            Self::OnSessionEnd => "LIFECYCLE_HOOK_ON_SESSION_END",
            Self::PreTurn => "LIFECYCLE_HOOK_PRE_TURN",
            Self::PostTurn => "LIFECYCLE_HOOK_POST_TURN",
            Self::PreTool => "LIFECYCLE_HOOK_PRE_TOOL",
            Self::PostTool => "LIFECYCLE_HOOK_POST_TOOL",
            Self::OnToolError => "LIFECYCLE_HOOK_ON_TOOL_ERROR",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for LifecycleHook {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_UNSPECIFIED" => {
                Self::Unspecified
            }
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_ON_SESSION_START" => {
                Self::OnSessionStart
            }
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_ON_SESSION_END" => {
                Self::OnSessionEnd
            }
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_PRE_TURN" => Self::PreTurn,
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_POST_TURN" => Self::PostTurn,
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_PRE_TOOL" => Self::PreTool,
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_POST_TOOL" => Self::PostTool,
            crate::wire::EnumRepr::Name(n) if n == "LIFECYCLE_HOOK_ON_TOOL_ERROR" => {
                Self::OnToolError
            }
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::OnSessionStart,
            crate::wire::EnumRepr::Number(2) => Self::OnSessionEnd,
            crate::wire::EnumRepr::Number(3) => Self::PreTurn,
            crate::wire::EnumRepr::Number(4) => Self::PostTurn,
            crate::wire::EnumRepr::Number(5) => Self::PreTool,
            crate::wire::EnumRepr::Number(6) => Self::PostTool,
            crate::wire::EnumRepr::Number(7) => Self::OnToolError,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.McpServerConfig.AuthProviderType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum McpServerConfigAuthProviderType {
    #[default]
    Unspecified,
    GoogleCredentials,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl McpServerConfigAuthProviderType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "AUTH_PROVIDER_TYPE_UNSPECIFIED",
            Self::GoogleCredentials => "AUTH_PROVIDER_TYPE_GOOGLE_CREDENTIALS",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for McpServerConfigAuthProviderType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "AUTH_PROVIDER_TYPE_UNSPECIFIED" => {
                Self::Unspecified
            }
            crate::wire::EnumRepr::Name(n) if n == "AUTH_PROVIDER_TYPE_GOOGLE_CREDENTIALS" => {
                Self::GoogleCredentials
            }
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::GoogleCredentials,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.MediaResolution`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum MediaResolution {
    #[default]
    Unspecified,
    Low,
    Medium,
    High,
    UltraHigh,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl MediaResolution {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "MEDIA_RESOLUTION_UNSPECIFIED",
            Self::Low => "LOW",
            Self::Medium => "MEDIUM",
            Self::High => "HIGH",
            Self::UltraHigh => "ULTRA_HIGH",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for MediaResolution {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "MEDIA_RESOLUTION_UNSPECIFIED" => {
                Self::Unspecified
            }
            crate::wire::EnumRepr::Name(n) if n == "LOW" => Self::Low,
            crate::wire::EnumRepr::Name(n) if n == "MEDIUM" => Self::Medium,
            crate::wire::EnumRepr::Name(n) if n == "HIGH" => Self::High,
            crate::wire::EnumRepr::Name(n) if n == "ULTRA_HIGH" => Self::UltraHigh,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Low,
            crate::wire::EnumRepr::Number(2) => Self::Medium,
            crate::wire::EnumRepr::Number(3) => Self::High,
            crate::wire::EnumRepr::Number(4) => Self::UltraHigh,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.ModelType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum ModelType {
    #[default]
    Unspecified,
    Text,
    Image,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl ModelType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "MODEL_TYPE_UNSPECIFIED",
            Self::Text => "MODEL_TYPE_TEXT",
            Self::Image => "MODEL_TYPE_IMAGE",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for ModelType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "MODEL_TYPE_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "MODEL_TYPE_TEXT" => Self::Text,
            crate::wire::EnumRepr::Name(n) if n == "MODEL_TYPE_IMAGE" => Self::Image,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Text,
            crate::wire::EnumRepr::Number(2) => Self::Image,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `google.protobuf.NullValue`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum NullValue {
    #[default]
    NullValue,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl NullValue {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::NullValue => "NULL_VALUE",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for NullValue {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "NULL_VALUE" => Self::NullValue,
            crate::wire::EnumRepr::Number(0) => Self::NullValue,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.PolicyDecision`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum PolicyDecision {
    #[default]
    Unspecified,
    Allow,
    Deny,
    AskUser,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl PolicyDecision {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "POLICY_DECISION_UNSPECIFIED",
            Self::Allow => "POLICY_DECISION_ALLOW",
            Self::Deny => "POLICY_DECISION_DENY",
            Self::AskUser => "POLICY_DECISION_ASK_USER",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for PolicyDecision {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "POLICY_DECISION_UNSPECIFIED" => {
                Self::Unspecified
            }
            crate::wire::EnumRepr::Name(n) if n == "POLICY_DECISION_ALLOW" => Self::Allow,
            crate::wire::EnumRepr::Name(n) if n == "POLICY_DECISION_DENY" => Self::Deny,
            crate::wire::EnumRepr::Name(n) if n == "POLICY_DECISION_ASK_USER" => Self::AskUser,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Allow,
            crate::wire::EnumRepr::Number(2) => Self::Deny,
            crate::wire::EnumRepr::Number(3) => Self::AskUser,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.PolicyEvaluationOutcome`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum PolicyEvaluationOutcome {
    #[default]
    Unspecified,
    Allow,
    Deny,
    NoMatch,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl PolicyEvaluationOutcome {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "POLICY_EVALUATION_OUTCOME_UNSPECIFIED",
            Self::Allow => "POLICY_EVALUATION_OUTCOME_ALLOW",
            Self::Deny => "POLICY_EVALUATION_OUTCOME_DENY",
            Self::NoMatch => "POLICY_EVALUATION_OUTCOME_NO_MATCH",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for PolicyEvaluationOutcome {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "POLICY_EVALUATION_OUTCOME_UNSPECIFIED" => {
                Self::Unspecified
            }
            crate::wire::EnumRepr::Name(n) if n == "POLICY_EVALUATION_OUTCOME_ALLOW" => Self::Allow,
            crate::wire::EnumRepr::Name(n) if n == "POLICY_EVALUATION_OUTCOME_DENY" => Self::Deny,
            crate::wire::EnumRepr::Name(n) if n == "POLICY_EVALUATION_OUTCOME_NO_MATCH" => {
                Self::NoMatch
            }
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Allow,
            crate::wire::EnumRepr::Number(2) => Self::Deny,
            crate::wire::EnumRepr::Number(3) => Self::NoMatch,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.PreToolResult.Decision`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum PreToolResultDecision {
    #[default]
    Unspecified,
    Allow,
    Deny,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl PreToolResultDecision {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "DECISION_UNSPECIFIED",
            Self::Allow => "ALLOW",
            Self::Deny => "DENY",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for PreToolResultDecision {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "DECISION_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "ALLOW" => Self::Allow,
            crate::wire::EnumRepr::Name(n) if n == "DENY" => Self::Deny,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Allow,
            crate::wire::EnumRepr::Number(2) => Self::Deny,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.PreTurnResult.Decision`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum PreTurnResultDecision {
    #[default]
    Unspecified,
    Allow,
    Deny,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl PreTurnResultDecision {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "DECISION_UNSPECIFIED",
            Self::Allow => "ALLOW",
            Self::Deny => "DENY",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for PreTurnResultDecision {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "DECISION_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "ALLOW" => Self::Allow,
            crate::wire::EnumRepr::Name(n) if n == "DENY" => Self::Deny,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Allow,
            crate::wire::EnumRepr::Number(2) => Self::Deny,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.StepUpdate.Source`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum StepUpdateSource {
    #[default]
    Unspecified,
    System,
    User,
    Model,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl StepUpdateSource {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "SOURCE_UNSPECIFIED",
            Self::System => "SOURCE_SYSTEM",
            Self::User => "SOURCE_USER",
            Self::Model => "SOURCE_MODEL",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for StepUpdateSource {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "SOURCE_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "SOURCE_SYSTEM" => Self::System,
            crate::wire::EnumRepr::Name(n) if n == "SOURCE_USER" => Self::User,
            crate::wire::EnumRepr::Name(n) if n == "SOURCE_MODEL" => Self::Model,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::System,
            crate::wire::EnumRepr::Number(2) => Self::User,
            crate::wire::EnumRepr::Number(3) => Self::Model,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.StepUpdate.State`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum StepUpdateState {
    #[default]
    Unspecified,
    Active,
    Done,
    WaitingForUser,
    Error,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl StepUpdateState {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "STATE_UNSPECIFIED",
            Self::Active => "STATE_ACTIVE",
            Self::Done => "STATE_DONE",
            Self::WaitingForUser => "STATE_WAITING_FOR_USER",
            Self::Error => "STATE_ERROR",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for StepUpdateState {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "STATE_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "STATE_ACTIVE" => Self::Active,
            crate::wire::EnumRepr::Name(n) if n == "STATE_DONE" => Self::Done,
            crate::wire::EnumRepr::Name(n) if n == "STATE_WAITING_FOR_USER" => Self::WaitingForUser,
            crate::wire::EnumRepr::Name(n) if n == "STATE_ERROR" => Self::Error,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Active,
            crate::wire::EnumRepr::Number(2) => Self::Done,
            crate::wire::EnumRepr::Number(3) => Self::WaitingForUser,
            crate::wire::EnumRepr::Number(4) => Self::Error,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.StepUpdate.Target`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum StepUpdateTarget {
    #[default]
    Unspecified,
    User,
    Model,
    Environment,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl StepUpdateTarget {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "TARGET_UNSPECIFIED",
            Self::User => "TARGET_USER",
            Self::Model => "TARGET_MODEL",
            Self::Environment => "TARGET_ENVIRONMENT",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for StepUpdateTarget {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "TARGET_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "TARGET_USER" => Self::User,
            crate::wire::EnumRepr::Name(n) if n == "TARGET_MODEL" => Self::Model,
            crate::wire::EnumRepr::Name(n) if n == "TARGET_ENVIRONMENT" => Self::Environment,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::User,
            crate::wire::EnumRepr::Number(2) => Self::Model,
            crate::wire::EnumRepr::Number(3) => Self::Environment,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.TrajectoryStateUpdate.State`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum TrajectoryStateUpdateState {
    #[default]
    Unspecified,
    Running,
    FullyIdle,
    Cancelled,
    WaitingForTasks,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl TrajectoryStateUpdateState {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "STATE_UNSPECIFIED",
            Self::Running => "STATE_RUNNING",
            Self::FullyIdle => "STATE_FULLY_IDLE",
            Self::Cancelled => "STATE_CANCELLED",
            Self::WaitingForTasks => "STATE_WAITING_FOR_TASKS",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for TrajectoryStateUpdateState {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "STATE_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "STATE_RUNNING" => Self::Running,
            crate::wire::EnumRepr::Name(n) if n == "STATE_FULLY_IDLE" => Self::FullyIdle,
            crate::wire::EnumRepr::Name(n) if n == "STATE_CANCELLED" => Self::Cancelled,
            crate::wire::EnumRepr::Name(n) if n == "STATE_WAITING_FOR_TASKS" => {
                Self::WaitingForTasks
            }
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Running,
            crate::wire::EnumRepr::Number(2) => Self::FullyIdle,
            crate::wire::EnumRepr::Number(3) => Self::Cancelled,
            crate::wire::EnumRepr::Number(4) => Self::WaitingForTasks,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.UrlContextResultContent.UrlContextResult.Status`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum UrlContextResultContentUrlContextResultStatus {
    #[default]
    Unspecified,
    Success,
    Error,
    Paywall,
    Unsafe,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl UrlContextResultContentUrlContextResultStatus {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Unspecified => "STATUS_UNSPECIFIED",
            Self::Success => "SUCCESS",
            Self::Error => "ERROR",
            Self::Paywall => "PAYWALL",
            Self::Unsafe => "UNSAFE",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for UrlContextResultContentUrlContextResultStatus {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "STATUS_UNSPECIFIED" => Self::Unspecified,
            crate::wire::EnumRepr::Name(n) if n == "SUCCESS" => Self::Success,
            crate::wire::EnumRepr::Name(n) if n == "ERROR" => Self::Error,
            crate::wire::EnumRepr::Name(n) if n == "PAYWALL" => Self::Paywall,
            crate::wire::EnumRepr::Name(n) if n == "UNSAFE" => Self::Unsafe,
            crate::wire::EnumRepr::Number(0) => Self::Unspecified,
            crate::wire::EnumRepr::Number(1) => Self::Success,
            crate::wire::EnumRepr::Number(2) => Self::Error,
            crate::wire::EnumRepr::Number(3) => Self::Paywall,
            crate::wire::EnumRepr::Number(4) => Self::Unsafe,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `genai.VideoContent.MimeType`
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum VideoContentMimeType {
    #[default]
    TypeUnspecified,
    TypeMp4,
    TypeMpeg,
    TypeMpg,
    TypeMov,
    TypeAvi,
    TypeXFlv,
    TypeWebm,
    TypeWmv,
    Type3gpp,
    TypeYtBeyond,
    /// A value this crate does not know about yet.
    ///
    /// The harness is versioned independently of this crate, so an
    /// unrecognised enum value is treated as forward compatibility rather
    /// than as a decode error.
    Unknown(String),
}

impl VideoContentMimeType {
    /// The protobuf-JSON spelling of this value.
    pub fn as_str(&self) -> &str {
        match self {
            Self::TypeUnspecified => "TYPE_UNSPECIFIED",
            Self::TypeMp4 => "TYPE_MP4",
            Self::TypeMpeg => "TYPE_MPEG",
            Self::TypeMpg => "TYPE_MPG",
            Self::TypeMov => "TYPE_MOV",
            Self::TypeAvi => "TYPE_AVI",
            Self::TypeXFlv => "TYPE_X_FLV",
            Self::TypeWebm => "TYPE_WEBM",
            Self::TypeWmv => "TYPE_WMV",
            Self::Type3gpp => "TYPE_3GPP",
            Self::TypeYtBeyond => "TYPE_YT_BEYOND",
            Self::Unknown(s) => s,
        }
    }
}

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

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

impl<'de> Deserialize<'de> for VideoContentMimeType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Ok(match crate::wire::EnumRepr::deserialize(d)? {
            crate::wire::EnumRepr::Name(n) if n == "TYPE_UNSPECIFIED" => Self::TypeUnspecified,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MP4" => Self::TypeMp4,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MPEG" => Self::TypeMpeg,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MPG" => Self::TypeMpg,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_MOV" => Self::TypeMov,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_AVI" => Self::TypeAvi,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_X_FLV" => Self::TypeXFlv,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_WEBM" => Self::TypeWebm,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_WMV" => Self::TypeWmv,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_3GPP" => Self::Type3gpp,
            crate::wire::EnumRepr::Name(n) if n == "TYPE_YT_BEYOND" => Self::TypeYtBeyond,
            crate::wire::EnumRepr::Number(0) => Self::TypeUnspecified,
            crate::wire::EnumRepr::Number(1) => Self::TypeMp4,
            crate::wire::EnumRepr::Number(2) => Self::TypeMpeg,
            crate::wire::EnumRepr::Number(3) => Self::TypeMpg,
            crate::wire::EnumRepr::Number(4) => Self::TypeMov,
            crate::wire::EnumRepr::Number(5) => Self::TypeAvi,
            crate::wire::EnumRepr::Number(6) => Self::TypeXFlv,
            crate::wire::EnumRepr::Number(7) => Self::TypeWebm,
            crate::wire::EnumRepr::Number(8) => Self::TypeWmv,
            crate::wire::EnumRepr::Number(9) => Self::Type3gpp,
            crate::wire::EnumRepr::Number(10) => Self::TypeYtBeyond,
            crate::wire::EnumRepr::Name(n) => Self::Unknown(n),
            crate::wire::EnumRepr::Number(n) => Self::Unknown(n.to_string()),
        })
    }
}

/// `antigravity.localharness.ActionCompaction`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionCompaction {}

/// `antigravity.localharness.ActionCreateFile`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionCreateFile {
    #[serde(alias = "file_path", default, skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub contents: Option<String>,
}

/// `antigravity.localharness.ActionCustomTool`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionCustomTool {
    #[serde(alias = "tool_call", default, skip_serializing_if = "Option::is_none")]
    pub tool_call: Option<ToolCall>,
    #[serde(
        alias = "tool_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_response: Option<ToolResponse>,
}

/// `antigravity.localharness.ActionEditFile`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionEditFile {
    #[serde(alias = "file_path", default, skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
    #[serde(alias = "diff_block", default, skip_serializing_if = "Vec::is_empty")]
    pub diff_block: Vec<ActionEditFileDiffBlock>,
}

/// `antigravity.localharness.ActionEditFile.DiffBlock`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionEditFileDiffBlock {
    #[serde(alias = "start_line", default, skip_serializing_if = "Option::is_none")]
    pub start_line: Option<i32>,
    #[serde(alias = "end_line", default, skip_serializing_if = "Option::is_none")]
    pub end_line: Option<i32>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub lines: Vec<ActionEditFileDiffLine>,
}

/// `antigravity.localharness.ActionEditFile.DiffLine`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionEditFileDiffLine {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<ActionEditFileDiffLineLineAction>,
}

/// `antigravity.localharness.ActionError`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionError {
    #[serde(
        alias = "error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub error_message: Option<String>,
    #[serde(alias = "http_code", default, skip_serializing_if = "Option::is_none")]
    pub http_code: Option<u32>,
}

/// `antigravity.localharness.ActionFindFile`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionFindFile {
    #[serde(
        alias = "directory_path",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub directory_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub output: Option<String>,
}

/// `antigravity.localharness.ActionFinish`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionFinish {
    #[serde(
        alias = "output_string",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub output_string: Option<String>,
}

/// `antigravity.localharness.ActionGenerateImage`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionGenerateImage {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub prompt: Option<String>,
    #[serde(alias = "image_paths", default, skip_serializing_if = "Vec::is_empty")]
    pub image_paths: Vec<String>,
    #[serde(alias = "image_name", default, skip_serializing_if = "Option::is_none")]
    pub image_name: Option<String>,
    #[serde(
        alias = "aspect_ratio",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub aspect_ratio: Option<String>,
}

/// `antigravity.localharness.ActionInvokeSubagent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionInvokeSubagent {}

/// `antigravity.localharness.ActionListDirectory`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionListDirectory {
    #[serde(
        alias = "directory_path",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub directory_path: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub results: Vec<ActionListDirectoryResult>,
}

/// `antigravity.localharness.ActionListDirectory.Result`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionListDirectoryResult {
    #[serde(
        alias = "is_directory",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub is_directory: Option<bool>,
    #[serde(
        alias = "file_size",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub file_size: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// The `info` oneof of [`ActionListDirectoryResult`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ActionListDirectoryResultInfo {
    IsDirectory(bool),
    FileSize(u64),
}

impl ActionListDirectoryResult {
    /// Takes the set arm of the `info` oneof, if any.
    pub fn into_info(self) -> Option<ActionListDirectoryResultInfo> {
        if let Some(v) = self.is_directory {
            return Some(ActionListDirectoryResultInfo::IsDirectory(v));
        }
        if let Some(v) = self.file_size {
            return Some(ActionListDirectoryResultInfo::FileSize(v));
        }
        None
    }

    /// True when any arm of the `info` oneof is set.
    pub fn has_info(&self) -> bool {
        self.is_directory.is_some() || self.file_size.is_some()
    }
}

/// `antigravity.localharness.ActionMcpTool`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionMcpTool {
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
    #[serde(alias = "tool_name", default, skip_serializing_if = "Option::is_none")]
    pub tool_name: Option<String>,
    #[serde(
        alias = "arguments_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub arguments_json: Option<String>,
}

/// `antigravity.localharness.ActionReadUrlContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionReadUrlContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
    #[serde(
        alias = "content_path",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub content_path: Option<String>,
}

/// `antigravity.localharness.ActionRunCommand`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionRunCommand {
    #[serde(
        alias = "command_line",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub command_line: Option<String>,
    #[serde(
        alias = "working_dir",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub working_dir: Option<String>,
    #[serde(alias = "exit_code", default, skip_serializing_if = "Option::is_none")]
    pub exit_code: Option<i32>,
    #[serde(
        alias = "combined_output",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub combined_output: Option<String>,
}

/// `antigravity.localharness.ActionSearchDirectory`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionSearchDirectory {
    #[serde(
        alias = "directory_path",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub directory_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    #[serde(
        alias = "num_results",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub num_results: Option<i32>,
}

/// `antigravity.localharness.ActionSearchWeb`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionSearchWeb {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub domain: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
}

/// `antigravity.localharness.ActionViewFile`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionViewFile {
    #[serde(alias = "file_path", default, skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
    #[serde(alias = "start_line", default, skip_serializing_if = "Option::is_none")]
    pub start_line: Option<u32>,
    #[serde(alias = "end_line", default, skip_serializing_if = "Option::is_none")]
    pub end_line: Option<u32>,
}

/// `antigravity.localharness.AppendedSystemInstructions`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppendedSystemInstructions {
    #[serde(
        alias = "custom_identity",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_identity: Option<String>,
    #[serde(
        alias = "appended_sections",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub appended_sections: Vec<AppendedSystemInstructionsSection>,
}

/// `antigravity.localharness.AppendedSystemInstructions.Section`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppendedSystemInstructionsSection {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
}

/// `genai.AudioContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AudioContent {
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub data: Option<Vec<u8>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    #[serde(alias = "mime_type", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<AudioContentMimeType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub channels: Option<i32>,
    #[serde(
        alias = "sample_rate",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub sample_rate: Option<i32>,
}

/// The `data_or_uri` oneof of [`AudioContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum AudioContentDataOrUri {
    Data(Vec<u8>),
    Uri(String),
}

impl AudioContent {
    /// Takes the set arm of the `data_or_uri` oneof, if any.
    pub fn into_data_or_uri(self) -> Option<AudioContentDataOrUri> {
        if let Some(v) = self.data {
            return Some(AudioContentDataOrUri::Data(v));
        }
        if let Some(v) = self.uri {
            return Some(AudioContentDataOrUri::Uri(v));
        }
        None
    }

    /// True when any arm of the `data_or_uri` oneof is set.
    pub fn has_data_or_uri(&self) -> bool {
        self.data.is_some() || self.uri.is_some()
    }
}

/// `antigravity.localharness.CallHookRequest`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CallHookRequest {
    #[serde(
        alias = "pre_turn_args",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub pre_turn_args: Option<PreTurnArgs>,
    #[serde(
        alias = "post_turn_args",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub post_turn_args: Option<PostTurnArgs>,
    #[serde(
        alias = "pre_tool_args",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub pre_tool_args: Option<PreToolArgs>,
    #[serde(
        alias = "post_tool_args",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub post_tool_args: Option<PostToolArgs>,
    #[serde(
        alias = "on_tool_error_args",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub on_tool_error_args: Option<OnToolErrorArgs>,
    #[serde(alias = "request_id", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<LifecycleHook>,
}

/// The `args` oneof of [`CallHookRequest`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum CallHookRequestArgs {
    PreTurnArgs(PreTurnArgs),
    PostTurnArgs(PostTurnArgs),
    PreToolArgs(PreToolArgs),
    PostToolArgs(PostToolArgs),
    OnToolErrorArgs(OnToolErrorArgs),
}

impl CallHookRequest {
    /// Takes the set arm of the `args` oneof, if any.
    pub fn into_args(self) -> Option<CallHookRequestArgs> {
        if let Some(v) = self.pre_turn_args {
            return Some(CallHookRequestArgs::PreTurnArgs(v));
        }
        if let Some(v) = self.post_turn_args {
            return Some(CallHookRequestArgs::PostTurnArgs(v));
        }
        if let Some(v) = self.pre_tool_args {
            return Some(CallHookRequestArgs::PreToolArgs(v));
        }
        if let Some(v) = self.post_tool_args {
            return Some(CallHookRequestArgs::PostToolArgs(v));
        }
        if let Some(v) = self.on_tool_error_args {
            return Some(CallHookRequestArgs::OnToolErrorArgs(v));
        }
        None
    }

    /// True when any arm of the `args` oneof is set.
    pub fn has_args(&self) -> bool {
        self.pre_turn_args.is_some()
            || self.post_turn_args.is_some()
            || self.pre_tool_args.is_some()
            || self.post_tool_args.is_some()
            || self.on_tool_error_args.is_some()
    }
}

/// `antigravity.localharness.CallHookResponse`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CallHookResponse {
    #[serde(
        alias = "pre_turn_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub pre_turn_result: Option<PreTurnResult>,
    #[serde(
        alias = "pre_tool_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub pre_tool_result: Option<PreToolResult>,
    #[serde(
        alias = "empty_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub empty_result: Option<EmptyResult>,
    #[serde(
        alias = "error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub error_message: Option<String>,
    #[serde(
        alias = "on_tool_error_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub on_tool_error_result: Option<OnToolErrorResult>,
    #[serde(alias = "request_id", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
}

/// The `result` oneof of [`CallHookResponse`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum CallHookResponseResult {
    PreTurnResult(PreTurnResult),
    PreToolResult(PreToolResult),
    EmptyResult(EmptyResult),
    ErrorMessage(String),
    OnToolErrorResult(OnToolErrorResult),
}

impl CallHookResponse {
    /// Takes the set arm of the `result` oneof, if any.
    pub fn into_result(self) -> Option<CallHookResponseResult> {
        if let Some(v) = self.pre_turn_result {
            return Some(CallHookResponseResult::PreTurnResult(v));
        }
        if let Some(v) = self.pre_tool_result {
            return Some(CallHookResponseResult::PreToolResult(v));
        }
        if let Some(v) = self.empty_result {
            return Some(CallHookResponseResult::EmptyResult(v));
        }
        if let Some(v) = self.error_message {
            return Some(CallHookResponseResult::ErrorMessage(v));
        }
        if let Some(v) = self.on_tool_error_result {
            return Some(CallHookResponseResult::OnToolErrorResult(v));
        }
        None
    }

    /// True when any arm of the `result` oneof is set.
    pub fn has_result(&self) -> bool {
        self.pre_turn_result.is_some()
            || self.pre_tool_result.is_some()
            || self.empty_result.is_some()
            || self.error_message.is_some()
            || self.on_tool_error_result.is_some()
    }
}

/// `antigravity.localharness.ClientInfo`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(
        alias = "language_version",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub language_version: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub os: Option<String>,
    #[serde(alias = "os_version", default, skip_serializing_if = "Option::is_none")]
    pub os_version: Option<String>,
}

/// `genai.CodeExecutionCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CodeExecutionCallContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<CodeExecutionCallContentCodeExecutionCallArguments>,
}

/// `genai.CodeExecutionCallContent.CodeExecutionCallArguments`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CodeExecutionCallContentCodeExecutionCallArguments {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub language: Option<CodeExecutionCallContentCodeExecutionCallArgumentsLanguage>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
}

/// `genai.CodeExecutionResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CodeExecutionResultContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<String>,
    #[serde(alias = "is_error", default, skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,
}

/// `genai.Content`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Content {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<TextContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<ImageContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub audio: Option<AudioContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub document: Option<DocumentContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub video: Option<VideoContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thought: Option<ThoughtContent>,
    #[serde(alias = "tool_call", default, skip_serializing_if = "Option::is_none")]
    pub tool_call: Option<ToolCallContent>,
    #[serde(
        alias = "tool_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_result: Option<ToolResultContent>,
}

/// The `type` oneof of [`Content`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ContentType {
    Text(TextContent),
    Image(ImageContent),
    Audio(AudioContent),
    Document(DocumentContent),
    Video(VideoContent),
    Thought(ThoughtContent),
    ToolCall(ToolCallContent),
    ToolResult(ToolResultContent),
}

impl Content {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<ContentType> {
        if let Some(v) = self.text {
            return Some(ContentType::Text(v));
        }
        if let Some(v) = self.image {
            return Some(ContentType::Image(v));
        }
        if let Some(v) = self.audio {
            return Some(ContentType::Audio(v));
        }
        if let Some(v) = self.document {
            return Some(ContentType::Document(v));
        }
        if let Some(v) = self.video {
            return Some(ContentType::Video(v));
        }
        if let Some(v) = self.thought {
            return Some(ContentType::Thought(v));
        }
        if let Some(v) = self.tool_call {
            return Some(ContentType::ToolCall(v));
        }
        if let Some(v) = self.tool_result {
            return Some(ContentType::ToolResult(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.text.is_some()
            || self.image.is_some()
            || self.audio.is_some()
            || self.document.is_some()
            || self.video.is_some()
            || self.thought.is_some()
            || self.tool_call.is_some()
            || self.tool_result.is_some()
    }
}

/// `antigravity.localharness.CustomAgent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomAgent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(
        alias = "system_instructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub system_instructions: Option<SystemInstructions>,
    #[serde(
        alias = "harness_side_tools",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub harness_side_tools: Option<HarnessSideTools>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub tools: Vec<Tool>,
}

/// `antigravity.localharness.CustomEndpoint`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomEndpoint {
    #[serde(
        alias = "backend_type",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub backend_type: Option<String>,
    #[serde(
        alias = "config_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub config_json: Option<String>,
}

/// `antigravity.localharness.CustomSystemInstructions`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomSystemInstructions {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub part: Vec<CustomSystemInstructionsPart>,
}

/// `antigravity.localharness.CustomSystemInstructions.Part`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomSystemInstructionsPart {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub template: Option<CustomSystemInstructionsSystemInstructionTemplate>,
}

/// The `part` oneof of [`CustomSystemInstructionsPart`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum CustomSystemInstructionsPartPart {
    Text(String),
    Template(CustomSystemInstructionsSystemInstructionTemplate),
}

impl CustomSystemInstructionsPart {
    /// Takes the set arm of the `part` oneof, if any.
    pub fn into_part(self) -> Option<CustomSystemInstructionsPartPart> {
        if let Some(v) = self.text {
            return Some(CustomSystemInstructionsPartPart::Text(v));
        }
        if let Some(v) = self.template {
            return Some(CustomSystemInstructionsPartPart::Template(v));
        }
        None
    }

    /// True when any arm of the `part` oneof is set.
    pub fn has_part(&self) -> bool {
        self.text.is_some() || self.template.is_some()
    }
}

/// `antigravity.localharness.CustomSystemInstructions.SystemInstructionTemplate`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomSystemInstructionsSystemInstructionTemplate {
    #[serde(
        alias = "template_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub template_name: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub args: Vec<CustomSystemInstructionsSystemInstructionTemplateArg>,
}

/// `antigravity.localharness.CustomSystemInstructions.SystemInstructionTemplate.Arg`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomSystemInstructionsSystemInstructionTemplateArg {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
}

/// `genai.DocumentContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentContent {
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub data: Option<Vec<u8>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    #[serde(alias = "mime_type", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<DocumentContentMimeType>,
}

/// The `data_or_uri` oneof of [`DocumentContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum DocumentContentDataOrUri {
    Data(Vec<u8>),
    Uri(String),
}

impl DocumentContent {
    /// Takes the set arm of the `data_or_uri` oneof, if any.
    pub fn into_data_or_uri(self) -> Option<DocumentContentDataOrUri> {
        if let Some(v) = self.data {
            return Some(DocumentContentDataOrUri::Data(v));
        }
        if let Some(v) = self.uri {
            return Some(DocumentContentDataOrUri::Uri(v));
        }
        None
    }

    /// True when any arm of the `data_or_uri` oneof is set.
    pub fn has_data_or_uri(&self) -> bool {
        self.data.is_some() || self.uri.is_some()
    }
}

/// `antigravity.localharness.EmptyResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EmptyResult {}

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

/// `genai.FileCitation`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileCitation {
    #[serde(
        alias = "document_uri",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub document_uri: Option<String>,
    #[serde(alias = "file_name", default, skip_serializing_if = "Option::is_none")]
    pub file_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    #[serde(
        alias = "custom_metadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_metadata: Option<Struct>,
    #[serde(
        alias = "page_number",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub page_number: Option<i32>,
    #[serde(alias = "media_id", default, skip_serializing_if = "Option::is_none")]
    pub media_id: Option<String>,
}

/// `antigravity.localharness.FileEditToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileEditToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `genai.FileSearchCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileSearchCallContent {}

/// `genai.FileSearchResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileSearchResultContent {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub result: Vec<FileSearchResultContentFileSearchResult>,
}

/// `genai.FileSearchResultContent.FileSearchResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileSearchResultContentFileSearchResult {}

/// `antigravity.localharness.FilesystemWorkspace`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FilesystemWorkspace {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub directory: Option<String>,
}

/// `antigravity.localharness.FindToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FindToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

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

/// `genai.FunctionResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FunctionResultContent {
    #[serde(
        alias = "struct_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub struct_result: Option<Struct>,
    #[serde(
        alias = "content_list",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub content_list: Option<FunctionResultSubcontentList>,
    #[serde(
        alias = "string_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub string_result: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(alias = "is_error", default, skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,
}

/// The `result` oneof of [`FunctionResultContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum FunctionResultContentResult {
    StructResult(Struct),
    ContentList(FunctionResultSubcontentList),
    StringResult(String),
}

impl FunctionResultContent {
    /// Takes the set arm of the `result` oneof, if any.
    pub fn into_result(self) -> Option<FunctionResultContentResult> {
        if let Some(v) = self.struct_result {
            return Some(FunctionResultContentResult::StructResult(v));
        }
        if let Some(v) = self.content_list {
            return Some(FunctionResultContentResult::ContentList(v));
        }
        if let Some(v) = self.string_result {
            return Some(FunctionResultContentResult::StringResult(v));
        }
        None
    }

    /// True when any arm of the `result` oneof is set.
    pub fn has_result(&self) -> bool {
        self.struct_result.is_some() || self.content_list.is_some() || self.string_result.is_some()
    }
}

/// `genai.FunctionResultSubcontent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FunctionResultSubcontent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<TextContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<ImageContent>,
}

/// The `type` oneof of [`FunctionResultSubcontent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum FunctionResultSubcontentType {
    Text(TextContent),
    Image(ImageContent),
}

impl FunctionResultSubcontent {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<FunctionResultSubcontentType> {
        if let Some(v) = self.text {
            return Some(FunctionResultSubcontentType::Text(v));
        }
        if let Some(v) = self.image {
            return Some(FunctionResultSubcontentType::Image(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.text.is_some() || self.image.is_some()
    }
}

/// `genai.FunctionResultSubcontentList`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FunctionResultSubcontentList {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub contents: Vec<FunctionResultSubcontent>,
}

/// `antigravity.localharness.GeminiAPIEndpoint`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GeminiAPIEndpoint {
    #[serde(alias = "base_url", default, skip_serializing_if = "Option::is_none")]
    pub base_url: Option<String>,
    #[serde(
        alias = "http_headers",
        default,
        skip_serializing_if = "HashMap::is_empty"
    )]
    pub http_headers: HashMap<String, String>,
    #[serde(alias = "api_key", default, skip_serializing_if = "Option::is_none")]
    pub api_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<GeminiModelOptions>,
}

/// `antigravity.localharness.GeminiModelOptions`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GeminiModelOptions {
    #[serde(
        alias = "thinking_level",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub thinking_level: Option<String>,
    #[serde(
        alias = "service_tier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
}

/// `antigravity.localharness.GemmaEndpoint`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GemmaEndpoint {
    #[serde(alias = "base_url", default, skip_serializing_if = "Option::is_none")]
    pub base_url: Option<String>,
}

/// `antigravity.localharness.GenerateImageToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GenerateImageToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `genai.GoogleMapsCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleMapsCallContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<GoogleMapsCallContentGoogleMapsCallArguments>,
}

/// `genai.GoogleMapsCallContent.GoogleMapsCallArguments`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleMapsCallContentGoogleMapsCallArguments {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub queries: Vec<String>,
}

/// `genai.GoogleMapsResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleMapsResultContent {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub result: Vec<GoogleMapsResultContentGoogleMapsResult>,
}

/// `genai.GoogleMapsResultContent.GoogleMapsResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleMapsResultContentGoogleMapsResult {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub places: Vec<GoogleMapsResultContentGoogleMapsResultPlaces>,
    #[serde(
        alias = "widget_context_token",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub widget_context_token: Option<String>,
}

/// `genai.GoogleMapsResultContent.GoogleMapsResult.Places`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleMapsResultContentGoogleMapsResultPlaces {
    #[serde(alias = "place_id", default, skip_serializing_if = "Option::is_none")]
    pub place_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(
        alias = "review_snippets",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub review_snippets: Vec<ReviewSnippet>,
}

/// `genai.GoogleSearchCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleSearchCallContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<GoogleSearchCallContentGoogleSearchCallArguments>,
    #[serde(
        alias = "search_type",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub search_type: Option<GoogleSearchSearchType>,
}

/// `genai.GoogleSearchCallContent.GoogleSearchCallArguments`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleSearchCallContentGoogleSearchCallArguments {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub queries: Vec<String>,
}

/// `genai.GoogleSearchResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleSearchResultContent {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub result: Vec<GoogleSearchResultContentGoogleSearchResult>,
    #[serde(alias = "is_error", default, skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,
}

/// `genai.GoogleSearchResultContent.GoogleSearchResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GoogleSearchResultContentGoogleSearchResult {
    #[serde(
        alias = "search_suggestions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub search_suggestions: Option<String>,
}

/// `antigravity.localharness.GrepSearchToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GrepSearchToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.HarnessConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HarnessConfig {
    #[serde(alias = "cascade_id", default, skip_serializing_if = "Option::is_none")]
    pub cascade_id: Option<String>,
    #[serde(
        alias = "session_continuation_mode",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub session_continuation_mode: Option<HarnessConfigSessionContinuationMode>,
    #[serde(
        alias = "system_instructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub system_instructions: Option<SystemInstructions>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub tools: Vec<Tool>,
    #[serde(
        alias = "harness_side_tools",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub harness_side_tools: Option<HarnessSideTools>,
    #[serde(
        alias = "compaction_threshold",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub compaction_threshold: Option<u32>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub workspaces: Vec<Workspace>,
    #[serde(alias = "skills_paths", default, skip_serializing_if = "Vec::is_empty")]
    pub skills_paths: Vec<String>,
    #[serde(
        alias = "finish_tool_schema_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub finish_tool_schema_json: Option<String>,
    #[serde(
        alias = "initial_trajectory",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub initial_trajectory: Option<Vec<u8>>,
    #[serde(
        alias = "app_data_dir",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub app_data_dir: Option<String>,
    #[serde(alias = "mcp_servers", default, skip_serializing_if = "Vec::is_empty")]
    pub mcp_servers: Vec<McpServerConfig>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub models: Vec<ModelConfig>,
    #[serde(
        alias = "enabled_hooks",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub enabled_hooks: Vec<LifecycleHook>,
    #[serde(
        alias = "custom_subagents",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub custom_subagents: Vec<CustomAgent>,
    #[serde(
        alias = "tool_output_truncation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_output_truncation: Option<ToolOutputTruncation>,
    #[serde(
        alias = "retry_config",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub retry_config: Option<RetryConfig>,
    #[serde(
        alias = "policy_config",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub policy_config: Option<PolicyConfig>,
}

/// `antigravity.localharness.HarnessSideTools`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HarnessSideTools {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub find: Option<FindToolConfig>,
    #[serde(
        alias = "run_command",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub run_command: Option<RunCommandToolConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subagents: Option<SubagentsConfig>,
    #[serde(
        alias = "user_questions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub user_questions: Option<UserQuestionsConfig>,
    #[serde(alias = "file_edit", default, skip_serializing_if = "Option::is_none")]
    pub file_edit: Option<FileEditToolConfig>,
    #[serde(alias = "view_file", default, skip_serializing_if = "Option::is_none")]
    pub view_file: Option<ViewFileToolConfig>,
    #[serde(
        alias = "write_to_file",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub write_to_file: Option<WriteToFileToolConfig>,
    #[serde(
        alias = "grep_search",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub grep_search: Option<GrepSearchToolConfig>,
    #[serde(alias = "list_dir", default, skip_serializing_if = "Option::is_none")]
    pub list_dir: Option<ListDirToolConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub permissions: Option<PermissionsConfig>,
    #[serde(
        alias = "generate_image",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub generate_image: Option<GenerateImageToolConfig>,
    #[serde(alias = "search_web", default, skip_serializing_if = "Option::is_none")]
    pub search_web: Option<SearchWebToolConfig>,
    #[serde(
        alias = "read_url_content",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub read_url_content: Option<ReadUrlContentToolConfig>,
    #[serde(
        alias = "tool_search_config",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_search_config: Option<ToolSearchConfig>,
}

/// `genai.ImageContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ImageContent {
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub data: Option<Vec<u8>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    #[serde(alias = "mime_type", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<ImageContentMimeType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolution: Option<MediaResolution>,
}

/// The `data_or_uri` oneof of [`ImageContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ImageContentDataOrUri {
    Data(Vec<u8>),
    Uri(String),
}

impl ImageContent {
    /// Takes the set arm of the `data_or_uri` oneof, if any.
    pub fn into_data_or_uri(self) -> Option<ImageContentDataOrUri> {
        if let Some(v) = self.data {
            return Some(ImageContentDataOrUri::Data(v));
        }
        if let Some(v) = self.uri {
            return Some(ImageContentDataOrUri::Uri(v));
        }
        None
    }

    /// True when any arm of the `data_or_uri` oneof is set.
    pub fn has_data_or_uri(&self) -> bool {
        self.data.is_some() || self.uri.is_some()
    }
}

/// `antigravity.localharness.InitializeConversationEvent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InitializeConversationEvent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<HarnessConfig>,
}

/// `antigravity.localharness.InitializeConversationResponse`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InitializeConversationResponse {
    #[serde(alias = "cascade_id", default, skip_serializing_if = "Option::is_none")]
    pub cascade_id: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub history: Vec<StepUpdate>,
    #[serde(
        alias = "cumulative_usage",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub cumulative_usage: Option<UsageMetadata>,
    #[serde(
        alias = "trajectory_usage",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub trajectory_usage: Vec<TrajectoryUsageEntry>,
}

/// `antigravity.localharness.InputConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InputConfig {
    #[serde(
        alias = "storage_directory",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub storage_directory: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<u32>,
    /// Proto default: `localhost`.
    #[serde(
        alias = "bind_address",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub bind_address: Option<String>,
    #[serde(
        alias = "client_info",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub client_info: Option<ClientInfo>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub env: HashMap<String, String>,
}

/// `antigravity.localharness.InputEvent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InputEvent {
    #[serde(alias = "user_input", default, skip_serializing_if = "Option::is_none")]
    pub user_input: Option<String>,
    #[serde(
        alias = "complex_user_input",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub complex_user_input: Option<UserInput>,
    #[serde(
        alias = "tool_confirmation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_confirmation: Option<ToolConfirmation>,
    #[serde(
        alias = "tool_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_response: Option<ToolResponse>,
    #[serde(
        alias = "question_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub question_response: Option<UserQuestionsResponse>,
    #[serde(
        alias = "halt_request",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub halt_request: Option<bool>,
    #[serde(
        alias = "automated_trigger",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub automated_trigger: Option<String>,
    #[serde(
        alias = "call_hook_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub call_hook_response: Option<CallHookResponse>,
    #[serde(
        alias = "session_end_request",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub session_end_request: Option<bool>,
    #[serde(
        alias = "policy_decision_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub policy_decision_response: Option<PolicyDecisionResponse>,
}

/// The `event` oneof of [`InputEvent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum InputEventEvent {
    UserInput(String),
    ComplexUserInput(UserInput),
    ToolConfirmation(ToolConfirmation),
    ToolResponse(ToolResponse),
    QuestionResponse(UserQuestionsResponse),
    HaltRequest(bool),
    AutomatedTrigger(String),
    CallHookResponse(CallHookResponse),
    SessionEndRequest(bool),
    PolicyDecisionResponse(PolicyDecisionResponse),
}

impl InputEvent {
    /// Takes the set arm of the `event` oneof, if any.
    pub fn into_event(self) -> Option<InputEventEvent> {
        if let Some(v) = self.user_input {
            return Some(InputEventEvent::UserInput(v));
        }
        if let Some(v) = self.complex_user_input {
            return Some(InputEventEvent::ComplexUserInput(v));
        }
        if let Some(v) = self.tool_confirmation {
            return Some(InputEventEvent::ToolConfirmation(v));
        }
        if let Some(v) = self.tool_response {
            return Some(InputEventEvent::ToolResponse(v));
        }
        if let Some(v) = self.question_response {
            return Some(InputEventEvent::QuestionResponse(v));
        }
        if let Some(v) = self.halt_request {
            return Some(InputEventEvent::HaltRequest(v));
        }
        if let Some(v) = self.automated_trigger {
            return Some(InputEventEvent::AutomatedTrigger(v));
        }
        if let Some(v) = self.call_hook_response {
            return Some(InputEventEvent::CallHookResponse(v));
        }
        if let Some(v) = self.session_end_request {
            return Some(InputEventEvent::SessionEndRequest(v));
        }
        if let Some(v) = self.policy_decision_response {
            return Some(InputEventEvent::PolicyDecisionResponse(v));
        }
        None
    }

    /// True when any arm of the `event` oneof is set.
    pub fn has_event(&self) -> bool {
        self.user_input.is_some()
            || self.complex_user_input.is_some()
            || self.tool_confirmation.is_some()
            || self.tool_response.is_some()
            || self.question_response.is_some()
            || self.halt_request.is_some()
            || self.automated_trigger.is_some()
            || self.call_hook_response.is_some()
            || self.session_end_request.is_some()
            || self.policy_decision_response.is_some()
    }
}

/// `antigravity.localharness.ListDirToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListDirToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `genai.ListValue`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListValue {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub values: Vec<Value>,
}

/// `antigravity.localharness.McpHttpTransport`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpHttpTransport {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub headers: HashMap<String, String>,
}

/// `antigravity.localharness.McpServerConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stdio: Option<McpStdioTransport>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub http: Option<McpHttpTransport>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        alias = "enabled_tools",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub enabled_tools: Vec<String>,
    #[serde(
        alias = "disabled_tools",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub disabled_tools: Vec<String>,
    #[serde(
        alias = "auth_provider_type",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub auth_provider_type: Option<McpServerConfigAuthProviderType>,
    #[serde(
        alias = "timeout_seconds",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub timeout_seconds: Option<i32>,
}

/// The `transport` oneof of [`McpServerConfig`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum McpServerConfigTransport {
    Stdio(McpStdioTransport),
    Http(McpHttpTransport),
}

impl McpServerConfig {
    /// Takes the set arm of the `transport` oneof, if any.
    pub fn into_transport(self) -> Option<McpServerConfigTransport> {
        if let Some(v) = self.stdio {
            return Some(McpServerConfigTransport::Stdio(v));
        }
        if let Some(v) = self.http {
            return Some(McpServerConfigTransport::Http(v));
        }
        None
    }

    /// True when any arm of the `transport` oneof is set.
    pub fn has_transport(&self) -> bool {
        self.stdio.is_some() || self.http.is_some()
    }
}

/// `genai.McpServerToolCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerToolCallContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<Struct>,
}

/// `genai.McpServerToolResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerToolResultContent {
    #[serde(
        alias = "struct_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub struct_result: Option<Struct>,
    #[serde(
        alias = "content_list",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub content_list: Option<FunctionResultSubcontentList>,
    #[serde(
        alias = "string_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub string_result: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
}

/// The `result` oneof of [`McpServerToolResultContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum McpServerToolResultContentResult {
    StructResult(Struct),
    ContentList(FunctionResultSubcontentList),
    StringResult(String),
}

impl McpServerToolResultContent {
    /// Takes the set arm of the `result` oneof, if any.
    pub fn into_result(self) -> Option<McpServerToolResultContentResult> {
        if let Some(v) = self.struct_result {
            return Some(McpServerToolResultContentResult::StructResult(v));
        }
        if let Some(v) = self.content_list {
            return Some(McpServerToolResultContentResult::ContentList(v));
        }
        if let Some(v) = self.string_result {
            return Some(McpServerToolResultContentResult::StringResult(v));
        }
        None
    }

    /// True when any arm of the `result` oneof is set.
    pub fn has_result(&self) -> bool {
        self.struct_result.is_some() || self.content_list.is_some() || self.string_result.is_some()
    }
}

/// `antigravity.localharness.McpStdioTransport`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpStdioTransport {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub args: Vec<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub env: HashMap<String, String>,
}

/// `antigravity.localharness.Media`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Media {
    #[serde(alias = "mime_type", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub data: Option<Vec<u8>>,
}

/// `antigravity.localharness.ModelAPIRetryConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelAPIRetryConfig {
    #[serde(
        alias = "max_retries",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub max_retries: Option<u32>,
    #[serde(
        alias = "initial_sleep_duration_ms",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub initial_sleep_duration_ms: Option<u32>,
    #[serde(
        alias = "exponential_multiplier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub exponential_multiplier: Option<f64>,
    #[serde(
        alias = "jitter_range",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub jitter_range: Option<f64>,
}

/// `antigravity.localharness.ModelConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelConfig {
    #[serde(
        alias = "gemini_api_endpoint",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub gemini_api_endpoint: Option<GeminiAPIEndpoint>,
    #[serde(
        alias = "vertex_endpoint",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub vertex_endpoint: Option<VertexEndpoint>,
    #[serde(
        alias = "gemma_endpoint",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub gemma_endpoint: Option<GemmaEndpoint>,
    #[serde(
        alias = "custom_endpoint",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_endpoint: Option<CustomEndpoint>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub types: Vec<ModelType>,
}

/// The `endpoint` oneof of [`ModelConfig`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ModelConfigEndpoint {
    GeminiApiEndpoint(GeminiAPIEndpoint),
    VertexEndpoint(VertexEndpoint),
    GemmaEndpoint(GemmaEndpoint),
    CustomEndpoint(CustomEndpoint),
}

impl ModelConfig {
    /// Takes the set arm of the `endpoint` oneof, if any.
    pub fn into_endpoint(self) -> Option<ModelConfigEndpoint> {
        if let Some(v) = self.gemini_api_endpoint {
            return Some(ModelConfigEndpoint::GeminiApiEndpoint(v));
        }
        if let Some(v) = self.vertex_endpoint {
            return Some(ModelConfigEndpoint::VertexEndpoint(v));
        }
        if let Some(v) = self.gemma_endpoint {
            return Some(ModelConfigEndpoint::GemmaEndpoint(v));
        }
        if let Some(v) = self.custom_endpoint {
            return Some(ModelConfigEndpoint::CustomEndpoint(v));
        }
        None
    }

    /// True when any arm of the `endpoint` oneof is set.
    pub fn has_endpoint(&self) -> bool {
        self.gemini_api_endpoint.is_some()
            || self.vertex_endpoint.is_some()
            || self.gemma_endpoint.is_some()
            || self.custom_endpoint.is_some()
    }
}

/// `antigravity.localharness.ModelOutputRetryConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelOutputRetryConfig {
    #[serde(
        alias = "max_retries",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub max_retries: Option<u32>,
}

/// `antigravity.localharness.MultipleChoice`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MultipleChoice {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub choices: Vec<String>,
    #[serde(
        alias = "is_multi_select",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub is_multi_select: Option<bool>,
}

/// `antigravity.localharness.MultipleChoiceAnswer`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MultipleChoiceAnswer {
    #[serde(
        alias = "selected_choice_indices",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub selected_choice_indices: Vec<i32>,
    #[serde(
        alias = "freeform_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub freeform_response: Option<String>,
}

/// `antigravity.localharness.OnToolErrorArgs`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OnToolErrorArgs {
    #[serde(alias = "tool_name", default, skip_serializing_if = "Option::is_none")]
    pub tool_name: Option<String>,
    #[serde(
        alias = "error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub error_message: Option<String>,
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
    #[serde(alias = "call_id", default, skip_serializing_if = "Option::is_none")]
    pub call_id: Option<String>,
}

/// `antigravity.localharness.OnToolErrorResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OnToolErrorResult {
    #[serde(
        alias = "custom_error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_error_message: Option<String>,
}

/// `antigravity.localharness.OutputConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OutputConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub port: Option<i32>,
    #[serde(alias = "api_key", default, skip_serializing_if = "Option::is_none")]
    pub api_key: Option<String>,
}

/// `antigravity.localharness.OutputEvent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OutputEvent {
    #[serde(
        alias = "step_update",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub step_update: Option<StepUpdate>,
    #[serde(
        alias = "trajectory_state_update",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub trajectory_state_update: Option<TrajectoryStateUpdate>,
    #[serde(alias = "tool_call", default, skip_serializing_if = "Option::is_none")]
    pub tool_call: Option<ToolCall>,
    #[serde(
        alias = "initialize_conversation_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub initialize_conversation_response: Option<InitializeConversationResponse>,
    #[serde(
        alias = "call_hook_request",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub call_hook_request: Option<CallHookRequest>,
    #[serde(
        alias = "session_end_response",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub session_end_response: Option<bool>,
    #[serde(
        alias = "policy_decision_request",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub policy_decision_request: Option<PolicyDecisionRequest>,
    #[serde(
        alias = "usage_update",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub usage_update: Option<UsageUpdate>,
    #[serde(
        alias = "seq_num",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub seq_num: Option<i64>,
    #[serde(
        alias = "timestamp_micros",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub timestamp_micros: Option<i64>,
}

/// The `event` oneof of [`OutputEvent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum OutputEventEvent {
    StepUpdate(StepUpdate),
    TrajectoryStateUpdate(TrajectoryStateUpdate),
    ToolCall(ToolCall),
    InitializeConversationResponse(InitializeConversationResponse),
    CallHookRequest(CallHookRequest),
    SessionEndResponse(bool),
    PolicyDecisionRequest(PolicyDecisionRequest),
    UsageUpdate(UsageUpdate),
}

impl OutputEvent {
    /// Takes the set arm of the `event` oneof, if any.
    pub fn into_event(self) -> Option<OutputEventEvent> {
        if let Some(v) = self.step_update {
            return Some(OutputEventEvent::StepUpdate(v));
        }
        if let Some(v) = self.trajectory_state_update {
            return Some(OutputEventEvent::TrajectoryStateUpdate(v));
        }
        if let Some(v) = self.tool_call {
            return Some(OutputEventEvent::ToolCall(v));
        }
        if let Some(v) = self.initialize_conversation_response {
            return Some(OutputEventEvent::InitializeConversationResponse(v));
        }
        if let Some(v) = self.call_hook_request {
            return Some(OutputEventEvent::CallHookRequest(v));
        }
        if let Some(v) = self.session_end_response {
            return Some(OutputEventEvent::SessionEndResponse(v));
        }
        if let Some(v) = self.policy_decision_request {
            return Some(OutputEventEvent::PolicyDecisionRequest(v));
        }
        if let Some(v) = self.usage_update {
            return Some(OutputEventEvent::UsageUpdate(v));
        }
        None
    }

    /// True when any arm of the `event` oneof is set.
    pub fn has_event(&self) -> bool {
        self.step_update.is_some()
            || self.trajectory_state_update.is_some()
            || self.tool_call.is_some()
            || self.initialize_conversation_response.is_some()
            || self.call_hook_request.is_some()
            || self.session_end_response.is_some()
            || self.policy_decision_request.is_some()
            || self.usage_update.is_some()
    }
}

/// `antigravity.localharness.PermissionsConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PermissionsConfig {
    #[serde(
        alias = "enforce_workspace_validation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub enforce_workspace_validation: Option<bool>,
}

/// `genai.PlaceCitation`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlaceCitation {
    #[serde(alias = "place_id", default, skip_serializing_if = "Option::is_none")]
    pub place_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(
        alias = "review_snippets",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub review_snippets: Vec<ReviewSnippet>,
}

/// `antigravity.localharness.PolicyConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PolicyConfig {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub rules: Vec<PolicyRule>,
}

/// `antigravity.localharness.PolicyDecisionRequest`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PolicyDecisionRequest {
    #[serde(alias = "request_id", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    #[serde(alias = "rule_id", default, skip_serializing_if = "Option::is_none")]
    pub rule_id: Option<String>,
    #[serde(alias = "tool_args", default, skip_serializing_if = "Option::is_none")]
    pub tool_args: Option<PreToolArgs>,
}

/// `antigravity.localharness.PolicyDecisionResponse`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PolicyDecisionResponse {
    #[serde(alias = "request_id", default, skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub outcome: Option<PolicyEvaluationOutcome>,
    #[serde(
        alias = "deny_reason",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub deny_reason: Option<String>,
}

/// `antigravity.localharness.PolicyRule`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PolicyRule {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tool: Option<String>,
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decision: Option<PolicyDecision>,
    #[serde(
        alias = "deny_reason",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub deny_reason: Option<String>,
    #[serde(alias = "is_dynamic", default, skip_serializing_if = "Option::is_none")]
    pub is_dynamic: Option<bool>,
    #[serde(alias = "rule_id", default, skip_serializing_if = "Option::is_none")]
    pub rule_id: Option<String>,
}

/// `antigravity.localharness.PostToolArgs`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PostToolArgs {
    #[serde(alias = "tool_name", default, skip_serializing_if = "Option::is_none")]
    pub tool_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub result: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
    #[serde(alias = "call_id", default, skip_serializing_if = "Option::is_none")]
    pub call_id: Option<String>,
}

/// `antigravity.localharness.PostTurnArgs`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PostTurnArgs {
    #[serde(
        alias = "response_text",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_text: Option<String>,
}

/// `antigravity.localharness.PreToolArgs`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PreToolArgs {
    #[serde(alias = "tool_name", default, skip_serializing_if = "Option::is_none")]
    pub tool_name: Option<String>,
    #[serde(
        alias = "arguments_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub arguments_json: Option<String>,
    #[serde(
        alias = "server_name",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub server_name: Option<String>,
    #[serde(alias = "call_id", default, skip_serializing_if = "Option::is_none")]
    pub call_id: Option<String>,
}

/// `antigravity.localharness.PreToolResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PreToolResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decision: Option<PreToolResultDecision>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(
        alias = "modified_arguments_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub modified_arguments_json: Option<String>,
}

/// `antigravity.localharness.PreTurnArgs`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PreTurnArgs {
    #[serde(alias = "user_input", default, skip_serializing_if = "Option::is_none")]
    pub user_input: Option<UserInput>,
}

/// `antigravity.localharness.PreTurnResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PreTurnResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub decision: Option<PreTurnResultDecision>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// `antigravity.localharness.ReadUrlContentToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReadUrlContentToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.RetryConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RetryConfig {
    #[serde(alias = "api_retry", default, skip_serializing_if = "Option::is_none")]
    pub api_retry: Option<ModelAPIRetryConfig>,
    #[serde(
        alias = "model_output_retry",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub model_output_retry: Option<ModelOutputRetryConfig>,
}

/// `genai.ReviewSnippet`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReviewSnippet {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(alias = "review_id", default, skip_serializing_if = "Option::is_none")]
    pub review_id: Option<String>,
}

/// `antigravity.localharness.RunCommandToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RunCommandToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.SearchWebToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SearchWebToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.StepUpdate`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StepUpdate {
    #[serde(alias = "cascade_id", default, skip_serializing_if = "Option::is_none")]
    pub cascade_id: Option<String>,
    #[serde(
        alias = "trajectory_id",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub trajectory_id: Option<String>,
    #[serde(alias = "step_index", default, skip_serializing_if = "Option::is_none")]
    pub step_index: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub state: Option<StepUpdateState>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<StepUpdateSource>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<StepUpdateTarget>,
    #[serde(
        alias = "error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub error_message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub thinking: Option<String>,
    #[serde(alias = "text_delta", default, skip_serializing_if = "Option::is_none")]
    pub text_delta: Option<String>,
    #[serde(
        alias = "thinking_delta",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub thinking_delta: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(
        alias = "list_directory",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub list_directory: Option<ActionListDirectory>,
    #[serde(alias = "find_file", default, skip_serializing_if = "Option::is_none")]
    pub find_file: Option<ActionFindFile>,
    #[serde(
        alias = "search_directory",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub search_directory: Option<ActionSearchDirectory>,
    #[serde(alias = "view_file", default, skip_serializing_if = "Option::is_none")]
    pub view_file: Option<ActionViewFile>,
    #[serde(
        alias = "create_file",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub create_file: Option<ActionCreateFile>,
    #[serde(alias = "edit_file", default, skip_serializing_if = "Option::is_none")]
    pub edit_file: Option<ActionEditFile>,
    #[serde(
        alias = "run_command",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub run_command: Option<ActionRunCommand>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compaction: Option<ActionCompaction>,
    #[serde(
        alias = "invoke_subagent",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub invoke_subagent: Option<ActionInvokeSubagent>,
    #[serde(
        alias = "generate_image",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub generate_image: Option<ActionGenerateImage>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub finish: Option<ActionFinish>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<ActionError>,
    #[serde(alias = "mcp_tool", default, skip_serializing_if = "Option::is_none")]
    pub mcp_tool: Option<ActionMcpTool>,
    #[serde(alias = "search_web", default, skip_serializing_if = "Option::is_none")]
    pub search_web: Option<ActionSearchWeb>,
    #[serde(
        alias = "read_url_content",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub read_url_content: Option<ActionReadUrlContent>,
    #[serde(
        alias = "custom_tool",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub custom_tool: Option<ActionCustomTool>,
    #[serde(
        alias = "request_text",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub request_text: Option<String>,
    #[serde(
        alias = "tool_confirmation_request",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub tool_confirmation_request: Option<ToolConfirmationRequest>,
    #[serde(
        alias = "questions_request",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub questions_request: Option<UserQuestionsRequest>,
}

/// `genai.Struct`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Struct {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub fields: Vec<Field>,
}

/// `antigravity.localharness.SubagentsConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubagentsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.SystemInstructions`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SystemInstructions {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub custom: Option<CustomSystemInstructions>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub appended: Option<AppendedSystemInstructions>,
}

/// The `type` oneof of [`SystemInstructions`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum SystemInstructionsType {
    Custom(CustomSystemInstructions),
    Appended(AppendedSystemInstructions),
}

impl SystemInstructions {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<SystemInstructionsType> {
        if let Some(v) = self.custom {
            return Some(SystemInstructionsType::Custom(v));
        }
        if let Some(v) = self.appended {
            return Some(SystemInstructionsType::Appended(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.custom.is_some() || self.appended.is_some()
    }
}

/// `genai.TextContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TextContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub annotations: Vec<TextContentAnnotation>,
}

/// `genai.TextContent.Annotation`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TextContentAnnotation {
    #[serde(
        alias = "url_citation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub url_citation: Option<UrlCitation>,
    #[serde(
        alias = "file_citation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub file_citation: Option<FileCitation>,
    #[serde(
        alias = "place_citation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub place_citation: Option<PlaceCitation>,
    #[serde(alias = "word_info", default, skip_serializing_if = "Option::is_none")]
    pub word_info: Option<WordInfo>,
    #[serde(
        alias = "start_index",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub start_index: Option<i32>,
    #[serde(alias = "end_index", default, skip_serializing_if = "Option::is_none")]
    pub end_index: Option<i32>,
}

/// The `type` oneof of [`TextContentAnnotation`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum TextContentAnnotationType {
    UrlCitation(UrlCitation),
    FileCitation(FileCitation),
    PlaceCitation(PlaceCitation),
    WordInfo(WordInfo),
}

impl TextContentAnnotation {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<TextContentAnnotationType> {
        if let Some(v) = self.url_citation {
            return Some(TextContentAnnotationType::UrlCitation(v));
        }
        if let Some(v) = self.file_citation {
            return Some(TextContentAnnotationType::FileCitation(v));
        }
        if let Some(v) = self.place_citation {
            return Some(TextContentAnnotationType::PlaceCitation(v));
        }
        if let Some(v) = self.word_info {
            return Some(TextContentAnnotationType::WordInfo(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.url_citation.is_some()
            || self.file_citation.is_some()
            || self.place_citation.is_some()
            || self.word_info.is_some()
    }
}

/// `genai.ThoughtContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThoughtContent {
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub signature: Option<Vec<u8>>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub summary: Vec<ThoughtSummaryContent>,
}

/// `genai.ThoughtSummaryContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThoughtSummaryContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<TextContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<ImageContent>,
}

/// The `type` oneof of [`ThoughtSummaryContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ThoughtSummaryContentType {
    Text(TextContent),
    Image(ImageContent),
}

impl ThoughtSummaryContent {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<ThoughtSummaryContentType> {
        if let Some(v) = self.text {
            return Some(ThoughtSummaryContentType::Text(v));
        }
        if let Some(v) = self.image {
            return Some(ThoughtSummaryContentType::Image(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.text.is_some() || self.image.is_some()
    }
}

/// `antigravity.localharness.Tool`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Tool {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(
        alias = "parameters_json_schema",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub parameters_json_schema: Option<String>,
    #[serde(
        alias = "response_json_schema",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_json_schema: Option<String>,
    #[serde(
        alias = "defer_loading",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub defer_loading: Option<bool>,
}

/// `antigravity.localharness.ToolCall`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolCall {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(
        alias = "arguments_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub arguments_json: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<Struct>,
}

/// `genai.ToolCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolCallContent {
    #[serde(
        alias = "function_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub function_call: Option<FunctionCallContent>,
    #[serde(
        alias = "code_execution_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub code_execution_call: Option<CodeExecutionCallContent>,
    #[serde(
        alias = "url_context_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub url_context_call: Option<UrlContextCallContent>,
    #[serde(
        alias = "mcp_server_tool_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub mcp_server_tool_call: Option<McpServerToolCallContent>,
    #[serde(
        alias = "google_search_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub google_search_call: Option<GoogleSearchCallContent>,
    #[serde(
        alias = "file_search_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub file_search_call: Option<FileSearchCallContent>,
    #[serde(
        alias = "google_maps_call",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub google_maps_call: Option<GoogleMapsCallContent>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub signature: Option<Vec<u8>>,
}

/// The `type` oneof of [`ToolCallContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ToolCallContentType {
    FunctionCall(FunctionCallContent),
    CodeExecutionCall(CodeExecutionCallContent),
    UrlContextCall(UrlContextCallContent),
    McpServerToolCall(McpServerToolCallContent),
    GoogleSearchCall(GoogleSearchCallContent),
    FileSearchCall(FileSearchCallContent),
    GoogleMapsCall(GoogleMapsCallContent),
}

impl ToolCallContent {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<ToolCallContentType> {
        if let Some(v) = self.function_call {
            return Some(ToolCallContentType::FunctionCall(v));
        }
        if let Some(v) = self.code_execution_call {
            return Some(ToolCallContentType::CodeExecutionCall(v));
        }
        if let Some(v) = self.url_context_call {
            return Some(ToolCallContentType::UrlContextCall(v));
        }
        if let Some(v) = self.mcp_server_tool_call {
            return Some(ToolCallContentType::McpServerToolCall(v));
        }
        if let Some(v) = self.google_search_call {
            return Some(ToolCallContentType::GoogleSearchCall(v));
        }
        if let Some(v) = self.file_search_call {
            return Some(ToolCallContentType::FileSearchCall(v));
        }
        if let Some(v) = self.google_maps_call {
            return Some(ToolCallContentType::GoogleMapsCall(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.function_call.is_some()
            || self.code_execution_call.is_some()
            || self.url_context_call.is_some()
            || self.mcp_server_tool_call.is_some()
            || self.google_search_call.is_some()
            || self.file_search_call.is_some()
            || self.google_maps_call.is_some()
    }
}

/// `antigravity.localharness.ToolConfirmation`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolConfirmation {
    #[serde(
        alias = "trajectory_id",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub trajectory_id: Option<String>,
    #[serde(alias = "step_index", default, skip_serializing_if = "Option::is_none")]
    pub step_index: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accepted: Option<bool>,
}

/// `antigravity.localharness.ToolConfirmationRequest`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolConfirmationRequest {}

/// `antigravity.localharness.ToolOutputTruncation`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolOutputTruncation {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub truncate: Option<ToolOutputTruncationTruncateStrategy>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<ToolOutputTruncationErrorStrategy>,
}

/// The `strategy` oneof of [`ToolOutputTruncation`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ToolOutputTruncationStrategy {
    Truncate(ToolOutputTruncationTruncateStrategy),
    Error(ToolOutputTruncationErrorStrategy),
}

impl ToolOutputTruncation {
    /// Takes the set arm of the `strategy` oneof, if any.
    pub fn into_strategy(self) -> Option<ToolOutputTruncationStrategy> {
        if let Some(v) = self.truncate {
            return Some(ToolOutputTruncationStrategy::Truncate(v));
        }
        if let Some(v) = self.error {
            return Some(ToolOutputTruncationStrategy::Error(v));
        }
        None
    }

    /// True when any arm of the `strategy` oneof is set.
    pub fn has_strategy(&self) -> bool {
        self.truncate.is_some() || self.error.is_some()
    }
}

/// `antigravity.localharness.ToolOutputTruncation.ErrorStrategy`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolOutputTruncationErrorStrategy {
    #[serde(alias = "max_tokens", default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i32>,
    #[serde(
        alias = "error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub error_message: Option<String>,
}

/// `antigravity.localharness.ToolOutputTruncation.TruncateStrategy`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolOutputTruncationTruncateStrategy {
    #[serde(alias = "max_tokens", default, skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i32>,
}

/// `antigravity.localharness.ToolResponse`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(
        alias = "response_json",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub response_json: Option<String>,
    #[serde(
        alias = "supplemental_media",
        default,
        skip_serializing_if = "Vec::is_empty"
    )]
    pub supplemental_media: Vec<Media>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: Option<Struct>,
    #[serde(
        alias = "error_message",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub error_message: Option<String>,
}

/// `genai.ToolResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolResultContent {
    #[serde(
        alias = "function_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub function_result: Option<FunctionResultContent>,
    #[serde(
        alias = "code_execution_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub code_execution_result: Option<CodeExecutionResultContent>,
    #[serde(
        alias = "url_context_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub url_context_result: Option<UrlContextResultContent>,
    #[serde(
        alias = "google_search_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub google_search_result: Option<GoogleSearchResultContent>,
    #[serde(
        alias = "mcp_server_tool_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub mcp_server_tool_result: Option<McpServerToolResultContent>,
    #[serde(
        alias = "file_search_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub file_search_result: Option<FileSearchResultContent>,
    #[serde(
        alias = "google_maps_result",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub google_maps_result: Option<GoogleMapsResultContent>,
    #[serde(alias = "call_id", default, skip_serializing_if = "Option::is_none")]
    pub call_id: Option<String>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub signature: Option<Vec<u8>>,
}

/// The `type` oneof of [`ToolResultContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ToolResultContentType {
    FunctionResult(FunctionResultContent),
    CodeExecutionResult(CodeExecutionResultContent),
    UrlContextResult(UrlContextResultContent),
    GoogleSearchResult(GoogleSearchResultContent),
    McpServerToolResult(McpServerToolResultContent),
    FileSearchResult(FileSearchResultContent),
    GoogleMapsResult(GoogleMapsResultContent),
}

impl ToolResultContent {
    /// Takes the set arm of the `type` oneof, if any.
    pub fn into_type(self) -> Option<ToolResultContentType> {
        if let Some(v) = self.function_result {
            return Some(ToolResultContentType::FunctionResult(v));
        }
        if let Some(v) = self.code_execution_result {
            return Some(ToolResultContentType::CodeExecutionResult(v));
        }
        if let Some(v) = self.url_context_result {
            return Some(ToolResultContentType::UrlContextResult(v));
        }
        if let Some(v) = self.google_search_result {
            return Some(ToolResultContentType::GoogleSearchResult(v));
        }
        if let Some(v) = self.mcp_server_tool_result {
            return Some(ToolResultContentType::McpServerToolResult(v));
        }
        if let Some(v) = self.file_search_result {
            return Some(ToolResultContentType::FileSearchResult(v));
        }
        if let Some(v) = self.google_maps_result {
            return Some(ToolResultContentType::GoogleMapsResult(v));
        }
        None
    }

    /// True when any arm of the `type` oneof is set.
    pub fn has_type(&self) -> bool {
        self.function_result.is_some()
            || self.code_execution_result.is_some()
            || self.url_context_result.is_some()
            || self.google_search_result.is_some()
            || self.mcp_server_tool_result.is_some()
            || self.file_search_result.is_some()
            || self.google_maps_result.is_some()
    }
}

/// `antigravity.localharness.ToolSearchConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolSearchConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.TrajectoryStateUpdate`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TrajectoryStateUpdate {
    #[serde(
        alias = "trajectory_id",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub trajectory_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub state: Option<TrajectoryStateUpdateState>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}

/// `antigravity.localharness.TrajectoryUsageEntry`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TrajectoryUsageEntry {
    #[serde(
        alias = "trajectory_id",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub trajectory_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usage: Option<UsageMetadata>,
}

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

/// `genai.UrlContextCallContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UrlContextCallContent {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<UrlContextCallContentUrlContextCallArguments>,
}

/// `genai.UrlContextCallContent.UrlContextCallArguments`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UrlContextCallContentUrlContextCallArguments {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub urls: Vec<String>,
}

/// `genai.UrlContextResultContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UrlContextResultContent {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub result: Vec<UrlContextResultContentUrlContextResult>,
    #[serde(alias = "is_error", default, skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,
}

/// `genai.UrlContextResultContent.UrlContextResult`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UrlContextResultContentUrlContextResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<UrlContextResultContentUrlContextResultStatus>,
}

/// `antigravity.localharness.UsageMetadata`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsageMetadata {
    #[serde(
        alias = "prompt_token_count",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub prompt_token_count: Option<u64>,
    #[serde(
        alias = "cached_content_token_count",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub cached_content_token_count: Option<u64>,
    #[serde(
        alias = "candidates_token_count",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub candidates_token_count: Option<u64>,
    #[serde(
        alias = "thoughts_token_count",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub thoughts_token_count: Option<u64>,
    #[serde(
        alias = "total_token_count",
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_int"
    )]
    pub total_token_count: Option<u64>,
    #[serde(
        alias = "service_tier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
}

/// `antigravity.localharness.UsageUpdate`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsageUpdate {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub agents: Vec<TrajectoryUsageEntry>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<UsageMetadata>,
}

/// `antigravity.localharness.UserInput`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserInput {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub parts: Vec<UserInputPart>,
}

/// `antigravity.localharness.UserInput.Media`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserInputMedia {
    #[serde(alias = "mime_type", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub data: Option<Vec<u8>>,
}

/// `antigravity.localharness.UserInput.Part`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserInputPart {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub media: Option<UserInputMedia>,
    #[serde(
        alias = "slash_command",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub slash_command: Option<UserInputSlashCommand>,
}

/// The `part` oneof of [`UserInputPart`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum UserInputPartPart {
    Text(String),
    Media(UserInputMedia),
    SlashCommand(UserInputSlashCommand),
}

impl UserInputPart {
    /// Takes the set arm of the `part` oneof, if any.
    pub fn into_part(self) -> Option<UserInputPartPart> {
        if let Some(v) = self.text {
            return Some(UserInputPartPart::Text(v));
        }
        if let Some(v) = self.media {
            return Some(UserInputPartPart::Media(v));
        }
        if let Some(v) = self.slash_command {
            return Some(UserInputPartPart::SlashCommand(v));
        }
        None
    }

    /// True when any arm of the `part` oneof is set.
    pub fn has_part(&self) -> bool {
        self.text.is_some() || self.media.is_some() || self.slash_command.is_some()
    }
}

/// `antigravity.localharness.UserInput.SlashCommand`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserInputSlashCommand {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// `antigravity.localharness.UserQuestion`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserQuestion {
    #[serde(
        alias = "multiple_choice",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub multiple_choice: Option<MultipleChoice>,
}

/// The `question_type` oneof of [`UserQuestion`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum UserQuestionQuestionType {
    MultipleChoice(MultipleChoice),
}

impl UserQuestion {
    /// Takes the set arm of the `question_type` oneof, if any.
    pub fn into_question_type(self) -> Option<UserQuestionQuestionType> {
        if let Some(v) = self.multiple_choice {
            return Some(UserQuestionQuestionType::MultipleChoice(v));
        }
        None
    }

    /// True when any arm of the `question_type` oneof is set.
    pub fn has_question_type(&self) -> bool {
        self.multiple_choice.is_some()
    }
}

/// `antigravity.localharness.UserQuestionAnswer`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserQuestionAnswer {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub unanswered: Option<bool>,
    #[serde(
        alias = "multiple_choice_answer",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub multiple_choice_answer: Option<MultipleChoiceAnswer>,
}

/// The `answer` oneof of [`UserQuestionAnswer`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum UserQuestionAnswerAnswer {
    Unanswered(bool),
    MultipleChoiceAnswer(MultipleChoiceAnswer),
}

impl UserQuestionAnswer {
    /// Takes the set arm of the `answer` oneof, if any.
    pub fn into_answer(self) -> Option<UserQuestionAnswerAnswer> {
        if let Some(v) = self.unanswered {
            return Some(UserQuestionAnswerAnswer::Unanswered(v));
        }
        if let Some(v) = self.multiple_choice_answer {
            return Some(UserQuestionAnswerAnswer::MultipleChoiceAnswer(v));
        }
        None
    }

    /// True when any arm of the `answer` oneof is set.
    pub fn has_answer(&self) -> bool {
        self.unanswered.is_some() || self.multiple_choice_answer.is_some()
    }
}

/// `antigravity.localharness.UserQuestionsConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserQuestionsConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `antigravity.localharness.UserQuestionsRequest`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserQuestionsRequest {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub questions: Vec<UserQuestion>,
}

/// `antigravity.localharness.UserQuestionsResponse`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserQuestionsResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cancelled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub response: Option<UserQuestionsResponseQuestionsResponse>,
    #[serde(
        alias = "trajectory_id",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub trajectory_id: Option<String>,
    #[serde(alias = "step_index", default, skip_serializing_if = "Option::is_none")]
    pub step_index: Option<u32>,
}

/// The `result` oneof of [`UserQuestionsResponse`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum UserQuestionsResponseResult {
    Cancelled(bool),
    Response(UserQuestionsResponseQuestionsResponse),
}

impl UserQuestionsResponse {
    /// Takes the set arm of the `result` oneof, if any.
    pub fn into_result(self) -> Option<UserQuestionsResponseResult> {
        if let Some(v) = self.cancelled {
            return Some(UserQuestionsResponseResult::Cancelled(v));
        }
        if let Some(v) = self.response {
            return Some(UserQuestionsResponseResult::Response(v));
        }
        None
    }

    /// True when any arm of the `result` oneof is set.
    pub fn has_result(&self) -> bool {
        self.cancelled.is_some() || self.response.is_some()
    }
}

/// `antigravity.localharness.UserQuestionsResponse.QuestionsResponse`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UserQuestionsResponseQuestionsResponse {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub answers: Vec<UserQuestionAnswer>,
}

/// `genai.Value`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Value {
    #[serde(alias = "null_value", default, skip_serializing_if = "Option::is_none")]
    pub null_value: Option<NullValue>,
    #[serde(
        alias = "number_value",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub number_value: Option<f64>,
    #[serde(
        alias = "string_value",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub string_value: Option<String>,
    #[serde(alias = "bool_value", default, skip_serializing_if = "Option::is_none")]
    pub bool_value: Option<bool>,
    #[serde(
        alias = "struct_value",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub struct_value: Option<Struct>,
    #[serde(alias = "list_value", default, skip_serializing_if = "Option::is_none")]
    pub list_value: Option<ListValue>,
    #[serde(
        alias = "content_value",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub content_value: Option<Content>,
}

/// The `kind` oneof of [`Value`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum ValueKind {
    NullValue(NullValue),
    NumberValue(f64),
    StringValue(String),
    BoolValue(bool),
    StructValue(Struct),
    ListValue(ListValue),
    ContentValue(Content),
}

impl Value {
    /// Takes the set arm of the `kind` oneof, if any.
    pub fn into_kind(self) -> Option<ValueKind> {
        if let Some(v) = self.null_value {
            return Some(ValueKind::NullValue(v));
        }
        if let Some(v) = self.number_value {
            return Some(ValueKind::NumberValue(v));
        }
        if let Some(v) = self.string_value {
            return Some(ValueKind::StringValue(v));
        }
        if let Some(v) = self.bool_value {
            return Some(ValueKind::BoolValue(v));
        }
        if let Some(v) = self.struct_value {
            return Some(ValueKind::StructValue(v));
        }
        if let Some(v) = self.list_value {
            return Some(ValueKind::ListValue(v));
        }
        if let Some(v) = self.content_value {
            return Some(ValueKind::ContentValue(v));
        }
        None
    }

    /// True when any arm of the `kind` oneof is set.
    pub fn has_kind(&self) -> bool {
        self.null_value.is_some()
            || self.number_value.is_some()
            || self.string_value.is_some()
            || self.bool_value.is_some()
            || self.struct_value.is_some()
            || self.list_value.is_some()
            || self.content_value.is_some()
    }
}

/// `antigravity.localharness.VertexEndpoint`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VertexEndpoint {
    #[serde(alias = "base_url", default, skip_serializing_if = "Option::is_none")]
    pub base_url: Option<String>,
    #[serde(
        alias = "http_headers",
        default,
        skip_serializing_if = "HashMap::is_empty"
    )]
    pub http_headers: HashMap<String, String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub project: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<GeminiModelOptions>,
}

/// `genai.VideoContent`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VideoContent {
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        with = "crate::wire::opt_bytes"
    )]
    pub data: Option<Vec<u8>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    #[serde(alias = "mime_type", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<VideoContentMimeType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resolution: Option<MediaResolution>,
}

/// The `data_or_uri` oneof of [`VideoContent`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum VideoContentDataOrUri {
    Data(Vec<u8>),
    Uri(String),
}

impl VideoContent {
    /// Takes the set arm of the `data_or_uri` oneof, if any.
    pub fn into_data_or_uri(self) -> Option<VideoContentDataOrUri> {
        if let Some(v) = self.data {
            return Some(VideoContentDataOrUri::Data(v));
        }
        if let Some(v) = self.uri {
            return Some(VideoContentDataOrUri::Uri(v));
        }
        None
    }

    /// True when any arm of the `data_or_uri` oneof is set.
    pub fn has_data_or_uri(&self) -> bool {
        self.data.is_some() || self.uri.is_some()
    }
}

/// `antigravity.localharness.ViewFileToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ViewFileToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// `genai.WordInfo`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WordInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    #[serde(
        alias = "start_offset",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub start_offset: Option<String>,
    #[serde(alias = "end_offset", default, skip_serializing_if = "Option::is_none")]
    pub end_offset: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub speaker: Option<String>,
}

/// `antigravity.localharness.Workspace`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Workspace {
    #[serde(
        alias = "filesystem_workspace",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub filesystem_workspace: Option<FilesystemWorkspace>,
}

/// The `workspace_type` oneof of [`Workspace`], as an owned value.
#[derive(Debug, Clone, PartialEq)]
pub enum WorkspaceWorkspaceType {
    FilesystemWorkspace(FilesystemWorkspace),
}

impl Workspace {
    /// Takes the set arm of the `workspace_type` oneof, if any.
    pub fn into_workspace_type(self) -> Option<WorkspaceWorkspaceType> {
        if let Some(v) = self.filesystem_workspace {
            return Some(WorkspaceWorkspaceType::FilesystemWorkspace(v));
        }
        None
    }

    /// True when any arm of the `workspace_type` oneof is set.
    pub fn has_workspace_type(&self) -> bool {
        self.filesystem_workspace.is_some()
    }
}

/// `antigravity.localharness.WriteToFileToolConfig`
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WriteToFileToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}