codex-codes 0.129.3

// AUTO-GENERATED by scripts/codegen_protocol.py — DO NOT EDIT BY HAND.
// Run `python3 scripts/codegen_protocol.py` to regenerate.
//
// Every wire type reachable from a method in the upstream codex
// app-server schema bundle is emitted here as a Rust struct or enum.
// Cross-references resolve to other types in this module.

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

use serde::{Deserialize, Serialize};
use serde_json::Value;

/// A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).
///
/// IMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.
#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq, Hash)]
#[serde(transparent)]
pub struct AbsolutePathBuf(pub String);

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum Account {
    #[serde(rename = "apiKey")]
    ApiKey,
    Chatgpt {
        email: String,
        #[serde(rename = "planType")]
        plan_type: PlanType,
    },
    #[serde(rename = "amazonBedrock")]
    AmazonBedrock,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AccountLoginCompletedNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(rename = "loginId", default, skip_serializing_if = "Option::is_none")]
    pub login_id: Option<String>,
    #[serde(default)]
    pub success: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AccountRateLimitsUpdatedNotification {
    #[serde(rename = "rateLimits")]
    pub rate_limits: RateLimitSnapshot,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AccountUpdatedNotification {
    #[serde(rename = "authMode", default, skip_serializing_if = "Option::is_none")]
    pub auth_mode: Option<AuthMode>,
    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
    pub plan_type: Option<PlanType>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum AddCreditsNudgeCreditType {
    #[serde(rename = "credits")]
    Credits,
    #[serde(rename = "usage_limit")]
    Usage_limit,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum AddCreditsNudgeEmailStatus {
    #[serde(rename = "sent")]
    Sent,
    #[serde(rename = "cooldown_active")]
    Cooldown_active,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalFileSystemPermissions {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<FileSystemSandboxEntry>>,
    #[serde(
        rename = "globScanMaxDepth",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub glob_scan_max_depth: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub read: Option<Vec<AbsolutePathBuf>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub write: Option<Vec<AbsolutePathBuf>>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AgentMessageDeltaNotification {
    #[serde(default)]
    pub delta: String,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

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

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppBranding {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub developer: Option<String>,
    #[serde(rename = "isDiscoverableApp", default)]
    pub is_discoverable_app: bool,
    #[serde(
        rename = "privacyPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub privacy_policy: Option<String>,
    #[serde(
        rename = "termsOfService",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub terms_of_service: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppInfo {
    #[serde(
        rename = "appMetadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub app_metadata: Option<AppMetadata>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branding: Option<AppBranding>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(
        rename = "distributionChannel",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub distribution_channel: Option<String>,
    #[serde(default)]
    pub id: String,
    #[serde(
        rename = "installUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub install_url: Option<String>,
    #[serde(
        rename = "isAccessible",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub is_accessible: Option<bool>,
    #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
    pub is_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub labels: Option<std::collections::BTreeMap<String, String>>,
    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    #[serde(
        rename = "logoUrlDark",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub logo_url_dark: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde(
        rename = "pluginDisplayNames",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub plugin_display_names: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppListUpdatedNotification {
    #[serde(default)]
    pub data: Vec<AppInfo>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppMetadata {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub categories: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub developer: Option<String>,
    #[serde(
        rename = "firstPartyRequiresInstall",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub first_party_requires_install: Option<bool>,
    #[serde(
        rename = "firstPartyType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub first_party_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub review: Option<AppReview>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub screenshots: Option<Vec<AppScreenshot>>,
    #[serde(
        rename = "seoDescription",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub seo_description: Option<String>,
    #[serde(
        rename = "showInComposerWhenUnlinked",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub show_in_composer_when_unlinked: Option<bool>,
    #[serde(
        rename = "subCategories",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub sub_categories: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "versionId", default, skip_serializing_if = "Option::is_none")]
    pub version_id: Option<String>,
    #[serde(
        rename = "versionNotes",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub version_notes: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppReview {
    #[serde(default)]
    pub status: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppScreenshot {
    #[serde(rename = "fileId", default, skip_serializing_if = "Option::is_none")]
    pub file_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(rename = "userPrompt", default)]
    pub user_prompt: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppSummary {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default)]
    pub id: String,
    #[serde(
        rename = "installUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub install_url: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde(rename = "needsAuth", default)]
    pub needs_auth: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplyPatchApprovalParams {
    #[serde(rename = "callId", default)]
    pub call_id: String,
    #[serde(rename = "conversationId")]
    pub conversation_id: ThreadId,
    #[serde(rename = "fileChanges", default)]
    pub file_changes: std::collections::BTreeMap<String, FileChange>,
    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
    pub grant_root: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplyPatchApprovalResponse {
    #[serde()]
    pub decision: ReviewDecision,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ApprovalsReviewer {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "auto_review")]
    Auto_review,
    #[serde(rename = "guardian_subagent")]
    Guardian_subagent,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppsListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(
        rename = "forceRefetch",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub force_refetch: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppsListResponse {
    #[serde(default)]
    pub data: Vec<AppInfo>,
    #[serde(
        rename = "nextCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum AskForApproval {
    #[serde(rename = "untrusted")]
    Untrusted,
    #[serde(rename = "on-failure")]
    OnFailure,
    #[serde(rename = "on-request")]
    OnRequest,
    #[serde(rename = "never")]
    Never,
    #[serde(rename = "granular")]
    Granular {
        mcp_elicitations: bool,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        request_permissions: Option<bool>,
        rules: bool,
        sandbox_approval: bool,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        skill_approval: Option<bool>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AttestationGenerateParams {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AttestationGenerateResponse {
    #[serde(default)]
    pub token: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum AuthMode {
    #[serde(rename = "apikey")]
    Apikey,
    #[serde(rename = "chatgpt")]
    Chatgpt,
    #[serde(rename = "chatgptAuthTokens")]
    ChatgptAuthTokens,
    #[serde(rename = "agentIdentity")]
    AgentIdentity,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum AutoReviewDecisionSource {
    #[serde(rename = "agent")]
    Agent,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ByteRange {
    #[serde(default)]
    pub end: i64,
    #[serde(default)]
    pub start: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelLoginAccountParams {
    #[serde(rename = "loginId", default)]
    pub login_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CancelLoginAccountResponse {
    #[serde()]
    pub status: CancelLoginAccountStatus,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum CancelLoginAccountStatus {
    #[serde(rename = "canceled")]
    Canceled,
    #[serde(rename = "notFound")]
    NotFound,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ChatgptAuthTokensRefreshParams {
    #[serde(
        rename = "previousAccountId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub previous_account_id: Option<String>,
    #[serde()]
    pub reason: ChatgptAuthTokensRefreshReason,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum ChatgptAuthTokensRefreshReason {
    #[serde(rename = "unauthorized")]
    Unauthorized,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ChatgptAuthTokensRefreshResponse {
    #[serde(rename = "accessToken", default)]
    pub access_token: String,
    #[serde(rename = "chatgptAccountId", default)]
    pub chatgpt_account_id: String,
    #[serde(
        rename = "chatgptPlanType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub chatgpt_plan_type: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientInfo {
    #[serde(default)]
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default)]
    pub version: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum CodexErrorInfo {
    #[serde(rename = "contextWindowExceeded")]
    ContextWindowExceeded,
    #[serde(rename = "usageLimitExceeded")]
    UsageLimitExceeded,
    #[serde(rename = "serverOverloaded")]
    ServerOverloaded,
    #[serde(rename = "cyberPolicy")]
    CyberPolicy,
    #[serde(rename = "internalServerError")]
    InternalServerError,
    #[serde(rename = "unauthorized")]
    Unauthorized,
    #[serde(rename = "badRequest")]
    BadRequest,
    #[serde(rename = "threadRollbackFailed")]
    ThreadRollbackFailed,
    #[serde(rename = "sandboxError")]
    SandboxError,
    #[serde(rename = "other")]
    Other,
    #[serde(rename = "httpConnectionFailed")]
    HttpConnectionFailed {
        #[serde(
            rename = "httpStatusCode",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        http_status_code: Option<i64>,
    },
    #[serde(rename = "responseStreamConnectionFailed")]
    ResponseStreamConnectionFailed {
        #[serde(
            rename = "httpStatusCode",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        http_status_code: Option<i64>,
    },
    #[serde(rename = "responseStreamDisconnected")]
    ResponseStreamDisconnected {
        #[serde(
            rename = "httpStatusCode",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        http_status_code: Option<i64>,
    },
    #[serde(rename = "responseTooManyFailedAttempts")]
    ResponseTooManyFailedAttempts {
        #[serde(
            rename = "httpStatusCode",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        http_status_code: Option<i64>,
    },
    #[serde(rename = "activeTurnNotSteerable")]
    ActiveTurnNotSteerable {
        #[serde(rename = "turnKind")]
        turn_kind: NonSteerableTurnKind,
    },
}

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

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum CollabAgentStatus {
    #[serde(rename = "pendingInit")]
    PendingInit,
    #[serde(rename = "running")]
    Running,
    #[serde(rename = "interrupted")]
    Interrupted,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "errored")]
    Errored,
    #[serde(rename = "shutdown")]
    Shutdown,
    #[serde(rename = "notFound")]
    NotFound,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum CollabAgentTool {
    #[serde(rename = "spawnAgent")]
    SpawnAgent,
    #[serde(rename = "sendInput")]
    SendInput,
    #[serde(rename = "resumeAgent")]
    ResumeAgent,
    #[serde(rename = "wait")]
    Wait,
    #[serde(rename = "closeAgent")]
    CloseAgent,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum CollabAgentToolCallStatus {
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum CommandAction {
    Read {
        command: String,
        name: String,
        path: AbsolutePathBuf,
    },
    #[serde(rename = "listFiles")]
    ListFiles {
        command: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        path: Option<String>,
    },
    Search {
        command: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        path: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        query: Option<String>,
    },
    Unknown {
        command: String,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecOutputDeltaNotification {
    #[serde(rename = "capReached", default)]
    pub cap_reached: bool,
    #[serde(rename = "deltaBase64", default)]
    pub delta_base64: String,
    #[serde(rename = "processId", default)]
    pub process_id: String,
    #[serde(default)]
    pub stream: Value,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum CommandExecOutputStream {
    #[serde(rename = "stdout")]
    Stdout,
    #[serde(rename = "stderr")]
    Stderr,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecParams {
    #[serde(default)]
    pub command: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(
        rename = "disableOutputCap",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub disable_output_cap: Option<bool>,
    #[serde(
        rename = "disableTimeout",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub disable_timeout: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub env: Option<std::collections::BTreeMap<String, Option<String>>>,
    #[serde(
        rename = "outputBytesCap",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub output_bytes_cap: Option<i64>,
    #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
    pub process_id: Option<String>,
    #[serde(
        rename = "sandboxPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub sandbox_policy: Option<SandboxPolicy>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<CommandExecTerminalSize>,
    #[serde(
        rename = "streamStdin",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub stream_stdin: Option<bool>,
    #[serde(
        rename = "streamStdoutStderr",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub stream_stdout_stderr: Option<bool>,
    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tty: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecResizeParams {
    #[serde(rename = "processId", default)]
    pub process_id: String,
    #[serde(default)]
    pub size: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecResizeResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecResponse {
    #[serde(rename = "exitCode", default)]
    pub exit_code: i64,
    #[serde(default)]
    pub stderr: String,
    #[serde(default)]
    pub stdout: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecTerminalSize {
    #[serde(default)]
    pub cols: i64,
    #[serde(default)]
    pub rows: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecTerminateParams {
    #[serde(rename = "processId", default)]
    pub process_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecTerminateResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecWriteParams {
    #[serde(
        rename = "closeStdin",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub close_stdin: Option<bool>,
    #[serde(
        rename = "deltaBase64",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub delta_base64: Option<String>,
    #[serde(rename = "processId", default)]
    pub process_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecWriteResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum CommandExecutionApprovalDecision {
    #[serde(rename = "accept")]
    Accept,
    #[serde(rename = "acceptForSession")]
    AcceptForSession,
    #[serde(rename = "acceptWithExecpolicyAmendment")]
    AcceptWithExecpolicyAmendment { execpolicy_amendment: Vec<String> },
    #[serde(rename = "applyNetworkPolicyAmendment")]
    ApplyNetworkPolicyAmendment {
        network_policy_amendment: NetworkPolicyAmendment,
    },
    #[serde(rename = "decline")]
    Decline,
    #[serde(rename = "cancel")]
    Cancel,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecutionOutputDeltaNotification {
    #[serde(default)]
    pub delta: String,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecutionRequestApprovalParams {
    #[serde(
        rename = "approvalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approval_id: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(
        rename = "commandActions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub command_actions: Option<Vec<CommandAction>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<AbsolutePathBuf>,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(
        rename = "networkApprovalContext",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub network_approval_context: Option<NetworkApprovalContext>,
    #[serde(
        rename = "proposedExecpolicyAmendment",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub proposed_execpolicy_amendment: Option<Vec<String>>,
    #[serde(
        rename = "proposedNetworkPolicyAmendments",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub proposed_network_policy_amendments: Option<Vec<NetworkPolicyAmendment>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "startedAtMs", default)]
    pub started_at_ms: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandExecutionRequestApprovalResponse {
    #[serde()]
    pub decision: CommandExecutionApprovalDecision,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum CommandExecutionSource {
    #[serde(rename = "agent")]
    Agent,
    #[serde(rename = "userShell")]
    UserShell,
    #[serde(rename = "unifiedExecStartup")]
    UnifiedExecStartup,
    #[serde(rename = "unifiedExecInteraction")]
    UnifiedExecInteraction,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum CommandExecutionStatus {
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "declined")]
    Declined,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CommandMigration {
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub analytics: Option<AnalyticsConfig>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approval_policy: Option<AskForApproval>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approvals_reviewer: Option<ApprovalsReviewer>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub compact_prompt: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub desktop: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub developer_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub forced_chatgpt_workspace_id: Option<ForcedChatgptWorkspaceIds>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub forced_login_method: Option<ForcedLoginMethod>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_auto_compact_token_limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_context_window: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_reasoning_effort: Option<ReasoningEffort>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_reasoning_summary: Option<ReasoningSummary>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_verbosity: Option<Verbosity>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub profile: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub profiles: Option<std::collections::BTreeMap<String, ProfileV2>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub review_model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sandbox_mode: Option<SandboxMode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sandbox_workspace_write: Option<SandboxWorkspaceWrite>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<ToolsV2>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub web_search: Option<WebSearchMode>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigBatchWriteParams {
    #[serde(default)]
    pub edits: Vec<ConfigEdit>,
    #[serde(
        rename = "expectedVersion",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub expected_version: Option<String>,
    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
    #[serde(
        rename = "reloadUserConfig",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub reload_user_config: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigEdit {
    #[serde(rename = "keyPath", default)]
    pub key_path: String,
    #[serde(rename = "mergeStrategy")]
    pub merge_strategy: MergeStrategy,
    #[serde(default)]
    pub value: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigLayer {
    #[serde(default)]
    pub config: Value,
    #[serde(
        rename = "disabledReason",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub disabled_reason: Option<String>,
    #[serde()]
    pub name: ConfigLayerSource,
    #[serde(default)]
    pub version: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigLayerMetadata {
    #[serde()]
    pub name: ConfigLayerSource,
    #[serde(default)]
    pub version: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ConfigLayerSource {
    Mdm {
        domain: String,
        key: String,
    },
    System {
        file: Value,
    },
    User {
        file: Value,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        profile: Option<String>,
    },
    Project {
        #[serde(rename = "dotCodexFolder")]
        dot_codex_folder: AbsolutePathBuf,
    },
    #[serde(rename = "sessionFlags")]
    SessionFlags,
    #[serde(rename = "legacyManagedConfigTomlFromFile")]
    LegacyManagedConfigTomlFromFile {
        file: AbsolutePathBuf,
    },
    #[serde(rename = "legacyManagedConfigTomlFromMdm")]
    LegacyManagedConfigTomlFromMdm,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigReadParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(
        rename = "includeLayers",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub include_layers: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigReadResponse {
    #[serde()]
    pub config: Config,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub layers: Option<Vec<ConfigLayer>>,
    #[serde(default)]
    pub origins: std::collections::BTreeMap<String, ConfigLayerMetadata>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigRequirements {
    #[serde(
        rename = "allowManagedHooksOnly",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub allow_managed_hooks_only: Option<bool>,
    #[serde(
        rename = "allowedApprovalPolicies",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub allowed_approval_policies: Option<Vec<AskForApproval>>,
    #[serde(
        rename = "allowedSandboxModes",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub allowed_sandbox_modes: Option<Vec<SandboxMode>>,
    #[serde(
        rename = "allowedWebSearchModes",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub allowed_web_search_modes: Option<Vec<WebSearchMode>>,
    #[serde(
        rename = "enforceResidency",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub enforce_residency: Option<ResidencyRequirement>,
    #[serde(
        rename = "featureRequirements",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub feature_requirements: Option<std::collections::BTreeMap<String, bool>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigRequirementsReadResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub requirements: Option<ConfigRequirements>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigValueWriteParams {
    #[serde(
        rename = "expectedVersion",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub expected_version: Option<String>,
    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
    pub file_path: Option<String>,
    #[serde(rename = "keyPath", default)]
    pub key_path: String,
    #[serde(rename = "mergeStrategy")]
    pub merge_strategy: MergeStrategy,
    #[serde(default)]
    pub value: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigWarningNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub range: Option<TextRange>,
    #[serde(default)]
    pub summary: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigWriteResponse {
    #[serde(rename = "filePath", default)]
    pub file_path: Value,
    #[serde(
        rename = "overriddenMetadata",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub overridden_metadata: Option<OverriddenMetadata>,
    #[serde()]
    pub status: WriteStatus,
    #[serde(default)]
    pub version: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ContextCompactedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreditsSnapshot {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub balance: Option<String>,
    #[serde(rename = "hasCredits", default)]
    pub has_credits: bool,
    #[serde(default)]
    pub unlimited: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeprecationNoticeNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<String>,
    #[serde(default)]
    pub summary: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum DynamicToolCallOutputContentItem {
    #[serde(rename = "inputText")]
    InputText { text: String },
    #[serde(rename = "inputImage")]
    InputImage {
        #[serde(rename = "imageUrl")]
        image_url: String,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DynamicToolCallParams {
    #[serde(default)]
    pub arguments: Value,
    #[serde(rename = "callId", default)]
    pub call_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(default)]
    pub tool: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DynamicToolCallResponse {
    #[serde(rename = "contentItems", default)]
    pub content_items: Vec<DynamicToolCallOutputContentItem>,
    #[serde(default)]
    pub success: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum DynamicToolCallStatus {
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ErrorNotification {
    #[serde()]
    pub error: TurnError,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
    #[serde(rename = "willRetry", default)]
    pub will_retry: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExecCommandApprovalParams {
    #[serde(
        rename = "approvalId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approval_id: Option<String>,
    #[serde(rename = "callId", default)]
    pub call_id: String,
    #[serde(default)]
    pub command: Vec<String>,
    #[serde(rename = "conversationId")]
    pub conversation_id: ThreadId,
    #[serde(default)]
    pub cwd: String,
    #[serde(rename = "parsedCmd", default)]
    pub parsed_cmd: Vec<ParsedCommand>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExecCommandApprovalResponse {
    #[serde()]
    pub decision: ReviewDecision,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExperimentalFeature {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub announcement: Option<String>,
    #[serde(rename = "defaultEnabled", default)]
    pub default_enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(
        rename = "displayName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub display_name: Option<String>,
    #[serde(default)]
    pub enabled: bool,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub stage: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExperimentalFeatureEnablementSetParams {
    #[serde(default)]
    pub enablement: std::collections::BTreeMap<String, bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExperimentalFeatureEnablementSetResponse {
    #[serde(default)]
    pub enablement: std::collections::BTreeMap<String, bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExperimentalFeatureListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExperimentalFeatureListResponse {
    #[serde(default)]
    pub data: Vec<ExperimentalFeature>,
    #[serde(
        rename = "nextCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum ExperimentalFeatureStage {
    #[serde(rename = "beta")]
    Beta,
    #[serde(rename = "underDevelopment")]
    UnderDevelopment,
    #[serde(rename = "stable")]
    Stable,
    #[serde(rename = "deprecated")]
    Deprecated,
    #[serde(rename = "removed")]
    Removed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalAgentConfigDetectParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwds: Option<Vec<String>>,
    #[serde(
        rename = "includeHome",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub include_home: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalAgentConfigDetectResponse {
    #[serde(default)]
    pub items: Vec<ExternalAgentConfigMigrationItem>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalAgentConfigImportCompletedNotification {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalAgentConfigImportParams {
    #[serde(rename = "migrationItems", default)]
    pub migration_items: Vec<ExternalAgentConfigMigrationItem>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalAgentConfigImportResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalAgentConfigMigrationItem {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(default)]
    pub description: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<MigrationDetails>,
    #[serde(rename = "itemType")]
    pub item_type: ExternalAgentConfigMigrationItemType,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ExternalAgentConfigMigrationItemType {
    #[serde(rename = "AGENTS_MD")]
    AGENTS_MD,
    #[serde(rename = "CONFIG")]
    CONFIG,
    #[serde(rename = "SKILLS")]
    SKILLS,
    #[serde(rename = "PLUGINS")]
    PLUGINS,
    #[serde(rename = "MCP_SERVER_CONFIG")]
    MCP_SERVER_CONFIG,
    #[serde(rename = "SUBAGENTS")]
    SUBAGENTS,
    #[serde(rename = "HOOKS")]
    HOOKS,
    #[serde(rename = "COMMANDS")]
    COMMANDS,
    #[serde(rename = "SESSIONS")]
    SESSIONS,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedbackUploadParams {
    #[serde(default)]
    pub classification: String,
    #[serde(
        rename = "extraLogFiles",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub extra_log_files: Option<Vec<String>>,
    #[serde(rename = "includeLogs", default)]
    pub include_logs: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<std::collections::BTreeMap<String, String>>,
    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FeedbackUploadResponse {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum FileChange {
    Add {
        content: String,
    },
    Delete {
        content: String,
    },
    Update {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        move_path: Option<String>,
        unified_diff: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum FileChangeApprovalDecision {
    #[serde(rename = "accept")]
    Accept,
    #[serde(rename = "acceptForSession")]
    AcceptForSession,
    #[serde(rename = "decline")]
    Decline,
    #[serde(rename = "cancel")]
    Cancel,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileChangeOutputDeltaNotification {
    #[serde(default)]
    pub delta: String,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileChangePatchUpdatedNotification {
    #[serde(default)]
    pub changes: Vec<FileUpdateChange>,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileChangeRequestApprovalParams {
    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
    pub grant_root: Option<String>,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "startedAtMs", default)]
    pub started_at_ms: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileChangeRequestApprovalResponse {
    #[serde()]
    pub decision: FileChangeApprovalDecision,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum FileSystemAccessMode {
    #[serde(rename = "read")]
    Read,
    #[serde(rename = "write")]
    Write,
    #[serde(rename = "none")]
    None,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum FileSystemPath {
    Path { path: AbsolutePathBuf },
    Glob_pattern { pattern: String },
    Special { value: FileSystemSpecialPath },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileSystemSandboxEntry {
    #[serde()]
    pub access: FileSystemAccessMode,
    #[serde()]
    pub path: FileSystemPath,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub enum FileSystemSpecialPath {
    Root,
    Minimal,
    ProjectRoots {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        subpath: Option<String>,
    },
    Tmpdir,
    SlashTmp,
    Unknown {
        path: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        subpath: Option<String>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FileUpdateChange {
    #[serde(default)]
    pub diff: String,
    #[serde()]
    pub kind: PatchChangeKind,
    #[serde(default)]
    pub path: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ForcedChatgptWorkspaceIds {
    Variant0(String),
    Variant1(Vec<String>),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ForcedLoginMethod {
    #[serde(rename = "chatgpt")]
    Chatgpt,
    #[serde(rename = "api")]
    Api,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsChangedNotification {
    #[serde(rename = "changedPaths", default)]
    pub changed_paths: Vec<AbsolutePathBuf>,
    #[serde(rename = "watchId", default)]
    pub watch_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsCopyParams {
    #[serde(rename = "destinationPath", default)]
    pub destination_path: Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub recursive: Option<bool>,
    #[serde(rename = "sourcePath", default)]
    pub source_path: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsCopyResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsCreateDirectoryParams {
    #[serde(default)]
    pub path: Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub recursive: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsCreateDirectoryResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsGetMetadataParams {
    #[serde(default)]
    pub path: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsGetMetadataResponse {
    #[serde(rename = "createdAtMs", default)]
    pub created_at_ms: i64,
    #[serde(rename = "isDirectory", default)]
    pub is_directory: bool,
    #[serde(rename = "isFile", default)]
    pub is_file: bool,
    #[serde(rename = "isSymlink", default)]
    pub is_symlink: bool,
    #[serde(rename = "modifiedAtMs", default)]
    pub modified_at_ms: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsReadDirectoryEntry {
    #[serde(rename = "fileName", default)]
    pub file_name: String,
    #[serde(rename = "isDirectory", default)]
    pub is_directory: bool,
    #[serde(rename = "isFile", default)]
    pub is_file: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsReadDirectoryParams {
    #[serde(default)]
    pub path: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsReadDirectoryResponse {
    #[serde(default)]
    pub entries: Vec<FsReadDirectoryEntry>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsReadFileParams {
    #[serde(default)]
    pub path: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsReadFileResponse {
    #[serde(rename = "dataBase64", default)]
    pub data_base64: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsRemoveParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub force: Option<bool>,
    #[serde(default)]
    pub path: Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub recursive: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsRemoveResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsUnwatchParams {
    #[serde(rename = "watchId", default)]
    pub watch_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsUnwatchResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsWatchParams {
    #[serde(default)]
    pub path: Value,
    #[serde(rename = "watchId", default)]
    pub watch_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsWatchResponse {
    #[serde(default)]
    pub path: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsWriteFileParams {
    #[serde(rename = "dataBase64", default)]
    pub data_base64: String,
    #[serde(default)]
    pub path: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FsWriteFileResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum FuzzyFileSearchMatchType {
    #[serde(rename = "file")]
    File,
    #[serde(rename = "directory")]
    Directory,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FuzzyFileSearchParams {
    #[serde(
        rename = "cancellationToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub cancellation_token: Option<String>,
    #[serde(default)]
    pub query: String,
    #[serde(default)]
    pub roots: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FuzzyFileSearchResponse {
    #[serde(default)]
    pub files: Vec<FuzzyFileSearchResult>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FuzzyFileSearchResult {
    #[serde(default)]
    pub file_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub indices: Option<Vec<i64>>,
    #[serde()]
    pub match_type: FuzzyFileSearchMatchType,
    #[serde(default)]
    pub path: String,
    #[serde(default)]
    pub root: String,
    #[serde(default)]
    pub score: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FuzzyFileSearchSessionCompletedNotification {
    #[serde(rename = "sessionId", default)]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FuzzyFileSearchSessionUpdatedNotification {
    #[serde(default)]
    pub files: Vec<FuzzyFileSearchResult>,
    #[serde(default)]
    pub query: String,
    #[serde(rename = "sessionId", default)]
    pub session_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GetAccountParams {
    #[serde(
        rename = "refreshToken",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub refresh_token: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GetAccountRateLimitsResponse {
    #[serde(rename = "rateLimits", default)]
    pub rate_limits: Value,
    #[serde(
        rename = "rateLimitsByLimitId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GetAccountResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub account: Option<Account>,
    #[serde(rename = "requiresOpenaiAuth", default)]
    pub requires_openai_auth: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GitInfo {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
    pub origin_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GrantedPermissionProfile {
    #[serde(
        rename = "fileSystem",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub file_system: Option<AdditionalFileSystemPermissions>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub network: Option<AdditionalNetworkPermissions>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GuardianApprovalReview {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rationale: Option<String>,
    #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
    pub risk_level: Option<GuardianRiskLevel>,
    #[serde()]
    pub status: GuardianApprovalReviewStatus,
    #[serde(
        rename = "userAuthorization",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub user_authorization: Option<GuardianUserAuthorization>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum GuardianApprovalReviewAction {
    Command {
        command: String,
        cwd: AbsolutePathBuf,
        source: GuardianCommandSource,
    },
    Execve {
        argv: Vec<String>,
        cwd: AbsolutePathBuf,
        program: String,
        source: GuardianCommandSource,
    },
    #[serde(rename = "applyPatch")]
    ApplyPatch {
        cwd: AbsolutePathBuf,
        files: Vec<AbsolutePathBuf>,
    },
    #[serde(rename = "networkAccess")]
    NetworkAccess {
        host: String,
        port: i64,
        protocol: NetworkApprovalProtocol,
        target: String,
    },
    #[serde(rename = "mcpToolCall")]
    McpToolCall {
        #[serde(
            rename = "connectorId",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        connector_id: Option<String>,
        #[serde(
            rename = "connectorName",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        connector_name: Option<String>,
        server: String,
        #[serde(rename = "toolName")]
        tool_name: String,
        #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
        tool_title: Option<String>,
    },
    #[serde(rename = "requestPermissions")]
    RequestPermissions {
        permissions: RequestPermissionProfile,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        reason: Option<String>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum GuardianApprovalReviewStatus {
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "denied")]
    Denied,
    #[serde(rename = "timedOut")]
    TimedOut,
    #[serde(rename = "aborted")]
    Aborted,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum GuardianCommandSource {
    #[serde(rename = "shell")]
    Shell,
    #[serde(rename = "unifiedExec")]
    UnifiedExec,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum GuardianRiskLevel {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "critical")]
    Critical,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum GuardianUserAuthorization {
    #[serde(rename = "unknown")]
    Unknown,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct GuardianWarningNotification {
    #[serde(default)]
    pub message: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookCompletedNotification {
    #[serde()]
    pub run: HookRunSummary,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
    pub turn_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookErrorInfo {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub path: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookEventName {
    #[serde(rename = "preToolUse")]
    PreToolUse,
    #[serde(rename = "permissionRequest")]
    PermissionRequest,
    #[serde(rename = "postToolUse")]
    PostToolUse,
    #[serde(rename = "preCompact")]
    PreCompact,
    #[serde(rename = "postCompact")]
    PostCompact,
    #[serde(rename = "sessionStart")]
    SessionStart,
    #[serde(rename = "userPromptSubmit")]
    UserPromptSubmit,
    #[serde(rename = "stop")]
    Stop,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookExecutionMode {
    #[serde(rename = "sync")]
    Sync,
    #[serde(rename = "async")]
    Async,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookHandlerType {
    #[serde(rename = "command")]
    Command,
    #[serde(rename = "prompt")]
    Prompt,
    #[serde(rename = "agent")]
    Agent,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookMetadata {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(rename = "currentHash", default)]
    pub current_hash: String,
    #[serde(rename = "displayOrder", default)]
    pub display_order: i64,
    #[serde(default)]
    pub enabled: bool,
    #[serde(rename = "eventName")]
    pub event_name: HookEventName,
    #[serde(rename = "handlerType")]
    pub handler_type: HookHandlerType,
    #[serde(rename = "isManaged", default)]
    pub is_managed: bool,
    #[serde(default)]
    pub key: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub matcher: Option<String>,
    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
    pub plugin_id: Option<String>,
    #[serde()]
    pub source: HookSource,
    #[serde(rename = "sourcePath")]
    pub source_path: AbsolutePathBuf,
    #[serde(
        rename = "statusMessage",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_message: Option<String>,
    #[serde(rename = "timeoutSec", default)]
    pub timeout_sec: i64,
    #[serde(rename = "trustStatus")]
    pub trust_status: HookTrustStatus,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookMigration {
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookOutputEntry {
    #[serde()]
    pub kind: HookOutputEntryKind,
    #[serde(default)]
    pub text: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookOutputEntryKind {
    #[serde(rename = "warning")]
    Warning,
    #[serde(rename = "stop")]
    Stop,
    #[serde(rename = "feedback")]
    Feedback,
    #[serde(rename = "context")]
    Context,
    #[serde(rename = "error")]
    Error,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookPromptFragment {
    #[serde(rename = "hookRunId", default)]
    pub hook_run_id: String,
    #[serde(default)]
    pub text: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookRunStatus {
    #[serde(rename = "running")]
    Running,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "blocked")]
    Blocked,
    #[serde(rename = "stopped")]
    Stopped,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookRunSummary {
    #[serde(
        rename = "completedAt",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub completed_at: Option<i64>,
    #[serde(rename = "displayOrder", default)]
    pub display_order: i64,
    #[serde(
        rename = "durationMs",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub duration_ms: Option<i64>,
    #[serde(default)]
    pub entries: Vec<HookOutputEntry>,
    #[serde(rename = "eventName")]
    pub event_name: HookEventName,
    #[serde(rename = "executionMode")]
    pub execution_mode: HookExecutionMode,
    #[serde(rename = "handlerType")]
    pub handler_type: HookHandlerType,
    #[serde(default)]
    pub id: String,
    #[serde()]
    pub scope: HookScope,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub source: Option<Value>,
    #[serde(rename = "sourcePath")]
    pub source_path: AbsolutePathBuf,
    #[serde(rename = "startedAt", default)]
    pub started_at: i64,
    #[serde()]
    pub status: HookRunStatus,
    #[serde(
        rename = "statusMessage",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub status_message: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookScope {
    #[serde(rename = "thread")]
    Thread,
    #[serde(rename = "turn")]
    Turn,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookSource {
    #[serde(rename = "system")]
    System,
    #[serde(rename = "user")]
    User,
    #[serde(rename = "project")]
    Project,
    #[serde(rename = "mdm")]
    Mdm,
    #[serde(rename = "sessionFlags")]
    SessionFlags,
    #[serde(rename = "plugin")]
    Plugin,
    #[serde(rename = "cloudRequirements")]
    CloudRequirements,
    #[serde(rename = "legacyManagedConfigFile")]
    LegacyManagedConfigFile,
    #[serde(rename = "legacyManagedConfigMdm")]
    LegacyManagedConfigMdm,
    #[serde(rename = "unknown")]
    Unknown,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HookStartedNotification {
    #[serde()]
    pub run: HookRunSummary,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
    pub turn_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HookTrustStatus {
    #[serde(rename = "managed")]
    Managed,
    #[serde(rename = "untrusted")]
    Untrusted,
    #[serde(rename = "trusted")]
    Trusted,
    #[serde(rename = "modified")]
    Modified,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HooksListEntry {
    #[serde(default)]
    pub cwd: String,
    #[serde(default)]
    pub errors: Vec<HookErrorInfo>,
    #[serde(default)]
    pub hooks: Vec<HookMetadata>,
    #[serde(default)]
    pub warnings: Vec<String>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HooksListResponse {
    #[serde(default)]
    pub data: Vec<HooksListEntry>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InitializeCapabilities {
    #[serde(
        rename = "experimentalApi",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub experimental_api: Option<bool>,
    #[serde(
        rename = "optOutNotificationMethods",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub opt_out_notification_methods: Option<Vec<String>>,
    #[serde(
        rename = "requestAttestation",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub request_attestation: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InitializeParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<InitializeCapabilities>,
    #[serde(rename = "clientInfo")]
    pub client_info: ClientInfo,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InitializeResponse {
    #[serde(rename = "codexHome", default)]
    pub codex_home: Value,
    #[serde(rename = "platformFamily", default)]
    pub platform_family: String,
    #[serde(rename = "platformOs", default)]
    pub platform_os: String,
    #[serde(rename = "userAgent", default)]
    pub user_agent: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum InputModality {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "image")]
    Image,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ItemCompletedNotification {
    #[serde(rename = "completedAtMs", default)]
    pub completed_at_ms: i64,
    #[serde()]
    pub item: ThreadItem,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ItemGuardianApprovalReviewCompletedNotification {
    #[serde()]
    pub action: GuardianApprovalReviewAction,
    #[serde(rename = "completedAtMs", default)]
    pub completed_at_ms: i64,
    #[serde(rename = "decisionSource")]
    pub decision_source: AutoReviewDecisionSource,
    #[serde()]
    pub review: GuardianApprovalReview,
    #[serde(rename = "reviewId", default)]
    pub review_id: String,
    #[serde(rename = "startedAtMs", default)]
    pub started_at_ms: i64,
    #[serde(
        rename = "targetItemId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub target_item_id: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ItemGuardianApprovalReviewStartedNotification {
    #[serde()]
    pub action: GuardianApprovalReviewAction,
    #[serde()]
    pub review: GuardianApprovalReview,
    #[serde(rename = "reviewId", default)]
    pub review_id: String,
    #[serde(rename = "startedAtMs", default)]
    pub started_at_ms: i64,
    #[serde(
        rename = "targetItemId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub target_item_id: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ItemStartedNotification {
    #[serde()]
    pub item: ThreadItem,
    #[serde(rename = "startedAtMs", default)]
    pub started_at_ms: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct JSONRPCResponse {
    #[serde()]
    pub id: RequestId,
    #[serde(default)]
    pub result: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListMcpServerStatusParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub detail: Option<McpServerStatusDetail>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListMcpServerStatusResponse {
    #[serde(default)]
    pub data: Vec<McpServerStatus>,
    #[serde(
        rename = "nextCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum LoginAccountParams {
    #[serde(rename = "apiKey")]
    ApiKey {
        #[serde(rename = "apiKey")]
        api_key: String,
    },
    Chatgpt {
        #[serde(
            rename = "codexStreamlinedLogin",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        codex_streamlined_login: Option<bool>,
    },
    #[serde(rename = "chatgptDeviceCode")]
    ChatgptDeviceCode,
    #[serde(rename = "chatgptAuthTokens")]
    ChatgptAuthTokens {
        #[serde(rename = "accessToken")]
        access_token: String,
        #[serde(rename = "chatgptAccountId")]
        chatgpt_account_id: String,
        #[serde(
            rename = "chatgptPlanType",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        chatgpt_plan_type: Option<String>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum LoginAccountResponse {
    #[serde(rename = "apiKey")]
    ApiKey,
    Chatgpt {
        #[serde(rename = "authUrl")]
        auth_url: String,
        #[serde(rename = "loginId")]
        login_id: String,
    },
    #[serde(rename = "chatgptDeviceCode")]
    ChatgptDeviceCode {
        #[serde(rename = "loginId")]
        login_id: String,
        #[serde(rename = "userCode")]
        user_code: String,
        #[serde(rename = "verificationUrl")]
        verification_url: String,
    },
    #[serde(rename = "chatgptAuthTokens")]
    ChatgptAuthTokens,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LogoutAccountResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceAddParams {
    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
    pub ref_name: Option<String>,
    #[serde(default)]
    pub source: String,
    #[serde(
        rename = "sparsePaths",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub sparse_paths: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceAddResponse {
    #[serde(rename = "alreadyAdded", default)]
    pub already_added: bool,
    #[serde(rename = "installedRoot")]
    pub installed_root: AbsolutePathBuf,
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceInterface {
    #[serde(
        rename = "displayName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub display_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceLoadErrorInfo {
    #[serde(rename = "marketplacePath")]
    pub marketplace_path: AbsolutePathBuf,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceRemoveParams {
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceRemoveResponse {
    #[serde(
        rename = "installedRoot",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub installed_root: Option<AbsolutePathBuf>,
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceUpgradeErrorInfo {
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceUpgradeParams {
    #[serde(
        rename = "marketplaceName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub marketplace_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketplaceUpgradeResponse {
    #[serde(default)]
    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
    #[serde(rename = "selectedMarketplaces", default)]
    pub selected_marketplaces: Vec<String>,
    #[serde(rename = "upgradedRoots", default)]
    pub upgraded_roots: Vec<AbsolutePathBuf>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpAuthStatus {
    #[serde(rename = "unsupported")]
    Unsupported,
    #[serde(rename = "notLoggedIn")]
    NotLoggedIn,
    #[serde(rename = "bearerToken")]
    BearerToken,
    #[serde(rename = "oAuth")]
    OAuth,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpElicitationArrayType {
    #[serde(rename = "array")]
    Array,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationBooleanSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationBooleanType,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpElicitationBooleanType {
    #[serde(rename = "boolean")]
    Boolean,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationConstOption {
    #[serde(rename = "const", default)]
    pub const_: String,
    #[serde(default)]
    pub title: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpElicitationEnumSchema {
    McpElicitationSingleSelectEnumSchema(McpElicitationSingleSelectEnumSchema),
    McpElicitationMultiSelectEnumSchema(McpElicitationMultiSelectEnumSchema),
    McpElicitationLegacyTitledEnumSchema(McpElicitationLegacyTitledEnumSchema),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationLegacyTitledEnumSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "enum", default)]
    pub enum_: Vec<String>,
    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
    pub enum_names: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationStringType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpElicitationMultiSelectEnumSchema {
    McpElicitationUntitledMultiSelectEnumSchema(McpElicitationUntitledMultiSelectEnumSchema),
    McpElicitationTitledMultiSelectEnumSchema(McpElicitationTitledMultiSelectEnumSchema),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationNumberSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub maximum: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub minimum: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationNumberType,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpElicitationNumberType {
    #[serde(rename = "number")]
    Number,
    #[serde(rename = "integer")]
    Integer,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpElicitationObjectType {
    #[serde(rename = "object")]
    Object,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpElicitationPrimitiveSchema {
    McpElicitationEnumSchema(McpElicitationEnumSchema),
    McpElicitationStringSchema(McpElicitationStringSchema),
    McpElicitationNumberSchema(McpElicitationNumberSchema),
    McpElicitationBooleanSchema(McpElicitationBooleanSchema),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationSchema {
    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
    pub schema: Option<String>,
    #[serde(default)]
    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub required: Option<Vec<String>>,
    #[serde(rename = "type")]
    pub type_: McpElicitationObjectType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpElicitationSingleSelectEnumSchema {
    McpElicitationUntitledSingleSelectEnumSchema(McpElicitationUntitledSingleSelectEnumSchema),
    McpElicitationTitledSingleSelectEnumSchema(McpElicitationTitledSingleSelectEnumSchema),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpElicitationStringFormat {
    #[serde(rename = "email")]
    Email,
    #[serde(rename = "uri")]
    Uri,
    #[serde(rename = "date")]
    Date,
    #[serde(rename = "date-time")]
    Date_time,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationStringSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub format: Option<McpElicitationStringFormat>,
    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
    pub max_length: Option<i64>,
    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
    pub min_length: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationStringType,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpElicitationStringType {
    #[serde(rename = "string")]
    String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationTitledEnumItems {
    #[serde(rename = "anyOf", default)]
    pub any_of: Vec<McpElicitationConstOption>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationTitledMultiSelectEnumSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde()]
    pub items: McpElicitationTitledEnumItems,
    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
    pub max_items: Option<i64>,
    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
    pub min_items: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationArrayType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationTitledSingleSelectEnumSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "oneOf", default)]
    pub one_of: Vec<McpElicitationConstOption>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationStringType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationUntitledEnumItems {
    #[serde(rename = "enum", default)]
    pub enum_: Vec<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationStringType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationUntitledMultiSelectEnumSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde()]
    pub items: McpElicitationUntitledEnumItems,
    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
    pub max_items: Option<i64>,
    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
    pub min_items: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationArrayType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpElicitationUntitledSingleSelectEnumSchema {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub default: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "enum", default)]
    pub enum_: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "type")]
    pub type_: McpElicitationStringType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpResourceReadParams {
    #[serde(default)]
    pub server: String,
    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
    #[serde(default)]
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpResourceReadResponse {
    #[serde(default)]
    pub contents: Vec<ResourceContent>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpServerElicitationAction {
    #[serde(rename = "accept")]
    Accept,
    #[serde(rename = "decline")]
    Decline,
    #[serde(rename = "cancel")]
    Cancel,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "mode", rename_all = "camelCase")]
pub enum McpServerElicitationRequestParams {
    Form {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        _meta: Option<Value>,
        message: String,
        #[serde(rename = "requestedSchema")]
        requested_schema: McpElicitationSchema,
    },
    Url {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        _meta: Option<Value>,
        #[serde(rename = "elicitationId")]
        elicitation_id: String,
        message: String,
        url: String,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerElicitationRequestResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub _meta: Option<Value>,
    #[serde()]
    pub action: McpServerElicitationAction,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub content: Option<Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerMigration {
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerOauthLoginCompletedNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub success: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerOauthLoginParams {
    #[serde(default)]
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
    #[serde(
        rename = "timeoutSecs",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub timeout_secs: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerOauthLoginResponse {
    #[serde(rename = "authorizationUrl", default)]
    pub authorization_url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerRefreshResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpServerStartupState {
    #[serde(rename = "starting")]
    Starting,
    #[serde(rename = "ready")]
    Ready,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "cancelled")]
    Cancelled,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerStatus {
    #[serde(rename = "authStatus")]
    pub auth_status: McpAuthStatus,
    #[serde(default)]
    pub name: String,
    #[serde(rename = "resourceTemplates", default)]
    pub resource_templates: Vec<ResourceTemplate>,
    #[serde(default)]
    pub resources: Vec<Resource>,
    #[serde(default)]
    pub tools: std::collections::BTreeMap<String, Tool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpServerStatusDetail {
    #[serde(rename = "full")]
    Full,
    #[serde(rename = "toolsAndAuthOnly")]
    ToolsAndAuthOnly,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerStatusUpdatedNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde()]
    pub status: McpServerStartupState,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerToolCallParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub _meta: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub arguments: Option<Value>,
    #[serde(default)]
    pub server: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(default)]
    pub tool: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpServerToolCallResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub _meta: Option<Value>,
    #[serde(default)]
    pub content: Vec<Value>,
    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
    pub is_error: Option<bool>,
    #[serde(
        rename = "structuredContent",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub structured_content: Option<Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpToolCallError {
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpToolCallProgressNotification {
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(default)]
    pub message: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct McpToolCallResult {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub _meta: Option<Value>,
    #[serde(default)]
    pub content: Vec<Value>,
    #[serde(
        rename = "structuredContent",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub structured_content: Option<Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum McpToolCallStatus {
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MemoryCitation {
    #[serde(default)]
    pub entries: Vec<MemoryCitationEntry>,
    #[serde(rename = "threadIds", default)]
    pub thread_ids: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MemoryCitationEntry {
    #[serde(rename = "lineEnd", default)]
    pub line_end: i64,
    #[serde(rename = "lineStart", default)]
    pub line_start: i64,
    #[serde(default)]
    pub note: String,
    #[serde(default)]
    pub path: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum MergeStrategy {
    #[serde(rename = "replace")]
    Replace,
    #[serde(rename = "upsert")]
    Upsert,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum MessagePhase {
    #[serde(rename = "commentary")]
    Commentary,
    #[serde(rename = "final_answer")]
    FinalAnswer,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MigrationDetails {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub commands: Option<Vec<CommandMigration>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hooks: Option<Vec<HookMigration>>,
    #[serde(
        rename = "mcpServers",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub mcp_servers: Option<Vec<McpServerMigration>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub plugins: Option<Vec<PluginsMigration>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sessions: Option<Vec<SessionMigration>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subagents: Option<Vec<SubagentMigration>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Model {
    #[serde(
        rename = "additionalSpeedTiers",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub additional_speed_tiers: Option<Vec<String>>,
    #[serde(
        rename = "availabilityNux",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub availability_nux: Option<ModelAvailabilityNux>,
    #[serde(rename = "defaultReasoningEffort")]
    pub default_reasoning_effort: ReasoningEffort,
    #[serde(default)]
    pub description: String,
    #[serde(rename = "displayName", default)]
    pub display_name: String,
    #[serde(default)]
    pub hidden: bool,
    #[serde(default)]
    pub id: String,
    #[serde(
        rename = "inputModalities",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub input_modalities: Option<Vec<InputModality>>,
    #[serde(rename = "isDefault", default)]
    pub is_default: bool,
    #[serde(default)]
    pub model: String,
    #[serde(
        rename = "serviceTiers",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tiers: Option<Vec<ModelServiceTier>>,
    #[serde(rename = "supportedReasoningEfforts", default)]
    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
    #[serde(
        rename = "supportsPersonality",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub supports_personality: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub upgrade: Option<String>,
    #[serde(
        rename = "upgradeInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub upgrade_info: Option<ModelUpgradeInfo>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelAvailabilityNux {
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(
        rename = "includeHidden",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub include_hidden: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelListResponse {
    #[serde(default)]
    pub data: Vec<Model>,
    #[serde(
        rename = "nextCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelProviderCapabilitiesReadParams {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelProviderCapabilitiesReadResponse {
    #[serde(rename = "imageGeneration", default)]
    pub image_generation: bool,
    #[serde(rename = "namespaceTools", default)]
    pub namespace_tools: bool,
    #[serde(rename = "webSearch", default)]
    pub web_search: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ModelRerouteReason {
    #[serde(rename = "highRiskCyberActivity")]
    HighRiskCyberActivity,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelReroutedNotification {
    #[serde(rename = "fromModel", default)]
    pub from_model: String,
    #[serde()]
    pub reason: ModelRerouteReason,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "toModel", default)]
    pub to_model: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelServiceTier {
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelUpgradeInfo {
    #[serde(
        rename = "migrationMarkdown",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub migration_markdown: Option<String>,
    #[serde(default)]
    pub model: String,
    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
    pub model_link: Option<String>,
    #[serde(
        rename = "upgradeCopy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub upgrade_copy: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ModelVerification {
    #[serde(rename = "trustedAccessForCyber")]
    TrustedAccessForCyber,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelVerificationNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
    #[serde(default)]
    pub verifications: Vec<ModelVerification>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum NetworkAccess {
    #[serde(rename = "restricted")]
    Restricted,
    #[serde(rename = "enabled")]
    Enabled,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetworkApprovalContext {
    #[serde(default)]
    pub host: String,
    #[serde()]
    pub protocol: NetworkApprovalProtocol,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum NetworkApprovalProtocol {
    #[serde(rename = "http")]
    Http,
    #[serde(rename = "https")]
    Https,
    #[serde(rename = "socks5Tcp")]
    Socks5Tcp,
    #[serde(rename = "socks5Udp")]
    Socks5Udp,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NetworkPolicyAmendment {
    #[serde()]
    pub action: NetworkPolicyRuleAction,
    #[serde(default)]
    pub host: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum NetworkPolicyRuleAction {
    #[serde(rename = "allow")]
    Allow,
    #[serde(rename = "deny")]
    Deny,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum NonSteerableTurnKind {
    #[serde(rename = "review")]
    Review,
    #[serde(rename = "compact")]
    Compact,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OverriddenMetadata {
    #[serde(rename = "effectiveValue", default)]
    pub effective_value: Value,
    #[serde(default)]
    pub message: String,
    #[serde(rename = "overridingLayer")]
    pub overriding_layer: ConfigLayerMetadata,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ParsedCommand {
    Read {
        cmd: String,
        name: String,
        path: String,
    },
    List_files {
        cmd: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        path: Option<String>,
    },
    Search {
        cmd: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        path: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        query: Option<String>,
    },
    Unknown {
        cmd: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PatchApplyStatus {
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "declined")]
    Declined,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum PatchChangeKind {
    Add,
    Delete,
    Update {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        move_path: Option<String>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PermissionGrantScope {
    #[serde(rename = "turn")]
    Turn,
    #[serde(rename = "session")]
    Session,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PermissionsRequestApprovalParams {
    #[serde()]
    pub cwd: AbsolutePathBuf,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde()]
    pub permissions: RequestPermissionProfile,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "startedAtMs", default)]
    pub started_at_ms: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PermissionsRequestApprovalResponse {
    #[serde()]
    pub permissions: GrantedPermissionProfile,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<Value>,
    #[serde(
        rename = "strictAutoReview",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub strict_auto_review: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum Personality {
    #[serde(rename = "none")]
    None,
    #[serde(rename = "friendly")]
    Friendly,
    #[serde(rename = "pragmatic")]
    Pragmatic,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PlanDeltaNotification {
    #[serde(default)]
    pub delta: String,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PlanType {
    #[serde(rename = "free")]
    Free,
    #[serde(rename = "go")]
    Go,
    #[serde(rename = "plus")]
    Plus,
    #[serde(rename = "pro")]
    Pro,
    #[serde(rename = "prolite")]
    Prolite,
    #[serde(rename = "team")]
    Team,
    #[serde(rename = "self_serve_business_usage_based")]
    Self_serve_business_usage_based,
    #[serde(rename = "business")]
    Business,
    #[serde(rename = "enterprise_cbp_usage_based")]
    Enterprise_cbp_usage_based,
    #[serde(rename = "enterprise")]
    Enterprise,
    #[serde(rename = "edu")]
    Edu,
    #[serde(rename = "unknown")]
    Unknown,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginAuthPolicy {
    #[serde(rename = "ON_INSTALL")]
    ON_INSTALL,
    #[serde(rename = "ON_USE")]
    ON_USE,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum PluginAvailability {
    #[serde(rename = "DISABLED_BY_ADMIN")]
    DISABLEDBYADMIN,
    AVAILABLE,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginDetail {
    #[serde(default)]
    pub apps: Vec<AppSummary>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default)]
    pub hooks: Vec<PluginHookSummary>,
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
    #[serde(
        rename = "marketplacePath",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub marketplace_path: Option<AbsolutePathBuf>,
    #[serde(rename = "mcpServers", default)]
    pub mcp_servers: Vec<String>,
    #[serde(default)]
    pub skills: Vec<SkillSummary>,
    #[serde()]
    pub summary: PluginSummary,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginHookSummary {
    #[serde(rename = "eventName")]
    pub event_name: HookEventName,
    #[serde(default)]
    pub key: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginInstallParams {
    #[serde(
        rename = "marketplacePath",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub marketplace_path: Option<AbsolutePathBuf>,
    #[serde(rename = "pluginName", default)]
    pub plugin_name: String,
    #[serde(
        rename = "remoteMarketplaceName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remote_marketplace_name: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginInstallPolicy {
    #[serde(rename = "NOT_AVAILABLE")]
    NOT_AVAILABLE,
    #[serde(rename = "AVAILABLE")]
    AVAILABLE,
    #[serde(rename = "INSTALLED_BY_DEFAULT")]
    INSTALLED_BY_DEFAULT,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginInstallResponse {
    #[serde(rename = "appsNeedingAuth", default)]
    pub apps_needing_auth: Vec<AppSummary>,
    #[serde(rename = "authPolicy")]
    pub auth_policy: PluginAuthPolicy,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginInterface {
    #[serde(
        rename = "brandColor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub brand_color: Option<String>,
    #[serde(default)]
    pub capabilities: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(
        rename = "composerIcon",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub composer_icon: Option<AbsolutePathBuf>,
    #[serde(
        rename = "composerIconUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub composer_icon_url: Option<String>,
    #[serde(
        rename = "defaultPrompt",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub default_prompt: Option<Vec<String>>,
    #[serde(
        rename = "developerName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub developer_name: Option<String>,
    #[serde(
        rename = "displayName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub display_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo: Option<AbsolutePathBuf>,
    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<String>,
    #[serde(
        rename = "longDescription",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub long_description: Option<String>,
    #[serde(
        rename = "privacyPolicyUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub privacy_policy_url: Option<String>,
    #[serde(rename = "screenshotUrls", default)]
    pub screenshot_urls: Vec<String>,
    #[serde(default)]
    pub screenshots: Vec<AbsolutePathBuf>,
    #[serde(
        rename = "shortDescription",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub short_description: Option<String>,
    #[serde(
        rename = "termsOfServiceUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub terms_of_service_url: Option<String>,
    #[serde(
        rename = "websiteUrl",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub website_url: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginListMarketplaceKind {
    #[serde(rename = "local")]
    Local,
    #[serde(rename = "workspace-directory")]
    Workspace_directory,
    #[serde(rename = "shared-with-me")]
    Shared_with_me,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwds: Option<Vec<AbsolutePathBuf>>,
    #[serde(
        rename = "marketplaceKinds",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginListResponse {
    #[serde(
        rename = "featuredPluginIds",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub featured_plugin_ids: Option<Vec<String>>,
    #[serde(
        rename = "marketplaceLoadErrors",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
    #[serde(default)]
    pub marketplaces: Vec<PluginMarketplaceEntry>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginMarketplaceEntry {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interface: Option<MarketplaceInterface>,
    #[serde(default)]
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<AbsolutePathBuf>,
    #[serde(default)]
    pub plugins: Vec<PluginSummary>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginReadParams {
    #[serde(
        rename = "marketplacePath",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub marketplace_path: Option<AbsolutePathBuf>,
    #[serde(rename = "pluginName", default)]
    pub plugin_name: String,
    #[serde(
        rename = "remoteMarketplaceName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remote_marketplace_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginReadResponse {
    #[serde()]
    pub plugin: PluginDetail,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareCheckoutParams {
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareCheckoutResponse {
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
    #[serde(rename = "marketplacePath")]
    pub marketplace_path: AbsolutePathBuf,
    #[serde(rename = "pluginId", default)]
    pub plugin_id: String,
    #[serde(rename = "pluginName", default)]
    pub plugin_name: String,
    #[serde(rename = "pluginPath")]
    pub plugin_path: AbsolutePathBuf,
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
    #[serde(
        rename = "remoteVersion",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remote_version: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareContext {
    #[serde(
        rename = "creatorAccountUserId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub creator_account_user_id: Option<String>,
    #[serde(
        rename = "creatorName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub creator_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discoverability: Option<PluginShareDiscoverability>,
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
    #[serde(
        rename = "remoteVersion",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remote_version: Option<String>,
    #[serde(
        rename = "sharePrincipals",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub share_principals: Option<Vec<PluginSharePrincipal>>,
    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
    pub share_url: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareDeleteParams {
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareDeleteResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginShareDiscoverability {
    #[serde(rename = "LISTED")]
    LISTED,
    #[serde(rename = "UNLISTED")]
    UNLISTED,
    #[serde(rename = "PRIVATE")]
    PRIVATE,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareListItem {
    #[serde(
        rename = "localPluginPath",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub local_plugin_path: Option<AbsolutePathBuf>,
    #[serde()]
    pub plugin: PluginSummary,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareListParams {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareListResponse {
    #[serde(default)]
    pub data: Vec<PluginShareListItem>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginSharePrincipal {
    #[serde(default)]
    pub name: String,
    #[serde(rename = "principalId", default)]
    pub principal_id: String,
    #[serde(rename = "principalType")]
    pub principal_type: PluginSharePrincipalType,
    #[serde()]
    pub role: PluginSharePrincipalRole,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginSharePrincipalRole {
    #[serde(rename = "reader")]
    Reader,
    #[serde(rename = "editor")]
    Editor,
    #[serde(rename = "owner")]
    Owner,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginSharePrincipalType {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "group")]
    Group,
    #[serde(rename = "workspace")]
    Workspace,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareSaveParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub discoverability: Option<PluginShareDiscoverability>,
    #[serde(rename = "pluginPath")]
    pub plugin_path: AbsolutePathBuf,
    #[serde(
        rename = "remotePluginId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remote_plugin_id: Option<String>,
    #[serde(
        rename = "shareTargets",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub share_targets: Option<Vec<PluginShareTarget>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareSaveResponse {
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
    #[serde(rename = "shareUrl", default)]
    pub share_url: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareTarget {
    #[serde(rename = "principalId", default)]
    pub principal_id: String,
    #[serde(rename = "principalType")]
    pub principal_type: PluginSharePrincipalType,
    #[serde()]
    pub role: PluginShareTargetRole,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginShareTargetRole {
    #[serde(rename = "reader")]
    Reader,
    #[serde(rename = "editor")]
    Editor,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum PluginShareUpdateDiscoverability {
    #[serde(rename = "UNLISTED")]
    UNLISTED,
    #[serde(rename = "PRIVATE")]
    PRIVATE,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareUpdateTargetsParams {
    #[serde()]
    pub discoverability: PluginShareUpdateDiscoverability,
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
    #[serde(rename = "shareTargets", default)]
    pub share_targets: Vec<PluginShareTarget>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginShareUpdateTargetsResponse {
    #[serde()]
    pub discoverability: PluginShareDiscoverability,
    #[serde(default)]
    pub principals: Vec<PluginSharePrincipal>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginSkillReadParams {
    #[serde(rename = "remoteMarketplaceName", default)]
    pub remote_marketplace_name: String,
    #[serde(rename = "remotePluginId", default)]
    pub remote_plugin_id: String,
    #[serde(rename = "skillName", default)]
    pub skill_name: String,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum PluginSource {
    Local {
        path: AbsolutePathBuf,
    },
    Git {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        path: Option<String>,
        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
        ref_name: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        sha: Option<String>,
        url: String,
    },
    Remote,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginSummary {
    #[serde(rename = "authPolicy")]
    pub auth_policy: PluginAuthPolicy,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub availability: Option<Value>,
    #[serde(default)]
    pub enabled: bool,
    #[serde(default)]
    pub id: String,
    #[serde(rename = "installPolicy")]
    pub install_policy: PluginInstallPolicy,
    #[serde(default)]
    pub installed: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interface: Option<PluginInterface>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub keywords: Option<Vec<String>>,
    #[serde(
        rename = "localVersion",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub local_version: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde(
        rename = "remotePluginId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub remote_plugin_id: Option<String>,
    #[serde(
        rename = "shareContext",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub share_context: Option<PluginShareContext>,
    #[serde()]
    pub source: PluginSource,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginUninstallParams {
    #[serde(rename = "pluginId", default)]
    pub plugin_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginUninstallResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PluginsMigration {
    #[serde(rename = "marketplaceName", default)]
    pub marketplace_name: String,
    #[serde(rename = "pluginNames", default)]
    pub plugin_names: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessExitedNotification {
    #[serde(rename = "exitCode", default)]
    pub exit_code: i64,
    #[serde(rename = "processHandle", default)]
    pub process_handle: String,
    #[serde(default)]
    pub stderr: String,
    #[serde(rename = "stderrCapReached", default)]
    pub stderr_cap_reached: bool,
    #[serde(default)]
    pub stdout: String,
    #[serde(rename = "stdoutCapReached", default)]
    pub stdout_cap_reached: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessOutputDeltaNotification {
    #[serde(rename = "capReached", default)]
    pub cap_reached: bool,
    #[serde(rename = "deltaBase64", default)]
    pub delta_base64: String,
    #[serde(rename = "processHandle", default)]
    pub process_handle: String,
    #[serde(default)]
    pub stream: Value,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum ProcessOutputStream {
    #[serde(rename = "stdout")]
    Stdout,
    #[serde(rename = "stderr")]
    Stderr,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ProfileV2 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approval_policy: Option<AskForApproval>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub approvals_reviewer: Option<ApprovalsReviewer>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub chatgpt_base_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_reasoning_effort: Option<ReasoningEffort>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_reasoning_summary: Option<ReasoningSummary>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model_verbosity: Option<Verbosity>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tools: Option<ToolsV2>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub web_search: Option<WebSearchMode>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum RateLimitReachedType {
    #[serde(rename = "rate_limit_reached")]
    Rate_limit_reached,
    #[serde(rename = "workspace_owner_credits_depleted")]
    Workspace_owner_credits_depleted,
    #[serde(rename = "workspace_member_credits_depleted")]
    Workspace_member_credits_depleted,
    #[serde(rename = "workspace_owner_usage_limit_reached")]
    Workspace_owner_usage_limit_reached,
    #[serde(rename = "workspace_member_usage_limit_reached")]
    Workspace_member_usage_limit_reached,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RateLimitSnapshot {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub credits: Option<CreditsSnapshot>,
    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
    pub limit_id: Option<String>,
    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
    pub limit_name: Option<String>,
    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
    pub plan_type: Option<PlanType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub primary: Option<RateLimitWindow>,
    #[serde(
        rename = "rateLimitReachedType",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub rate_limit_reached_type: Option<RateLimitReachedType>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub secondary: Option<RateLimitWindow>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RateLimitWindow {
    #[serde(rename = "resetsAt", default, skip_serializing_if = "Option::is_none")]
    pub resets_at: Option<i64>,
    #[serde(rename = "usedPercent", default)]
    pub used_percent: i64,
    #[serde(
        rename = "windowDurationMins",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub window_duration_mins: Option<i64>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum RealtimeConversationVersion {
    #[serde(rename = "v1")]
    V1,
    #[serde(rename = "v2")]
    V2,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ReasoningEffort {
    #[serde(rename = "none")]
    None,
    #[serde(rename = "minimal")]
    Minimal,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "xhigh")]
    Xhigh,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReasoningEffortOption {
    #[serde(default)]
    pub description: String,
    #[serde(rename = "reasoningEffort")]
    pub reasoning_effort: ReasoningEffort,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum ReasoningSummary {
    #[serde(rename = "auto")]
    Auto,
    #[serde(rename = "concise")]
    Concise,
    #[serde(rename = "detailed")]
    Detailed,
    #[serde(rename = "none")]
    None,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReasoningSummaryPartAddedNotification {
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "summaryIndex", default)]
    pub summary_index: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReasoningSummaryTextDeltaNotification {
    #[serde(default)]
    pub delta: String,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "summaryIndex", default)]
    pub summary_index: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReasoningTextDeltaNotification {
    #[serde(rename = "contentIndex", default)]
    pub content_index: i64,
    #[serde(default)]
    pub delta: String,
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum RemoteControlConnectionStatus {
    #[serde(rename = "disabled")]
    Disabled,
    #[serde(rename = "connecting")]
    Connecting,
    #[serde(rename = "connected")]
    Connected,
    #[serde(rename = "errored")]
    Errored,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteControlStatusChangedNotification {
    #[serde(
        rename = "environmentId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub environment_id: Option<String>,
    #[serde(rename = "installationId", default)]
    pub installation_id: String,
    #[serde()]
    pub status: RemoteControlConnectionStatus,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RequestId {
    Variant0(String),
    Variant1(i64),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RequestPermissionProfile {
    #[serde(
        rename = "fileSystem",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub file_system: Option<AdditionalFileSystemPermissions>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub network: Option<AdditionalNetworkPermissions>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ResidencyRequirement {
    #[serde(rename = "us")]
    Us,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Resource {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub _meta: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icons: Option<Vec<Value>>,
    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(default)]
    pub uri: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ResourceContent {
    Variant0(Value),
    Variant1(Value),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResourceTemplate {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
    pub mime_type: Option<String>,
    #[serde(default)]
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    #[serde(rename = "uriTemplate", default)]
    pub uri_template: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ReviewDecision {
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "approved_execpolicy_amendment")]
    ApprovedExecpolicyAmendment {
        proposed_execpolicy_amendment: Vec<String>,
    },
    #[serde(rename = "approved_for_session")]
    ApprovedForSession,
    #[serde(rename = "network_policy_amendment")]
    NetworkPolicyAmendment {
        network_policy_amendment: NetworkPolicyAmendment,
    },
    #[serde(rename = "denied")]
    Denied,
    #[serde(rename = "timed_out")]
    TimedOut,
    #[serde(rename = "abort")]
    Abort,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ReviewDelivery {
    #[serde(rename = "inline")]
    Inline,
    #[serde(rename = "detached")]
    Detached,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReviewStartParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delivery: Option<ReviewDelivery>,
    #[serde()]
    pub target: ReviewTarget,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReviewStartResponse {
    #[serde(rename = "reviewThreadId", default)]
    pub review_thread_id: String,
    #[serde()]
    pub turn: Turn,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ReviewTarget {
    #[serde(rename = "uncommittedChanges")]
    UncommittedChanges,
    #[serde(rename = "baseBranch")]
    BaseBranch {
        branch: String,
    },
    Commit {
        sha: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        title: Option<String>,
    },
    Custom {
        instructions: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum SandboxMode {
    #[serde(rename = "read-only")]
    Read_only,
    #[serde(rename = "workspace-write")]
    Workspace_write,
    #[serde(rename = "danger-full-access")]
    Danger_full_access,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum SandboxPolicy {
    #[serde(rename = "dangerFullAccess")]
    DangerFullAccess,
    #[serde(rename = "readOnly")]
    ReadOnly {
        #[serde(
            rename = "networkAccess",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        network_access: Option<bool>,
    },
    #[serde(rename = "externalSandbox")]
    ExternalSandbox {
        #[serde(
            rename = "networkAccess",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        network_access: Option<Value>,
    },
    #[serde(rename = "workspaceWrite")]
    WorkspaceWrite {
        #[serde(
            rename = "excludeSlashTmp",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        exclude_slash_tmp: Option<bool>,
        #[serde(
            rename = "excludeTmpdirEnvVar",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        exclude_tmpdir_env_var: Option<bool>,
        #[serde(
            rename = "networkAccess",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        network_access: Option<bool>,
        #[serde(
            rename = "writableRoots",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        writable_roots: Option<Vec<AbsolutePathBuf>>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SandboxWorkspaceWrite {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exclude_slash_tmp: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub exclude_tmpdir_env_var: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub network_access: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub writable_roots: Option<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SendAddCreditsNudgeEmailParams {
    #[serde(rename = "creditType")]
    pub credit_type: AddCreditsNudgeCreditType,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SendAddCreditsNudgeEmailResponse {
    #[serde()]
    pub status: AddCreditsNudgeEmailStatus,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServerRequestResolvedNotification {
    #[serde(rename = "requestId")]
    pub request_id: RequestId,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionMigration {
    #[serde(default)]
    pub cwd: String,
    #[serde(default)]
    pub path: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum SessionSource {
    #[serde(rename = "cli")]
    Cli,
    #[serde(rename = "vscode")]
    Vscode,
    #[serde(rename = "exec")]
    Exec,
    #[serde(rename = "appServer")]
    AppServer,
    #[serde(rename = "unknown")]
    Unknown,
    #[serde(rename = "custom")]
    Custom(String),
    #[serde(rename = "subAgent")]
    SubAgent(SubAgentSource),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillDependencies {
    #[serde(default)]
    pub tools: Vec<SkillToolDependency>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillErrorInfo {
    #[serde(default)]
    pub message: String,
    #[serde(default)]
    pub path: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillInterface {
    #[serde(
        rename = "brandColor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub brand_color: Option<String>,
    #[serde(
        rename = "defaultPrompt",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub default_prompt: Option<String>,
    #[serde(
        rename = "displayName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub display_name: Option<String>,
    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
    pub icon_large: Option<AbsolutePathBuf>,
    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
    pub icon_small: Option<AbsolutePathBuf>,
    #[serde(
        rename = "shortDescription",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub short_description: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillMetadata {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub dependencies: Option<SkillDependencies>,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interface: Option<SkillInterface>,
    #[serde(default)]
    pub name: String,
    #[serde()]
    pub path: AbsolutePathBuf,
    #[serde()]
    pub scope: SkillScope,
    #[serde(
        rename = "shortDescription",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub short_description: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum SkillScope {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "repo")]
    Repo,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "admin")]
    Admin,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillSummary {
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interface: Option<SkillInterface>,
    #[serde(default)]
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<AbsolutePathBuf>,
    #[serde(
        rename = "shortDescription",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub short_description: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillToolDependency {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub command: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub transport: Option<String>,
    #[serde(rename = "type", default)]
    pub type_: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub url: Option<String>,
    #[serde(default)]
    pub value: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillsChangedNotification {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillsConfigWriteParams {
    #[serde(default)]
    pub enabled: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<AbsolutePathBuf>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillsConfigWriteResponse {
    #[serde(rename = "effectiveEnabled", default)]
    pub effective_enabled: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillsListEntry {
    #[serde(default)]
    pub cwd: String,
    #[serde(default)]
    pub errors: Vec<SkillErrorInfo>,
    #[serde(default)]
    pub skills: Vec<SkillMetadata>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillsListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwds: Option<Vec<String>>,
    #[serde(
        rename = "forceReload",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub force_reload: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SkillsListResponse {
    #[serde(default)]
    pub data: Vec<SkillsListEntry>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum SortDirection {
    #[serde(rename = "asc")]
    Asc,
    #[serde(rename = "desc")]
    Desc,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum SubAgentSource {
    #[serde(rename = "review")]
    Review,
    #[serde(rename = "compact")]
    Compact,
    #[serde(rename = "memory_consolidation")]
    MemoryConsolidation,
    #[serde(rename = "thread_spawn")]
    ThreadSpawn {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        agent_nickname: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        agent_path: Option<AgentPath>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        agent_role: Option<String>,
        depth: i64,
        parent_thread_id: ThreadId,
    },
    #[serde(rename = "other")]
    Other(String),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SubagentMigration {
    #[serde(default)]
    pub name: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TerminalInteractionNotification {
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(rename = "processId", default)]
    pub process_id: String,
    #[serde(default)]
    pub stdin: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TextElement {
    #[serde(rename = "byteRange", default)]
    pub byte_range: Value,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub placeholder: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TextPosition {
    #[serde(default)]
    pub column: i64,
    #[serde(default)]
    pub line: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TextRange {
    #[serde()]
    pub end: TextPosition,
    #[serde()]
    pub start: TextPosition,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Thread {
    #[serde(
        rename = "agentNickname",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub agent_nickname: Option<String>,
    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
    pub agent_role: Option<String>,
    #[serde(rename = "cliVersion", default)]
    pub cli_version: String,
    #[serde(rename = "createdAt", default)]
    pub created_at: i64,
    #[serde(default)]
    pub cwd: Value,
    #[serde(default)]
    pub ephemeral: bool,
    #[serde(
        rename = "forkedFromId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub forked_from_id: Option<String>,
    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
    pub git_info: Option<GitInfo>,
    #[serde(default)]
    pub id: String,
    #[serde(rename = "modelProvider", default)]
    pub model_provider: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(default)]
    pub preview: String,
    #[serde(rename = "sessionId", default)]
    pub session_id: String,
    #[serde(default)]
    pub source: Value,
    #[serde(default)]
    pub status: Value,
    #[serde(
        rename = "threadSource",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub thread_source: Option<ThreadSource>,
    #[serde(default)]
    pub turns: Vec<Turn>,
    #[serde(rename = "updatedAt", default)]
    pub updated_at: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadActiveFlag {
    #[serde(rename = "waitingOnApproval")]
    WaitingOnApproval,
    #[serde(rename = "waitingOnUserInput")]
    WaitingOnUserInput,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadApproveGuardianDeniedActionParams {
    #[serde(default)]
    pub event: Value,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadApproveGuardianDeniedActionResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadArchiveParams {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadArchiveResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadArchivedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadClosedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadCompactStartParams {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadCompactStartResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadForkParams {
    #[serde(
        rename = "approvalPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approval_policy: Option<AskForApproval>,
    #[serde(
        rename = "approvalsReviewer",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approvals_reviewer: Option<ApprovalsReviewer>,
    #[serde(
        rename = "baseInstructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub base_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(
        rename = "developerInstructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub developer_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(
        rename = "modelProvider",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub model_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sandbox: Option<SandboxMode>,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(
        rename = "threadSource",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub thread_source: Option<ThreadSource>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadForkResponse {
    #[serde(rename = "approvalPolicy")]
    pub approval_policy: AskForApproval,
    #[serde(rename = "approvalsReviewer", default)]
    pub approvals_reviewer: Value,
    #[serde()]
    pub cwd: AbsolutePathBuf,
    #[serde(
        rename = "instructionSources",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
    #[serde(default)]
    pub model: String,
    #[serde(rename = "modelProvider", default)]
    pub model_provider: String,
    #[serde(
        rename = "reasoningEffort",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub reasoning_effort: Option<ReasoningEffort>,
    #[serde(default)]
    pub sandbox: Value,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadGoal {
    #[serde(rename = "createdAt", default)]
    pub created_at: i64,
    #[serde(default)]
    pub objective: String,
    #[serde()]
    pub status: ThreadGoalStatus,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "timeUsedSeconds", default)]
    pub time_used_seconds: i64,
    #[serde(
        rename = "tokenBudget",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub token_budget: Option<i64>,
    #[serde(rename = "tokensUsed", default)]
    pub tokens_used: i64,
    #[serde(rename = "updatedAt", default)]
    pub updated_at: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadGoalClearedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadGoalStatus {
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "paused")]
    Paused,
    #[serde(rename = "budgetLimited")]
    BudgetLimited,
    #[serde(rename = "complete")]
    Complete,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadGoalUpdatedNotification {
    #[serde()]
    pub goal: ThreadGoal,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
    pub turn_id: Option<String>,
}

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

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadInjectItemsParams {
    #[serde(default)]
    pub items: Vec<Value>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadInjectItemsResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ThreadItem {
    #[serde(rename = "userMessage")]
    UserMessage {
        content: Vec<UserInput>,
        id: String,
    },
    #[serde(rename = "hookPrompt")]
    HookPrompt {
        fragments: Vec<HookPromptFragment>,
        id: String,
    },
    #[serde(rename = "agentMessage")]
    AgentMessage {
        id: String,
        #[serde(
            rename = "memoryCitation",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        memory_citation: Option<MemoryCitation>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        phase: Option<MessagePhase>,
        text: String,
    },
    Plan {
        id: String,
        text: String,
    },
    Reasoning {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        content: Option<Vec<String>>,
        id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        summary: Option<Vec<String>>,
    },
    #[serde(rename = "commandExecution")]
    CommandExecution {
        #[serde(
            rename = "aggregatedOutput",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        aggregated_output: Option<String>,
        command: String,
        #[serde(rename = "commandActions")]
        command_actions: Vec<CommandAction>,
        cwd: Value,
        #[serde(
            rename = "durationMs",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        duration_ms: Option<i64>,
        #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
        exit_code: Option<i64>,
        id: String,
        #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
        process_id: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        source: Option<Value>,
        status: CommandExecutionStatus,
    },
    #[serde(rename = "fileChange")]
    FileChange {
        changes: Vec<FileUpdateChange>,
        id: String,
        status: PatchApplyStatus,
    },
    #[serde(rename = "mcpToolCall")]
    McpToolCall {
        arguments: Value,
        #[serde(
            rename = "durationMs",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        duration_ms: Option<i64>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        error: Option<McpToolCallError>,
        id: String,
        #[serde(
            rename = "mcpAppResourceUri",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        mcp_app_resource_uri: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        result: Option<McpToolCallResult>,
        server: String,
        status: McpToolCallStatus,
        tool: String,
    },
    #[serde(rename = "dynamicToolCall")]
    DynamicToolCall {
        arguments: Value,
        #[serde(
            rename = "contentItems",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        content_items: Option<Vec<DynamicToolCallOutputContentItem>>,
        #[serde(
            rename = "durationMs",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        duration_ms: Option<i64>,
        id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        namespace: Option<String>,
        status: DynamicToolCallStatus,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        success: Option<bool>,
        tool: String,
    },
    #[serde(rename = "collabAgentToolCall")]
    CollabAgentToolCall {
        #[serde(rename = "agentsStates")]
        agents_states: std::collections::BTreeMap<String, CollabAgentState>,
        id: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        model: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        prompt: Option<String>,
        #[serde(
            rename = "reasoningEffort",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        reasoning_effort: Option<ReasoningEffort>,
        #[serde(rename = "receiverThreadIds")]
        receiver_thread_ids: Vec<String>,
        #[serde(rename = "senderThreadId")]
        sender_thread_id: String,
        status: Value,
        tool: Value,
    },
    #[serde(rename = "webSearch")]
    WebSearch {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        action: Option<WebSearchAction>,
        id: String,
        query: String,
    },
    #[serde(rename = "imageView")]
    ImageView {
        id: String,
        path: AbsolutePathBuf,
    },
    #[serde(rename = "imageGeneration")]
    ImageGeneration {
        id: String,
        result: String,
        #[serde(
            rename = "revisedPrompt",
            default,
            skip_serializing_if = "Option::is_none"
        )]
        revised_prompt: Option<String>,
        #[serde(rename = "savedPath", default, skip_serializing_if = "Option::is_none")]
        saved_path: Option<AbsolutePathBuf>,
        status: String,
    },
    #[serde(rename = "enteredReviewMode")]
    EnteredReviewMode {
        id: String,
        review: String,
    },
    #[serde(rename = "exitedReviewMode")]
    ExitedReviewMode {
        id: String,
        review: String,
    },
    #[serde(rename = "contextCompaction")]
    ContextCompaction {
        id: String,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ThreadListCwdFilter {
    Variant0(String),
    Variant1(Vec<String>),
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub archived: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<ThreadListCwdFilter>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(
        rename = "modelProviders",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub model_providers: Option<Vec<String>>,
    #[serde(
        rename = "searchTerm",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub search_term: Option<String>,
    #[serde(
        rename = "sortDirection",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub sort_direction: Option<SortDirection>,
    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
    pub sort_key: Option<ThreadSortKey>,
    #[serde(
        rename = "sourceKinds",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub source_kinds: Option<Vec<ThreadSourceKind>>,
    #[serde(
        rename = "useStateDbOnly",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub use_state_db_only: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadListResponse {
    #[serde(
        rename = "backwardsCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub backwards_cursor: Option<String>,
    #[serde(default)]
    pub data: Vec<Thread>,
    #[serde(
        rename = "nextCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadLoadedListParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadLoadedListResponse {
    #[serde(default)]
    pub data: Vec<String>,
    #[serde(
        rename = "nextCursor",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub next_cursor: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadMetadataGitInfoUpdateParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
    pub origin_url: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sha: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadMetadataUpdateParams {
    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadMetadataUpdateResponse {
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadNameUpdatedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(
        rename = "threadName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub thread_name: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadReadParams {
    #[serde(
        rename = "includeTurns",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub include_turns: Option<bool>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadReadResponse {
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeAudioChunk {
    #[serde(default)]
    pub data: String,
    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
    pub item_id: Option<String>,
    #[serde(rename = "numChannels", default)]
    pub num_channels: i64,
    #[serde(rename = "sampleRate", default)]
    pub sample_rate: i64,
    #[serde(
        rename = "samplesPerChannel",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub samples_per_channel: Option<i64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeClosedNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeErrorNotification {
    #[serde(default)]
    pub message: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeItemAddedNotification {
    #[serde(default)]
    pub item: Value,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeOutputAudioDeltaNotification {
    #[serde()]
    pub audio: ThreadRealtimeAudioChunk,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeSdpNotification {
    #[serde(default)]
    pub sdp: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeStartedNotification {
    #[serde(
        rename = "realtimeSessionId",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub realtime_session_id: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde()]
    pub version: RealtimeConversationVersion,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeTranscriptDeltaNotification {
    #[serde(default)]
    pub delta: String,
    #[serde(default)]
    pub role: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRealtimeTranscriptDoneNotification {
    #[serde(default)]
    pub role: String,
    #[serde(default)]
    pub text: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadResumeParams {
    #[serde(
        rename = "approvalPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approval_policy: Option<AskForApproval>,
    #[serde(
        rename = "approvalsReviewer",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approvals_reviewer: Option<ApprovalsReviewer>,
    #[serde(
        rename = "baseInstructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub base_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(
        rename = "developerInstructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub developer_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(
        rename = "modelProvider",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub model_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub personality: Option<Personality>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sandbox: Option<SandboxMode>,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadResumeResponse {
    #[serde(rename = "approvalPolicy")]
    pub approval_policy: AskForApproval,
    #[serde(rename = "approvalsReviewer", default)]
    pub approvals_reviewer: Value,
    #[serde()]
    pub cwd: AbsolutePathBuf,
    #[serde(
        rename = "instructionSources",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
    #[serde(default)]
    pub model: String,
    #[serde(rename = "modelProvider", default)]
    pub model_provider: String,
    #[serde(
        rename = "reasoningEffort",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub reasoning_effort: Option<ReasoningEffort>,
    #[serde(default)]
    pub sandbox: Value,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRollbackParams {
    #[serde(rename = "numTurns", default)]
    pub num_turns: i64,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadRollbackResponse {
    #[serde(default)]
    pub thread: Value,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadSetNameParams {
    #[serde(default)]
    pub name: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadSetNameResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadShellCommandParams {
    #[serde(default)]
    pub command: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadShellCommandResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadSortKey {
    #[serde(rename = "created_at")]
    Created_at,
    #[serde(rename = "updated_at")]
    Updated_at,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadSource {
    #[serde(rename = "user")]
    User,
    #[serde(rename = "subagent")]
    Subagent,
    #[serde(rename = "memory_consolidation")]
    Memory_consolidation,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadSourceKind {
    #[serde(rename = "cli")]
    Cli,
    #[serde(rename = "vscode")]
    Vscode,
    #[serde(rename = "exec")]
    Exec,
    #[serde(rename = "appServer")]
    AppServer,
    #[serde(rename = "subAgent")]
    SubAgent,
    #[serde(rename = "subAgentReview")]
    SubAgentReview,
    #[serde(rename = "subAgentCompact")]
    SubAgentCompact,
    #[serde(rename = "subAgentThreadSpawn")]
    SubAgentThreadSpawn,
    #[serde(rename = "subAgentOther")]
    SubAgentOther,
    #[serde(rename = "unknown")]
    Unknown,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadStartParams {
    #[serde(
        rename = "approvalPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approval_policy: Option<AskForApproval>,
    #[serde(
        rename = "approvalsReviewer",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approvals_reviewer: Option<ApprovalsReviewer>,
    #[serde(
        rename = "baseInstructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub base_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub config: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(
        rename = "developerInstructions",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub developer_instructions: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(
        rename = "modelProvider",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub model_provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub personality: Option<Personality>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sandbox: Option<SandboxMode>,
    #[serde(
        rename = "serviceName",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_name: Option<String>,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde(
        rename = "sessionStartSource",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub session_start_source: Option<ThreadStartSource>,
    #[serde(
        rename = "threadSource",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub thread_source: Option<ThreadSource>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadStartResponse {
    #[serde(rename = "approvalPolicy")]
    pub approval_policy: AskForApproval,
    #[serde(rename = "approvalsReviewer", default)]
    pub approvals_reviewer: Value,
    #[serde()]
    pub cwd: AbsolutePathBuf,
    #[serde(
        rename = "instructionSources",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
    #[serde(default)]
    pub model: String,
    #[serde(rename = "modelProvider", default)]
    pub model_provider: String,
    #[serde(
        rename = "reasoningEffort",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub reasoning_effort: Option<ReasoningEffort>,
    #[serde(default)]
    pub sandbox: Value,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadStartSource {
    #[serde(rename = "startup")]
    Startup,
    #[serde(rename = "clear")]
    Clear,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadStartedNotification {
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ThreadStatus {
    #[serde(rename = "notLoaded")]
    NotLoaded,
    Idle,
    #[serde(rename = "systemError")]
    SystemError,
    Active {
        #[serde(rename = "activeFlags")]
        active_flags: Vec<ThreadActiveFlag>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadStatusChangedNotification {
    #[serde()]
    pub status: ThreadStatus,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadTokenUsage {
    #[serde()]
    pub last: TokenUsageBreakdown,
    #[serde(
        rename = "modelContextWindow",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub model_context_window: Option<i64>,
    #[serde()]
    pub total: TokenUsageBreakdown,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadTokenUsageUpdatedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "tokenUsage")]
    pub token_usage: ThreadTokenUsage,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadUnarchiveParams {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadUnarchiveResponse {
    #[serde()]
    pub thread: Thread,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadUnarchivedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadUnsubscribeParams {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadUnsubscribeResponse {
    #[serde()]
    pub status: ThreadUnsubscribeStatus,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum ThreadUnsubscribeStatus {
    #[serde(rename = "notLoaded")]
    NotLoaded,
    #[serde(rename = "notSubscribed")]
    NotSubscribed,
    #[serde(rename = "unsubscribed")]
    Unsubscribed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TokenUsageBreakdown {
    #[serde(rename = "cachedInputTokens", default)]
    pub cached_input_tokens: i64,
    #[serde(rename = "inputTokens", default)]
    pub input_tokens: i64,
    #[serde(rename = "outputTokens", default)]
    pub output_tokens: i64,
    #[serde(rename = "reasoningOutputTokens", default)]
    pub reasoning_output_tokens: i64,
    #[serde(rename = "totalTokens", default)]
    pub total_tokens: i64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Tool {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub _meta: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icons: Option<Vec<Value>>,
    #[serde(rename = "inputSchema", default)]
    pub input_schema: Value,
    #[serde(default)]
    pub name: String,
    #[serde(
        rename = "outputSchema",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub output_schema: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolRequestUserInputAnswer {
    #[serde(default)]
    pub answers: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolRequestUserInputOption {
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub label: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolRequestUserInputParams {
    #[serde(rename = "itemId", default)]
    pub item_id: String,
    #[serde(default)]
    pub questions: Vec<ToolRequestUserInputQuestion>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolRequestUserInputQuestion {
    #[serde(default)]
    pub header: String,
    #[serde(default)]
    pub id: String,
    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
    pub is_other: Option<bool>,
    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
    pub is_secret: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub options: Option<Vec<ToolRequestUserInputOption>>,
    #[serde(default)]
    pub question: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolRequestUserInputResponse {
    #[serde(default)]
    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolsV2 {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub web_search: Option<WebSearchToolConfig>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Turn {
    #[serde(
        rename = "completedAt",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub completed_at: Option<i64>,
    #[serde(
        rename = "durationMs",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub duration_ms: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<TurnError>,
    #[serde(default)]
    pub id: String,
    #[serde(default)]
    pub items: Vec<ThreadItem>,
    #[serde(rename = "itemsView", default, skip_serializing_if = "Option::is_none")]
    pub items_view: Option<Value>,
    #[serde(rename = "startedAt", default, skip_serializing_if = "Option::is_none")]
    pub started_at: Option<i64>,
    #[serde()]
    pub status: TurnStatus,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnCompletedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde()]
    pub turn: Turn,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnDiffUpdatedNotification {
    #[serde(default)]
    pub diff: String,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnError {
    #[serde(
        rename = "additionalDetails",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub additional_details: Option<String>,
    #[serde(
        rename = "codexErrorInfo",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub codex_error_info: Option<CodexErrorInfo>,
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnInterruptParams {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnInterruptResponse {
    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
    pub extra: serde_json::Map<String, Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum TurnItemsView {
    #[serde(rename = "notLoaded")]
    NotLoaded,
    #[serde(rename = "summary")]
    Summary,
    #[serde(rename = "full")]
    Full,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnPlanStep {
    #[serde()]
    pub status: TurnPlanStepStatus,
    #[serde(default)]
    pub step: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum TurnPlanStepStatus {
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "inProgress")]
    InProgress,
    #[serde(rename = "completed")]
    Completed,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnPlanUpdatedNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub explanation: Option<String>,
    #[serde(default)]
    pub plan: Vec<TurnPlanStep>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnStartParams {
    #[serde(
        rename = "approvalPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approval_policy: Option<AskForApproval>,
    #[serde(
        rename = "approvalsReviewer",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub approvals_reviewer: Option<ApprovalsReviewer>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub effort: Option<ReasoningEffort>,
    #[serde(default)]
    pub input: Vec<UserInput>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(
        rename = "outputSchema",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub output_schema: Option<Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub personality: Option<Personality>,
    #[serde(
        rename = "sandboxPolicy",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub sandbox_policy: Option<SandboxPolicy>,
    #[serde(
        rename = "serviceTier",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub service_tier: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub summary: Option<ReasoningSummary>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnStartResponse {
    #[serde()]
    pub turn: Turn,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnStartedNotification {
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
    #[serde()]
    pub turn: Turn,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum TurnStatus {
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "interrupted")]
    Interrupted,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "inProgress")]
    InProgress,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnSteerParams {
    #[serde(rename = "expectedTurnId", default)]
    pub expected_turn_id: String,
    #[serde(default)]
    pub input: Vec<UserInput>,
    #[serde(rename = "threadId", default)]
    pub thread_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnSteerResponse {
    #[serde(rename = "turnId", default)]
    pub turn_id: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum UserInput {
    Text {
        text: String,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        text_elements: Option<Vec<TextElement>>,
    },
    Image {
        url: String,
    },
    #[serde(rename = "localImage")]
    LocalImage {
        path: String,
    },
    Skill {
        name: String,
        path: String,
    },
    Mention {
        name: String,
        path: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum Verbosity {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WarningNotification {
    #[serde(default)]
    pub message: String,
    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum WebSearchAction {
    Search {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        queries: Option<Vec<String>>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        query: Option<String>,
    },
    #[serde(rename = "openPage")]
    OpenPage {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        url: Option<String>,
    },
    #[serde(rename = "findInPage")]
    FindInPage {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        pattern: Option<String>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        url: Option<String>,
    },
    Other,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum WebSearchContextSize {
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WebSearchLocation {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum WebSearchMode {
    #[serde(rename = "disabled")]
    Disabled,
    #[serde(rename = "cached")]
    Cached,
    #[serde(rename = "live")]
    Live,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WebSearchToolConfig {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub allowed_domains: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub context_size: Option<WebSearchContextSize>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<WebSearchLocation>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum WindowsSandboxReadiness {
    #[serde(rename = "ready")]
    Ready,
    #[serde(rename = "notConfigured")]
    NotConfigured,
    #[serde(rename = "updateRequired")]
    UpdateRequired,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WindowsSandboxReadinessResponse {
    #[serde()]
    pub status: WindowsSandboxReadiness,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WindowsSandboxSetupCompletedNotification {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde()]
    pub mode: WindowsSandboxSetupMode,
    #[serde(default)]
    pub success: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum WindowsSandboxSetupMode {
    #[serde(rename = "elevated")]
    Elevated,
    #[serde(rename = "unelevated")]
    Unelevated,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WindowsSandboxSetupStartParams {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cwd: Option<AbsolutePathBuf>,
    #[serde()]
    pub mode: WindowsSandboxSetupMode,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WindowsSandboxSetupStartResponse {
    #[serde(default)]
    pub started: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WindowsWorldWritableWarningNotification {
    #[serde(rename = "extraCount", default)]
    pub extra_count: i64,
    #[serde(rename = "failedScan", default)]
    pub failed_scan: bool,
    #[serde(rename = "samplePaths", default)]
    pub sample_paths: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum WriteStatus {
    #[serde(rename = "ok")]
    Ok,
    #[serde(rename = "okOverridden")]
    OkOverridden,
}