Skip to main content

opencode_codes/protocol_generated/
types.rs

1// AUTO-GENERATED by scripts/codegen_opencode.py — DO NOT EDIT BY HAND.
2// Source: opencode-codes/tests/schemas/opencode_openapi.json (opencode 1.18.5).
3// Run `python3 scripts/codegen_opencode.py` to regenerate.
4//
5// Every schema in components.schemas is emitted, plus synthesized named types
6// for the six hand-wrapped endpoints' inline request/response bodies and for
7// inline object / union field shapes. Discriminated unions become internally-
8// tagged serde enums; all-string unions become open enums with Unknown(String);
9// remaining unions are #[serde(untagged)] with branch order preserved. Inline
10// string-enum fields are represented as String.
11
12#![allow(
13    clippy::large_enum_variant,
14    clippy::enum_variant_names,
15    clippy::doc_markdown,
16    clippy::doc_lazy_continuation
17)]
18
19use serde::{Deserialize, Deserializer, Serialize, Serializer};
20
21#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
22pub struct APIError {
23    pub data: APIErrorData,
24    #[serde(default, skip_serializing)]
25    pub name: String,
26}
27
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
29pub struct APIErrorData {
30    #[serde(rename = "isRetryable")]
31    pub is_retryable: bool,
32    pub message: String,
33    #[serde(default, skip_serializing_if = "Option::is_none")]
34    pub metadata: Option<std::collections::BTreeMap<String, String>>,
35    #[serde(
36        rename = "responseBody",
37        default,
38        skip_serializing_if = "Option::is_none"
39    )]
40    pub response_body: Option<String>,
41    #[serde(
42        rename = "responseHeaders",
43        default,
44        skip_serializing_if = "Option::is_none"
45    )]
46    pub response_headers: Option<std::collections::BTreeMap<String, String>>,
47    #[serde(
48        rename = "statusCode",
49        default,
50        skip_serializing_if = "Option::is_none"
51    )]
52    pub status_code: Option<u64>,
53}
54
55#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
56pub struct Agent {
57    #[serde(default, skip_serializing_if = "Option::is_none")]
58    pub color: Option<String>,
59    #[serde(default, skip_serializing_if = "Option::is_none")]
60    pub description: Option<String>,
61    #[serde(default, skip_serializing_if = "Option::is_none")]
62    pub hidden: Option<bool>,
63    pub mode: String,
64    #[serde(default, skip_serializing_if = "Option::is_none")]
65    pub model: Option<AgentModel>,
66    pub name: String,
67    #[serde(default, skip_serializing_if = "Option::is_none")]
68    pub native: Option<bool>,
69    pub options: serde_json::Map<String, serde_json::Value>,
70    pub permission: PermissionRuleset,
71    #[serde(default, skip_serializing_if = "Option::is_none")]
72    pub prompt: Option<String>,
73    #[serde(default, skip_serializing_if = "Option::is_none")]
74    pub steps: Option<f64>,
75    #[serde(default, skip_serializing_if = "Option::is_none")]
76    pub temperature: Option<f64>,
77    #[serde(rename = "topP", default, skip_serializing_if = "Option::is_none")]
78    pub top_p: Option<f64>,
79    #[serde(default, skip_serializing_if = "Option::is_none")]
80    pub variant: Option<String>,
81}
82
83#[derive(Debug, Clone, PartialEq, Eq, Hash)]
84pub enum AgentColor {
85    Primary,
86    Secondary,
87    Accent,
88    Success,
89    Warning,
90    Error,
91    Info,
92    Unknown(String),
93}
94
95impl AgentColor {
96    pub fn as_str(&self) -> &str {
97        match self {
98            Self::Primary => "primary",
99            Self::Secondary => "secondary",
100            Self::Accent => "accent",
101            Self::Success => "success",
102            Self::Warning => "warning",
103            Self::Error => "error",
104            Self::Info => "info",
105            Self::Unknown(s) => s.as_str(),
106        }
107    }
108}
109
110impl std::fmt::Display for AgentColor {
111    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
112        f.write_str(self.as_str())
113    }
114}
115
116impl From<&str> for AgentColor {
117    fn from(s: &str) -> Self {
118        match s {
119            "primary" => Self::Primary,
120            "secondary" => Self::Secondary,
121            "accent" => Self::Accent,
122            "success" => Self::Success,
123            "warning" => Self::Warning,
124            "error" => Self::Error,
125            "info" => Self::Info,
126            other => Self::Unknown(other.to_string()),
127        }
128    }
129}
130
131impl Serialize for AgentColor {
132    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
133        serializer.serialize_str(self.as_str())
134    }
135}
136
137impl<'de> Deserialize<'de> for AgentColor {
138    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
139        let s = String::deserialize(deserializer)?;
140        Ok(Self::from(s.as_str()))
141    }
142}
143
144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
145pub struct AgentConfig {
146    #[serde(default, skip_serializing_if = "Option::is_none")]
147    pub color: Option<AgentConfigColor>,
148    #[serde(default, skip_serializing_if = "Option::is_none")]
149    pub description: Option<String>,
150    #[serde(default, skip_serializing_if = "Option::is_none")]
151    pub disable: Option<bool>,
152    #[serde(default, skip_serializing_if = "Option::is_none")]
153    pub hidden: Option<bool>,
154    #[serde(rename = "maxSteps", default, skip_serializing_if = "Option::is_none")]
155    pub max_steps: Option<i64>,
156    #[serde(default, skip_serializing_if = "Option::is_none")]
157    pub mode: Option<String>,
158    #[serde(default, skip_serializing_if = "Option::is_none")]
159    pub model: Option<String>,
160    #[serde(default, skip_serializing_if = "Option::is_none")]
161    pub options: Option<serde_json::Map<String, serde_json::Value>>,
162    #[serde(default, skip_serializing_if = "Option::is_none")]
163    pub permission: Option<PermissionConfig>,
164    #[serde(default, skip_serializing_if = "Option::is_none")]
165    pub prompt: Option<String>,
166    #[serde(default, skip_serializing_if = "Option::is_none")]
167    pub steps: Option<i64>,
168    #[serde(default, skip_serializing_if = "Option::is_none")]
169    pub temperature: Option<f64>,
170    #[serde(default, skip_serializing_if = "Option::is_none")]
171    pub tools: Option<std::collections::BTreeMap<String, bool>>,
172    #[serde(default, skip_serializing_if = "Option::is_none")]
173    pub top_p: Option<f64>,
174    #[serde(default, skip_serializing_if = "Option::is_none")]
175    pub variant: Option<String>,
176}
177
178/// Hex color code (e.g., #FF5733) or theme color (e.g., primary)
179#[derive(Debug, Clone, PartialEq, Eq, Hash)]
180pub enum AgentConfigColor {
181    Primary,
182    Secondary,
183    Accent,
184    Success,
185    Warning,
186    Error,
187    Info,
188    Unknown(String),
189}
190
191impl AgentConfigColor {
192    pub fn as_str(&self) -> &str {
193        match self {
194            Self::Primary => "primary",
195            Self::Secondary => "secondary",
196            Self::Accent => "accent",
197            Self::Success => "success",
198            Self::Warning => "warning",
199            Self::Error => "error",
200            Self::Info => "info",
201            Self::Unknown(s) => s.as_str(),
202        }
203    }
204}
205
206impl std::fmt::Display for AgentConfigColor {
207    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
208        f.write_str(self.as_str())
209    }
210}
211
212impl From<&str> for AgentConfigColor {
213    fn from(s: &str) -> Self {
214        match s {
215            "primary" => Self::Primary,
216            "secondary" => Self::Secondary,
217            "accent" => Self::Accent,
218            "success" => Self::Success,
219            "warning" => Self::Warning,
220            "error" => Self::Error,
221            "info" => Self::Info,
222            other => Self::Unknown(other.to_string()),
223        }
224    }
225}
226
227impl Serialize for AgentConfigColor {
228    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
229        serializer.serialize_str(self.as_str())
230    }
231}
232
233impl<'de> Deserialize<'de> for AgentConfigColor {
234    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
235        let s = String::deserialize(deserializer)?;
236        Ok(Self::from(s.as_str()))
237    }
238}
239
240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
241pub struct AgentModel {
242    #[serde(rename = "modelID")]
243    pub model_id: String,
244    #[serde(rename = "providerID")]
245    pub provider_id: String,
246}
247
248#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
249pub struct AgentPart {
250    pub id: String,
251    #[serde(rename = "messageID")]
252    pub message_id: String,
253    pub name: String,
254    #[serde(rename = "sessionID")]
255    pub session_id: String,
256    #[serde(default, skip_serializing_if = "Option::is_none")]
257    pub source: Option<AgentPartInputSource>,
258    #[serde(rename = "type", default, skip_serializing)]
259    pub type_: String,
260}
261
262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
263pub struct AgentPartInput {
264    #[serde(default, skip_serializing_if = "Option::is_none")]
265    pub id: Option<String>,
266    pub name: String,
267    #[serde(default, skip_serializing_if = "Option::is_none")]
268    pub source: Option<AgentPartInputSource>,
269    #[serde(rename = "type", default, skip_serializing)]
270    pub type_: String,
271}
272
273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
274pub struct AgentPartInputSource {
275    pub end: u64,
276    pub start: u64,
277    pub value: String,
278}
279
280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
281pub struct AgentV2Info {
282    #[serde(default, skip_serializing_if = "Option::is_none")]
283    pub color: Option<AgentColor>,
284    #[serde(default, skip_serializing_if = "Option::is_none")]
285    pub description: Option<String>,
286    pub hidden: bool,
287    pub id: String,
288    pub mode: String,
289    #[serde(default, skip_serializing_if = "Option::is_none")]
290    pub model: Option<ModelRef>,
291    pub permissions: PermissionV2Ruleset,
292    pub request: ProviderRequest,
293    #[serde(default, skip_serializing_if = "Option::is_none")]
294    pub steps: Option<i64>,
295    #[serde(default, skip_serializing_if = "Option::is_none")]
296    pub system: Option<String>,
297}
298
299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
300pub struct ApiAuth {
301    pub key: String,
302    #[serde(default, skip_serializing_if = "Option::is_none")]
303    pub metadata: Option<std::collections::BTreeMap<String, String>>,
304    #[serde(rename = "type", default, skip_serializing)]
305    pub type_: String,
306}
307
308#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
309pub struct AssistantMessage {
310    pub agent: String,
311    pub cost: f64,
312    #[serde(default, skip_serializing_if = "Option::is_none")]
313    pub error: Option<SessionErrorDataError>,
314    #[serde(default, skip_serializing_if = "Option::is_none")]
315    pub finish: Option<String>,
316    pub id: String,
317    pub mode: String,
318    #[serde(rename = "modelID")]
319    pub model_id: String,
320    #[serde(rename = "parentID")]
321    pub parent_id: String,
322    pub path: AssistantMessagePath,
323    #[serde(rename = "providerID")]
324    pub provider_id: String,
325    #[serde(default, skip_serializing)]
326    pub role: String,
327    #[serde(rename = "sessionID")]
328    pub session_id: String,
329    #[serde(default, skip_serializing_if = "Option::is_none")]
330    pub structured: Option<serde_json::Value>,
331    #[serde(default, skip_serializing_if = "Option::is_none")]
332    pub summary: Option<bool>,
333    pub time: AssistantMessageTime,
334    pub tokens: StepFinishPartTokens,
335    #[serde(default, skip_serializing_if = "Option::is_none")]
336    pub variant: Option<String>,
337}
338
339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
340pub struct AssistantMessagePath {
341    pub cwd: String,
342    pub root: String,
343}
344
345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
346pub struct AssistantMessageTime {
347    #[serde(default, skip_serializing_if = "Option::is_none")]
348    pub completed: Option<u64>,
349    pub created: u64,
350}
351
352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
353pub struct AttachmentConfig {
354    #[serde(default, skip_serializing_if = "Option::is_none")]
355    pub image: Option<ImageAttachmentConfig>,
356}
357
358#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
359#[serde(tag = "type")]
360pub enum Auth {
361    #[serde(rename = "oauth")]
362    Oauth(OAuth),
363    #[serde(rename = "api")]
364    Api(ApiAuth),
365    #[serde(rename = "wellknown")]
366    Wellknown(WellKnownAuth),
367}
368
369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
370pub struct BadRequestError {
371    pub data: BadRequestErrorData,
372    pub name: String,
373}
374
375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
376pub struct BadRequestErrorData {
377    #[serde(default, skip_serializing_if = "Option::is_none")]
378    pub kind: Option<String>,
379    pub message: String,
380}
381
382#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
383pub struct CatalogUpdated {
384    pub data: serde_json::Map<String, serde_json::Value>,
385    #[serde(default, skip_serializing_if = "Option::is_none")]
386    pub durable: Option<SessionStatus2Durable>,
387    pub id: String,
388    #[serde(default, skip_serializing_if = "Option::is_none")]
389    pub location: Option<LocationRef>,
390    #[serde(default, skip_serializing_if = "Option::is_none")]
391    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
392    #[serde(rename = "type", default, skip_serializing)]
393    pub type_: String,
394}
395
396#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
397pub struct Command {
398    #[serde(default, skip_serializing_if = "Option::is_none")]
399    pub agent: Option<String>,
400    #[serde(default, skip_serializing_if = "Option::is_none")]
401    pub description: Option<String>,
402    pub hints: Vec<String>,
403    #[serde(default, skip_serializing_if = "Option::is_none")]
404    pub model: Option<String>,
405    pub name: String,
406    #[serde(default, skip_serializing_if = "Option::is_none")]
407    pub source: Option<String>,
408    #[serde(default, skip_serializing_if = "Option::is_none")]
409    pub subtask: Option<bool>,
410    pub template: String,
411}
412
413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
414pub struct CommandExecuted {
415    pub data: CommandExecutedData,
416    #[serde(default, skip_serializing_if = "Option::is_none")]
417    pub durable: Option<SessionStatus2Durable>,
418    pub id: String,
419    #[serde(default, skip_serializing_if = "Option::is_none")]
420    pub location: Option<LocationRef>,
421    #[serde(default, skip_serializing_if = "Option::is_none")]
422    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
423    #[serde(rename = "type", default, skip_serializing)]
424    pub type_: String,
425}
426
427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
428pub struct CommandExecutedData {
429    pub arguments: String,
430    #[serde(rename = "messageID")]
431    pub message_id: String,
432    pub name: String,
433    #[serde(rename = "sessionID")]
434    pub session_id: String,
435}
436
437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
438pub struct CommandV2Info {
439    #[serde(default, skip_serializing_if = "Option::is_none")]
440    pub agent: Option<String>,
441    #[serde(default, skip_serializing_if = "Option::is_none")]
442    pub description: Option<String>,
443    #[serde(default, skip_serializing_if = "Option::is_none")]
444    pub model: Option<ModelRef>,
445    pub name: String,
446    #[serde(default, skip_serializing_if = "Option::is_none")]
447    pub subtask: Option<bool>,
448    pub template: String,
449}
450
451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
452pub struct CompactionPart {
453    pub auto: bool,
454    pub id: String,
455    #[serde(rename = "messageID")]
456    pub message_id: String,
457    #[serde(default, skip_serializing_if = "Option::is_none")]
458    pub overflow: Option<bool>,
459    #[serde(rename = "sessionID")]
460    pub session_id: String,
461    #[serde(default, skip_serializing_if = "Option::is_none")]
462    pub tail_start_id: Option<String>,
463    #[serde(rename = "type", default, skip_serializing)]
464    pub type_: String,
465}
466
467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
468pub struct Config {
469    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
470    pub schema: Option<String>,
471    #[serde(default, skip_serializing_if = "Option::is_none")]
472    pub agent: Option<ConfigAgent>,
473    #[serde(default, skip_serializing_if = "Option::is_none")]
474    pub attachment: Option<AttachmentConfig>,
475    #[serde(default, skip_serializing_if = "Option::is_none")]
476    pub autoshare: Option<bool>,
477    #[serde(default, skip_serializing_if = "Option::is_none")]
478    pub autoupdate: Option<ConfigAutoupdate>,
479    #[serde(default, skip_serializing_if = "Option::is_none")]
480    pub command: Option<std::collections::BTreeMap<String, ConfigCommandValue>>,
481    #[serde(default, skip_serializing_if = "Option::is_none")]
482    pub compaction: Option<ConfigCompaction>,
483    #[serde(default, skip_serializing_if = "Option::is_none")]
484    pub default_agent: Option<String>,
485    #[serde(default, skip_serializing_if = "Option::is_none")]
486    pub disabled_providers: Option<Vec<String>>,
487    #[serde(default, skip_serializing_if = "Option::is_none")]
488    pub enabled_providers: Option<Vec<String>>,
489    #[serde(default, skip_serializing_if = "Option::is_none")]
490    pub enterprise: Option<ConfigEnterprise>,
491    #[serde(default, skip_serializing_if = "Option::is_none")]
492    pub experimental: Option<ConfigExperimental>,
493    #[serde(default, skip_serializing_if = "Option::is_none")]
494    pub formatter: Option<ConfigFormatter>,
495    #[serde(default, skip_serializing_if = "Option::is_none")]
496    pub instructions: Option<Vec<String>>,
497    #[serde(default, skip_serializing_if = "Option::is_none")]
498    pub layout: Option<LayoutConfig>,
499    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
500    pub log_level: Option<LogLevel>,
501    #[serde(default, skip_serializing_if = "Option::is_none")]
502    pub lsp: Option<ConfigLsp>,
503    #[serde(default, skip_serializing_if = "Option::is_none")]
504    pub mcp: Option<std::collections::BTreeMap<String, ConfigMcpValue>>,
505    #[serde(default, skip_serializing_if = "Option::is_none")]
506    pub mode: Option<ConfigMode>,
507    #[serde(default, skip_serializing_if = "Option::is_none")]
508    pub model: Option<String>,
509    #[serde(default, skip_serializing_if = "Option::is_none")]
510    pub permission: Option<PermissionConfig>,
511    #[serde(default, skip_serializing_if = "Option::is_none")]
512    pub plugin: Option<Vec<ConfigPluginItem>>,
513    #[serde(default, skip_serializing_if = "Option::is_none")]
514    pub provider: Option<std::collections::BTreeMap<String, ProviderConfig>>,
515    #[serde(default, skip_serializing_if = "Option::is_none")]
516    pub reference: Option<std::collections::BTreeMap<String, ConfigReferencesValue>>,
517    #[serde(default, skip_serializing_if = "Option::is_none")]
518    pub references: Option<std::collections::BTreeMap<String, ConfigReferencesValue>>,
519    #[serde(default, skip_serializing_if = "Option::is_none")]
520    pub server: Option<ServerConfig>,
521    #[serde(default, skip_serializing_if = "Option::is_none")]
522    pub share: Option<String>,
523    #[serde(default, skip_serializing_if = "Option::is_none")]
524    pub shell: Option<String>,
525    #[serde(default, skip_serializing_if = "Option::is_none")]
526    pub skills: Option<ConfigSkills>,
527    #[serde(default, skip_serializing_if = "Option::is_none")]
528    pub small_model: Option<String>,
529    #[serde(default, skip_serializing_if = "Option::is_none")]
530    pub snapshot: Option<bool>,
531    #[serde(default, skip_serializing_if = "Option::is_none")]
532    pub subagent_depth: Option<u64>,
533    #[serde(default, skip_serializing_if = "Option::is_none")]
534    pub tool_output: Option<ConfigToolOutput>,
535    #[serde(default, skip_serializing_if = "Option::is_none")]
536    pub tools: Option<std::collections::BTreeMap<String, bool>>,
537    #[serde(default, skip_serializing_if = "Option::is_none")]
538    pub username: Option<String>,
539    #[serde(default, skip_serializing_if = "Option::is_none")]
540    pub watcher: Option<ConfigWatcher>,
541}
542
543#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
544pub struct ConfigAgent {
545    #[serde(default, skip_serializing_if = "Option::is_none")]
546    pub build: Option<AgentConfig>,
547    #[serde(default, skip_serializing_if = "Option::is_none")]
548    pub compaction: Option<AgentConfig>,
549    #[serde(default, skip_serializing_if = "Option::is_none")]
550    pub explore: Option<AgentConfig>,
551    #[serde(default, skip_serializing_if = "Option::is_none")]
552    pub general: Option<AgentConfig>,
553    #[serde(default, skip_serializing_if = "Option::is_none")]
554    pub plan: Option<AgentConfig>,
555    #[serde(default, skip_serializing_if = "Option::is_none")]
556    pub summary: Option<AgentConfig>,
557    #[serde(default, skip_serializing_if = "Option::is_none")]
558    pub title: Option<AgentConfig>,
559}
560
561/// Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications
562/// Untagged union: serde tries each variant in the order below.
563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
564#[serde(untagged)]
565pub enum ConfigAutoupdate {
566    Variant0(bool),
567    Variant1(String),
568}
569
570#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
571pub struct ConfigCommandValue {
572    #[serde(default, skip_serializing_if = "Option::is_none")]
573    pub agent: Option<String>,
574    #[serde(default, skip_serializing_if = "Option::is_none")]
575    pub description: Option<String>,
576    #[serde(default, skip_serializing_if = "Option::is_none")]
577    pub model: Option<String>,
578    #[serde(default, skip_serializing_if = "Option::is_none")]
579    pub subtask: Option<bool>,
580    pub template: String,
581    #[serde(default, skip_serializing_if = "Option::is_none")]
582    pub variant: Option<String>,
583}
584
585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
586pub struct ConfigCompaction {
587    #[serde(default, skip_serializing_if = "Option::is_none")]
588    pub auto: Option<bool>,
589    #[serde(default, skip_serializing_if = "Option::is_none")]
590    pub preserve_recent_tokens: Option<u64>,
591    #[serde(default, skip_serializing_if = "Option::is_none")]
592    pub prune: Option<bool>,
593    #[serde(default, skip_serializing_if = "Option::is_none")]
594    pub reserved: Option<u64>,
595    #[serde(default, skip_serializing_if = "Option::is_none")]
596    pub tail_turns: Option<u64>,
597}
598
599#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
600pub struct ConfigEnterprise {
601    #[serde(default, skip_serializing_if = "Option::is_none")]
602    pub url: Option<String>,
603}
604
605#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
606pub struct ConfigExperimental {
607    #[serde(default, skip_serializing_if = "Option::is_none")]
608    pub batch_tool: Option<bool>,
609    #[serde(default, skip_serializing_if = "Option::is_none")]
610    pub continue_loop_on_deny: Option<bool>,
611    #[serde(default, skip_serializing_if = "Option::is_none")]
612    pub disable_paste_summary: Option<bool>,
613    #[serde(default, skip_serializing_if = "Option::is_none")]
614    pub mcp_timeout: Option<i64>,
615    #[serde(
616        rename = "openTelemetry",
617        default,
618        skip_serializing_if = "Option::is_none"
619    )]
620    pub open_telemetry: Option<bool>,
621    #[serde(default, skip_serializing_if = "Option::is_none")]
622    pub policies: Option<Vec<ConfigV2ExperimentalPolicy>>,
623    #[serde(default, skip_serializing_if = "Option::is_none")]
624    pub primary_tools: Option<Vec<String>>,
625}
626
627/// Enable or configure formatters. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides.
628/// Untagged union: serde tries each variant in the order below.
629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
630#[serde(untagged)]
631pub enum ConfigFormatter {
632    Variant0(bool),
633    Variant1(std::collections::BTreeMap<String, ConfigFormatterVariant1Value>),
634}
635
636#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
637pub struct ConfigFormatterVariant1Value {
638    #[serde(default, skip_serializing_if = "Option::is_none")]
639    pub command: Option<Vec<String>>,
640    #[serde(default, skip_serializing_if = "Option::is_none")]
641    pub disabled: Option<bool>,
642    #[serde(default, skip_serializing_if = "Option::is_none")]
643    pub environment: Option<std::collections::BTreeMap<String, String>>,
644    #[serde(default, skip_serializing_if = "Option::is_none")]
645    pub extensions: Option<Vec<String>>,
646}
647
648/// Enable or configure LSP servers. Omit or set to false to disable, true to enable built-ins, or an object to enable built-ins with overrides.
649/// Untagged union: serde tries each variant in the order below.
650#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
651#[serde(untagged)]
652pub enum ConfigLsp {
653    Variant0(bool),
654    Variant1(std::collections::BTreeMap<String, ConfigLspVariant1Value>),
655}
656
657/// Untagged union: serde tries each variant in the order below.
658#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
659#[serde(untagged)]
660pub enum ConfigLspVariant1Value {
661    Variant0(ConfigLspVariant1ValueVariant0),
662    Variant1(ConfigLspVariant1ValueVariant1),
663}
664
665#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
666pub struct ConfigLspVariant1ValueVariant0 {
667    pub disabled: bool,
668}
669
670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
671pub struct ConfigLspVariant1ValueVariant1 {
672    pub command: Vec<String>,
673    #[serde(default, skip_serializing_if = "Option::is_none")]
674    pub disabled: Option<bool>,
675    #[serde(default, skip_serializing_if = "Option::is_none")]
676    pub env: Option<std::collections::BTreeMap<String, String>>,
677    #[serde(default, skip_serializing_if = "Option::is_none")]
678    pub extensions: Option<Vec<String>>,
679    #[serde(default, skip_serializing_if = "Option::is_none")]
680    pub initialization: Option<serde_json::Map<String, serde_json::Value>>,
681}
682
683/// Untagged union: serde tries each variant in the order below.
684#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
685#[serde(untagged)]
686pub enum ConfigMcpValue {
687    McpLocalConfig(McpLocalConfig),
688    McpRemoteConfig(McpRemoteConfig),
689    Variant2(ConfigMcpValueVariant2),
690}
691
692#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
693pub struct ConfigMcpValueVariant2 {
694    pub enabled: bool,
695}
696
697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
698pub struct ConfigMode {
699    #[serde(default, skip_serializing_if = "Option::is_none")]
700    pub build: Option<AgentConfig>,
701    #[serde(default, skip_serializing_if = "Option::is_none")]
702    pub plan: Option<AgentConfig>,
703}
704
705/// Untagged union: serde tries each variant in the order below.
706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
707#[serde(untagged)]
708pub enum ConfigPluginItem {
709    Variant0(String),
710    Variant1(Vec<serde_json::Value>),
711}
712
713/// Untagged union: serde tries each variant in the order below.
714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
715#[serde(untagged)]
716pub enum ConfigReferencesValue {
717    Variant0(String),
718    ConfigV2ReferenceGit(ConfigV2ReferenceGit),
719    ConfigV2ReferenceLocal(ConfigV2ReferenceLocal),
720}
721
722#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
723pub struct ConfigSkills {
724    #[serde(default, skip_serializing_if = "Option::is_none")]
725    pub paths: Option<Vec<String>>,
726    #[serde(default, skip_serializing_if = "Option::is_none")]
727    pub urls: Option<Vec<String>>,
728}
729
730#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
731pub struct ConfigToolOutput {
732    #[serde(default, skip_serializing_if = "Option::is_none")]
733    pub max_bytes: Option<i64>,
734    #[serde(default, skip_serializing_if = "Option::is_none")]
735    pub max_lines: Option<i64>,
736}
737
738#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
739pub struct ConfigV2ExperimentalPolicy {
740    pub action: String,
741    pub effect: PolicyEffect,
742    pub resource: String,
743}
744
745#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
746pub struct ConfigV2ReferenceGit {
747    #[serde(default, skip_serializing_if = "Option::is_none")]
748    pub branch: Option<String>,
749    #[serde(default, skip_serializing_if = "Option::is_none")]
750    pub description: Option<String>,
751    #[serde(default, skip_serializing_if = "Option::is_none")]
752    pub hidden: Option<bool>,
753    pub repository: String,
754}
755
756#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
757pub struct ConfigV2ReferenceLocal {
758    #[serde(default, skip_serializing_if = "Option::is_none")]
759    pub description: Option<String>,
760    #[serde(default, skip_serializing_if = "Option::is_none")]
761    pub hidden: Option<bool>,
762    pub path: String,
763}
764
765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
766pub struct ConfigWatcher {
767    #[serde(default, skip_serializing_if = "Option::is_none")]
768    pub ignore: Option<Vec<String>>,
769}
770
771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
772pub struct ConflictError {
773    pub _tag: String,
774    pub message: String,
775    #[serde(default, skip_serializing_if = "Option::is_none")]
776    pub resource: Option<String>,
777}
778
779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
780pub struct ConnectionCredentialInfo {
781    pub id: String,
782    pub label: String,
783    #[serde(rename = "type", default, skip_serializing)]
784    pub type_: String,
785}
786
787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
788pub struct ConnectionEnvInfo {
789    pub name: String,
790    #[serde(rename = "type", default, skip_serializing)]
791    pub type_: String,
792}
793
794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
795#[serde(tag = "type")]
796pub enum ConnectionInfo {
797    #[serde(rename = "credential")]
798    Credential(ConnectionCredentialInfo),
799    #[serde(rename = "env")]
800    Env(ConnectionEnvInfo),
801}
802
803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
804pub struct ConsoleState {
805    #[serde(
806        rename = "activeOrgName",
807        default,
808        skip_serializing_if = "Option::is_none"
809    )]
810    pub active_org_name: Option<String>,
811    #[serde(rename = "consoleManagedProviders")]
812    pub console_managed_providers: Vec<String>,
813    #[serde(rename = "switchableOrgCount")]
814    pub switchable_org_count: u64,
815}
816
817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
818pub struct ContentFilterError {
819    pub data: WorktreeFailedData,
820    #[serde(default, skip_serializing)]
821    pub name: String,
822}
823
824#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
825pub struct ContextOverflowError {
826    pub data: ContextOverflowErrorData,
827    #[serde(default, skip_serializing)]
828    pub name: String,
829}
830
831#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
832pub struct ContextOverflowErrorData {
833    pub message: String,
834    #[serde(
835        rename = "responseBody",
836        default,
837        skip_serializing_if = "Option::is_none"
838    )]
839    pub response_body: Option<String>,
840}
841
842#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
843pub struct CredentialKey {
844    pub key: String,
845    #[serde(default, skip_serializing_if = "Option::is_none")]
846    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
847    #[serde(rename = "type", default, skip_serializing)]
848    pub type_: String,
849}
850
851#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
852pub struct CredentialOAuth {
853    pub access: String,
854    pub expires: u64,
855    #[serde(default, skip_serializing_if = "Option::is_none")]
856    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
857    #[serde(rename = "methodID")]
858    pub method_id: String,
859    pub refresh: String,
860    #[serde(rename = "type", default, skip_serializing)]
861    pub type_: String,
862}
863
864#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
865#[serde(tag = "type")]
866pub enum CredentialValue {
867    #[serde(rename = "oauth")]
868    Oauth(CredentialOAuth),
869    #[serde(rename = "key")]
870    Key(CredentialKey),
871}
872
873#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
874#[serde(tag = "type")]
875pub enum Event {
876    #[serde(rename = "models-dev.refreshed")]
877    ModelsDevRefreshed(EventModelsDevRefreshed),
878    #[serde(rename = "integration.updated")]
879    IntegrationUpdated(EventIntegrationUpdated),
880    #[serde(rename = "integration.connection.updated")]
881    IntegrationConnectionUpdated(EventIntegrationConnectionUpdated),
882    #[serde(rename = "catalog.updated")]
883    CatalogUpdated(EventCatalogUpdated),
884    #[serde(rename = "session.created")]
885    SessionCreated(EventSessionCreated),
886    #[serde(rename = "session.updated")]
887    SessionUpdated(EventSessionUpdated),
888    #[serde(rename = "session.deleted")]
889    SessionDeleted(EventSessionDeleted),
890    #[serde(rename = "message.updated")]
891    MessageUpdated(EventMessageUpdated),
892    #[serde(rename = "message.removed")]
893    MessageRemoved(EventMessageRemoved),
894    #[serde(rename = "message.part.updated")]
895    MessagePartUpdated(EventMessagePartUpdated),
896    #[serde(rename = "message.part.removed")]
897    MessagePartRemoved(EventMessagePartRemoved),
898    #[serde(rename = "session.next.agent.switched")]
899    SessionNextAgentSwitched(EventSessionNextAgentSwitched),
900    #[serde(rename = "session.next.model.switched")]
901    SessionNextModelSwitched(EventSessionNextModelSwitched),
902    #[serde(rename = "session.next.moved")]
903    SessionNextMoved(EventSessionNextMoved),
904    #[serde(rename = "session.next.prompted")]
905    SessionNextPrompted(EventSessionNextPrompted),
906    #[serde(rename = "session.next.prompt.admitted")]
907    SessionNextPromptAdmitted(EventSessionNextPromptAdmitted),
908    #[serde(rename = "session.next.context.updated")]
909    SessionNextContextUpdated(EventSessionNextContextUpdated),
910    #[serde(rename = "session.next.synthetic")]
911    SessionNextSynthetic(EventSessionNextSynthetic),
912    #[serde(rename = "session.next.shell.started")]
913    SessionNextShellStarted(EventSessionNextShellStarted),
914    #[serde(rename = "session.next.shell.ended")]
915    SessionNextShellEnded(EventSessionNextShellEnded),
916    #[serde(rename = "session.next.step.started")]
917    SessionNextStepStarted(EventSessionNextStepStarted),
918    #[serde(rename = "session.next.step.ended")]
919    SessionNextStepEnded(EventSessionNextStepEnded),
920    #[serde(rename = "session.next.step.failed")]
921    SessionNextStepFailed(EventSessionNextStepFailed),
922    #[serde(rename = "session.next.text.started")]
923    SessionNextTextStarted(EventSessionNextTextStarted),
924    #[serde(rename = "session.next.text.delta")]
925    SessionNextTextDelta(EventSessionNextTextDelta),
926    #[serde(rename = "session.next.text.ended")]
927    SessionNextTextEnded(EventSessionNextTextEnded),
928    #[serde(rename = "session.next.reasoning.started")]
929    SessionNextReasoningStarted(EventSessionNextReasoningStarted),
930    #[serde(rename = "session.next.reasoning.delta")]
931    SessionNextReasoningDelta(EventSessionNextReasoningDelta),
932    #[serde(rename = "session.next.reasoning.ended")]
933    SessionNextReasoningEnded(EventSessionNextReasoningEnded),
934    #[serde(rename = "session.next.tool.input.started")]
935    SessionNextToolInputStarted(EventSessionNextToolInputStarted),
936    #[serde(rename = "session.next.tool.input.delta")]
937    SessionNextToolInputDelta(EventSessionNextToolInputDelta),
938    #[serde(rename = "session.next.tool.input.ended")]
939    SessionNextToolInputEnded(EventSessionNextToolInputEnded),
940    #[serde(rename = "session.next.tool.called")]
941    SessionNextToolCalled(EventSessionNextToolCalled),
942    #[serde(rename = "session.next.tool.progress")]
943    SessionNextToolProgress(EventSessionNextToolProgress),
944    #[serde(rename = "session.next.tool.success")]
945    SessionNextToolSuccess(EventSessionNextToolSuccess),
946    #[serde(rename = "session.next.tool.failed")]
947    SessionNextToolFailed(EventSessionNextToolFailed),
948    #[serde(rename = "session.next.retried")]
949    SessionNextRetried(EventSessionNextRetried),
950    #[serde(rename = "session.next.compaction.started")]
951    SessionNextCompactionStarted(EventSessionNextCompactionStarted),
952    #[serde(rename = "session.next.compaction.delta")]
953    SessionNextCompactionDelta(EventSessionNextCompactionDelta),
954    #[serde(rename = "session.next.compaction.ended")]
955    SessionNextCompactionEnded(EventSessionNextCompactionEnded),
956    #[serde(rename = "session.next.revert.staged")]
957    SessionNextRevertStaged(EventSessionNextRevertStaged),
958    #[serde(rename = "session.next.revert.cleared")]
959    SessionNextRevertCleared(EventSessionNextRevertCleared),
960    #[serde(rename = "session.next.revert.committed")]
961    SessionNextRevertCommitted(EventSessionNextRevertCommitted),
962    #[serde(rename = "message.part.delta")]
963    MessagePartDelta(EventMessagePartDelta),
964    #[serde(rename = "session.diff")]
965    SessionDiff(EventSessionDiff),
966    #[serde(rename = "session.error")]
967    SessionError(EventSessionError),
968    #[serde(rename = "installation.updated")]
969    InstallationUpdated(EventInstallationUpdated),
970    #[serde(rename = "installation.update-available")]
971    InstallationUpdateAvailable(EventInstallationUpdateAvailable),
972    #[serde(rename = "file.edited")]
973    FileEdited(EventFileEdited),
974    #[serde(rename = "reference.updated")]
975    ReferenceUpdated(EventReferenceUpdated),
976    #[serde(rename = "permission.v2.asked")]
977    PermissionV2Asked(EventPermissionV2Asked),
978    #[serde(rename = "permission.v2.replied")]
979    PermissionV2Replied(EventPermissionV2Replied),
980    #[serde(rename = "plugin.added")]
981    PluginAdded(EventPluginAdded),
982    #[serde(rename = "project.directories.updated")]
983    ProjectDirectoriesUpdated(EventProjectDirectoriesUpdated),
984    #[serde(rename = "file.watcher.updated")]
985    FileWatcherUpdated(EventFileWatcherUpdated),
986    #[serde(rename = "pty.created")]
987    PtyCreated(EventPtyCreated),
988    #[serde(rename = "pty.updated")]
989    PtyUpdated(EventPtyUpdated),
990    #[serde(rename = "pty.exited")]
991    PtyExited(EventPtyExited),
992    #[serde(rename = "pty.deleted")]
993    PtyDeleted(EventPtyDeleted),
994    #[serde(rename = "question.v2.asked")]
995    QuestionV2Asked(EventQuestionV2Asked),
996    #[serde(rename = "question.v2.replied")]
997    QuestionV2Replied(EventQuestionV2Replied),
998    #[serde(rename = "question.v2.rejected")]
999    QuestionV2Rejected(EventQuestionV2Rejected),
1000    #[serde(rename = "todo.updated")]
1001    TodoUpdated(EventTodoUpdated),
1002    #[serde(rename = "lsp.updated")]
1003    LspUpdated(EventLspUpdated),
1004    #[serde(rename = "permission.asked")]
1005    PermissionAsked(EventPermissionAsked),
1006    #[serde(rename = "permission.replied")]
1007    PermissionReplied(EventPermissionReplied),
1008    #[serde(rename = "tui.prompt.append")]
1009    TuiPromptAppend(EventTuiPromptAppend),
1010    #[serde(rename = "tui.command.execute")]
1011    TuiCommandExecute(EventTuiCommandExecute),
1012    #[serde(rename = "tui.toast.show")]
1013    TuiToastShow(EventTuiToastShow),
1014    #[serde(rename = "tui.session.select")]
1015    TuiSessionSelect(EventTuiSessionSelect),
1016    #[serde(rename = "mcp.tools.changed")]
1017    McpToolsChanged(EventMcpToolsChanged),
1018    #[serde(rename = "mcp.browser.open.failed")]
1019    McpBrowserOpenFailed(EventMcpBrowserOpenFailed),
1020    #[serde(rename = "command.executed")]
1021    CommandExecuted(EventCommandExecuted),
1022    #[serde(rename = "project.updated")]
1023    ProjectUpdated(EventProjectUpdated),
1024    #[serde(rename = "session.status")]
1025    SessionStatus(EventSessionStatus),
1026    #[serde(rename = "session.idle")]
1027    SessionIdle(EventSessionIdle),
1028    #[serde(rename = "question.asked")]
1029    QuestionAsked(EventQuestionAsked),
1030    #[serde(rename = "question.replied")]
1031    QuestionReplied(EventQuestionReplied),
1032    #[serde(rename = "question.rejected")]
1033    QuestionRejected(EventQuestionRejected),
1034    #[serde(rename = "session.compacted")]
1035    SessionCompacted(EventSessionCompacted),
1036    #[serde(rename = "vcs.branch.updated")]
1037    VcsBranchUpdated(EventVcsBranchUpdated),
1038    #[serde(rename = "workspace.ready")]
1039    WorkspaceReady(EventWorkspaceReady),
1040    #[serde(rename = "workspace.failed")]
1041    WorkspaceFailed(EventWorkspaceFailed),
1042    #[serde(rename = "workspace.status")]
1043    WorkspaceStatus(EventWorkspaceStatus),
1044    #[serde(rename = "worktree.ready")]
1045    WorktreeReady(EventWorktreeReady),
1046    #[serde(rename = "worktree.failed")]
1047    WorktreeFailed(EventWorktreeFailed),
1048    #[serde(rename = "server.connected")]
1049    ServerConnected(EventServerConnected),
1050    #[serde(rename = "global.disposed")]
1051    GlobalDisposed(EventGlobalDisposed),
1052    #[serde(rename = "server.instance.disposed")]
1053    ServerInstanceDisposed(EventServerInstanceDisposed),
1054}
1055
1056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1057pub struct EventTuiCommandExecute {
1058    pub id: String,
1059    pub properties: TuiCommandExecuteData,
1060    #[serde(rename = "type", default, skip_serializing)]
1061    pub type_: String,
1062}
1063
1064#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1065pub struct EventTuiPromptAppend {
1066    pub id: String,
1067    pub properties: TuiPromptAppendData,
1068    #[serde(rename = "type", default, skip_serializing)]
1069    pub type_: String,
1070}
1071
1072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1073pub struct EventTuiSessionSelect {
1074    pub id: String,
1075    pub properties: TuiSessionSelectData,
1076    #[serde(rename = "type", default, skip_serializing)]
1077    pub type_: String,
1078}
1079
1080#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1081pub struct EventTuiToastShow {
1082    pub id: String,
1083    pub properties: TuiToastShowData,
1084    #[serde(rename = "type", default, skip_serializing)]
1085    pub type_: String,
1086}
1087
1088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1089pub struct EventCatalogUpdated {
1090    pub id: String,
1091    pub properties: serde_json::Map<String, serde_json::Value>,
1092    #[serde(rename = "type", default, skip_serializing)]
1093    pub type_: String,
1094}
1095
1096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1097pub struct EventCommandExecuted {
1098    pub id: String,
1099    pub properties: CommandExecutedData,
1100    #[serde(rename = "type", default, skip_serializing)]
1101    pub type_: String,
1102}
1103
1104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1105pub struct EventFileEdited {
1106    pub id: String,
1107    pub properties: FileEditedData,
1108    #[serde(rename = "type", default, skip_serializing)]
1109    pub type_: String,
1110}
1111
1112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1113pub struct EventFileWatcherUpdated {
1114    pub id: String,
1115    pub properties: FileWatcherUpdatedData,
1116    #[serde(rename = "type", default, skip_serializing)]
1117    pub type_: String,
1118}
1119
1120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1121pub struct EventGlobalDisposed {
1122    pub id: String,
1123    pub properties: serde_json::Map<String, serde_json::Value>,
1124    #[serde(rename = "type", default, skip_serializing)]
1125    pub type_: String,
1126}
1127
1128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1129pub struct EventInstallationUpdateAvailable {
1130    pub id: String,
1131    pub properties: InstallationUpdatedData,
1132    #[serde(rename = "type", default, skip_serializing)]
1133    pub type_: String,
1134}
1135
1136#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1137pub struct EventInstallationUpdated {
1138    pub id: String,
1139    pub properties: InstallationUpdatedData,
1140    #[serde(rename = "type", default, skip_serializing)]
1141    pub type_: String,
1142}
1143
1144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1145pub struct EventIntegrationConnectionUpdated {
1146    pub id: String,
1147    pub properties: IntegrationConnectionUpdatedData,
1148    #[serde(rename = "type", default, skip_serializing)]
1149    pub type_: String,
1150}
1151
1152#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1153pub struct EventIntegrationUpdated {
1154    pub id: String,
1155    pub properties: serde_json::Map<String, serde_json::Value>,
1156    #[serde(rename = "type", default, skip_serializing)]
1157    pub type_: String,
1158}
1159
1160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1161pub struct EventLspUpdated {
1162    pub id: String,
1163    pub properties: serde_json::Map<String, serde_json::Value>,
1164    #[serde(rename = "type", default, skip_serializing)]
1165    pub type_: String,
1166}
1167
1168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1169pub struct EventMcpBrowserOpenFailed {
1170    pub id: String,
1171    pub properties: McpBrowserOpenFailedData,
1172    #[serde(rename = "type", default, skip_serializing)]
1173    pub type_: String,
1174}
1175
1176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1177pub struct EventMcpToolsChanged {
1178    pub id: String,
1179    pub properties: McpToolsChangedData,
1180    #[serde(rename = "type", default, skip_serializing)]
1181    pub type_: String,
1182}
1183
1184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1185pub struct EventMessagePartDelta {
1186    pub id: String,
1187    pub properties: MessagePartDeltaData,
1188    #[serde(rename = "type", default, skip_serializing)]
1189    pub type_: String,
1190}
1191
1192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1193pub struct EventMessagePartRemoved {
1194    pub id: String,
1195    pub properties: MessagePartRemovedData,
1196    #[serde(rename = "type", default, skip_serializing)]
1197    pub type_: String,
1198}
1199
1200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1201pub struct EventMessagePartUpdated {
1202    pub id: String,
1203    pub properties: MessagePartUpdatedData,
1204    #[serde(rename = "type", default, skip_serializing)]
1205    pub type_: String,
1206}
1207
1208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1209pub struct EventMessageRemoved {
1210    pub id: String,
1211    pub properties: MessageRemovedData,
1212    #[serde(rename = "type", default, skip_serializing)]
1213    pub type_: String,
1214}
1215
1216#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1217pub struct EventMessageUpdated {
1218    pub id: String,
1219    pub properties: MessageUpdatedData,
1220    #[serde(rename = "type", default, skip_serializing)]
1221    pub type_: String,
1222}
1223
1224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1225pub struct EventModelsDevRefreshed {
1226    pub id: String,
1227    pub properties: serde_json::Map<String, serde_json::Value>,
1228    #[serde(rename = "type", default, skip_serializing)]
1229    pub type_: String,
1230}
1231
1232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1233pub struct EventPermissionAsked {
1234    pub id: String,
1235    pub properties: PermissionAskedData,
1236    #[serde(rename = "type", default, skip_serializing)]
1237    pub type_: String,
1238}
1239
1240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1241pub struct EventPermissionReplied {
1242    pub id: String,
1243    pub properties: PermissionRepliedData,
1244    #[serde(rename = "type", default, skip_serializing)]
1245    pub type_: String,
1246}
1247
1248#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1249pub struct EventPermissionV2Asked {
1250    pub id: String,
1251    pub properties: PermissionV2AskedData,
1252    #[serde(rename = "type", default, skip_serializing)]
1253    pub type_: String,
1254}
1255
1256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1257pub struct EventPermissionV2Replied {
1258    pub id: String,
1259    pub properties: PermissionV2RepliedData,
1260    #[serde(rename = "type", default, skip_serializing)]
1261    pub type_: String,
1262}
1263
1264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1265pub struct EventPluginAdded {
1266    pub id: String,
1267    pub properties: PluginAddedData,
1268    #[serde(rename = "type", default, skip_serializing)]
1269    pub type_: String,
1270}
1271
1272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1273pub struct EventProjectDirectoriesUpdated {
1274    pub id: String,
1275    pub properties: ProjectDirectoriesUpdatedData,
1276    #[serde(rename = "type", default, skip_serializing)]
1277    pub type_: String,
1278}
1279
1280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1281pub struct EventProjectUpdated {
1282    pub id: String,
1283    pub properties: ProjectUpdatedData,
1284    #[serde(rename = "type", default, skip_serializing)]
1285    pub type_: String,
1286}
1287
1288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1289pub struct EventPtyCreated {
1290    pub id: String,
1291    pub properties: PtyCreatedData,
1292    #[serde(rename = "type", default, skip_serializing)]
1293    pub type_: String,
1294}
1295
1296#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1297pub struct EventPtyDeleted {
1298    pub id: String,
1299    pub properties: PtyDeletedData,
1300    #[serde(rename = "type", default, skip_serializing)]
1301    pub type_: String,
1302}
1303
1304#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1305pub struct EventPtyExited {
1306    pub id: String,
1307    pub properties: PtyExitedData,
1308    #[serde(rename = "type", default, skip_serializing)]
1309    pub type_: String,
1310}
1311
1312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1313pub struct EventPtyUpdated {
1314    pub id: String,
1315    pub properties: PtyCreatedData,
1316    #[serde(rename = "type", default, skip_serializing)]
1317    pub type_: String,
1318}
1319
1320#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1321pub struct EventQuestionAsked {
1322    pub id: String,
1323    pub properties: QuestionAskedData,
1324    #[serde(rename = "type", default, skip_serializing)]
1325    pub type_: String,
1326}
1327
1328#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1329pub struct EventQuestionRejected {
1330    pub id: String,
1331    pub properties: QuestionRejected2Data,
1332    #[serde(rename = "type", default, skip_serializing)]
1333    pub type_: String,
1334}
1335
1336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1337pub struct EventQuestionReplied {
1338    pub id: String,
1339    pub properties: QuestionReplied2Data,
1340    #[serde(rename = "type", default, skip_serializing)]
1341    pub type_: String,
1342}
1343
1344#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1345pub struct EventQuestionV2Asked {
1346    pub id: String,
1347    pub properties: QuestionV2AskedData,
1348    #[serde(rename = "type", default, skip_serializing)]
1349    pub type_: String,
1350}
1351
1352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1353pub struct EventQuestionV2Rejected {
1354    pub id: String,
1355    pub properties: QuestionRejected2Data,
1356    #[serde(rename = "type", default, skip_serializing)]
1357    pub type_: String,
1358}
1359
1360#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1361pub struct EventQuestionV2Replied {
1362    pub id: String,
1363    pub properties: QuestionV2RepliedData,
1364    #[serde(rename = "type", default, skip_serializing)]
1365    pub type_: String,
1366}
1367
1368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1369pub struct EventReferenceUpdated {
1370    pub id: String,
1371    pub properties: serde_json::Map<String, serde_json::Value>,
1372    #[serde(rename = "type", default, skip_serializing)]
1373    pub type_: String,
1374}
1375
1376#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1377pub struct EventServerConnected {
1378    pub id: String,
1379    pub properties: serde_json::Map<String, serde_json::Value>,
1380    #[serde(rename = "type", default, skip_serializing)]
1381    pub type_: String,
1382}
1383
1384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1385pub struct EventServerInstanceDisposed {
1386    pub id: String,
1387    pub properties: EventServerInstanceDisposedProperties,
1388    #[serde(rename = "type", default, skip_serializing)]
1389    pub type_: String,
1390}
1391
1392#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1393pub struct EventServerInstanceDisposedProperties {
1394    pub directory: String,
1395}
1396
1397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1398pub struct EventSessionCompacted {
1399    pub id: String,
1400    pub properties: SessionIdleData,
1401    #[serde(rename = "type", default, skip_serializing)]
1402    pub type_: String,
1403}
1404
1405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1406pub struct EventSessionCreated {
1407    pub id: String,
1408    pub properties: SessionCreatedData,
1409    #[serde(rename = "type", default, skip_serializing)]
1410    pub type_: String,
1411}
1412
1413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1414pub struct EventSessionDeleted {
1415    pub id: String,
1416    pub properties: SessionCreatedData,
1417    #[serde(rename = "type", default, skip_serializing)]
1418    pub type_: String,
1419}
1420
1421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1422pub struct EventSessionDiff {
1423    pub id: String,
1424    pub properties: SessionDiffData,
1425    #[serde(rename = "type", default, skip_serializing)]
1426    pub type_: String,
1427}
1428
1429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1430pub struct EventSessionError {
1431    pub id: String,
1432    pub properties: SessionErrorData,
1433    #[serde(rename = "type", default, skip_serializing)]
1434    pub type_: String,
1435}
1436
1437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1438pub struct EventSessionIdle {
1439    pub id: String,
1440    pub properties: SessionIdleData,
1441    #[serde(rename = "type", default, skip_serializing)]
1442    pub type_: String,
1443}
1444
1445#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1446pub struct EventSessionNextAgentSwitched {
1447    pub id: String,
1448    pub properties: SessionNextAgentSwitchedData,
1449    #[serde(rename = "type", default, skip_serializing)]
1450    pub type_: String,
1451}
1452
1453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1454pub struct EventSessionNextCompactionDelta {
1455    pub id: String,
1456    pub properties: SessionNextContextUpdatedData,
1457    #[serde(rename = "type", default, skip_serializing)]
1458    pub type_: String,
1459}
1460
1461#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1462pub struct EventSessionNextCompactionEnded {
1463    pub id: String,
1464    pub properties: SessionNextCompactionEndedData,
1465    #[serde(rename = "type", default, skip_serializing)]
1466    pub type_: String,
1467}
1468
1469#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1470pub struct EventSessionNextCompactionStarted {
1471    pub id: String,
1472    pub properties: SessionNextCompactionStartedData,
1473    #[serde(rename = "type", default, skip_serializing)]
1474    pub type_: String,
1475}
1476
1477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1478pub struct EventSessionNextContextUpdated {
1479    pub id: String,
1480    pub properties: SessionNextContextUpdatedData,
1481    #[serde(rename = "type", default, skip_serializing)]
1482    pub type_: String,
1483}
1484
1485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1486pub struct EventSessionNextModelSwitched {
1487    pub id: String,
1488    pub properties: SessionNextModelSwitchedData,
1489    #[serde(rename = "type", default, skip_serializing)]
1490    pub type_: String,
1491}
1492
1493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1494pub struct EventSessionNextMoved {
1495    pub id: String,
1496    pub properties: SessionNextMovedData,
1497    #[serde(rename = "type", default, skip_serializing)]
1498    pub type_: String,
1499}
1500
1501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1502pub struct EventSessionNextPromptAdmitted {
1503    pub id: String,
1504    pub properties: SessionNextPromptedData,
1505    #[serde(rename = "type", default, skip_serializing)]
1506    pub type_: String,
1507}
1508
1509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1510pub struct EventSessionNextPrompted {
1511    pub id: String,
1512    pub properties: SessionNextPromptedData,
1513    #[serde(rename = "type", default, skip_serializing)]
1514    pub type_: String,
1515}
1516
1517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1518pub struct EventSessionNextReasoningDelta {
1519    pub id: String,
1520    pub properties: SessionNextReasoningDeltaData,
1521    #[serde(rename = "type", default, skip_serializing)]
1522    pub type_: String,
1523}
1524
1525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1526pub struct EventSessionNextReasoningEnded {
1527    pub id: String,
1528    pub properties: SessionNextReasoningEndedData,
1529    #[serde(rename = "type", default, skip_serializing)]
1530    pub type_: String,
1531}
1532
1533#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1534pub struct EventSessionNextReasoningStarted {
1535    pub id: String,
1536    pub properties: SessionNextReasoningStartedData,
1537    #[serde(rename = "type", default, skip_serializing)]
1538    pub type_: String,
1539}
1540
1541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1542pub struct EventSessionNextRetried {
1543    pub id: String,
1544    pub properties: SessionNextRetriedData,
1545    #[serde(rename = "type", default, skip_serializing)]
1546    pub type_: String,
1547}
1548
1549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1550pub struct EventSessionNextRevertCleared {
1551    pub id: String,
1552    pub properties: SessionNextRevertClearedData,
1553    #[serde(rename = "type", default, skip_serializing)]
1554    pub type_: String,
1555}
1556
1557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1558pub struct EventSessionNextRevertCommitted {
1559    pub id: String,
1560    pub properties: SessionNextRevertCommittedData,
1561    #[serde(rename = "type", default, skip_serializing)]
1562    pub type_: String,
1563}
1564
1565#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1566pub struct EventSessionNextRevertStaged {
1567    pub id: String,
1568    pub properties: SessionNextRevertStagedData,
1569    #[serde(rename = "type", default, skip_serializing)]
1570    pub type_: String,
1571}
1572
1573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1574pub struct EventSessionNextShellEnded {
1575    pub id: String,
1576    pub properties: SessionNextShellEndedData,
1577    #[serde(rename = "type", default, skip_serializing)]
1578    pub type_: String,
1579}
1580
1581#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1582pub struct EventSessionNextShellStarted {
1583    pub id: String,
1584    pub properties: SessionNextShellStartedData,
1585    #[serde(rename = "type", default, skip_serializing)]
1586    pub type_: String,
1587}
1588
1589#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1590pub struct EventSessionNextStepEnded {
1591    pub id: String,
1592    pub properties: SessionNextStepEndedData,
1593    #[serde(rename = "type", default, skip_serializing)]
1594    pub type_: String,
1595}
1596
1597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1598pub struct EventSessionNextStepFailed {
1599    pub id: String,
1600    pub properties: SessionNextStepFailedData,
1601    #[serde(rename = "type", default, skip_serializing)]
1602    pub type_: String,
1603}
1604
1605#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1606pub struct EventSessionNextStepStarted {
1607    pub id: String,
1608    pub properties: SessionNextStepStartedData,
1609    #[serde(rename = "type", default, skip_serializing)]
1610    pub type_: String,
1611}
1612
1613#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1614pub struct EventSessionNextSynthetic {
1615    pub id: String,
1616    pub properties: SessionNextContextUpdatedData,
1617    #[serde(rename = "type", default, skip_serializing)]
1618    pub type_: String,
1619}
1620
1621#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1622pub struct EventSessionNextTextDelta {
1623    pub id: String,
1624    pub properties: SessionNextTextDeltaData,
1625    #[serde(rename = "type", default, skip_serializing)]
1626    pub type_: String,
1627}
1628
1629#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1630pub struct EventSessionNextTextEnded {
1631    pub id: String,
1632    pub properties: SessionNextTextEndedData,
1633    #[serde(rename = "type", default, skip_serializing)]
1634    pub type_: String,
1635}
1636
1637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1638pub struct EventSessionNextTextStarted {
1639    pub id: String,
1640    pub properties: SessionNextTextStartedData,
1641    #[serde(rename = "type", default, skip_serializing)]
1642    pub type_: String,
1643}
1644
1645#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1646pub struct EventSessionNextToolCalled {
1647    pub id: String,
1648    pub properties: SessionNextToolCalledData,
1649    #[serde(rename = "type", default, skip_serializing)]
1650    pub type_: String,
1651}
1652
1653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1654pub struct EventSessionNextToolFailed {
1655    pub id: String,
1656    pub properties: SessionNextToolFailedData,
1657    #[serde(rename = "type", default, skip_serializing)]
1658    pub type_: String,
1659}
1660
1661#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1662pub struct EventSessionNextToolInputDelta {
1663    pub id: String,
1664    pub properties: SessionNextToolInputDeltaData,
1665    #[serde(rename = "type", default, skip_serializing)]
1666    pub type_: String,
1667}
1668
1669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1670pub struct EventSessionNextToolInputEnded {
1671    pub id: String,
1672    pub properties: SessionNextToolInputEndedData,
1673    #[serde(rename = "type", default, skip_serializing)]
1674    pub type_: String,
1675}
1676
1677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1678pub struct EventSessionNextToolInputStarted {
1679    pub id: String,
1680    pub properties: SessionNextToolInputStartedData,
1681    #[serde(rename = "type", default, skip_serializing)]
1682    pub type_: String,
1683}
1684
1685#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1686pub struct EventSessionNextToolProgress {
1687    pub id: String,
1688    pub properties: SessionNextToolProgressData,
1689    #[serde(rename = "type", default, skip_serializing)]
1690    pub type_: String,
1691}
1692
1693#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1694pub struct EventSessionNextToolSuccess {
1695    pub id: String,
1696    pub properties: SessionNextToolSuccessData,
1697    #[serde(rename = "type", default, skip_serializing)]
1698    pub type_: String,
1699}
1700
1701#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1702pub struct EventSessionStatus {
1703    pub id: String,
1704    pub properties: SessionStatus2Data,
1705    #[serde(rename = "type", default, skip_serializing)]
1706    pub type_: String,
1707}
1708
1709#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1710pub struct EventSessionUpdated {
1711    pub id: String,
1712    pub properties: SessionCreatedData,
1713    #[serde(rename = "type", default, skip_serializing)]
1714    pub type_: String,
1715}
1716
1717#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1718pub struct EventTodoUpdated {
1719    pub id: String,
1720    pub properties: TodoUpdatedData,
1721    #[serde(rename = "type", default, skip_serializing)]
1722    pub type_: String,
1723}
1724
1725#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1726pub struct EventTuiCommandExecute2 {
1727    pub properties: TuiCommandExecuteData,
1728    #[serde(rename = "type")]
1729    pub type_: String,
1730}
1731
1732#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1733pub struct EventTuiPromptAppend2 {
1734    pub properties: TuiPromptAppendData,
1735    #[serde(rename = "type")]
1736    pub type_: String,
1737}
1738
1739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1740pub struct EventTuiSessionSelect2 {
1741    pub properties: TuiSessionSelectData,
1742    #[serde(rename = "type")]
1743    pub type_: String,
1744}
1745
1746#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1747pub struct EventTuiToastShow2 {
1748    pub properties: TuiToastShowData,
1749    #[serde(rename = "type")]
1750    pub type_: String,
1751}
1752
1753#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1754pub struct EventVcsBranchUpdated {
1755    pub id: String,
1756    pub properties: VcsBranchUpdatedData,
1757    #[serde(rename = "type", default, skip_serializing)]
1758    pub type_: String,
1759}
1760
1761#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1762pub struct EventWorkspaceFailed {
1763    pub id: String,
1764    pub properties: WorktreeFailedData,
1765    #[serde(rename = "type", default, skip_serializing)]
1766    pub type_: String,
1767}
1768
1769#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1770pub struct EventWorkspaceReady {
1771    pub id: String,
1772    pub properties: WorkspaceReadyData,
1773    #[serde(rename = "type", default, skip_serializing)]
1774    pub type_: String,
1775}
1776
1777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1778pub struct EventWorkspaceStatus {
1779    pub id: String,
1780    pub properties: WorkspaceStatusData,
1781    #[serde(rename = "type", default, skip_serializing)]
1782    pub type_: String,
1783}
1784
1785#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1786pub struct EventWorktreeFailed {
1787    pub id: String,
1788    pub properties: WorktreeFailedData,
1789    #[serde(rename = "type", default, skip_serializing)]
1790    pub type_: String,
1791}
1792
1793#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1794pub struct EventWorktreeReady {
1795    pub id: String,
1796    pub properties: WorktreeReadyData,
1797    #[serde(rename = "type", default, skip_serializing)]
1798    pub type_: String,
1799}
1800
1801#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1802pub struct ExperimentalCapabilities {
1803    #[serde(rename = "backgroundSubagents")]
1804    pub background_subagents: bool,
1805}
1806
1807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1808pub struct File {
1809    pub added: u64,
1810    pub path: String,
1811    pub removed: u64,
1812    pub status: String,
1813}
1814
1815#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1816pub struct FileContent {
1817    pub content: String,
1818    #[serde(default, skip_serializing_if = "Option::is_none")]
1819    pub diff: Option<String>,
1820    #[serde(default, skip_serializing_if = "Option::is_none")]
1821    pub encoding: Option<String>,
1822    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
1823    pub mime_type: Option<String>,
1824    #[serde(default, skip_serializing_if = "Option::is_none")]
1825    pub patch: Option<FileContentPatch>,
1826    #[serde(rename = "type")]
1827    pub type_: String,
1828}
1829
1830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1831pub struct FileContentPatch {
1832    pub hunks: Vec<FileContentPatchHunksItem>,
1833    #[serde(default, skip_serializing_if = "Option::is_none")]
1834    pub index: Option<String>,
1835    #[serde(rename = "newFileName")]
1836    pub new_file_name: String,
1837    #[serde(rename = "newHeader", default, skip_serializing_if = "Option::is_none")]
1838    pub new_header: Option<String>,
1839    #[serde(rename = "oldFileName")]
1840    pub old_file_name: String,
1841    #[serde(rename = "oldHeader", default, skip_serializing_if = "Option::is_none")]
1842    pub old_header: Option<String>,
1843}
1844
1845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1846pub struct FileContentPatchHunksItem {
1847    pub lines: Vec<String>,
1848    #[serde(rename = "newLines")]
1849    pub new_lines: u64,
1850    #[serde(rename = "newStart")]
1851    pub new_start: u64,
1852    #[serde(rename = "oldLines")]
1853    pub old_lines: u64,
1854    #[serde(rename = "oldStart")]
1855    pub old_start: u64,
1856}
1857
1858#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1859pub struct FileDiff {
1860    pub additions: u64,
1861    pub deletions: u64,
1862    pub patch: String,
1863    pub path: String,
1864    pub status: String,
1865}
1866
1867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1868pub struct FileEdited {
1869    pub data: FileEditedData,
1870    #[serde(default, skip_serializing_if = "Option::is_none")]
1871    pub durable: Option<SessionStatus2Durable>,
1872    pub id: String,
1873    #[serde(default, skip_serializing_if = "Option::is_none")]
1874    pub location: Option<LocationRef>,
1875    #[serde(default, skip_serializing_if = "Option::is_none")]
1876    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
1877    #[serde(rename = "type", default, skip_serializing)]
1878    pub type_: String,
1879}
1880
1881#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1882pub struct FileEditedData {
1883    pub file: String,
1884}
1885
1886#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1887pub struct FileNode {
1888    pub absolute: String,
1889    pub ignored: bool,
1890    pub name: String,
1891    pub path: String,
1892    #[serde(rename = "type")]
1893    pub type_: String,
1894}
1895
1896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1897pub struct FilePart {
1898    #[serde(default, skip_serializing_if = "Option::is_none")]
1899    pub filename: Option<String>,
1900    pub id: String,
1901    #[serde(rename = "messageID")]
1902    pub message_id: String,
1903    pub mime: String,
1904    #[serde(rename = "sessionID")]
1905    pub session_id: String,
1906    #[serde(default, skip_serializing_if = "Option::is_none")]
1907    pub source: Option<FilePartSource>,
1908    #[serde(rename = "type", default, skip_serializing)]
1909    pub type_: String,
1910    pub url: String,
1911}
1912
1913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1914pub struct FilePartInput {
1915    #[serde(default, skip_serializing_if = "Option::is_none")]
1916    pub filename: Option<String>,
1917    #[serde(default, skip_serializing_if = "Option::is_none")]
1918    pub id: Option<String>,
1919    pub mime: String,
1920    #[serde(default, skip_serializing_if = "Option::is_none")]
1921    pub source: Option<FilePartSource>,
1922    #[serde(rename = "type", default, skip_serializing)]
1923    pub type_: String,
1924    pub url: String,
1925}
1926
1927#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1928#[serde(tag = "type")]
1929pub enum FilePartSource {
1930    #[serde(rename = "file")]
1931    File(FileSource),
1932    #[serde(rename = "symbol")]
1933    Symbol(SymbolSource),
1934    #[serde(rename = "resource")]
1935    Resource(ResourceSource),
1936}
1937
1938#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1939pub struct FilePartSourceText {
1940    pub end: f64,
1941    pub start: f64,
1942    pub value: String,
1943}
1944
1945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1946pub struct FileSource {
1947    pub path: String,
1948    pub text: FilePartSourceText,
1949    #[serde(rename = "type", default, skip_serializing)]
1950    pub type_: String,
1951}
1952
1953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1954pub struct FileSystemEntry {
1955    pub path: String,
1956    #[serde(rename = "type")]
1957    pub type_: String,
1958}
1959
1960#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1961pub struct FileWatcherUpdated {
1962    pub data: FileWatcherUpdatedData,
1963    #[serde(default, skip_serializing_if = "Option::is_none")]
1964    pub durable: Option<SessionStatus2Durable>,
1965    pub id: String,
1966    #[serde(default, skip_serializing_if = "Option::is_none")]
1967    pub location: Option<LocationRef>,
1968    #[serde(default, skip_serializing_if = "Option::is_none")]
1969    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
1970    #[serde(rename = "type", default, skip_serializing)]
1971    pub type_: String,
1972}
1973
1974#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1975pub struct FileWatcherUpdatedData {
1976    pub event: String,
1977    pub file: String,
1978}
1979
1980#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1981pub struct ForbiddenError {
1982    pub _tag: String,
1983    pub message: String,
1984}
1985
1986#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1987pub struct FormatterStatus {
1988    pub enabled: bool,
1989    pub extensions: Vec<String>,
1990    pub name: String,
1991}
1992
1993#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1994pub struct GlobalDisposed {
1995    pub data: serde_json::Map<String, serde_json::Value>,
1996    #[serde(default, skip_serializing_if = "Option::is_none")]
1997    pub durable: Option<SessionStatus2Durable>,
1998    pub id: String,
1999    #[serde(default, skip_serializing_if = "Option::is_none")]
2000    pub location: Option<LocationRef>,
2001    #[serde(default, skip_serializing_if = "Option::is_none")]
2002    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
2003    #[serde(rename = "type", default, skip_serializing)]
2004    pub type_: String,
2005}
2006
2007#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2008pub struct GlobalEvent {
2009    pub directory: String,
2010    pub payload: GlobalEventPayload,
2011    #[serde(default, skip_serializing_if = "Option::is_none")]
2012    pub project: Option<String>,
2013    #[serde(default, skip_serializing_if = "Option::is_none")]
2014    pub workspace: Option<String>,
2015}
2016
2017/// Untagged union: serde tries each variant in the order below.
2018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2019#[serde(untagged)]
2020pub enum GlobalEventPayload {
2021    Variant0(GlobalEventPayloadVariant0),
2022    Variant1(GlobalEventPayloadVariant1),
2023    Variant2(GlobalEventPayloadVariant2),
2024    Variant3(GlobalEventPayloadVariant3),
2025    Variant4(GlobalEventPayloadVariant4),
2026    Variant5(GlobalEventPayloadVariant5),
2027    Variant6(GlobalEventPayloadVariant6),
2028    Variant7(GlobalEventPayloadVariant7),
2029    Variant8(GlobalEventPayloadVariant8),
2030    Variant9(GlobalEventPayloadVariant9),
2031    Variant10(GlobalEventPayloadVariant10),
2032    Variant11(GlobalEventPayloadVariant11),
2033    Variant12(GlobalEventPayloadVariant12),
2034    Variant13(GlobalEventPayloadVariant13),
2035    Variant14(GlobalEventPayloadVariant14),
2036    Variant15(GlobalEventPayloadVariant15),
2037    Variant16(GlobalEventPayloadVariant16),
2038    Variant17(GlobalEventPayloadVariant17),
2039    Variant18(GlobalEventPayloadVariant18),
2040    Variant19(GlobalEventPayloadVariant19),
2041    Variant20(GlobalEventPayloadVariant20),
2042    Variant21(GlobalEventPayloadVariant21),
2043    Variant22(GlobalEventPayloadVariant22),
2044    Variant23(GlobalEventPayloadVariant23),
2045    Variant24(GlobalEventPayloadVariant24),
2046    Variant25(GlobalEventPayloadVariant25),
2047    Variant26(GlobalEventPayloadVariant26),
2048    Variant27(GlobalEventPayloadVariant27),
2049    Variant28(GlobalEventPayloadVariant28),
2050    Variant29(GlobalEventPayloadVariant29),
2051    Variant30(GlobalEventPayloadVariant30),
2052    Variant31(GlobalEventPayloadVariant31),
2053    Variant32(GlobalEventPayloadVariant32),
2054    Variant33(GlobalEventPayloadVariant33),
2055    Variant34(GlobalEventPayloadVariant34),
2056    Variant35(GlobalEventPayloadVariant35),
2057    Variant36(GlobalEventPayloadVariant36),
2058    Variant37(GlobalEventPayloadVariant37),
2059    Variant38(GlobalEventPayloadVariant38),
2060    Variant39(GlobalEventPayloadVariant39),
2061    Variant40(GlobalEventPayloadVariant40),
2062    Variant41(GlobalEventPayloadVariant41),
2063    Variant42(GlobalEventPayloadVariant42),
2064    Variant43(GlobalEventPayloadVariant43),
2065    Variant44(GlobalEventPayloadVariant44),
2066    Variant45(GlobalEventPayloadVariant45),
2067    Variant46(GlobalEventPayloadVariant46),
2068    Variant47(GlobalEventPayloadVariant47),
2069    Variant48(GlobalEventPayloadVariant48),
2070    Variant49(GlobalEventPayloadVariant49),
2071    Variant50(GlobalEventPayloadVariant50),
2072    Variant51(GlobalEventPayloadVariant51),
2073    Variant52(GlobalEventPayloadVariant52),
2074    Variant53(GlobalEventPayloadVariant53),
2075    Variant54(GlobalEventPayloadVariant54),
2076    Variant55(GlobalEventPayloadVariant55),
2077    Variant56(GlobalEventPayloadVariant56),
2078    Variant57(GlobalEventPayloadVariant57),
2079    Variant58(GlobalEventPayloadVariant58),
2080    Variant59(GlobalEventPayloadVariant59),
2081    Variant60(GlobalEventPayloadVariant60),
2082    Variant61(GlobalEventPayloadVariant61),
2083    Variant62(GlobalEventPayloadVariant62),
2084    Variant63(GlobalEventPayloadVariant63),
2085    Variant64(GlobalEventPayloadVariant64),
2086    Variant65(GlobalEventPayloadVariant65),
2087    Variant66(GlobalEventPayloadVariant66),
2088    Variant67(GlobalEventPayloadVariant67),
2089    Variant68(GlobalEventPayloadVariant68),
2090    Variant69(GlobalEventPayloadVariant69),
2091    Variant70(GlobalEventPayloadVariant70),
2092    Variant71(GlobalEventPayloadVariant71),
2093    Variant72(GlobalEventPayloadVariant72),
2094    Variant73(GlobalEventPayloadVariant73),
2095    Variant74(GlobalEventPayloadVariant74),
2096    Variant75(GlobalEventPayloadVariant75),
2097    Variant76(GlobalEventPayloadVariant76),
2098    Variant77(GlobalEventPayloadVariant77),
2099    Variant78(GlobalEventPayloadVariant78),
2100    Variant79(GlobalEventPayloadVariant79),
2101    Variant80(GlobalEventPayloadVariant80),
2102    Variant81(GlobalEventPayloadVariant81),
2103    Variant82(GlobalEventPayloadVariant82),
2104    Variant83(GlobalEventPayloadVariant83),
2105    Variant84(GlobalEventPayloadVariant84),
2106    Variant85(GlobalEventPayloadVariant85),
2107    Variant86(GlobalEventPayloadVariant86),
2108    Variant87(GlobalEventPayloadVariant87),
2109    EventServerInstanceDisposed(EventServerInstanceDisposed),
2110    SyncEventSessionCreated(SyncEventSessionCreated),
2111    SyncEventSessionUpdated(SyncEventSessionUpdated),
2112    SyncEventSessionDeleted(SyncEventSessionDeleted),
2113    SyncEventMessageUpdated(SyncEventMessageUpdated),
2114    SyncEventMessageRemoved(SyncEventMessageRemoved),
2115    SyncEventMessagePartUpdated(SyncEventMessagePartUpdated),
2116    SyncEventMessagePartRemoved(SyncEventMessagePartRemoved),
2117    SyncEventSessionNextAgentSwitched(SyncEventSessionNextAgentSwitched),
2118    SyncEventSessionNextModelSwitched(SyncEventSessionNextModelSwitched),
2119    SyncEventSessionNextMoved(SyncEventSessionNextMoved),
2120    SyncEventSessionNextPrompted(SyncEventSessionNextPrompted),
2121    SyncEventSessionNextPromptAdmitted(SyncEventSessionNextPromptAdmitted),
2122    SyncEventSessionNextContextUpdated(SyncEventSessionNextContextUpdated),
2123    SyncEventSessionNextSynthetic(SyncEventSessionNextSynthetic),
2124    SyncEventSessionNextShellStarted(SyncEventSessionNextShellStarted),
2125    SyncEventSessionNextShellEnded(SyncEventSessionNextShellEnded),
2126    SyncEventSessionNextStepStarted(SyncEventSessionNextStepStarted),
2127    SyncEventSessionNextStepEnded(SyncEventSessionNextStepEnded),
2128    SyncEventSessionNextStepFailed(SyncEventSessionNextStepFailed),
2129    SyncEventSessionNextTextStarted(SyncEventSessionNextTextStarted),
2130    SyncEventSessionNextTextEnded(SyncEventSessionNextTextEnded),
2131    SyncEventSessionNextReasoningStarted(SyncEventSessionNextReasoningStarted),
2132    SyncEventSessionNextReasoningEnded(SyncEventSessionNextReasoningEnded),
2133    SyncEventSessionNextToolInputStarted(SyncEventSessionNextToolInputStarted),
2134    SyncEventSessionNextToolInputEnded(SyncEventSessionNextToolInputEnded),
2135    SyncEventSessionNextToolCalled(SyncEventSessionNextToolCalled),
2136    SyncEventSessionNextToolProgress(SyncEventSessionNextToolProgress),
2137    SyncEventSessionNextToolSuccess(SyncEventSessionNextToolSuccess),
2138    SyncEventSessionNextToolFailed(SyncEventSessionNextToolFailed),
2139    SyncEventSessionNextRetried(SyncEventSessionNextRetried),
2140    SyncEventSessionNextCompactionStarted(SyncEventSessionNextCompactionStarted),
2141    SyncEventSessionNextCompactionEnded(SyncEventSessionNextCompactionEnded),
2142    SyncEventSessionNextRevertStaged(SyncEventSessionNextRevertStaged),
2143    SyncEventSessionNextRevertCleared(SyncEventSessionNextRevertCleared),
2144    SyncEventSessionNextRevertCommitted(SyncEventSessionNextRevertCommitted),
2145}
2146
2147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2148pub struct GlobalEventPayloadVariant0 {
2149    pub id: String,
2150    pub properties: serde_json::Map<String, serde_json::Value>,
2151    #[serde(rename = "type")]
2152    pub type_: String,
2153}
2154
2155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2156pub struct GlobalEventPayloadVariant1 {
2157    pub id: String,
2158    pub properties: serde_json::Map<String, serde_json::Value>,
2159    #[serde(rename = "type")]
2160    pub type_: String,
2161}
2162
2163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2164pub struct GlobalEventPayloadVariant10 {
2165    pub id: String,
2166    pub properties: MessagePartRemovedData,
2167    #[serde(rename = "type")]
2168    pub type_: String,
2169}
2170
2171#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2172pub struct GlobalEventPayloadVariant11 {
2173    pub id: String,
2174    pub properties: SessionNextAgentSwitchedData,
2175    #[serde(rename = "type")]
2176    pub type_: String,
2177}
2178
2179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2180pub struct GlobalEventPayloadVariant12 {
2181    pub id: String,
2182    pub properties: SessionNextModelSwitchedData,
2183    #[serde(rename = "type")]
2184    pub type_: String,
2185}
2186
2187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2188pub struct GlobalEventPayloadVariant13 {
2189    pub id: String,
2190    pub properties: SessionNextMovedData,
2191    #[serde(rename = "type")]
2192    pub type_: String,
2193}
2194
2195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2196pub struct GlobalEventPayloadVariant14 {
2197    pub id: String,
2198    pub properties: SessionNextPromptedData,
2199    #[serde(rename = "type")]
2200    pub type_: String,
2201}
2202
2203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2204pub struct GlobalEventPayloadVariant15 {
2205    pub id: String,
2206    pub properties: SessionNextPromptedData,
2207    #[serde(rename = "type")]
2208    pub type_: String,
2209}
2210
2211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2212pub struct GlobalEventPayloadVariant16 {
2213    pub id: String,
2214    pub properties: SessionNextContextUpdatedData,
2215    #[serde(rename = "type")]
2216    pub type_: String,
2217}
2218
2219#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2220pub struct GlobalEventPayloadVariant17 {
2221    pub id: String,
2222    pub properties: SessionNextContextUpdatedData,
2223    #[serde(rename = "type")]
2224    pub type_: String,
2225}
2226
2227#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2228pub struct GlobalEventPayloadVariant18 {
2229    pub id: String,
2230    pub properties: SessionNextShellStartedData,
2231    #[serde(rename = "type")]
2232    pub type_: String,
2233}
2234
2235#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2236pub struct GlobalEventPayloadVariant19 {
2237    pub id: String,
2238    pub properties: SessionNextShellEndedData,
2239    #[serde(rename = "type")]
2240    pub type_: String,
2241}
2242
2243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2244pub struct GlobalEventPayloadVariant2 {
2245    pub id: String,
2246    pub properties: IntegrationConnectionUpdatedData,
2247    #[serde(rename = "type")]
2248    pub type_: String,
2249}
2250
2251#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2252pub struct GlobalEventPayloadVariant20 {
2253    pub id: String,
2254    pub properties: SessionNextStepStartedData,
2255    #[serde(rename = "type")]
2256    pub type_: String,
2257}
2258
2259#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2260pub struct GlobalEventPayloadVariant21 {
2261    pub id: String,
2262    pub properties: SessionNextStepEndedData,
2263    #[serde(rename = "type")]
2264    pub type_: String,
2265}
2266
2267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2268pub struct GlobalEventPayloadVariant22 {
2269    pub id: String,
2270    pub properties: SessionNextStepFailedData,
2271    #[serde(rename = "type")]
2272    pub type_: String,
2273}
2274
2275#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2276pub struct GlobalEventPayloadVariant23 {
2277    pub id: String,
2278    pub properties: SessionNextTextStartedData,
2279    #[serde(rename = "type")]
2280    pub type_: String,
2281}
2282
2283#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2284pub struct GlobalEventPayloadVariant24 {
2285    pub id: String,
2286    pub properties: SessionNextTextDeltaData,
2287    #[serde(rename = "type")]
2288    pub type_: String,
2289}
2290
2291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2292pub struct GlobalEventPayloadVariant25 {
2293    pub id: String,
2294    pub properties: SessionNextTextEndedData,
2295    #[serde(rename = "type")]
2296    pub type_: String,
2297}
2298
2299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2300pub struct GlobalEventPayloadVariant26 {
2301    pub id: String,
2302    pub properties: SessionNextReasoningStartedData,
2303    #[serde(rename = "type")]
2304    pub type_: String,
2305}
2306
2307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2308pub struct GlobalEventPayloadVariant27 {
2309    pub id: String,
2310    pub properties: SessionNextReasoningDeltaData,
2311    #[serde(rename = "type")]
2312    pub type_: String,
2313}
2314
2315#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2316pub struct GlobalEventPayloadVariant28 {
2317    pub id: String,
2318    pub properties: SessionNextReasoningEndedData,
2319    #[serde(rename = "type")]
2320    pub type_: String,
2321}
2322
2323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2324pub struct GlobalEventPayloadVariant29 {
2325    pub id: String,
2326    pub properties: SessionNextToolInputStartedData,
2327    #[serde(rename = "type")]
2328    pub type_: String,
2329}
2330
2331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2332pub struct GlobalEventPayloadVariant3 {
2333    pub id: String,
2334    pub properties: serde_json::Map<String, serde_json::Value>,
2335    #[serde(rename = "type")]
2336    pub type_: String,
2337}
2338
2339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2340pub struct GlobalEventPayloadVariant30 {
2341    pub id: String,
2342    pub properties: SessionNextToolInputDeltaData,
2343    #[serde(rename = "type")]
2344    pub type_: String,
2345}
2346
2347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2348pub struct GlobalEventPayloadVariant31 {
2349    pub id: String,
2350    pub properties: SessionNextToolInputEndedData,
2351    #[serde(rename = "type")]
2352    pub type_: String,
2353}
2354
2355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2356pub struct GlobalEventPayloadVariant32 {
2357    pub id: String,
2358    pub properties: SessionNextToolCalledData,
2359    #[serde(rename = "type")]
2360    pub type_: String,
2361}
2362
2363#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2364pub struct GlobalEventPayloadVariant33 {
2365    pub id: String,
2366    pub properties: SessionNextToolProgressData,
2367    #[serde(rename = "type")]
2368    pub type_: String,
2369}
2370
2371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2372pub struct GlobalEventPayloadVariant34 {
2373    pub id: String,
2374    pub properties: SessionNextToolSuccessData,
2375    #[serde(rename = "type")]
2376    pub type_: String,
2377}
2378
2379#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2380pub struct GlobalEventPayloadVariant35 {
2381    pub id: String,
2382    pub properties: SessionNextToolFailedData,
2383    #[serde(rename = "type")]
2384    pub type_: String,
2385}
2386
2387#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2388pub struct GlobalEventPayloadVariant36 {
2389    pub id: String,
2390    pub properties: SessionNextRetriedData,
2391    #[serde(rename = "type")]
2392    pub type_: String,
2393}
2394
2395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2396pub struct GlobalEventPayloadVariant37 {
2397    pub id: String,
2398    pub properties: SessionNextCompactionStartedData,
2399    #[serde(rename = "type")]
2400    pub type_: String,
2401}
2402
2403#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2404pub struct GlobalEventPayloadVariant38 {
2405    pub id: String,
2406    pub properties: SessionNextContextUpdatedData,
2407    #[serde(rename = "type")]
2408    pub type_: String,
2409}
2410
2411#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2412pub struct GlobalEventPayloadVariant39 {
2413    pub id: String,
2414    pub properties: SessionNextCompactionEndedData,
2415    #[serde(rename = "type")]
2416    pub type_: String,
2417}
2418
2419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2420pub struct GlobalEventPayloadVariant4 {
2421    pub id: String,
2422    pub properties: SessionCreatedData,
2423    #[serde(rename = "type")]
2424    pub type_: String,
2425}
2426
2427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2428pub struct GlobalEventPayloadVariant40 {
2429    pub id: String,
2430    pub properties: SessionNextRevertStagedData,
2431    #[serde(rename = "type")]
2432    pub type_: String,
2433}
2434
2435#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2436pub struct GlobalEventPayloadVariant41 {
2437    pub id: String,
2438    pub properties: SessionNextRevertClearedData,
2439    #[serde(rename = "type")]
2440    pub type_: String,
2441}
2442
2443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2444pub struct GlobalEventPayloadVariant42 {
2445    pub id: String,
2446    pub properties: SessionNextRevertCommittedData,
2447    #[serde(rename = "type")]
2448    pub type_: String,
2449}
2450
2451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2452pub struct GlobalEventPayloadVariant43 {
2453    pub id: String,
2454    pub properties: MessagePartDeltaData,
2455    #[serde(rename = "type")]
2456    pub type_: String,
2457}
2458
2459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2460pub struct GlobalEventPayloadVariant44 {
2461    pub id: String,
2462    pub properties: SessionDiffData,
2463    #[serde(rename = "type")]
2464    pub type_: String,
2465}
2466
2467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2468pub struct GlobalEventPayloadVariant45 {
2469    pub id: String,
2470    pub properties: SessionErrorData,
2471    #[serde(rename = "type")]
2472    pub type_: String,
2473}
2474
2475#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2476pub struct GlobalEventPayloadVariant46 {
2477    pub id: String,
2478    pub properties: InstallationUpdatedData,
2479    #[serde(rename = "type")]
2480    pub type_: String,
2481}
2482
2483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2484pub struct GlobalEventPayloadVariant47 {
2485    pub id: String,
2486    pub properties: InstallationUpdatedData,
2487    #[serde(rename = "type")]
2488    pub type_: String,
2489}
2490
2491#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2492pub struct GlobalEventPayloadVariant48 {
2493    pub id: String,
2494    pub properties: FileEditedData,
2495    #[serde(rename = "type")]
2496    pub type_: String,
2497}
2498
2499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2500pub struct GlobalEventPayloadVariant49 {
2501    pub id: String,
2502    pub properties: serde_json::Map<String, serde_json::Value>,
2503    #[serde(rename = "type")]
2504    pub type_: String,
2505}
2506
2507#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2508pub struct GlobalEventPayloadVariant5 {
2509    pub id: String,
2510    pub properties: SessionCreatedData,
2511    #[serde(rename = "type")]
2512    pub type_: String,
2513}
2514
2515#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2516pub struct GlobalEventPayloadVariant50 {
2517    pub id: String,
2518    pub properties: PermissionV2AskedData,
2519    #[serde(rename = "type")]
2520    pub type_: String,
2521}
2522
2523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2524pub struct GlobalEventPayloadVariant51 {
2525    pub id: String,
2526    pub properties: PermissionV2RepliedData,
2527    #[serde(rename = "type")]
2528    pub type_: String,
2529}
2530
2531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2532pub struct GlobalEventPayloadVariant52 {
2533    pub id: String,
2534    pub properties: PluginAddedData,
2535    #[serde(rename = "type")]
2536    pub type_: String,
2537}
2538
2539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2540pub struct GlobalEventPayloadVariant53 {
2541    pub id: String,
2542    pub properties: ProjectDirectoriesUpdatedData,
2543    #[serde(rename = "type")]
2544    pub type_: String,
2545}
2546
2547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2548pub struct GlobalEventPayloadVariant54 {
2549    pub id: String,
2550    pub properties: FileWatcherUpdatedData,
2551    #[serde(rename = "type")]
2552    pub type_: String,
2553}
2554
2555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2556pub struct GlobalEventPayloadVariant55 {
2557    pub id: String,
2558    pub properties: PtyCreatedData,
2559    #[serde(rename = "type")]
2560    pub type_: String,
2561}
2562
2563#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2564pub struct GlobalEventPayloadVariant56 {
2565    pub id: String,
2566    pub properties: PtyCreatedData,
2567    #[serde(rename = "type")]
2568    pub type_: String,
2569}
2570
2571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2572pub struct GlobalEventPayloadVariant57 {
2573    pub id: String,
2574    pub properties: PtyExitedData,
2575    #[serde(rename = "type")]
2576    pub type_: String,
2577}
2578
2579#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2580pub struct GlobalEventPayloadVariant58 {
2581    pub id: String,
2582    pub properties: PtyDeletedData,
2583    #[serde(rename = "type")]
2584    pub type_: String,
2585}
2586
2587#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2588pub struct GlobalEventPayloadVariant59 {
2589    pub id: String,
2590    pub properties: QuestionV2AskedData,
2591    #[serde(rename = "type")]
2592    pub type_: String,
2593}
2594
2595#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2596pub struct GlobalEventPayloadVariant6 {
2597    pub id: String,
2598    pub properties: SessionCreatedData,
2599    #[serde(rename = "type")]
2600    pub type_: String,
2601}
2602
2603#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2604pub struct GlobalEventPayloadVariant60 {
2605    pub id: String,
2606    pub properties: QuestionV2RepliedData,
2607    #[serde(rename = "type")]
2608    pub type_: String,
2609}
2610
2611#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2612pub struct GlobalEventPayloadVariant61 {
2613    pub id: String,
2614    pub properties: QuestionRejected2Data,
2615    #[serde(rename = "type")]
2616    pub type_: String,
2617}
2618
2619#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2620pub struct GlobalEventPayloadVariant62 {
2621    pub id: String,
2622    pub properties: TodoUpdatedData,
2623    #[serde(rename = "type")]
2624    pub type_: String,
2625}
2626
2627#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2628pub struct GlobalEventPayloadVariant63 {
2629    pub id: String,
2630    pub properties: serde_json::Map<String, serde_json::Value>,
2631    #[serde(rename = "type")]
2632    pub type_: String,
2633}
2634
2635#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2636pub struct GlobalEventPayloadVariant64 {
2637    pub id: String,
2638    pub properties: PermissionAskedData,
2639    #[serde(rename = "type")]
2640    pub type_: String,
2641}
2642
2643#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2644pub struct GlobalEventPayloadVariant65 {
2645    pub id: String,
2646    pub properties: PermissionRepliedData,
2647    #[serde(rename = "type")]
2648    pub type_: String,
2649}
2650
2651#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2652pub struct GlobalEventPayloadVariant66 {
2653    pub id: String,
2654    pub properties: TuiPromptAppendData,
2655    #[serde(rename = "type")]
2656    pub type_: String,
2657}
2658
2659#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2660pub struct GlobalEventPayloadVariant67 {
2661    pub id: String,
2662    pub properties: TuiCommandExecuteData,
2663    #[serde(rename = "type")]
2664    pub type_: String,
2665}
2666
2667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2668pub struct GlobalEventPayloadVariant68 {
2669    pub id: String,
2670    pub properties: TuiToastShowData,
2671    #[serde(rename = "type")]
2672    pub type_: String,
2673}
2674
2675#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2676pub struct GlobalEventPayloadVariant69 {
2677    pub id: String,
2678    pub properties: TuiSessionSelectData,
2679    #[serde(rename = "type")]
2680    pub type_: String,
2681}
2682
2683#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2684pub struct GlobalEventPayloadVariant7 {
2685    pub id: String,
2686    pub properties: MessageUpdatedData,
2687    #[serde(rename = "type")]
2688    pub type_: String,
2689}
2690
2691#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2692pub struct GlobalEventPayloadVariant70 {
2693    pub id: String,
2694    pub properties: McpToolsChangedData,
2695    #[serde(rename = "type")]
2696    pub type_: String,
2697}
2698
2699#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2700pub struct GlobalEventPayloadVariant71 {
2701    pub id: String,
2702    pub properties: McpBrowserOpenFailedData,
2703    #[serde(rename = "type")]
2704    pub type_: String,
2705}
2706
2707#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2708pub struct GlobalEventPayloadVariant72 {
2709    pub id: String,
2710    pub properties: CommandExecutedData,
2711    #[serde(rename = "type")]
2712    pub type_: String,
2713}
2714
2715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2716pub struct GlobalEventPayloadVariant73 {
2717    pub id: String,
2718    pub properties: ProjectUpdatedData,
2719    #[serde(rename = "type")]
2720    pub type_: String,
2721}
2722
2723#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2724pub struct GlobalEventPayloadVariant74 {
2725    pub id: String,
2726    pub properties: SessionStatus2Data,
2727    #[serde(rename = "type")]
2728    pub type_: String,
2729}
2730
2731#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2732pub struct GlobalEventPayloadVariant75 {
2733    pub id: String,
2734    pub properties: SessionIdleData,
2735    #[serde(rename = "type")]
2736    pub type_: String,
2737}
2738
2739#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2740pub struct GlobalEventPayloadVariant76 {
2741    pub id: String,
2742    pub properties: QuestionAskedData,
2743    #[serde(rename = "type")]
2744    pub type_: String,
2745}
2746
2747#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2748pub struct GlobalEventPayloadVariant77 {
2749    pub id: String,
2750    pub properties: QuestionReplied2Data,
2751    #[serde(rename = "type")]
2752    pub type_: String,
2753}
2754
2755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2756pub struct GlobalEventPayloadVariant78 {
2757    pub id: String,
2758    pub properties: QuestionRejected2Data,
2759    #[serde(rename = "type")]
2760    pub type_: String,
2761}
2762
2763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2764pub struct GlobalEventPayloadVariant79 {
2765    pub id: String,
2766    pub properties: SessionIdleData,
2767    #[serde(rename = "type")]
2768    pub type_: String,
2769}
2770
2771#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2772pub struct GlobalEventPayloadVariant8 {
2773    pub id: String,
2774    pub properties: MessageRemovedData,
2775    #[serde(rename = "type")]
2776    pub type_: String,
2777}
2778
2779#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2780pub struct GlobalEventPayloadVariant80 {
2781    pub id: String,
2782    pub properties: VcsBranchUpdatedData,
2783    #[serde(rename = "type")]
2784    pub type_: String,
2785}
2786
2787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2788pub struct GlobalEventPayloadVariant81 {
2789    pub id: String,
2790    pub properties: WorkspaceReadyData,
2791    #[serde(rename = "type")]
2792    pub type_: String,
2793}
2794
2795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2796pub struct GlobalEventPayloadVariant82 {
2797    pub id: String,
2798    pub properties: WorktreeFailedData,
2799    #[serde(rename = "type")]
2800    pub type_: String,
2801}
2802
2803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2804pub struct GlobalEventPayloadVariant83 {
2805    pub id: String,
2806    pub properties: WorkspaceStatusData,
2807    #[serde(rename = "type")]
2808    pub type_: String,
2809}
2810
2811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2812pub struct GlobalEventPayloadVariant84 {
2813    pub id: String,
2814    pub properties: WorktreeReadyData,
2815    #[serde(rename = "type")]
2816    pub type_: String,
2817}
2818
2819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2820pub struct GlobalEventPayloadVariant85 {
2821    pub id: String,
2822    pub properties: WorktreeFailedData,
2823    #[serde(rename = "type")]
2824    pub type_: String,
2825}
2826
2827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2828pub struct GlobalEventPayloadVariant86 {
2829    pub id: String,
2830    pub properties: serde_json::Map<String, serde_json::Value>,
2831    #[serde(rename = "type")]
2832    pub type_: String,
2833}
2834
2835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2836pub struct GlobalEventPayloadVariant87 {
2837    pub id: String,
2838    pub properties: serde_json::Map<String, serde_json::Value>,
2839    #[serde(rename = "type")]
2840    pub type_: String,
2841}
2842
2843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2844pub struct GlobalEventPayloadVariant9 {
2845    pub id: String,
2846    pub properties: MessagePartUpdatedData,
2847    #[serde(rename = "type")]
2848    pub type_: String,
2849}
2850
2851#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2852pub struct GlobalSession {
2853    #[serde(default, skip_serializing_if = "Option::is_none")]
2854    pub agent: Option<String>,
2855    #[serde(default, skip_serializing_if = "Option::is_none")]
2856    pub cost: Option<f64>,
2857    pub directory: String,
2858    pub id: String,
2859    #[serde(default, skip_serializing_if = "Option::is_none")]
2860    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
2861    #[serde(default, skip_serializing_if = "Option::is_none")]
2862    pub model: Option<SessionCreateParamsModel>,
2863    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
2864    pub parent_id: Option<String>,
2865    #[serde(default, skip_serializing_if = "Option::is_none")]
2866    pub path: Option<String>,
2867    #[serde(default, skip_serializing_if = "Option::is_none")]
2868    pub permission: Option<PermissionRuleset>,
2869    pub project: Option<ProjectSummary>,
2870    #[serde(rename = "projectID")]
2871    pub project_id: String,
2872    #[serde(default, skip_serializing_if = "Option::is_none")]
2873    pub revert: Option<SessionRevert>,
2874    #[serde(default, skip_serializing_if = "Option::is_none")]
2875    pub share: Option<SessionShare>,
2876    pub slug: String,
2877    #[serde(default, skip_serializing_if = "Option::is_none")]
2878    pub summary: Option<SessionSummary>,
2879    pub time: SessionTime,
2880    pub title: String,
2881    #[serde(default, skip_serializing_if = "Option::is_none")]
2882    pub tokens: Option<SessionNextStepEndedDataTokens>,
2883    pub version: String,
2884    #[serde(
2885        rename = "workspaceID",
2886        default,
2887        skip_serializing_if = "Option::is_none"
2888    )]
2889    pub workspace_id: Option<String>,
2890}
2891
2892#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2893pub struct ImageAttachmentConfig {
2894    #[serde(default, skip_serializing_if = "Option::is_none")]
2895    pub auto_resize: Option<bool>,
2896    #[serde(default, skip_serializing_if = "Option::is_none")]
2897    pub max_base64_bytes: Option<i64>,
2898    #[serde(default, skip_serializing_if = "Option::is_none")]
2899    pub max_height: Option<i64>,
2900    #[serde(default, skip_serializing_if = "Option::is_none")]
2901    pub max_width: Option<i64>,
2902}
2903
2904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2905pub struct InstallationUpdateAvailable {
2906    pub data: InstallationUpdatedData,
2907    #[serde(default, skip_serializing_if = "Option::is_none")]
2908    pub durable: Option<SessionStatus2Durable>,
2909    pub id: String,
2910    #[serde(default, skip_serializing_if = "Option::is_none")]
2911    pub location: Option<LocationRef>,
2912    #[serde(default, skip_serializing_if = "Option::is_none")]
2913    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
2914    #[serde(rename = "type", default, skip_serializing)]
2915    pub type_: String,
2916}
2917
2918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2919pub struct InstallationUpdated {
2920    pub data: InstallationUpdatedData,
2921    #[serde(default, skip_serializing_if = "Option::is_none")]
2922    pub durable: Option<SessionStatus2Durable>,
2923    pub id: String,
2924    #[serde(default, skip_serializing_if = "Option::is_none")]
2925    pub location: Option<LocationRef>,
2926    #[serde(default, skip_serializing_if = "Option::is_none")]
2927    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
2928    #[serde(rename = "type", default, skip_serializing)]
2929    pub type_: String,
2930}
2931
2932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2933pub struct InstallationUpdatedData {
2934    pub version: String,
2935}
2936
2937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2938pub struct IntegrationAttempt {
2939    #[serde(rename = "attemptID")]
2940    pub attempt_id: String,
2941    pub instructions: String,
2942    pub mode: String,
2943    pub time: IntegrationAttemptStatusPendingTime,
2944    pub url: String,
2945}
2946
2947#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2948#[serde(tag = "status")]
2949pub enum IntegrationAttemptStatus {
2950    #[serde(rename = "pending")]
2951    Pending {
2952        time: IntegrationAttemptStatusPendingTime,
2953    },
2954    #[serde(rename = "complete")]
2955    Complete {
2956        time: IntegrationAttemptStatusPendingTime,
2957    },
2958    #[serde(rename = "failed")]
2959    Failed {
2960        message: String,
2961        time: IntegrationAttemptStatusPendingTime,
2962    },
2963    #[serde(rename = "expired")]
2964    Expired {
2965        time: IntegrationAttemptStatusPendingTime,
2966    },
2967}
2968
2969#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2970pub struct IntegrationAttemptStatusPendingTime {
2971    pub created: WorkspaceTimeUsed,
2972    pub expires: WorkspaceTimeUsed,
2973}
2974
2975#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2976pub struct IntegrationConnectionUpdated {
2977    pub data: IntegrationConnectionUpdatedData,
2978    #[serde(default, skip_serializing_if = "Option::is_none")]
2979    pub durable: Option<SessionStatus2Durable>,
2980    pub id: String,
2981    #[serde(default, skip_serializing_if = "Option::is_none")]
2982    pub location: Option<LocationRef>,
2983    #[serde(default, skip_serializing_if = "Option::is_none")]
2984    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
2985    #[serde(rename = "type", default, skip_serializing)]
2986    pub type_: String,
2987}
2988
2989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2990pub struct IntegrationConnectionUpdatedData {
2991    #[serde(rename = "integrationID")]
2992    pub integration_id: String,
2993}
2994
2995#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
2996pub struct IntegrationEnvMethod {
2997    pub names: Vec<String>,
2998    #[serde(rename = "type", default, skip_serializing)]
2999    pub type_: String,
3000}
3001
3002#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3003pub struct IntegrationInfo {
3004    pub connections: Vec<ConnectionInfo>,
3005    pub id: String,
3006    pub methods: Vec<IntegrationMethod>,
3007    pub name: String,
3008}
3009
3010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3011pub struct IntegrationInputs {
3012    #[serde(flatten)]
3013    pub map: std::collections::BTreeMap<String, String>,
3014}
3015
3016#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3017pub struct IntegrationKeyMethod {
3018    #[serde(default, skip_serializing_if = "Option::is_none")]
3019    pub label: Option<String>,
3020    #[serde(rename = "type", default, skip_serializing)]
3021    pub type_: String,
3022}
3023
3024#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3025#[serde(tag = "type")]
3026pub enum IntegrationMethod {
3027    #[serde(rename = "oauth")]
3028    Oauth(IntegrationOAuthMethod),
3029    #[serde(rename = "key")]
3030    Key(IntegrationKeyMethod),
3031    #[serde(rename = "env")]
3032    Env(IntegrationEnvMethod),
3033}
3034
3035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3036pub struct IntegrationOAuthMethod {
3037    pub id: String,
3038    pub label: String,
3039    #[serde(default, skip_serializing_if = "Option::is_none")]
3040    pub prompts: Option<Vec<IntegrationOAuthMethodPromptsItem>>,
3041    #[serde(rename = "type", default, skip_serializing)]
3042    pub type_: String,
3043}
3044
3045#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3046#[serde(tag = "type")]
3047pub enum IntegrationOAuthMethodPromptsItem {
3048    #[serde(rename = "text")]
3049    Text(IntegrationTextPrompt),
3050    #[serde(rename = "select")]
3051    Select(IntegrationSelectPrompt),
3052}
3053
3054#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3055pub struct IntegrationRef {
3056    pub id: String,
3057    pub name: String,
3058}
3059
3060#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3061pub struct IntegrationSelectPrompt {
3062    pub key: String,
3063    pub message: String,
3064    pub options: Vec<ProviderAuthMethodPromptsItemSelectOptionsItem>,
3065    #[serde(rename = "type", default, skip_serializing)]
3066    pub type_: String,
3067    #[serde(default, skip_serializing_if = "Option::is_none")]
3068    pub when: Option<IntegrationWhen>,
3069}
3070
3071#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3072pub struct IntegrationTextPrompt {
3073    pub key: String,
3074    pub message: String,
3075    #[serde(default, skip_serializing_if = "Option::is_none")]
3076    pub placeholder: Option<String>,
3077    #[serde(rename = "type", default, skip_serializing)]
3078    pub type_: String,
3079    #[serde(default, skip_serializing_if = "Option::is_none")]
3080    pub when: Option<IntegrationWhen>,
3081}
3082
3083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3084pub struct IntegrationUpdated {
3085    pub data: serde_json::Map<String, serde_json::Value>,
3086    #[serde(default, skip_serializing_if = "Option::is_none")]
3087    pub durable: Option<SessionStatus2Durable>,
3088    pub id: String,
3089    #[serde(default, skip_serializing_if = "Option::is_none")]
3090    pub location: Option<LocationRef>,
3091    #[serde(default, skip_serializing_if = "Option::is_none")]
3092    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3093    #[serde(rename = "type", default, skip_serializing)]
3094    pub type_: String,
3095}
3096
3097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3098pub struct IntegrationWhen {
3099    pub key: String,
3100    pub op: String,
3101    pub value: String,
3102}
3103
3104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3105pub struct InvalidCursorError {
3106    pub _tag: String,
3107    pub message: String,
3108}
3109
3110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3111pub struct InvalidRequestError {
3112    pub _tag: String,
3113    #[serde(default, skip_serializing_if = "Option::is_none")]
3114    pub field: Option<String>,
3115    #[serde(default, skip_serializing_if = "Option::is_none")]
3116    pub kind: Option<String>,
3117    pub message: String,
3118}
3119
3120#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3121pub struct JSONSchema {
3122    #[serde(flatten)]
3123    pub extra: serde_json::Map<String, serde_json::Value>,
3124}
3125
3126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3127pub struct LLMProviderMetadata {
3128    #[serde(flatten)]
3129    pub map: std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
3130}
3131
3132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3133#[serde(tag = "type")]
3134pub enum LLMToolContent {
3135    #[serde(rename = "text")]
3136    Text(ToolTextContent),
3137    #[serde(rename = "file")]
3138    File(ToolFileContent),
3139}
3140
3141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3142pub struct LSPStatus {
3143    pub id: String,
3144    pub name: String,
3145    pub root: String,
3146    pub status: String,
3147}
3148
3149/// @deprecated Always uses stretch layout.
3150#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3151pub enum LayoutConfig {
3152    Auto,
3153    Stretch,
3154    Unknown(String),
3155}
3156
3157impl LayoutConfig {
3158    pub fn as_str(&self) -> &str {
3159        match self {
3160            Self::Auto => "auto",
3161            Self::Stretch => "stretch",
3162            Self::Unknown(s) => s.as_str(),
3163        }
3164    }
3165}
3166
3167impl std::fmt::Display for LayoutConfig {
3168    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3169        f.write_str(self.as_str())
3170    }
3171}
3172
3173impl From<&str> for LayoutConfig {
3174    fn from(s: &str) -> Self {
3175        match s {
3176            "auto" => Self::Auto,
3177            "stretch" => Self::Stretch,
3178            other => Self::Unknown(other.to_string()),
3179        }
3180    }
3181}
3182
3183impl Serialize for LayoutConfig {
3184    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3185        serializer.serialize_str(self.as_str())
3186    }
3187}
3188
3189impl<'de> Deserialize<'de> for LayoutConfig {
3190    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3191        let s = String::deserialize(deserializer)?;
3192        Ok(Self::from(s.as_str()))
3193    }
3194}
3195
3196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3197pub struct LocationInfo {
3198    pub directory: String,
3199    pub project: LocationInfoProject,
3200    #[serde(
3201        rename = "workspaceID",
3202        default,
3203        skip_serializing_if = "Option::is_none"
3204    )]
3205    pub workspace_id: Option<String>,
3206}
3207
3208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3209pub struct LocationInfoProject {
3210    pub directory: String,
3211    pub id: String,
3212}
3213
3214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3215pub struct LocationRef {
3216    pub directory: String,
3217    #[serde(
3218        rename = "workspaceID",
3219        default,
3220        skip_serializing_if = "Option::is_none"
3221    )]
3222    pub workspace_id: Option<String>,
3223}
3224
3225/// Log level
3226#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3227pub enum LogLevel {
3228    DEBUG,
3229    INFO,
3230    WARN,
3231    ERROR,
3232    Unknown(String),
3233}
3234
3235impl LogLevel {
3236    pub fn as_str(&self) -> &str {
3237        match self {
3238            Self::DEBUG => "DEBUG",
3239            Self::INFO => "INFO",
3240            Self::WARN => "WARN",
3241            Self::ERROR => "ERROR",
3242            Self::Unknown(s) => s.as_str(),
3243        }
3244    }
3245}
3246
3247impl std::fmt::Display for LogLevel {
3248    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3249        f.write_str(self.as_str())
3250    }
3251}
3252
3253impl From<&str> for LogLevel {
3254    fn from(s: &str) -> Self {
3255        match s {
3256            "DEBUG" => Self::DEBUG,
3257            "INFO" => Self::INFO,
3258            "WARN" => Self::WARN,
3259            "ERROR" => Self::ERROR,
3260            other => Self::Unknown(other.to_string()),
3261        }
3262    }
3263}
3264
3265impl Serialize for LogLevel {
3266    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3267        serializer.serialize_str(self.as_str())
3268    }
3269}
3270
3271impl<'de> Deserialize<'de> for LogLevel {
3272    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3273        let s = String::deserialize(deserializer)?;
3274        Ok(Self::from(s.as_str()))
3275    }
3276}
3277
3278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3279pub struct LspUpdated {
3280    pub data: serde_json::Map<String, serde_json::Value>,
3281    #[serde(default, skip_serializing_if = "Option::is_none")]
3282    pub durable: Option<SessionStatus2Durable>,
3283    pub id: String,
3284    #[serde(default, skip_serializing_if = "Option::is_none")]
3285    pub location: Option<LocationRef>,
3286    #[serde(default, skip_serializing_if = "Option::is_none")]
3287    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3288    #[serde(rename = "type", default, skip_serializing)]
3289    pub type_: String,
3290}
3291
3292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3293#[serde(tag = "status")]
3294pub enum MCPStatus {
3295    #[serde(rename = "connected")]
3296    Connected(MCPStatusConnected),
3297    #[serde(rename = "disabled")]
3298    Disabled(MCPStatusDisabled),
3299    #[serde(rename = "failed")]
3300    Failed(MCPStatusFailed),
3301    #[serde(rename = "needs_auth")]
3302    NeedsAuth(MCPStatusNeedsAuth),
3303    #[serde(rename = "needs_client_registration")]
3304    NeedsClientRegistration(MCPStatusNeedsClientRegistration),
3305}
3306
3307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3308pub struct MCPStatusConnected {
3309    #[serde(default, skip_serializing)]
3310    pub status: String,
3311}
3312
3313#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3314pub struct MCPStatusDisabled {
3315    #[serde(default, skip_serializing)]
3316    pub status: String,
3317}
3318
3319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3320pub struct MCPStatusFailed {
3321    pub error: String,
3322    #[serde(default, skip_serializing)]
3323    pub status: String,
3324}
3325
3326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3327pub struct MCPStatusNeedsAuth {
3328    #[serde(default, skip_serializing)]
3329    pub status: String,
3330}
3331
3332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3333pub struct MCPStatusNeedsClientRegistration {
3334    pub error: String,
3335    #[serde(default, skip_serializing)]
3336    pub status: String,
3337}
3338
3339#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3340pub struct McpBrowserOpenFailed {
3341    pub data: McpBrowserOpenFailedData,
3342    #[serde(default, skip_serializing_if = "Option::is_none")]
3343    pub durable: Option<SessionStatus2Durable>,
3344    pub id: String,
3345    #[serde(default, skip_serializing_if = "Option::is_none")]
3346    pub location: Option<LocationRef>,
3347    #[serde(default, skip_serializing_if = "Option::is_none")]
3348    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3349    #[serde(rename = "type", default, skip_serializing)]
3350    pub type_: String,
3351}
3352
3353#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3354pub struct McpBrowserOpenFailedData {
3355    #[serde(rename = "mcpName")]
3356    pub mcp_name: String,
3357    pub url: String,
3358}
3359
3360#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3361pub struct McpLocalConfig {
3362    pub command: Vec<String>,
3363    #[serde(default, skip_serializing_if = "Option::is_none")]
3364    pub cwd: Option<String>,
3365    #[serde(default, skip_serializing_if = "Option::is_none")]
3366    pub enabled: Option<bool>,
3367    #[serde(default, skip_serializing_if = "Option::is_none")]
3368    pub environment: Option<std::collections::BTreeMap<String, String>>,
3369    #[serde(default, skip_serializing_if = "Option::is_none")]
3370    pub timeout: Option<i64>,
3371    #[serde(rename = "type")]
3372    pub type_: String,
3373}
3374
3375#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3376pub struct McpOAuthConfig {
3377    #[serde(
3378        rename = "callbackPort",
3379        default,
3380        skip_serializing_if = "Option::is_none"
3381    )]
3382    pub callback_port: Option<u64>,
3383    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
3384    pub client_id: Option<String>,
3385    #[serde(
3386        rename = "clientSecret",
3387        default,
3388        skip_serializing_if = "Option::is_none"
3389    )]
3390    pub client_secret: Option<String>,
3391    #[serde(
3392        rename = "redirectUri",
3393        default,
3394        skip_serializing_if = "Option::is_none"
3395    )]
3396    pub redirect_uri: Option<String>,
3397    #[serde(default, skip_serializing_if = "Option::is_none")]
3398    pub scope: Option<String>,
3399}
3400
3401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3402pub struct McpRemoteConfig {
3403    #[serde(default, skip_serializing_if = "Option::is_none")]
3404    pub enabled: Option<bool>,
3405    #[serde(default, skip_serializing_if = "Option::is_none")]
3406    pub headers: Option<std::collections::BTreeMap<String, String>>,
3407    #[serde(default, skip_serializing_if = "Option::is_none")]
3408    pub oauth: Option<McpRemoteConfigOauth>,
3409    #[serde(default, skip_serializing_if = "Option::is_none")]
3410    pub timeout: Option<i64>,
3411    #[serde(rename = "type")]
3412    pub type_: String,
3413    pub url: String,
3414}
3415
3416/// OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection.
3417/// Untagged union: serde tries each variant in the order below.
3418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3419#[serde(untagged)]
3420pub enum McpRemoteConfigOauth {
3421    McpOAuthConfig(McpOAuthConfig),
3422    Variant1(bool),
3423}
3424
3425#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3426pub struct McpResource {
3427    pub client: String,
3428    #[serde(default, skip_serializing_if = "Option::is_none")]
3429    pub description: Option<String>,
3430    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
3431    pub mime_type: Option<String>,
3432    pub name: String,
3433    pub uri: String,
3434}
3435
3436#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3437pub struct McpServerNotFoundError {
3438    pub _tag: String,
3439    pub message: String,
3440    pub name: String,
3441}
3442
3443#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3444pub struct McpToolsChanged {
3445    pub data: McpToolsChangedData,
3446    #[serde(default, skip_serializing_if = "Option::is_none")]
3447    pub durable: Option<SessionStatus2Durable>,
3448    pub id: String,
3449    #[serde(default, skip_serializing_if = "Option::is_none")]
3450    pub location: Option<LocationRef>,
3451    #[serde(default, skip_serializing_if = "Option::is_none")]
3452    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3453    #[serde(rename = "type", default, skip_serializing)]
3454    pub type_: String,
3455}
3456
3457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3458pub struct McpToolsChangedData {
3459    pub server: String,
3460}
3461
3462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3463pub struct McpUnsupportedOAuthError {
3464    pub error: String,
3465}
3466
3467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3468#[serde(tag = "role")]
3469pub enum Message {
3470    #[serde(rename = "user")]
3471    User(UserMessage),
3472    #[serde(rename = "assistant")]
3473    Assistant(AssistantMessage),
3474}
3475
3476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3477pub struct MessageAbortedError {
3478    pub data: WorktreeFailedData,
3479    #[serde(default, skip_serializing)]
3480    pub name: String,
3481}
3482
3483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3484pub struct MessageNotFoundError {
3485    pub _tag: String,
3486    pub message: String,
3487    #[serde(rename = "messageID")]
3488    pub message_id: String,
3489    #[serde(rename = "sessionID")]
3490    pub session_id: String,
3491}
3492
3493#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3494pub struct MessageOutputLengthError {
3495    pub data: serde_json::Map<String, serde_json::Value>,
3496    #[serde(default, skip_serializing)]
3497    pub name: String,
3498}
3499
3500#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3501pub struct MessagePartDelta {
3502    pub data: MessagePartDeltaData,
3503    #[serde(default, skip_serializing_if = "Option::is_none")]
3504    pub durable: Option<SessionStatus2Durable>,
3505    pub id: String,
3506    #[serde(default, skip_serializing_if = "Option::is_none")]
3507    pub location: Option<LocationRef>,
3508    #[serde(default, skip_serializing_if = "Option::is_none")]
3509    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3510    #[serde(rename = "type", default, skip_serializing)]
3511    pub type_: String,
3512}
3513
3514#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3515pub struct MessagePartDeltaData {
3516    pub delta: String,
3517    pub field: String,
3518    #[serde(rename = "messageID")]
3519    pub message_id: String,
3520    #[serde(rename = "partID")]
3521    pub part_id: String,
3522    #[serde(rename = "sessionID")]
3523    pub session_id: String,
3524}
3525
3526#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3527pub struct MessagePartRemoved {
3528    pub data: MessagePartRemovedData,
3529    #[serde(default, skip_serializing_if = "Option::is_none")]
3530    pub durable: Option<SessionStatus2Durable>,
3531    pub id: String,
3532    #[serde(default, skip_serializing_if = "Option::is_none")]
3533    pub location: Option<LocationRef>,
3534    #[serde(default, skip_serializing_if = "Option::is_none")]
3535    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3536    #[serde(rename = "type", default, skip_serializing)]
3537    pub type_: String,
3538}
3539
3540#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3541pub struct MessagePartRemovedData {
3542    #[serde(rename = "messageID")]
3543    pub message_id: String,
3544    #[serde(rename = "partID")]
3545    pub part_id: String,
3546    #[serde(rename = "sessionID")]
3547    pub session_id: String,
3548}
3549
3550#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3551pub struct MessagePartUpdated {
3552    pub data: MessagePartUpdatedData,
3553    #[serde(default, skip_serializing_if = "Option::is_none")]
3554    pub durable: Option<SessionStatus2Durable>,
3555    pub id: String,
3556    #[serde(default, skip_serializing_if = "Option::is_none")]
3557    pub location: Option<LocationRef>,
3558    #[serde(default, skip_serializing_if = "Option::is_none")]
3559    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3560    #[serde(rename = "type", default, skip_serializing)]
3561    pub type_: String,
3562}
3563
3564#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3565pub struct MessagePartUpdatedData {
3566    pub part: Part,
3567    #[serde(rename = "sessionID")]
3568    pub session_id: String,
3569    pub time: f64,
3570}
3571
3572#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3573pub struct MessageRemoved {
3574    pub data: MessageRemovedData,
3575    #[serde(default, skip_serializing_if = "Option::is_none")]
3576    pub durable: Option<SessionStatus2Durable>,
3577    pub id: String,
3578    #[serde(default, skip_serializing_if = "Option::is_none")]
3579    pub location: Option<LocationRef>,
3580    #[serde(default, skip_serializing_if = "Option::is_none")]
3581    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3582    #[serde(rename = "type", default, skip_serializing)]
3583    pub type_: String,
3584}
3585
3586#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3587pub struct MessageRemovedData {
3588    #[serde(rename = "messageID")]
3589    pub message_id: String,
3590    #[serde(rename = "sessionID")]
3591    pub session_id: String,
3592}
3593
3594#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3595pub struct MessageUpdated {
3596    pub data: MessageUpdatedData,
3597    #[serde(default, skip_serializing_if = "Option::is_none")]
3598    pub durable: Option<SessionStatus2Durable>,
3599    pub id: String,
3600    #[serde(default, skip_serializing_if = "Option::is_none")]
3601    pub location: Option<LocationRef>,
3602    #[serde(default, skip_serializing_if = "Option::is_none")]
3603    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3604    #[serde(rename = "type", default, skip_serializing)]
3605    pub type_: String,
3606}
3607
3608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3609pub struct MessageUpdatedData {
3610    pub info: Message,
3611    #[serde(rename = "sessionID")]
3612    pub session_id: String,
3613}
3614
3615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3616pub struct MessageWithParts {
3617    pub info: Message,
3618    pub parts: Vec<Part>,
3619}
3620
3621#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3622pub struct Model {
3623    pub api: ModelApi2,
3624    pub capabilities: ModelCapabilities2,
3625    pub cost: ModelCost2,
3626    #[serde(default, skip_serializing_if = "Option::is_none")]
3627    pub family: Option<String>,
3628    pub headers: std::collections::BTreeMap<String, String>,
3629    pub id: String,
3630    pub limit: ProviderConfigModelsValueLimit,
3631    pub name: String,
3632    pub options: serde_json::Map<String, serde_json::Value>,
3633    #[serde(rename = "providerID")]
3634    pub provider_id: String,
3635    pub release_date: String,
3636    pub status: String,
3637    #[serde(default, skip_serializing_if = "Option::is_none")]
3638    pub variants:
3639        Option<std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>>,
3640}
3641
3642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3643#[serde(tag = "type")]
3644pub enum ModelApi {
3645    #[serde(rename = "aisdk")]
3646    Aisdk {
3647        id: String,
3648        package: String,
3649        #[serde(default, skip_serializing_if = "Option::is_none")]
3650        settings: Option<serde_json::Map<String, serde_json::Value>>,
3651        #[serde(default, skip_serializing_if = "Option::is_none")]
3652        url: Option<String>,
3653    },
3654    #[serde(rename = "native")]
3655    Native {
3656        id: String,
3657        settings: serde_json::Map<String, serde_json::Value>,
3658        #[serde(default, skip_serializing_if = "Option::is_none")]
3659        url: Option<String>,
3660    },
3661}
3662
3663#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3664pub struct ModelApi2 {
3665    pub id: String,
3666    pub npm: String,
3667    pub url: String,
3668}
3669
3670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3671pub struct ModelCapabilities {
3672    pub input: Vec<String>,
3673    pub output: Vec<String>,
3674    pub tools: bool,
3675}
3676
3677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3678pub struct ModelCapabilities2 {
3679    pub attachment: bool,
3680    pub input: ModelCapabilities2Input,
3681    pub interleaved: ModelCapabilities2Interleaved,
3682    pub output: ModelCapabilities2Input,
3683    pub reasoning: bool,
3684    pub temperature: bool,
3685    pub toolcall: bool,
3686}
3687
3688#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3689pub struct ModelCapabilities2Input {
3690    pub audio: bool,
3691    pub image: bool,
3692    pub pdf: bool,
3693    pub text: bool,
3694    pub video: bool,
3695}
3696
3697/// Untagged union: serde tries each variant in the order below.
3698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3699#[serde(untagged)]
3700pub enum ModelCapabilities2Interleaved {
3701    Variant0(bool),
3702    Variant1(ProviderConfigModelsValueInterleavedVariant3),
3703}
3704
3705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3706pub struct ModelCost {
3707    pub cache: SessionNextStepEndedDataTokensCache,
3708    pub input: f64,
3709    pub output: f64,
3710    #[serde(default, skip_serializing_if = "Option::is_none")]
3711    pub tier: Option<ModelCostTier>,
3712}
3713
3714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3715pub struct ModelCost2 {
3716    pub cache: SessionNextStepEndedDataTokensCache,
3717    #[serde(
3718        rename = "experimentalOver200K",
3719        default,
3720        skip_serializing_if = "Option::is_none"
3721    )]
3722    pub experimental_over200_k: Option<ModelCost2ExperimentalOver200K>,
3723    pub input: f64,
3724    pub output: f64,
3725    #[serde(default, skip_serializing_if = "Option::is_none")]
3726    pub tiers: Option<Vec<ModelCost2TiersItem>>,
3727}
3728
3729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3730pub struct ModelCost2ExperimentalOver200K {
3731    pub cache: SessionNextStepEndedDataTokensCache,
3732    pub input: f64,
3733    pub output: f64,
3734}
3735
3736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3737pub struct ModelCost2TiersItem {
3738    pub cache: SessionNextStepEndedDataTokensCache,
3739    pub input: f64,
3740    pub output: f64,
3741    pub tier: ModelCost2TiersItemTier,
3742}
3743
3744#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3745pub struct ModelCost2TiersItemTier {
3746    pub size: f64,
3747    #[serde(rename = "type")]
3748    pub type_: String,
3749}
3750
3751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3752pub struct ModelCostTier {
3753    pub size: i64,
3754    #[serde(rename = "type")]
3755    pub type_: String,
3756}
3757
3758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3759pub struct ModelRef {
3760    pub id: String,
3761    #[serde(rename = "providerID")]
3762    pub provider_id: String,
3763    #[serde(default, skip_serializing_if = "Option::is_none")]
3764    pub variant: Option<String>,
3765}
3766
3767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3768pub struct ModelV2Info {
3769    pub api: ModelApi,
3770    pub capabilities: ModelCapabilities,
3771    pub cost: Vec<ModelCost>,
3772    pub enabled: bool,
3773    #[serde(default, skip_serializing_if = "Option::is_none")]
3774    pub family: Option<String>,
3775    pub id: String,
3776    pub limit: ModelV2InfoLimit,
3777    pub name: String,
3778    #[serde(rename = "providerID")]
3779    pub provider_id: String,
3780    pub request: ModelV2InfoRequest,
3781    pub status: String,
3782    pub time: ModelV2InfoTime,
3783    pub variants: Vec<ModelV2InfoVariantsItem>,
3784}
3785
3786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3787pub struct ModelV2InfoLimit {
3788    pub context: i64,
3789    #[serde(default, skip_serializing_if = "Option::is_none")]
3790    pub input: Option<i64>,
3791    pub output: i64,
3792}
3793
3794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3795pub struct ModelV2InfoRequest {
3796    pub body: serde_json::Map<String, serde_json::Value>,
3797    pub headers: std::collections::BTreeMap<String, String>,
3798    #[serde(default, skip_serializing_if = "Option::is_none")]
3799    pub variant: Option<String>,
3800}
3801
3802#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3803pub struct ModelV2InfoTime {
3804    pub released: f64,
3805}
3806
3807#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3808pub struct ModelV2InfoVariantsItem {
3809    pub body: serde_json::Map<String, serde_json::Value>,
3810    pub headers: std::collections::BTreeMap<String, String>,
3811    pub id: String,
3812}
3813
3814#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3815pub struct ModelsDevRefreshed {
3816    pub data: serde_json::Map<String, serde_json::Value>,
3817    #[serde(default, skip_serializing_if = "Option::is_none")]
3818    pub durable: Option<SessionStatus2Durable>,
3819    pub id: String,
3820    #[serde(default, skip_serializing_if = "Option::is_none")]
3821    pub location: Option<LocationRef>,
3822    #[serde(default, skip_serializing_if = "Option::is_none")]
3823    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
3824    #[serde(rename = "type", default, skip_serializing)]
3825    pub type_: String,
3826}
3827
3828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3829pub struct MoveSessionDestination {
3830    pub directory: String,
3831}
3832
3833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3834pub struct MoveSessionError {
3835    pub data: WorktreeFailedData,
3836    pub name: String,
3837}
3838
3839#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3840pub struct NotFoundError {
3841    pub data: NotFoundErrorData,
3842    pub name: String,
3843}
3844
3845#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3846pub struct NotFoundErrorData {
3847    pub message: String,
3848}
3849
3850#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3851pub struct OAuth {
3852    pub access: String,
3853    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
3854    pub account_id: Option<String>,
3855    #[serde(
3856        rename = "enterpriseUrl",
3857        default,
3858        skip_serializing_if = "Option::is_none"
3859    )]
3860    pub enterprise_url: Option<String>,
3861    pub expires: u64,
3862    pub refresh: String,
3863    #[serde(rename = "type", default, skip_serializing)]
3864    pub type_: String,
3865}
3866
3867#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3868#[serde(tag = "type")]
3869pub enum OutputFormat {
3870    #[serde(rename = "text")]
3871    Text(OutputFormatText),
3872    #[serde(rename = "json_schema")]
3873    JsonSchema(OutputFormatJsonSchema),
3874}
3875
3876#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3877#[serde(tag = "type")]
3878pub enum OutputFormat1 {
3879    #[serde(rename = "text")]
3880    Text,
3881    #[serde(rename = "json_schema")]
3882    JsonSchema {
3883        #[serde(
3884            rename = "retryCount",
3885            default,
3886            skip_serializing_if = "Option::is_none"
3887        )]
3888        retry_count: Option<u64>,
3889        schema: JSONSchema,
3890    },
3891}
3892
3893#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3894pub struct OutputFormatJsonSchema {
3895    #[serde(
3896        rename = "retryCount",
3897        default,
3898        skip_serializing_if = "Option::is_none"
3899    )]
3900    pub retry_count: Option<u64>,
3901    pub schema: JSONSchema,
3902    #[serde(rename = "type", default, skip_serializing)]
3903    pub type_: String,
3904}
3905
3906#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3907pub struct OutputFormatText {
3908    #[serde(rename = "type", default, skip_serializing)]
3909    pub type_: String,
3910}
3911
3912#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3913#[serde(tag = "type")]
3914pub enum Part {
3915    #[serde(rename = "text")]
3916    Text(TextPart),
3917    #[serde(rename = "subtask")]
3918    Subtask(SubtaskPart),
3919    #[serde(rename = "reasoning")]
3920    Reasoning(ReasoningPart),
3921    #[serde(rename = "file")]
3922    File(FilePart),
3923    #[serde(rename = "tool")]
3924    Tool(ToolPart),
3925    #[serde(rename = "step-start")]
3926    StepStart(StepStartPart),
3927    #[serde(rename = "step-finish")]
3928    StepFinish(StepFinishPart),
3929    #[serde(rename = "snapshot")]
3930    Snapshot(SnapshotPart),
3931    #[serde(rename = "patch")]
3932    Patch(PatchPart),
3933    #[serde(rename = "agent")]
3934    Agent(AgentPart),
3935    #[serde(rename = "retry")]
3936    Retry(RetryPart),
3937    #[serde(rename = "compaction")]
3938    Compaction(CompactionPart),
3939}
3940
3941#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3942pub struct PatchPart {
3943    pub files: Vec<String>,
3944    pub hash: String,
3945    pub id: String,
3946    #[serde(rename = "messageID")]
3947    pub message_id: String,
3948    #[serde(rename = "sessionID")]
3949    pub session_id: String,
3950    #[serde(rename = "type", default, skip_serializing)]
3951    pub type_: String,
3952}
3953
3954#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
3955pub struct Path {
3956    pub config: String,
3957    pub directory: String,
3958    pub home: String,
3959    pub state: String,
3960    pub worktree: String,
3961}
3962
3963#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3964pub enum PermissionAction {
3965    Allow,
3966    Deny,
3967    Ask,
3968    Unknown(String),
3969}
3970
3971impl PermissionAction {
3972    pub fn as_str(&self) -> &str {
3973        match self {
3974            Self::Allow => "allow",
3975            Self::Deny => "deny",
3976            Self::Ask => "ask",
3977            Self::Unknown(s) => s.as_str(),
3978        }
3979    }
3980}
3981
3982impl std::fmt::Display for PermissionAction {
3983    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3984        f.write_str(self.as_str())
3985    }
3986}
3987
3988impl From<&str> for PermissionAction {
3989    fn from(s: &str) -> Self {
3990        match s {
3991            "allow" => Self::Allow,
3992            "deny" => Self::Deny,
3993            "ask" => Self::Ask,
3994            other => Self::Unknown(other.to_string()),
3995        }
3996    }
3997}
3998
3999impl Serialize for PermissionAction {
4000    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4001        serializer.serialize_str(self.as_str())
4002    }
4003}
4004
4005impl<'de> Deserialize<'de> for PermissionAction {
4006    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4007        let s = String::deserialize(deserializer)?;
4008        Ok(Self::from(s.as_str()))
4009    }
4010}
4011
4012#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4013pub enum PermissionActionConfig {
4014    Ask,
4015    Allow,
4016    Deny,
4017    Unknown(String),
4018}
4019
4020impl PermissionActionConfig {
4021    pub fn as_str(&self) -> &str {
4022        match self {
4023            Self::Ask => "ask",
4024            Self::Allow => "allow",
4025            Self::Deny => "deny",
4026            Self::Unknown(s) => s.as_str(),
4027        }
4028    }
4029}
4030
4031impl std::fmt::Display for PermissionActionConfig {
4032    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4033        f.write_str(self.as_str())
4034    }
4035}
4036
4037impl From<&str> for PermissionActionConfig {
4038    fn from(s: &str) -> Self {
4039        match s {
4040            "ask" => Self::Ask,
4041            "allow" => Self::Allow,
4042            "deny" => Self::Deny,
4043            other => Self::Unknown(other.to_string()),
4044        }
4045    }
4046}
4047
4048impl Serialize for PermissionActionConfig {
4049    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4050        serializer.serialize_str(self.as_str())
4051    }
4052}
4053
4054impl<'de> Deserialize<'de> for PermissionActionConfig {
4055    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4056        let s = String::deserialize(deserializer)?;
4057        Ok(Self::from(s.as_str()))
4058    }
4059}
4060
4061#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4062pub struct PermissionAsked {
4063    pub data: PermissionAskedData,
4064    #[serde(default, skip_serializing_if = "Option::is_none")]
4065    pub durable: Option<SessionStatus2Durable>,
4066    pub id: String,
4067    #[serde(default, skip_serializing_if = "Option::is_none")]
4068    pub location: Option<LocationRef>,
4069    #[serde(default, skip_serializing_if = "Option::is_none")]
4070    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4071    #[serde(rename = "type", default, skip_serializing)]
4072    pub type_: String,
4073}
4074
4075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4076pub struct PermissionAskedData {
4077    pub always: Vec<String>,
4078    pub id: String,
4079    pub metadata: serde_json::Map<String, serde_json::Value>,
4080    pub patterns: Vec<String>,
4081    pub permission: String,
4082    #[serde(rename = "sessionID")]
4083    pub session_id: String,
4084    #[serde(default, skip_serializing_if = "Option::is_none")]
4085    pub tool: Option<PermissionAskedDataTool>,
4086}
4087
4088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4089pub struct PermissionAskedDataTool {
4090    #[serde(rename = "callID")]
4091    pub call_id: String,
4092    #[serde(rename = "messageID")]
4093    pub message_id: String,
4094}
4095
4096/// Untagged union: serde tries each variant in the order below.
4097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4098#[serde(untagged)]
4099pub enum PermissionConfig {
4100    PermissionActionConfig(PermissionActionConfig),
4101    Variant1(PermissionConfigVariant1),
4102}
4103
4104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4105pub struct PermissionConfigVariant1 {
4106    #[serde(default, skip_serializing_if = "Option::is_none")]
4107    pub bash: Option<PermissionRuleConfig>,
4108    #[serde(default, skip_serializing_if = "Option::is_none")]
4109    pub doom_loop: Option<PermissionActionConfig>,
4110    #[serde(default, skip_serializing_if = "Option::is_none")]
4111    pub edit: Option<PermissionRuleConfig>,
4112    #[serde(default, skip_serializing_if = "Option::is_none")]
4113    pub external_directory: Option<PermissionRuleConfig>,
4114    #[serde(default, skip_serializing_if = "Option::is_none")]
4115    pub glob: Option<PermissionRuleConfig>,
4116    #[serde(default, skip_serializing_if = "Option::is_none")]
4117    pub grep: Option<PermissionRuleConfig>,
4118    #[serde(default, skip_serializing_if = "Option::is_none")]
4119    pub list: Option<PermissionRuleConfig>,
4120    #[serde(default, skip_serializing_if = "Option::is_none")]
4121    pub lsp: Option<PermissionRuleConfig>,
4122    #[serde(default, skip_serializing_if = "Option::is_none")]
4123    pub question: Option<PermissionActionConfig>,
4124    #[serde(default, skip_serializing_if = "Option::is_none")]
4125    pub read: Option<PermissionRuleConfig>,
4126    #[serde(default, skip_serializing_if = "Option::is_none")]
4127    pub skill: Option<PermissionRuleConfig>,
4128    #[serde(default, skip_serializing_if = "Option::is_none")]
4129    pub task: Option<PermissionRuleConfig>,
4130    #[serde(default, skip_serializing_if = "Option::is_none")]
4131    pub todowrite: Option<PermissionActionConfig>,
4132    #[serde(default, skip_serializing_if = "Option::is_none")]
4133    pub webfetch: Option<PermissionActionConfig>,
4134    #[serde(default, skip_serializing_if = "Option::is_none")]
4135    pub websearch: Option<PermissionActionConfig>,
4136}
4137
4138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4139pub struct PermissionNotFoundError {
4140    pub _tag: String,
4141    pub message: String,
4142    #[serde(rename = "requestID")]
4143    pub request_id: String,
4144}
4145
4146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4147pub struct PermissionObjectConfig {
4148    #[serde(flatten)]
4149    pub map: std::collections::BTreeMap<String, PermissionActionConfig>,
4150}
4151
4152#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4153pub struct PermissionReplied {
4154    pub data: PermissionRepliedData,
4155    #[serde(default, skip_serializing_if = "Option::is_none")]
4156    pub durable: Option<SessionStatus2Durable>,
4157    pub id: String,
4158    #[serde(default, skip_serializing_if = "Option::is_none")]
4159    pub location: Option<LocationRef>,
4160    #[serde(default, skip_serializing_if = "Option::is_none")]
4161    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4162    #[serde(rename = "type", default, skip_serializing)]
4163    pub type_: String,
4164}
4165
4166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4167pub struct PermissionRepliedData {
4168    pub reply: String,
4169    #[serde(rename = "requestID")]
4170    pub request_id: String,
4171    #[serde(rename = "sessionID")]
4172    pub session_id: String,
4173}
4174
4175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4176pub struct PermissionReplyParams {
4177    pub response: PermissionReplyResponse,
4178}
4179
4180/// Decision sent when replying to a permission request
4181/// (`POST /session/{sessionID}/permissions/{permissionID}`). The wire schema
4182/// pins this to `once` / `always` / `reject`; the [`Unknown`](Self::Unknown)
4183/// fallback preserves forward compatibility with newer server values.
4184#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4185pub enum PermissionReplyResponse {
4186    /// Grant the permission for this request only.
4187    Once,
4188    /// Grant the permission and remember the decision.
4189    Always,
4190    /// Deny the permission.
4191    Reject,
4192    /// A value not known to this crate version.
4193    Unknown(String),
4194}
4195
4196impl PermissionReplyResponse {
4197    pub fn as_str(&self) -> &str {
4198        match self {
4199            Self::Once => "once",
4200            Self::Always => "always",
4201            Self::Reject => "reject",
4202            Self::Unknown(s) => s.as_str(),
4203        }
4204    }
4205}
4206
4207impl std::fmt::Display for PermissionReplyResponse {
4208    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4209        f.write_str(self.as_str())
4210    }
4211}
4212
4213impl From<&str> for PermissionReplyResponse {
4214    fn from(s: &str) -> Self {
4215        match s {
4216            "once" => Self::Once,
4217            "always" => Self::Always,
4218            "reject" => Self::Reject,
4219            other => Self::Unknown(other.to_string()),
4220        }
4221    }
4222}
4223
4224impl Serialize for PermissionReplyResponse {
4225    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4226        serializer.serialize_str(self.as_str())
4227    }
4228}
4229
4230impl<'de> Deserialize<'de> for PermissionReplyResponse {
4231    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4232        let s = String::deserialize(deserializer)?;
4233        Ok(Self::from(s.as_str()))
4234    }
4235}
4236
4237#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4238pub struct PermissionRequest {
4239    pub always: Vec<String>,
4240    pub id: String,
4241    pub metadata: serde_json::Map<String, serde_json::Value>,
4242    pub patterns: Vec<String>,
4243    pub permission: String,
4244    #[serde(rename = "sessionID")]
4245    pub session_id: String,
4246    #[serde(default, skip_serializing_if = "Option::is_none")]
4247    pub tool: Option<PermissionAskedDataTool>,
4248}
4249
4250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4251pub struct PermissionRule {
4252    pub action: PermissionAction,
4253    pub pattern: String,
4254    pub permission: String,
4255}
4256
4257/// Untagged union: serde tries each variant in the order below.
4258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4259#[serde(untagged)]
4260pub enum PermissionRuleConfig {
4261    PermissionActionConfig(PermissionActionConfig),
4262    PermissionObjectConfig(PermissionObjectConfig),
4263}
4264
4265pub type PermissionRuleset = Vec<PermissionRule>;
4266
4267#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4268pub struct PermissionSavedInfo {
4269    pub action: String,
4270    pub id: String,
4271    #[serde(rename = "projectID")]
4272    pub project_id: String,
4273    pub resource: String,
4274}
4275
4276#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4277pub struct PermissionV2Asked {
4278    pub data: PermissionV2AskedData,
4279    #[serde(default, skip_serializing_if = "Option::is_none")]
4280    pub durable: Option<SessionStatus2Durable>,
4281    pub id: String,
4282    #[serde(default, skip_serializing_if = "Option::is_none")]
4283    pub location: Option<LocationRef>,
4284    #[serde(default, skip_serializing_if = "Option::is_none")]
4285    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4286    #[serde(rename = "type", default, skip_serializing)]
4287    pub type_: String,
4288}
4289
4290#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4291pub struct PermissionV2AskedData {
4292    pub action: String,
4293    pub id: String,
4294    #[serde(default, skip_serializing_if = "Option::is_none")]
4295    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4296    pub resources: Vec<String>,
4297    #[serde(default, skip_serializing_if = "Option::is_none")]
4298    pub save: Option<Vec<String>>,
4299    #[serde(rename = "sessionID")]
4300    pub session_id: String,
4301    #[serde(default, skip_serializing_if = "Option::is_none")]
4302    pub source: Option<PermissionV2Source>,
4303}
4304
4305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4306pub enum PermissionV2Effect {
4307    Allow,
4308    Deny,
4309    Ask,
4310    Unknown(String),
4311}
4312
4313impl PermissionV2Effect {
4314    pub fn as_str(&self) -> &str {
4315        match self {
4316            Self::Allow => "allow",
4317            Self::Deny => "deny",
4318            Self::Ask => "ask",
4319            Self::Unknown(s) => s.as_str(),
4320        }
4321    }
4322}
4323
4324impl std::fmt::Display for PermissionV2Effect {
4325    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4326        f.write_str(self.as_str())
4327    }
4328}
4329
4330impl From<&str> for PermissionV2Effect {
4331    fn from(s: &str) -> Self {
4332        match s {
4333            "allow" => Self::Allow,
4334            "deny" => Self::Deny,
4335            "ask" => Self::Ask,
4336            other => Self::Unknown(other.to_string()),
4337        }
4338    }
4339}
4340
4341impl Serialize for PermissionV2Effect {
4342    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4343        serializer.serialize_str(self.as_str())
4344    }
4345}
4346
4347impl<'de> Deserialize<'de> for PermissionV2Effect {
4348    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4349        let s = String::deserialize(deserializer)?;
4350        Ok(Self::from(s.as_str()))
4351    }
4352}
4353
4354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4355pub struct PermissionV2Replied {
4356    pub data: PermissionV2RepliedData,
4357    #[serde(default, skip_serializing_if = "Option::is_none")]
4358    pub durable: Option<SessionStatus2Durable>,
4359    pub id: String,
4360    #[serde(default, skip_serializing_if = "Option::is_none")]
4361    pub location: Option<LocationRef>,
4362    #[serde(default, skip_serializing_if = "Option::is_none")]
4363    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4364    #[serde(rename = "type", default, skip_serializing)]
4365    pub type_: String,
4366}
4367
4368#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4369pub struct PermissionV2RepliedData {
4370    pub reply: PermissionV2Reply,
4371    #[serde(rename = "requestID")]
4372    pub request_id: String,
4373    #[serde(rename = "sessionID")]
4374    pub session_id: String,
4375}
4376
4377#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4378pub enum PermissionV2Reply {
4379    Once,
4380    Always,
4381    Reject,
4382    Unknown(String),
4383}
4384
4385impl PermissionV2Reply {
4386    pub fn as_str(&self) -> &str {
4387        match self {
4388            Self::Once => "once",
4389            Self::Always => "always",
4390            Self::Reject => "reject",
4391            Self::Unknown(s) => s.as_str(),
4392        }
4393    }
4394}
4395
4396impl std::fmt::Display for PermissionV2Reply {
4397    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4398        f.write_str(self.as_str())
4399    }
4400}
4401
4402impl From<&str> for PermissionV2Reply {
4403    fn from(s: &str) -> Self {
4404        match s {
4405            "once" => Self::Once,
4406            "always" => Self::Always,
4407            "reject" => Self::Reject,
4408            other => Self::Unknown(other.to_string()),
4409        }
4410    }
4411}
4412
4413impl Serialize for PermissionV2Reply {
4414    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4415        serializer.serialize_str(self.as_str())
4416    }
4417}
4418
4419impl<'de> Deserialize<'de> for PermissionV2Reply {
4420    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4421        let s = String::deserialize(deserializer)?;
4422        Ok(Self::from(s.as_str()))
4423    }
4424}
4425
4426#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4427pub struct PermissionV2Request {
4428    pub action: String,
4429    pub id: String,
4430    #[serde(default, skip_serializing_if = "Option::is_none")]
4431    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4432    pub resources: Vec<String>,
4433    #[serde(default, skip_serializing_if = "Option::is_none")]
4434    pub save: Option<Vec<String>>,
4435    #[serde(rename = "sessionID")]
4436    pub session_id: String,
4437    #[serde(default, skip_serializing_if = "Option::is_none")]
4438    pub source: Option<PermissionV2Source>,
4439}
4440
4441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4442pub struct PermissionV2Rule {
4443    pub action: String,
4444    pub effect: PermissionV2Effect,
4445    pub resource: String,
4446}
4447
4448pub type PermissionV2Ruleset = Vec<PermissionV2Rule>;
4449
4450#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4451pub struct PermissionV2Source {
4452    #[serde(rename = "callID")]
4453    pub call_id: String,
4454    #[serde(rename = "messageID")]
4455    pub message_id: String,
4456    #[serde(rename = "type")]
4457    pub type_: String,
4458}
4459
4460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4461pub struct PluginAdded {
4462    pub data: PluginAddedData,
4463    #[serde(default, skip_serializing_if = "Option::is_none")]
4464    pub durable: Option<SessionStatus2Durable>,
4465    pub id: String,
4466    #[serde(default, skip_serializing_if = "Option::is_none")]
4467    pub location: Option<LocationRef>,
4468    #[serde(default, skip_serializing_if = "Option::is_none")]
4469    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4470    #[serde(rename = "type", default, skip_serializing)]
4471    pub type_: String,
4472}
4473
4474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4475pub struct PluginAddedData {
4476    pub id: String,
4477}
4478
4479#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4480pub enum PolicyEffect {
4481    Allow,
4482    Deny,
4483    Unknown(String),
4484}
4485
4486impl PolicyEffect {
4487    pub fn as_str(&self) -> &str {
4488        match self {
4489            Self::Allow => "allow",
4490            Self::Deny => "deny",
4491            Self::Unknown(s) => s.as_str(),
4492        }
4493    }
4494}
4495
4496impl std::fmt::Display for PolicyEffect {
4497    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4498        f.write_str(self.as_str())
4499    }
4500}
4501
4502impl From<&str> for PolicyEffect {
4503    fn from(s: &str) -> Self {
4504        match s {
4505            "allow" => Self::Allow,
4506            "deny" => Self::Deny,
4507            other => Self::Unknown(other.to_string()),
4508        }
4509    }
4510}
4511
4512impl Serialize for PolicyEffect {
4513    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4514        serializer.serialize_str(self.as_str())
4515    }
4516}
4517
4518impl<'de> Deserialize<'de> for PolicyEffect {
4519    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4520        let s = String::deserialize(deserializer)?;
4521        Ok(Self::from(s.as_str()))
4522    }
4523}
4524
4525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4526pub struct Project {
4527    #[serde(default, skip_serializing_if = "Option::is_none")]
4528    pub commands: Option<ProjectCommands>,
4529    #[serde(default, skip_serializing_if = "Option::is_none")]
4530    pub icon: Option<ProjectIcon>,
4531    pub id: String,
4532    #[serde(default, skip_serializing_if = "Option::is_none")]
4533    pub name: Option<String>,
4534    pub sandboxes: Vec<String>,
4535    pub time: ProjectTime,
4536    #[serde(default, skip_serializing_if = "Option::is_none")]
4537    pub vcs: Option<ProjectVcs>,
4538    pub worktree: String,
4539}
4540
4541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4542pub struct ProjectCommands {
4543    #[serde(default, skip_serializing_if = "Option::is_none")]
4544    pub start: Option<String>,
4545}
4546
4547#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4548pub struct ProjectCopyCopy {
4549    pub directory: String,
4550}
4551
4552#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4553pub struct ProjectCopyError {
4554    pub data: ProjectCopyErrorData,
4555    pub name: String,
4556}
4557
4558#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4559pub struct ProjectCopyErrorData {
4560    #[serde(
4561        rename = "forceRequired",
4562        default,
4563        skip_serializing_if = "Option::is_none"
4564    )]
4565    pub force_required: Option<bool>,
4566    pub message: String,
4567}
4568
4569pub type ProjectDirectories = Vec<ProjectDirectoriesItem>;
4570
4571#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4572pub struct ProjectDirectoriesItem {
4573    pub directory: String,
4574    #[serde(default, skip_serializing_if = "Option::is_none")]
4575    pub strategy: Option<String>,
4576}
4577
4578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4579pub struct ProjectDirectoriesUpdated {
4580    pub data: ProjectDirectoriesUpdatedData,
4581    #[serde(default, skip_serializing_if = "Option::is_none")]
4582    pub durable: Option<SessionStatus2Durable>,
4583    pub id: String,
4584    #[serde(default, skip_serializing_if = "Option::is_none")]
4585    pub location: Option<LocationRef>,
4586    #[serde(default, skip_serializing_if = "Option::is_none")]
4587    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4588    #[serde(rename = "type", default, skip_serializing)]
4589    pub type_: String,
4590}
4591
4592#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4593pub struct ProjectDirectoriesUpdatedData {
4594    #[serde(rename = "projectID")]
4595    pub project_id: String,
4596}
4597
4598#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4599pub struct ProjectIcon {
4600    #[serde(default, skip_serializing_if = "Option::is_none")]
4601    pub color: Option<String>,
4602    #[serde(rename = "override", default, skip_serializing_if = "Option::is_none")]
4603    pub override_: Option<String>,
4604    #[serde(default, skip_serializing_if = "Option::is_none")]
4605    pub url: Option<String>,
4606}
4607
4608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4609pub struct ProjectNotFoundError {
4610    pub _tag: String,
4611    pub message: String,
4612    #[serde(rename = "projectID")]
4613    pub project_id: String,
4614}
4615
4616#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4617pub struct ProjectSummary {
4618    pub id: String,
4619    #[serde(default, skip_serializing_if = "Option::is_none")]
4620    pub name: Option<String>,
4621    pub worktree: String,
4622}
4623
4624#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4625pub struct ProjectTime {
4626    pub created: u64,
4627    #[serde(default, skip_serializing_if = "Option::is_none")]
4628    pub initialized: Option<u64>,
4629    pub updated: u64,
4630}
4631
4632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4633pub struct ProjectUpdated {
4634    pub data: ProjectUpdatedData,
4635    #[serde(default, skip_serializing_if = "Option::is_none")]
4636    pub durable: Option<SessionStatus2Durable>,
4637    pub id: String,
4638    #[serde(default, skip_serializing_if = "Option::is_none")]
4639    pub location: Option<LocationRef>,
4640    #[serde(default, skip_serializing_if = "Option::is_none")]
4641    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
4642    #[serde(rename = "type", default, skip_serializing)]
4643    pub type_: String,
4644}
4645
4646#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4647pub struct ProjectUpdatedData {
4648    #[serde(default, skip_serializing_if = "Option::is_none")]
4649    pub commands: Option<ProjectCommands>,
4650    #[serde(default, skip_serializing_if = "Option::is_none")]
4651    pub icon: Option<ProjectIcon>,
4652    pub id: String,
4653    #[serde(default, skip_serializing_if = "Option::is_none")]
4654    pub name: Option<String>,
4655    pub sandboxes: Vec<String>,
4656    pub time: ProjectTime,
4657    #[serde(default, skip_serializing_if = "Option::is_none")]
4658    pub vcs: Option<ProjectVcs>,
4659    pub worktree: String,
4660}
4661
4662#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4663pub enum ProjectVcs {
4664    Git,
4665    Unknown(String),
4666}
4667
4668impl ProjectVcs {
4669    pub fn as_str(&self) -> &str {
4670        match self {
4671            Self::Git => "git",
4672            Self::Unknown(s) => s.as_str(),
4673        }
4674    }
4675}
4676
4677impl std::fmt::Display for ProjectVcs {
4678    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4679        f.write_str(self.as_str())
4680    }
4681}
4682
4683impl From<&str> for ProjectVcs {
4684    fn from(s: &str) -> Self {
4685        match s {
4686            "git" => Self::Git,
4687            other => Self::Unknown(other.to_string()),
4688        }
4689    }
4690}
4691
4692impl Serialize for ProjectVcs {
4693    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4694        serializer.serialize_str(self.as_str())
4695    }
4696}
4697
4698impl<'de> Deserialize<'de> for ProjectVcs {
4699    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4700        let s = String::deserialize(deserializer)?;
4701        Ok(Self::from(s.as_str()))
4702    }
4703}
4704
4705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4706pub struct Prompt {
4707    #[serde(default, skip_serializing_if = "Option::is_none")]
4708    pub agents: Option<Vec<PromptAgentAttachment>>,
4709    #[serde(default, skip_serializing_if = "Option::is_none")]
4710    pub files: Option<Vec<PromptFileAttachment>>,
4711    pub text: String,
4712}
4713
4714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4715pub struct PromptAgentAttachment {
4716    pub name: String,
4717    #[serde(default, skip_serializing_if = "Option::is_none")]
4718    pub source: Option<PromptSource>,
4719}
4720
4721#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
4722pub struct PromptAsyncParams {
4723    #[serde(default, skip_serializing_if = "Option::is_none")]
4724    pub agent: Option<String>,
4725    #[serde(default, skip_serializing_if = "Option::is_none")]
4726    pub format: Option<OutputFormat>,
4727    #[serde(rename = "messageID", default, skip_serializing_if = "Option::is_none")]
4728    pub message_id: Option<String>,
4729    #[serde(default, skip_serializing_if = "Option::is_none")]
4730    pub model: Option<SubtaskPartInputModel>,
4731    #[serde(rename = "noReply", default, skip_serializing_if = "Option::is_none")]
4732    pub no_reply: Option<bool>,
4733    pub parts: Vec<PromptAsyncParamsPartsItem>,
4734    #[serde(default, skip_serializing_if = "Option::is_none")]
4735    pub system: Option<String>,
4736    #[serde(default, skip_serializing_if = "Option::is_none")]
4737    pub tools: Option<std::collections::BTreeMap<String, bool>>,
4738    #[serde(default, skip_serializing_if = "Option::is_none")]
4739    pub variant: Option<String>,
4740}
4741
4742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4743#[serde(tag = "type")]
4744pub enum PromptAsyncParamsPartsItem {
4745    #[serde(rename = "text")]
4746    Text(TextPartInput),
4747    #[serde(rename = "file")]
4748    File(FilePartInput),
4749    #[serde(rename = "agent")]
4750    Agent(AgentPartInput),
4751    #[serde(rename = "subtask")]
4752    Subtask(SubtaskPartInput),
4753}
4754
4755#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4756pub struct PromptFileAttachment {
4757    #[serde(default, skip_serializing_if = "Option::is_none")]
4758    pub description: Option<String>,
4759    pub mime: String,
4760    #[serde(default, skip_serializing_if = "Option::is_none")]
4761    pub name: Option<String>,
4762    #[serde(default, skip_serializing_if = "Option::is_none")]
4763    pub source: Option<PromptSource>,
4764    pub uri: String,
4765}
4766
4767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4768pub struct PromptInput {
4769    #[serde(default, skip_serializing_if = "Option::is_none")]
4770    pub agents: Option<Vec<PromptAgentAttachment>>,
4771    #[serde(default, skip_serializing_if = "Option::is_none")]
4772    pub files: Option<Vec<PromptInputFileAttachment>>,
4773    pub text: String,
4774}
4775
4776#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4777pub struct PromptInputFileAttachment {
4778    #[serde(default, skip_serializing_if = "Option::is_none")]
4779    pub description: Option<String>,
4780    #[serde(default, skip_serializing_if = "Option::is_none")]
4781    pub name: Option<String>,
4782    #[serde(default, skip_serializing_if = "Option::is_none")]
4783    pub source: Option<PromptSource>,
4784    pub uri: String,
4785}
4786
4787#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4788pub struct PromptSource {
4789    pub end: f64,
4790    pub start: f64,
4791    pub text: String,
4792}
4793
4794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4795pub struct Provider {
4796    pub env: Vec<String>,
4797    pub id: String,
4798    #[serde(default, skip_serializing_if = "Option::is_none")]
4799    pub key: Option<String>,
4800    pub models: std::collections::BTreeMap<String, Model>,
4801    pub name: String,
4802    pub options: serde_json::Map<String, serde_json::Value>,
4803    pub source: String,
4804}
4805
4806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4807pub struct ProviderAISDK {
4808    pub package: String,
4809    #[serde(default, skip_serializing_if = "Option::is_none")]
4810    pub settings: Option<serde_json::Map<String, serde_json::Value>>,
4811    #[serde(rename = "type", default, skip_serializing)]
4812    pub type_: String,
4813    #[serde(default, skip_serializing_if = "Option::is_none")]
4814    pub url: Option<String>,
4815}
4816
4817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4818#[serde(tag = "type")]
4819pub enum ProviderApi {
4820    #[serde(rename = "aisdk")]
4821    Aisdk(ProviderAISDK),
4822    #[serde(rename = "native")]
4823    Native(ProviderNative),
4824}
4825
4826#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4827pub struct ProviderAuthAuthorization {
4828    pub instructions: String,
4829    pub method: String,
4830    pub url: String,
4831}
4832
4833#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4834pub struct ProviderAuthError {
4835    pub data: ProviderAuthErrorData,
4836    #[serde(default, skip_serializing)]
4837    pub name: String,
4838}
4839
4840#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4841pub struct ProviderAuthError1 {
4842    pub data: ProviderAuthError1Data,
4843    pub name: String,
4844}
4845
4846#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4847pub struct ProviderAuthError1Data {
4848    #[serde(default, skip_serializing_if = "Option::is_none")]
4849    pub field: Option<String>,
4850    #[serde(default, skip_serializing_if = "Option::is_none")]
4851    pub kind: Option<String>,
4852    #[serde(default, skip_serializing_if = "Option::is_none")]
4853    pub message: Option<String>,
4854    #[serde(
4855        rename = "providerID",
4856        default,
4857        skip_serializing_if = "Option::is_none"
4858    )]
4859    pub provider_id: Option<String>,
4860}
4861
4862#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4863pub struct ProviderAuthErrorData {
4864    pub message: String,
4865    #[serde(rename = "providerID")]
4866    pub provider_id: String,
4867}
4868
4869#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4870pub struct ProviderAuthMethod {
4871    pub label: String,
4872    #[serde(default, skip_serializing_if = "Option::is_none")]
4873    pub prompts: Option<Vec<ProviderAuthMethodPromptsItem>>,
4874    #[serde(rename = "type")]
4875    pub type_: String,
4876}
4877
4878#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4879#[serde(tag = "type")]
4880pub enum ProviderAuthMethodPromptsItem {
4881    #[serde(rename = "text")]
4882    Text {
4883        key: String,
4884        message: String,
4885        #[serde(default, skip_serializing_if = "Option::is_none")]
4886        placeholder: Option<String>,
4887        #[serde(default, skip_serializing_if = "Option::is_none")]
4888        when: Option<ProviderAuthMethodPromptsItemTextWhen>,
4889    },
4890    #[serde(rename = "select")]
4891    Select {
4892        key: String,
4893        message: String,
4894        options: Vec<ProviderAuthMethodPromptsItemSelectOptionsItem>,
4895        #[serde(default, skip_serializing_if = "Option::is_none")]
4896        when: Option<ProviderAuthMethodPromptsItemTextWhen>,
4897    },
4898}
4899
4900#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4901pub struct ProviderAuthMethodPromptsItemSelectOptionsItem {
4902    #[serde(default, skip_serializing_if = "Option::is_none")]
4903    pub hint: Option<String>,
4904    pub label: String,
4905    pub value: String,
4906}
4907
4908#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4909pub struct ProviderAuthMethodPromptsItemTextWhen {
4910    pub key: String,
4911    pub op: String,
4912    pub value: String,
4913}
4914
4915#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4916pub struct ProviderConfig {
4917    #[serde(default, skip_serializing_if = "Option::is_none")]
4918    pub api: Option<String>,
4919    #[serde(default, skip_serializing_if = "Option::is_none")]
4920    pub blacklist: Option<Vec<String>>,
4921    #[serde(default, skip_serializing_if = "Option::is_none")]
4922    pub env: Option<Vec<String>>,
4923    #[serde(default, skip_serializing_if = "Option::is_none")]
4924    pub id: Option<String>,
4925    #[serde(default, skip_serializing_if = "Option::is_none")]
4926    pub models: Option<std::collections::BTreeMap<String, ProviderConfigModelsValue>>,
4927    #[serde(default, skip_serializing_if = "Option::is_none")]
4928    pub name: Option<String>,
4929    #[serde(default, skip_serializing_if = "Option::is_none")]
4930    pub npm: Option<String>,
4931    #[serde(default, skip_serializing_if = "Option::is_none")]
4932    pub options: Option<ProviderConfigOptions>,
4933    #[serde(default, skip_serializing_if = "Option::is_none")]
4934    pub whitelist: Option<Vec<String>>,
4935}
4936
4937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4938pub struct ProviderConfigModelsValue {
4939    #[serde(default, skip_serializing_if = "Option::is_none")]
4940    pub attachment: Option<bool>,
4941    #[serde(default, skip_serializing_if = "Option::is_none")]
4942    pub cost: Option<ProviderConfigModelsValueCost>,
4943    #[serde(default, skip_serializing_if = "Option::is_none")]
4944    pub experimental: Option<bool>,
4945    #[serde(default, skip_serializing_if = "Option::is_none")]
4946    pub family: Option<String>,
4947    #[serde(default, skip_serializing_if = "Option::is_none")]
4948    pub headers: Option<std::collections::BTreeMap<String, String>>,
4949    #[serde(default, skip_serializing_if = "Option::is_none")]
4950    pub id: Option<String>,
4951    #[serde(default, skip_serializing_if = "Option::is_none")]
4952    pub interleaved: Option<ProviderConfigModelsValueInterleaved>,
4953    #[serde(default, skip_serializing_if = "Option::is_none")]
4954    pub limit: Option<ProviderConfigModelsValueLimit>,
4955    #[serde(default, skip_serializing_if = "Option::is_none")]
4956    pub modalities: Option<ProviderConfigModelsValueModalities>,
4957    #[serde(default, skip_serializing_if = "Option::is_none")]
4958    pub name: Option<String>,
4959    #[serde(default, skip_serializing_if = "Option::is_none")]
4960    pub options: Option<serde_json::Map<String, serde_json::Value>>,
4961    #[serde(default, skip_serializing_if = "Option::is_none")]
4962    pub provider: Option<ProviderConfigModelsValueProvider>,
4963    #[serde(default, skip_serializing_if = "Option::is_none")]
4964    pub reasoning: Option<bool>,
4965    #[serde(default, skip_serializing_if = "Option::is_none")]
4966    pub release_date: Option<String>,
4967    #[serde(default, skip_serializing_if = "Option::is_none")]
4968    pub status: Option<String>,
4969    #[serde(default, skip_serializing_if = "Option::is_none")]
4970    pub temperature: Option<bool>,
4971    #[serde(default, skip_serializing_if = "Option::is_none")]
4972    pub tool_call: Option<bool>,
4973    #[serde(default, skip_serializing_if = "Option::is_none")]
4974    pub variants:
4975        Option<std::collections::BTreeMap<String, ProviderConfigModelsValueVariantsValue>>,
4976}
4977
4978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4979pub struct ProviderConfigModelsValueCost {
4980    #[serde(default, skip_serializing_if = "Option::is_none")]
4981    pub cache_read: Option<f64>,
4982    #[serde(default, skip_serializing_if = "Option::is_none")]
4983    pub cache_write: Option<f64>,
4984    #[serde(default, skip_serializing_if = "Option::is_none")]
4985    pub context_over_200k: Option<ProviderConfigModelsValueCostContextOver200k>,
4986    pub input: f64,
4987    pub output: f64,
4988}
4989
4990#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
4991pub struct ProviderConfigModelsValueCostContextOver200k {
4992    #[serde(default, skip_serializing_if = "Option::is_none")]
4993    pub cache_read: Option<f64>,
4994    #[serde(default, skip_serializing_if = "Option::is_none")]
4995    pub cache_write: Option<f64>,
4996    pub input: f64,
4997    pub output: f64,
4998}
4999
5000/// Untagged union: serde tries each variant in the order below.
5001#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5002#[serde(untagged)]
5003pub enum ProviderConfigModelsValueInterleaved {
5004    Variant0(bool),
5005    Variant1(String),
5006    Variant2(String),
5007    Variant3(ProviderConfigModelsValueInterleavedVariant3),
5008}
5009
5010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5011pub struct ProviderConfigModelsValueInterleavedVariant3 {
5012    pub field: ProviderConfigModelsValueInterleavedVariant3Field,
5013}
5014
5015#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5016pub enum ProviderConfigModelsValueInterleavedVariant3Field {
5017    Reasoning,
5018    ReasoningContent,
5019    ReasoningText,
5020    Unknown(String),
5021}
5022
5023impl ProviderConfigModelsValueInterleavedVariant3Field {
5024    pub fn as_str(&self) -> &str {
5025        match self {
5026            Self::Reasoning => "reasoning",
5027            Self::ReasoningContent => "reasoning_content",
5028            Self::ReasoningText => "reasoning_text",
5029            Self::Unknown(s) => s.as_str(),
5030        }
5031    }
5032}
5033
5034impl std::fmt::Display for ProviderConfigModelsValueInterleavedVariant3Field {
5035    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5036        f.write_str(self.as_str())
5037    }
5038}
5039
5040impl From<&str> for ProviderConfigModelsValueInterleavedVariant3Field {
5041    fn from(s: &str) -> Self {
5042        match s {
5043            "reasoning" => Self::Reasoning,
5044            "reasoning_content" => Self::ReasoningContent,
5045            "reasoning_text" => Self::ReasoningText,
5046            other => Self::Unknown(other.to_string()),
5047        }
5048    }
5049}
5050
5051impl Serialize for ProviderConfigModelsValueInterleavedVariant3Field {
5052    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
5053        serializer.serialize_str(self.as_str())
5054    }
5055}
5056
5057impl<'de> Deserialize<'de> for ProviderConfigModelsValueInterleavedVariant3Field {
5058    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
5059        let s = String::deserialize(deserializer)?;
5060        Ok(Self::from(s.as_str()))
5061    }
5062}
5063
5064#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5065pub struct ProviderConfigModelsValueLimit {
5066    pub context: f64,
5067    #[serde(default, skip_serializing_if = "Option::is_none")]
5068    pub input: Option<f64>,
5069    pub output: f64,
5070}
5071
5072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5073pub struct ProviderConfigModelsValueModalities {
5074    #[serde(default, skip_serializing_if = "Option::is_none")]
5075    pub input: Option<Vec<String>>,
5076    #[serde(default, skip_serializing_if = "Option::is_none")]
5077    pub output: Option<Vec<String>>,
5078}
5079
5080#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5081pub struct ProviderConfigModelsValueProvider {
5082    #[serde(default, skip_serializing_if = "Option::is_none")]
5083    pub api: Option<String>,
5084    #[serde(default, skip_serializing_if = "Option::is_none")]
5085    pub npm: Option<String>,
5086}
5087
5088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5089pub struct ProviderConfigModelsValueVariantsValue {
5090    #[serde(default, skip_serializing_if = "Option::is_none")]
5091    pub disabled: Option<bool>,
5092}
5093
5094#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5095pub struct ProviderConfigOptions {
5096    #[serde(rename = "apiKey", default, skip_serializing_if = "Option::is_none")]
5097    pub api_key: Option<String>,
5098    #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
5099    pub base_url: Option<String>,
5100    #[serde(
5101        rename = "chunkTimeout",
5102        default,
5103        skip_serializing_if = "Option::is_none"
5104    )]
5105    pub chunk_timeout: Option<ProviderConfigOptionsChunkTimeout>,
5106    #[serde(
5107        rename = "enterpriseUrl",
5108        default,
5109        skip_serializing_if = "Option::is_none"
5110    )]
5111    pub enterprise_url: Option<String>,
5112    #[serde(
5113        rename = "headerTimeout",
5114        default,
5115        skip_serializing_if = "Option::is_none"
5116    )]
5117    pub header_timeout: Option<ProviderConfigOptionsHeaderTimeout>,
5118    #[serde(
5119        rename = "setCacheKey",
5120        default,
5121        skip_serializing_if = "Option::is_none"
5122    )]
5123    pub set_cache_key: Option<bool>,
5124    #[serde(default, skip_serializing_if = "Option::is_none")]
5125    pub timeout: Option<ProviderConfigOptionsTimeout>,
5126}
5127
5128/// Timeout in milliseconds between streamed SSE chunks for this provider (default: 300000). If no chunk arrives within this window, the request is aborted. Set to false to disable timeout.
5129/// Untagged union: serde tries each variant in the order below.
5130#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5131#[serde(untagged)]
5132pub enum ProviderConfigOptionsChunkTimeout {
5133    Variant0(i64),
5134    Variant1(bool),
5135}
5136
5137/// Timeout in milliseconds to wait for response headers (default: 300000). Set to false to disable timeout.
5138/// Untagged union: serde tries each variant in the order below.
5139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5140#[serde(untagged)]
5141pub enum ProviderConfigOptionsHeaderTimeout {
5142    Variant0(i64),
5143    Variant1(bool),
5144}
5145
5146/// Timeout in milliseconds for full requests to this provider. Set to false to disable timeout.
5147/// Untagged union: serde tries each variant in the order below.
5148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5149#[serde(untagged)]
5150pub enum ProviderConfigOptionsTimeout {
5151    Variant0(i64),
5152    Variant1(bool),
5153}
5154
5155#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5156pub struct ProviderNative {
5157    pub settings: serde_json::Map<String, serde_json::Value>,
5158    #[serde(rename = "type", default, skip_serializing)]
5159    pub type_: String,
5160    #[serde(default, skip_serializing_if = "Option::is_none")]
5161    pub url: Option<String>,
5162}
5163
5164#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5165pub struct ProviderNotFoundError {
5166    pub _tag: String,
5167    pub message: String,
5168    #[serde(rename = "providerID")]
5169    pub provider_id: String,
5170}
5171
5172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5173pub struct ProviderRequest {
5174    pub body: serde_json::Map<String, serde_json::Value>,
5175    pub headers: std::collections::BTreeMap<String, String>,
5176}
5177
5178#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5179pub struct ProviderV2Info {
5180    pub api: ProviderApi,
5181    #[serde(default, skip_serializing_if = "Option::is_none")]
5182    pub disabled: Option<bool>,
5183    pub id: String,
5184    #[serde(
5185        rename = "integrationID",
5186        default,
5187        skip_serializing_if = "Option::is_none"
5188    )]
5189    pub integration_id: Option<String>,
5190    pub name: String,
5191    pub request: ProviderRequest,
5192}
5193
5194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5195pub struct Pty {
5196    pub args: Vec<String>,
5197    pub command: String,
5198    pub cwd: String,
5199    #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
5200    pub exit_code: Option<u64>,
5201    pub id: String,
5202    pub pid: u64,
5203    pub status: String,
5204    pub title: String,
5205}
5206
5207#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5208pub struct PtyCreated {
5209    pub data: PtyCreatedData,
5210    #[serde(default, skip_serializing_if = "Option::is_none")]
5211    pub durable: Option<SessionStatus2Durable>,
5212    pub id: String,
5213    #[serde(default, skip_serializing_if = "Option::is_none")]
5214    pub location: Option<LocationRef>,
5215    #[serde(default, skip_serializing_if = "Option::is_none")]
5216    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5217    #[serde(rename = "type", default, skip_serializing)]
5218    pub type_: String,
5219}
5220
5221#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5222pub struct PtyCreatedData {
5223    pub info: Pty,
5224}
5225
5226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5227pub struct PtyDeleted {
5228    pub data: PtyDeletedData,
5229    #[serde(default, skip_serializing_if = "Option::is_none")]
5230    pub durable: Option<SessionStatus2Durable>,
5231    pub id: String,
5232    #[serde(default, skip_serializing_if = "Option::is_none")]
5233    pub location: Option<LocationRef>,
5234    #[serde(default, skip_serializing_if = "Option::is_none")]
5235    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5236    #[serde(rename = "type", default, skip_serializing)]
5237    pub type_: String,
5238}
5239
5240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5241pub struct PtyDeletedData {
5242    pub id: String,
5243}
5244
5245#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5246pub struct PtyExited {
5247    pub data: PtyExitedData,
5248    #[serde(default, skip_serializing_if = "Option::is_none")]
5249    pub durable: Option<SessionStatus2Durable>,
5250    pub id: String,
5251    #[serde(default, skip_serializing_if = "Option::is_none")]
5252    pub location: Option<LocationRef>,
5253    #[serde(default, skip_serializing_if = "Option::is_none")]
5254    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5255    #[serde(rename = "type", default, skip_serializing)]
5256    pub type_: String,
5257}
5258
5259#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5260pub struct PtyExitedData {
5261    #[serde(rename = "exitCode")]
5262    pub exit_code: u64,
5263    pub id: String,
5264}
5265
5266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5267pub struct PtyForbiddenError {
5268    pub _tag: String,
5269    pub message: String,
5270}
5271
5272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5273pub struct PtyNotFoundError {
5274    pub _tag: String,
5275    pub message: String,
5276    #[serde(rename = "ptyID")]
5277    pub pty_id: String,
5278}
5279
5280#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5281pub struct PtyTicketConnectToken {
5282    pub expires_in: i64,
5283    pub ticket: String,
5284}
5285
5286#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5287pub struct PtyUpdated {
5288    pub data: PtyCreatedData,
5289    #[serde(default, skip_serializing_if = "Option::is_none")]
5290    pub durable: Option<SessionStatus2Durable>,
5291    pub id: String,
5292    #[serde(default, skip_serializing_if = "Option::is_none")]
5293    pub location: Option<LocationRef>,
5294    #[serde(default, skip_serializing_if = "Option::is_none")]
5295    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5296    #[serde(rename = "type", default, skip_serializing)]
5297    pub type_: String,
5298}
5299
5300pub type QuestionAnswer = Vec<String>;
5301
5302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5303pub struct QuestionAsked {
5304    pub data: QuestionAskedData,
5305    #[serde(default, skip_serializing_if = "Option::is_none")]
5306    pub durable: Option<SessionStatus2Durable>,
5307    pub id: String,
5308    #[serde(default, skip_serializing_if = "Option::is_none")]
5309    pub location: Option<LocationRef>,
5310    #[serde(default, skip_serializing_if = "Option::is_none")]
5311    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5312    #[serde(rename = "type", default, skip_serializing)]
5313    pub type_: String,
5314}
5315
5316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5317pub struct QuestionAskedData {
5318    pub id: String,
5319    pub questions: Vec<QuestionInfo>,
5320    #[serde(rename = "sessionID")]
5321    pub session_id: String,
5322    #[serde(default, skip_serializing_if = "Option::is_none")]
5323    pub tool: Option<QuestionTool>,
5324}
5325
5326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5327pub struct QuestionInfo {
5328    #[serde(default, skip_serializing_if = "Option::is_none")]
5329    pub custom: Option<bool>,
5330    pub header: String,
5331    #[serde(default, skip_serializing_if = "Option::is_none")]
5332    pub multiple: Option<bool>,
5333    pub options: Vec<QuestionOption>,
5334    pub question: String,
5335}
5336
5337#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5338pub struct QuestionNotFoundError {
5339    pub _tag: String,
5340    pub message: String,
5341    #[serde(rename = "requestID")]
5342    pub request_id: String,
5343}
5344
5345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5346pub struct QuestionOption {
5347    pub description: String,
5348    pub label: String,
5349}
5350
5351#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5352pub struct QuestionRejected {
5353    #[serde(rename = "requestID")]
5354    pub request_id: String,
5355    #[serde(rename = "sessionID")]
5356    pub session_id: String,
5357}
5358
5359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5360pub struct QuestionRejected2Data {
5361    #[serde(rename = "requestID")]
5362    pub request_id: String,
5363    #[serde(rename = "sessionID")]
5364    pub session_id: String,
5365}
5366
5367#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5368pub struct QuestionReplied {
5369    pub answers: Vec<QuestionAnswer>,
5370    #[serde(rename = "requestID")]
5371    pub request_id: String,
5372    #[serde(rename = "sessionID")]
5373    pub session_id: String,
5374}
5375
5376#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5377pub struct QuestionReplied2Data {
5378    pub answers: Vec<QuestionAnswer>,
5379    #[serde(rename = "requestID")]
5380    pub request_id: String,
5381    #[serde(rename = "sessionID")]
5382    pub session_id: String,
5383}
5384
5385#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5386pub struct QuestionRequest {
5387    pub id: String,
5388    pub questions: Vec<QuestionInfo>,
5389    #[serde(rename = "sessionID")]
5390    pub session_id: String,
5391    #[serde(default, skip_serializing_if = "Option::is_none")]
5392    pub tool: Option<QuestionTool>,
5393}
5394
5395#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5396pub struct QuestionTool {
5397    #[serde(rename = "callID")]
5398    pub call_id: String,
5399    #[serde(rename = "messageID")]
5400    pub message_id: String,
5401}
5402
5403pub type QuestionV2Answer = Vec<String>;
5404
5405#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5406pub struct QuestionV2Asked {
5407    pub data: QuestionV2AskedData,
5408    #[serde(default, skip_serializing_if = "Option::is_none")]
5409    pub durable: Option<SessionStatus2Durable>,
5410    pub id: String,
5411    #[serde(default, skip_serializing_if = "Option::is_none")]
5412    pub location: Option<LocationRef>,
5413    #[serde(default, skip_serializing_if = "Option::is_none")]
5414    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5415    #[serde(rename = "type", default, skip_serializing)]
5416    pub type_: String,
5417}
5418
5419#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5420pub struct QuestionV2AskedData {
5421    pub id: String,
5422    pub questions: Vec<QuestionV2Info>,
5423    #[serde(rename = "sessionID")]
5424    pub session_id: String,
5425    #[serde(default, skip_serializing_if = "Option::is_none")]
5426    pub tool: Option<QuestionV2Tool>,
5427}
5428
5429#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5430pub struct QuestionV2Info {
5431    #[serde(default, skip_serializing_if = "Option::is_none")]
5432    pub custom: Option<bool>,
5433    pub header: String,
5434    #[serde(default, skip_serializing_if = "Option::is_none")]
5435    pub multiple: Option<bool>,
5436    pub options: Vec<QuestionV2Option>,
5437    pub question: String,
5438}
5439
5440#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5441pub struct QuestionV2Option {
5442    pub description: String,
5443    pub label: String,
5444}
5445
5446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5447pub struct QuestionV2Rejected {
5448    pub data: QuestionRejected2Data,
5449    #[serde(default, skip_serializing_if = "Option::is_none")]
5450    pub durable: Option<SessionStatus2Durable>,
5451    pub id: String,
5452    #[serde(default, skip_serializing_if = "Option::is_none")]
5453    pub location: Option<LocationRef>,
5454    #[serde(default, skip_serializing_if = "Option::is_none")]
5455    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5456    #[serde(rename = "type", default, skip_serializing)]
5457    pub type_: String,
5458}
5459
5460#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5461pub struct QuestionV2Replied {
5462    pub data: QuestionV2RepliedData,
5463    #[serde(default, skip_serializing_if = "Option::is_none")]
5464    pub durable: Option<SessionStatus2Durable>,
5465    pub id: String,
5466    #[serde(default, skip_serializing_if = "Option::is_none")]
5467    pub location: Option<LocationRef>,
5468    #[serde(default, skip_serializing_if = "Option::is_none")]
5469    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5470    #[serde(rename = "type", default, skip_serializing)]
5471    pub type_: String,
5472}
5473
5474#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5475pub struct QuestionV2RepliedData {
5476    pub answers: Vec<QuestionV2Answer>,
5477    #[serde(rename = "requestID")]
5478    pub request_id: String,
5479    #[serde(rename = "sessionID")]
5480    pub session_id: String,
5481}
5482
5483#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5484pub struct QuestionV2Reply {
5485    pub answers: Vec<QuestionV2Answer>,
5486}
5487
5488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5489pub struct QuestionV2Request {
5490    pub id: String,
5491    pub questions: Vec<QuestionV2Info>,
5492    #[serde(rename = "sessionID")]
5493    pub session_id: String,
5494    #[serde(default, skip_serializing_if = "Option::is_none")]
5495    pub tool: Option<QuestionV2Tool>,
5496}
5497
5498#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5499pub struct QuestionV2Tool {
5500    #[serde(rename = "callID")]
5501    pub call_id: String,
5502    #[serde(rename = "messageID")]
5503    pub message_id: String,
5504}
5505
5506#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5507pub struct Range {
5508    pub end: RangeStart,
5509    pub start: RangeStart,
5510}
5511
5512#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5513pub struct RangeStart {
5514    pub character: u64,
5515    pub line: u64,
5516}
5517
5518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5519pub struct ReasoningPart {
5520    pub id: String,
5521    #[serde(rename = "messageID")]
5522    pub message_id: String,
5523    #[serde(default, skip_serializing_if = "Option::is_none")]
5524    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5525    #[serde(rename = "sessionID")]
5526    pub session_id: String,
5527    pub text: String,
5528    pub time: TextPartInputTime,
5529    #[serde(rename = "type", default, skip_serializing)]
5530    pub type_: String,
5531}
5532
5533#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5534pub struct ReferenceGitSource {
5535    #[serde(default, skip_serializing_if = "Option::is_none")]
5536    pub branch: Option<String>,
5537    #[serde(default, skip_serializing_if = "Option::is_none")]
5538    pub description: Option<String>,
5539    #[serde(default, skip_serializing_if = "Option::is_none")]
5540    pub hidden: Option<bool>,
5541    pub repository: String,
5542    #[serde(rename = "type", default, skip_serializing)]
5543    pub type_: String,
5544}
5545
5546#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5547pub struct ReferenceInfo {
5548    #[serde(default, skip_serializing_if = "Option::is_none")]
5549    pub description: Option<String>,
5550    #[serde(default, skip_serializing_if = "Option::is_none")]
5551    pub hidden: Option<bool>,
5552    pub name: String,
5553    pub path: String,
5554    pub source: ReferenceSource,
5555}
5556
5557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5558pub struct ReferenceLocalSource {
5559    #[serde(default, skip_serializing_if = "Option::is_none")]
5560    pub description: Option<String>,
5561    #[serde(default, skip_serializing_if = "Option::is_none")]
5562    pub hidden: Option<bool>,
5563    pub path: String,
5564    #[serde(rename = "type", default, skip_serializing)]
5565    pub type_: String,
5566}
5567
5568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5569#[serde(tag = "type")]
5570pub enum ReferenceSource {
5571    #[serde(rename = "local")]
5572    Local(ReferenceLocalSource),
5573    #[serde(rename = "git")]
5574    Git(ReferenceGitSource),
5575}
5576
5577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5578pub struct ReferenceUpdated {
5579    pub data: serde_json::Map<String, serde_json::Value>,
5580    #[serde(default, skip_serializing_if = "Option::is_none")]
5581    pub durable: Option<SessionStatus2Durable>,
5582    pub id: String,
5583    #[serde(default, skip_serializing_if = "Option::is_none")]
5584    pub location: Option<LocationRef>,
5585    #[serde(default, skip_serializing_if = "Option::is_none")]
5586    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5587    #[serde(rename = "type", default, skip_serializing)]
5588    pub type_: String,
5589}
5590
5591#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5592pub struct ResourceSource {
5593    #[serde(rename = "clientName")]
5594    pub client_name: String,
5595    pub text: FilePartSourceText,
5596    #[serde(rename = "type", default, skip_serializing)]
5597    pub type_: String,
5598    pub uri: String,
5599}
5600
5601#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5602pub struct RetryPart {
5603    pub attempt: u64,
5604    pub error: APIError,
5605    pub id: String,
5606    #[serde(rename = "messageID")]
5607    pub message_id: String,
5608    #[serde(rename = "sessionID")]
5609    pub session_id: String,
5610    pub time: RetryPartTime,
5611    #[serde(rename = "type", default, skip_serializing)]
5612    pub type_: String,
5613}
5614
5615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5616pub struct RetryPartTime {
5617    pub created: u64,
5618}
5619
5620#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5621pub struct RevertState {
5622    #[serde(default, skip_serializing_if = "Option::is_none")]
5623    pub diff: Option<String>,
5624    #[serde(default, skip_serializing_if = "Option::is_none")]
5625    pub files: Option<Vec<FileDiff>>,
5626    #[serde(rename = "messageID")]
5627    pub message_id: String,
5628    #[serde(rename = "partID", default, skip_serializing_if = "Option::is_none")]
5629    pub part_id: Option<String>,
5630    #[serde(default, skip_serializing_if = "Option::is_none")]
5631    pub snapshot: Option<String>,
5632}
5633
5634/// Server configuration for opencode serve and web commands
5635#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5636pub struct ServerConfig {
5637    #[serde(default, skip_serializing_if = "Option::is_none")]
5638    pub cors: Option<Vec<String>>,
5639    #[serde(default, skip_serializing_if = "Option::is_none")]
5640    pub hostname: Option<String>,
5641    #[serde(default, skip_serializing_if = "Option::is_none")]
5642    pub mdns: Option<bool>,
5643    #[serde(
5644        rename = "mdnsDomain",
5645        default,
5646        skip_serializing_if = "Option::is_none"
5647    )]
5648    pub mdns_domain: Option<String>,
5649    #[serde(default, skip_serializing_if = "Option::is_none")]
5650    pub port: Option<i64>,
5651}
5652
5653#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5654pub struct ServerConnected {
5655    pub data: serde_json::Map<String, serde_json::Value>,
5656    #[serde(default, skip_serializing_if = "Option::is_none")]
5657    pub durable: Option<SessionStatus2Durable>,
5658    pub id: String,
5659    #[serde(default, skip_serializing_if = "Option::is_none")]
5660    pub location: Option<LocationRef>,
5661    #[serde(default, skip_serializing_if = "Option::is_none")]
5662    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5663    #[serde(rename = "type", default, skip_serializing)]
5664    pub type_: String,
5665}
5666
5667#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5668pub struct ServiceUnavailableError {
5669    pub _tag: String,
5670    pub message: String,
5671    #[serde(default, skip_serializing_if = "Option::is_none")]
5672    pub service: Option<String>,
5673}
5674
5675#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5676pub struct Session {
5677    #[serde(default, skip_serializing_if = "Option::is_none")]
5678    pub agent: Option<String>,
5679    #[serde(default, skip_serializing_if = "Option::is_none")]
5680    pub cost: Option<f64>,
5681    pub directory: String,
5682    pub id: String,
5683    #[serde(default, skip_serializing_if = "Option::is_none")]
5684    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5685    #[serde(default, skip_serializing_if = "Option::is_none")]
5686    pub model: Option<SessionCreateParamsModel>,
5687    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
5688    pub parent_id: Option<String>,
5689    #[serde(default, skip_serializing_if = "Option::is_none")]
5690    pub path: Option<String>,
5691    #[serde(default, skip_serializing_if = "Option::is_none")]
5692    pub permission: Option<PermissionRuleset>,
5693    #[serde(rename = "projectID")]
5694    pub project_id: String,
5695    #[serde(default, skip_serializing_if = "Option::is_none")]
5696    pub revert: Option<SessionRevert>,
5697    #[serde(default, skip_serializing_if = "Option::is_none")]
5698    pub share: Option<SessionShare>,
5699    pub slug: String,
5700    #[serde(default, skip_serializing_if = "Option::is_none")]
5701    pub summary: Option<SessionSummary>,
5702    pub time: SessionTime,
5703    pub title: String,
5704    #[serde(default, skip_serializing_if = "Option::is_none")]
5705    pub tokens: Option<SessionNextStepEndedDataTokens>,
5706    pub version: String,
5707    #[serde(
5708        rename = "workspaceID",
5709        default,
5710        skip_serializing_if = "Option::is_none"
5711    )]
5712    pub workspace_id: Option<String>,
5713}
5714
5715#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5716pub struct SessionActive {
5717    #[serde(rename = "type")]
5718    pub type_: String,
5719}
5720
5721#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5722pub struct SessionBusyError {
5723    pub _tag: String,
5724    pub message: String,
5725    #[serde(rename = "sessionID")]
5726    pub session_id: String,
5727}
5728
5729#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5730pub struct SessionCompacted {
5731    pub data: SessionIdleData,
5732    #[serde(default, skip_serializing_if = "Option::is_none")]
5733    pub durable: Option<SessionStatus2Durable>,
5734    pub id: String,
5735    #[serde(default, skip_serializing_if = "Option::is_none")]
5736    pub location: Option<LocationRef>,
5737    #[serde(default, skip_serializing_if = "Option::is_none")]
5738    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5739    #[serde(rename = "type", default, skip_serializing)]
5740    pub type_: String,
5741}
5742
5743#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
5744pub struct SessionCreateParams {
5745    #[serde(default, skip_serializing_if = "Option::is_none")]
5746    pub agent: Option<String>,
5747    #[serde(default, skip_serializing_if = "Option::is_none")]
5748    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5749    #[serde(default, skip_serializing_if = "Option::is_none")]
5750    pub model: Option<SessionCreateParamsModel>,
5751    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
5752    pub parent_id: Option<String>,
5753    #[serde(default, skip_serializing_if = "Option::is_none")]
5754    pub permission: Option<PermissionRuleset>,
5755    #[serde(default, skip_serializing_if = "Option::is_none")]
5756    pub title: Option<String>,
5757    #[serde(
5758        rename = "workspaceID",
5759        default,
5760        skip_serializing_if = "Option::is_none"
5761    )]
5762    pub workspace_id: Option<String>,
5763}
5764
5765#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5766pub struct SessionCreateParamsModel {
5767    pub id: String,
5768    #[serde(rename = "providerID")]
5769    pub provider_id: String,
5770    #[serde(default, skip_serializing_if = "Option::is_none")]
5771    pub variant: Option<String>,
5772}
5773
5774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5775pub struct SessionCreated {
5776    pub data: SessionCreatedData,
5777    #[serde(default, skip_serializing_if = "Option::is_none")]
5778    pub durable: Option<SessionStatus2Durable>,
5779    pub id: String,
5780    #[serde(default, skip_serializing_if = "Option::is_none")]
5781    pub location: Option<LocationRef>,
5782    #[serde(default, skip_serializing_if = "Option::is_none")]
5783    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5784    #[serde(rename = "type", default, skip_serializing)]
5785    pub type_: String,
5786}
5787
5788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5789pub struct SessionCreatedData {
5790    pub info: Session,
5791    #[serde(rename = "sessionID")]
5792    pub session_id: String,
5793}
5794
5795#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5796pub struct SessionDeleted {
5797    pub data: SessionCreatedData,
5798    #[serde(default, skip_serializing_if = "Option::is_none")]
5799    pub durable: Option<SessionStatus2Durable>,
5800    pub id: String,
5801    #[serde(default, skip_serializing_if = "Option::is_none")]
5802    pub location: Option<LocationRef>,
5803    #[serde(default, skip_serializing_if = "Option::is_none")]
5804    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5805    #[serde(rename = "type", default, skip_serializing)]
5806    pub type_: String,
5807}
5808
5809#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5810pub struct SessionDiff {
5811    pub data: SessionDiffData,
5812    #[serde(default, skip_serializing_if = "Option::is_none")]
5813    pub durable: Option<SessionStatus2Durable>,
5814    pub id: String,
5815    #[serde(default, skip_serializing_if = "Option::is_none")]
5816    pub location: Option<LocationRef>,
5817    #[serde(default, skip_serializing_if = "Option::is_none")]
5818    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5819    #[serde(rename = "type", default, skip_serializing)]
5820    pub type_: String,
5821}
5822
5823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5824pub struct SessionDiffData {
5825    pub diff: Vec<SnapshotFileDiff>,
5826    #[serde(rename = "sessionID")]
5827    pub session_id: String,
5828}
5829
5830#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5831#[serde(tag = "type")]
5832pub enum SessionDurableEvent {
5833    #[serde(rename = "session.next.agent.switched")]
5834    SessionNextAgentSwitched(SessionNextAgentSwitched),
5835    #[serde(rename = "session.next.model.switched")]
5836    SessionNextModelSwitched(SessionNextModelSwitched),
5837    #[serde(rename = "session.next.moved")]
5838    SessionNextMoved(SessionNextMoved),
5839    #[serde(rename = "session.next.prompted")]
5840    SessionNextPrompted(SessionNextPrompted),
5841    #[serde(rename = "session.next.prompt.admitted")]
5842    SessionNextPromptAdmitted(SessionNextPromptAdmitted),
5843    #[serde(rename = "session.next.context.updated")]
5844    SessionNextContextUpdated(SessionNextContextUpdated),
5845    #[serde(rename = "session.next.synthetic")]
5846    SessionNextSynthetic(SessionNextSynthetic),
5847    #[serde(rename = "session.next.shell.started")]
5848    SessionNextShellStarted(SessionNextShellStarted),
5849    #[serde(rename = "session.next.shell.ended")]
5850    SessionNextShellEnded(SessionNextShellEnded),
5851    #[serde(rename = "session.next.step.started")]
5852    SessionNextStepStarted(SessionNextStepStarted),
5853    #[serde(rename = "session.next.step.ended")]
5854    SessionNextStepEnded(SessionNextStepEnded),
5855    #[serde(rename = "session.next.step.failed")]
5856    SessionNextStepFailed(SessionNextStepFailed),
5857    #[serde(rename = "session.next.text.started")]
5858    SessionNextTextStarted(SessionNextTextStarted),
5859    #[serde(rename = "session.next.text.ended")]
5860    SessionNextTextEnded(SessionNextTextEnded),
5861    #[serde(rename = "session.next.tool.input.started")]
5862    SessionNextToolInputStarted(SessionNextToolInputStarted),
5863    #[serde(rename = "session.next.tool.input.ended")]
5864    SessionNextToolInputEnded(SessionNextToolInputEnded),
5865    #[serde(rename = "session.next.tool.called")]
5866    SessionNextToolCalled(SessionNextToolCalled),
5867    #[serde(rename = "session.next.tool.progress")]
5868    SessionNextToolProgress(SessionNextToolProgress),
5869    #[serde(rename = "session.next.tool.success")]
5870    SessionNextToolSuccess(SessionNextToolSuccess),
5871    #[serde(rename = "session.next.tool.failed")]
5872    SessionNextToolFailed(SessionNextToolFailed),
5873    #[serde(rename = "session.next.reasoning.started")]
5874    SessionNextReasoningStarted(SessionNextReasoningStarted),
5875    #[serde(rename = "session.next.reasoning.ended")]
5876    SessionNextReasoningEnded(SessionNextReasoningEnded),
5877    #[serde(rename = "session.next.retried")]
5878    SessionNextRetried(SessionNextRetried),
5879    #[serde(rename = "session.next.compaction.started")]
5880    SessionNextCompactionStarted(SessionNextCompactionStarted),
5881    #[serde(rename = "session.next.compaction.ended")]
5882    SessionNextCompactionEnded(SessionNextCompactionEnded),
5883    #[serde(rename = "session.next.revert.staged")]
5884    SessionNextRevertStaged(SessionNextRevertStaged),
5885    #[serde(rename = "session.next.revert.cleared")]
5886    SessionNextRevertCleared(SessionNextRevertCleared),
5887    #[serde(rename = "session.next.revert.committed")]
5888    SessionNextRevertCommitted(SessionNextRevertCommitted),
5889}
5890
5891#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
5892#[serde(transparent)]
5893pub struct SessionDurableEventStream(pub String);
5894
5895#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5896pub struct SessionError {
5897    pub data: SessionErrorData,
5898    #[serde(default, skip_serializing_if = "Option::is_none")]
5899    pub durable: Option<SessionStatus2Durable>,
5900    pub id: String,
5901    #[serde(default, skip_serializing_if = "Option::is_none")]
5902    pub location: Option<LocationRef>,
5903    #[serde(default, skip_serializing_if = "Option::is_none")]
5904    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5905    #[serde(rename = "type", default, skip_serializing)]
5906    pub type_: String,
5907}
5908
5909#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5910pub struct SessionErrorData {
5911    #[serde(default, skip_serializing_if = "Option::is_none")]
5912    pub error: Option<SessionErrorDataError>,
5913    #[serde(rename = "sessionID", default, skip_serializing_if = "Option::is_none")]
5914    pub session_id: Option<String>,
5915}
5916
5917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5918#[serde(tag = "name")]
5919pub enum SessionErrorDataError {
5920    ProviderAuthError(ProviderAuthError),
5921    UnknownError(UnknownError),
5922    MessageOutputLengthError(MessageOutputLengthError),
5923    MessageAbortedError(MessageAbortedError),
5924    StructuredOutputError(StructuredOutputError),
5925    ContextOverflowError(ContextOverflowError),
5926    ContentFilterError(ContentFilterError),
5927    APIError(APIError),
5928}
5929
5930#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5931pub struct SessionErrorUnknown {
5932    pub message: String,
5933    #[serde(rename = "type")]
5934    pub type_: String,
5935}
5936
5937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5938pub struct SessionHistory {
5939    pub data: Vec<SessionDurableEvent>,
5940    #[serde(rename = "hasMore")]
5941    pub has_more: bool,
5942}
5943
5944#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5945pub struct SessionIdle {
5946    pub data: SessionIdleData,
5947    #[serde(default, skip_serializing_if = "Option::is_none")]
5948    pub durable: Option<SessionStatus2Durable>,
5949    pub id: String,
5950    #[serde(default, skip_serializing_if = "Option::is_none")]
5951    pub location: Option<LocationRef>,
5952    #[serde(default, skip_serializing_if = "Option::is_none")]
5953    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5954    #[serde(rename = "type", default, skip_serializing)]
5955    pub type_: String,
5956}
5957
5958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5959pub struct SessionIdleData {
5960    #[serde(rename = "sessionID")]
5961    pub session_id: String,
5962}
5963
5964#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5965pub struct SessionInputAdmitted {
5966    #[serde(rename = "admittedSeq")]
5967    pub admitted_seq: u64,
5968    pub delivery: String,
5969    pub id: String,
5970    #[serde(
5971        rename = "promotedSeq",
5972        default,
5973        skip_serializing_if = "Option::is_none"
5974    )]
5975    pub promoted_seq: Option<u64>,
5976    pub prompt: Prompt,
5977    #[serde(rename = "sessionID")]
5978    pub session_id: String,
5979    #[serde(rename = "timeCreated")]
5980    pub time_created: f64,
5981}
5982
5983#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5984#[serde(tag = "type")]
5985pub enum SessionMessage {
5986    #[serde(rename = "agent-switched")]
5987    AgentSwitched(SessionMessageAgentSwitched),
5988    #[serde(rename = "model-switched")]
5989    ModelSwitched(SessionMessageModelSwitched),
5990    #[serde(rename = "user")]
5991    User(SessionMessageUser),
5992    #[serde(rename = "synthetic")]
5993    Synthetic(SessionMessageSynthetic),
5994    #[serde(rename = "system")]
5995    System(SessionMessageSystem),
5996    #[serde(rename = "shell")]
5997    Shell(SessionMessageShell),
5998    #[serde(rename = "assistant")]
5999    Assistant(SessionMessageAssistant),
6000    #[serde(rename = "compaction")]
6001    Compaction(SessionMessageCompaction),
6002}
6003
6004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6005pub struct SessionMessageAgentSwitched {
6006    pub agent: String,
6007    pub id: String,
6008    #[serde(default, skip_serializing_if = "Option::is_none")]
6009    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6010    pub time: SessionMessageUserTime,
6011    #[serde(rename = "type", default, skip_serializing)]
6012    pub type_: String,
6013}
6014
6015#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6016pub struct SessionMessageAssistant {
6017    pub agent: String,
6018    pub content: Vec<SessionMessageAssistantContentItem>,
6019    #[serde(default, skip_serializing_if = "Option::is_none")]
6020    pub cost: Option<f64>,
6021    #[serde(default, skip_serializing_if = "Option::is_none")]
6022    pub error: Option<SessionErrorUnknown>,
6023    #[serde(default, skip_serializing_if = "Option::is_none")]
6024    pub finish: Option<String>,
6025    pub id: String,
6026    #[serde(default, skip_serializing_if = "Option::is_none")]
6027    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6028    pub model: ModelRef,
6029    #[serde(default, skip_serializing_if = "Option::is_none")]
6030    pub snapshot: Option<SessionMessageAssistantSnapshot>,
6031    pub time: SessionMessageShellTime,
6032    #[serde(default, skip_serializing_if = "Option::is_none")]
6033    pub tokens: Option<SessionNextStepEndedDataTokens>,
6034    #[serde(rename = "type", default, skip_serializing)]
6035    pub type_: String,
6036}
6037
6038#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6039#[serde(tag = "type")]
6040pub enum SessionMessageAssistantContentItem {
6041    #[serde(rename = "text")]
6042    Text(SessionMessageAssistantText),
6043    #[serde(rename = "reasoning")]
6044    Reasoning(SessionMessageAssistantReasoning),
6045    #[serde(rename = "tool")]
6046    Tool(SessionMessageAssistantTool),
6047}
6048
6049#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6050pub struct SessionMessageAssistantReasoning {
6051    pub id: String,
6052    #[serde(
6053        rename = "providerMetadata",
6054        default,
6055        skip_serializing_if = "Option::is_none"
6056    )]
6057    pub provider_metadata: Option<LLMProviderMetadata>,
6058    pub text: String,
6059    #[serde(default, skip_serializing_if = "Option::is_none")]
6060    pub time: Option<SessionMessageShellTime>,
6061    #[serde(rename = "type", default, skip_serializing)]
6062    pub type_: String,
6063}
6064
6065#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6066pub struct SessionMessageAssistantSnapshot {
6067    #[serde(default, skip_serializing_if = "Option::is_none")]
6068    pub end: Option<String>,
6069    #[serde(default, skip_serializing_if = "Option::is_none")]
6070    pub files: Option<Vec<String>>,
6071    #[serde(default, skip_serializing_if = "Option::is_none")]
6072    pub start: Option<String>,
6073}
6074
6075#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6076pub struct SessionMessageAssistantText {
6077    pub id: String,
6078    pub text: String,
6079    #[serde(rename = "type", default, skip_serializing)]
6080    pub type_: String,
6081}
6082
6083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6084pub struct SessionMessageAssistantTool {
6085    pub id: String,
6086    pub name: String,
6087    #[serde(default, skip_serializing_if = "Option::is_none")]
6088    pub provider: Option<SessionMessageAssistantToolProvider>,
6089    pub state: SessionMessageAssistantToolState,
6090    pub time: SessionMessageAssistantToolTime,
6091    #[serde(rename = "type", default, skip_serializing)]
6092    pub type_: String,
6093}
6094
6095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6096pub struct SessionMessageAssistantToolProvider {
6097    pub executed: bool,
6098    #[serde(default, skip_serializing_if = "Option::is_none")]
6099    pub metadata: Option<LLMProviderMetadata>,
6100    #[serde(
6101        rename = "resultMetadata",
6102        default,
6103        skip_serializing_if = "Option::is_none"
6104    )]
6105    pub result_metadata: Option<LLMProviderMetadata>,
6106}
6107
6108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6109#[serde(tag = "status")]
6110pub enum SessionMessageAssistantToolState {
6111    #[serde(rename = "pending")]
6112    Pending(SessionMessageToolStatePending),
6113    #[serde(rename = "running")]
6114    Running(SessionMessageToolStateRunning),
6115    #[serde(rename = "completed")]
6116    Completed(SessionMessageToolStateCompleted),
6117    #[serde(rename = "error")]
6118    Error(SessionMessageToolStateError),
6119}
6120
6121#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6122pub struct SessionMessageAssistantToolTime {
6123    #[serde(default, skip_serializing_if = "Option::is_none")]
6124    pub completed: Option<f64>,
6125    pub created: f64,
6126    #[serde(default, skip_serializing_if = "Option::is_none")]
6127    pub pruned: Option<f64>,
6128    #[serde(default, skip_serializing_if = "Option::is_none")]
6129    pub ran: Option<f64>,
6130}
6131
6132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6133pub struct SessionMessageCompaction {
6134    pub id: String,
6135    #[serde(default, skip_serializing_if = "Option::is_none")]
6136    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6137    pub reason: String,
6138    pub recent: String,
6139    pub summary: String,
6140    pub time: SessionMessageUserTime,
6141    #[serde(rename = "type", default, skip_serializing)]
6142    pub type_: String,
6143}
6144
6145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6146pub struct SessionMessageModelSwitched {
6147    pub id: String,
6148    #[serde(default, skip_serializing_if = "Option::is_none")]
6149    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6150    pub model: ModelRef,
6151    pub time: SessionMessageUserTime,
6152    #[serde(rename = "type", default, skip_serializing)]
6153    pub type_: String,
6154}
6155
6156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6157pub struct SessionMessageShell {
6158    #[serde(rename = "callID")]
6159    pub call_id: String,
6160    pub command: String,
6161    pub id: String,
6162    #[serde(default, skip_serializing_if = "Option::is_none")]
6163    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6164    pub output: String,
6165    pub time: SessionMessageShellTime,
6166    #[serde(rename = "type", default, skip_serializing)]
6167    pub type_: String,
6168}
6169
6170#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6171pub struct SessionMessageShellTime {
6172    #[serde(default, skip_serializing_if = "Option::is_none")]
6173    pub completed: Option<f64>,
6174    pub created: f64,
6175}
6176
6177#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6178pub struct SessionMessageSynthetic {
6179    pub id: String,
6180    #[serde(default, skip_serializing_if = "Option::is_none")]
6181    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6182    #[serde(rename = "sessionID")]
6183    pub session_id: String,
6184    pub text: String,
6185    pub time: SessionMessageUserTime,
6186    #[serde(rename = "type", default, skip_serializing)]
6187    pub type_: String,
6188}
6189
6190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6191pub struct SessionMessageSystem {
6192    pub id: String,
6193    #[serde(default, skip_serializing_if = "Option::is_none")]
6194    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6195    pub text: String,
6196    pub time: SessionMessageUserTime,
6197    #[serde(rename = "type", default, skip_serializing)]
6198    pub type_: String,
6199}
6200
6201#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6202pub struct SessionMessageToolStateCompleted {
6203    #[serde(default, skip_serializing_if = "Option::is_none")]
6204    pub attachments: Option<Vec<PromptFileAttachment>>,
6205    pub content: Vec<LLMToolContent>,
6206    pub input: serde_json::Map<String, serde_json::Value>,
6207    #[serde(
6208        rename = "outputPaths",
6209        default,
6210        skip_serializing_if = "Option::is_none"
6211    )]
6212    pub output_paths: Option<Vec<String>>,
6213    #[serde(default, skip_serializing_if = "Option::is_none")]
6214    pub result: Option<serde_json::Value>,
6215    #[serde(default, skip_serializing)]
6216    pub status: String,
6217    pub structured: serde_json::Map<String, serde_json::Value>,
6218}
6219
6220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6221pub struct SessionMessageToolStateError {
6222    pub content: Vec<LLMToolContent>,
6223    pub error: SessionErrorUnknown,
6224    pub input: serde_json::Map<String, serde_json::Value>,
6225    #[serde(default, skip_serializing_if = "Option::is_none")]
6226    pub result: Option<serde_json::Value>,
6227    #[serde(default, skip_serializing)]
6228    pub status: String,
6229    pub structured: serde_json::Map<String, serde_json::Value>,
6230}
6231
6232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6233pub struct SessionMessageToolStatePending {
6234    pub input: String,
6235    #[serde(default, skip_serializing)]
6236    pub status: String,
6237}
6238
6239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6240pub struct SessionMessageToolStateRunning {
6241    pub content: Vec<LLMToolContent>,
6242    pub input: serde_json::Map<String, serde_json::Value>,
6243    #[serde(default, skip_serializing)]
6244    pub status: String,
6245    pub structured: serde_json::Map<String, serde_json::Value>,
6246}
6247
6248#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6249pub struct SessionMessageUser {
6250    #[serde(default, skip_serializing_if = "Option::is_none")]
6251    pub agents: Option<Vec<PromptAgentAttachment>>,
6252    #[serde(default, skip_serializing_if = "Option::is_none")]
6253    pub files: Option<Vec<PromptFileAttachment>>,
6254    pub id: String,
6255    #[serde(default, skip_serializing_if = "Option::is_none")]
6256    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6257    pub text: String,
6258    pub time: SessionMessageUserTime,
6259    #[serde(rename = "type", default, skip_serializing)]
6260    pub type_: String,
6261}
6262
6263#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6264pub struct SessionMessageUserTime {
6265    pub created: f64,
6266}
6267
6268#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6269pub struct SessionMessagesResponse {
6270    pub cursor: SessionsResponseCursor,
6271    pub data: Vec<SessionMessage>,
6272}
6273
6274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6275pub struct SessionNextAgentSwitched {
6276    pub data: SessionNextAgentSwitchedData,
6277    #[serde(default, skip_serializing_if = "Option::is_none")]
6278    pub durable: Option<SessionStatus2Durable>,
6279    pub id: String,
6280    #[serde(default, skip_serializing_if = "Option::is_none")]
6281    pub location: Option<LocationRef>,
6282    #[serde(default, skip_serializing_if = "Option::is_none")]
6283    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6284    #[serde(rename = "type", default, skip_serializing)]
6285    pub type_: String,
6286}
6287
6288#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6289pub struct SessionNextAgentSwitchedData {
6290    pub agent: String,
6291    #[serde(rename = "messageID")]
6292    pub message_id: String,
6293    #[serde(rename = "sessionID")]
6294    pub session_id: String,
6295    pub timestamp: f64,
6296}
6297
6298#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6299pub struct SessionNextCompactionDelta {
6300    pub data: SessionNextContextUpdatedData,
6301    #[serde(default, skip_serializing_if = "Option::is_none")]
6302    pub durable: Option<SessionStatus2Durable>,
6303    pub id: String,
6304    #[serde(default, skip_serializing_if = "Option::is_none")]
6305    pub location: Option<LocationRef>,
6306    #[serde(default, skip_serializing_if = "Option::is_none")]
6307    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6308    #[serde(rename = "type", default, skip_serializing)]
6309    pub type_: String,
6310}
6311
6312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6313pub struct SessionNextCompactionEnded {
6314    pub data: SessionNextCompactionEndedData,
6315    #[serde(default, skip_serializing_if = "Option::is_none")]
6316    pub durable: Option<SessionStatus2Durable>,
6317    pub id: String,
6318    #[serde(default, skip_serializing_if = "Option::is_none")]
6319    pub location: Option<LocationRef>,
6320    #[serde(default, skip_serializing_if = "Option::is_none")]
6321    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6322    #[serde(rename = "type", default, skip_serializing)]
6323    pub type_: String,
6324}
6325
6326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6327pub struct SessionNextCompactionEndedData {
6328    #[serde(rename = "messageID")]
6329    pub message_id: String,
6330    pub reason: String,
6331    pub recent: String,
6332    #[serde(rename = "sessionID")]
6333    pub session_id: String,
6334    pub text: String,
6335    pub timestamp: f64,
6336}
6337
6338#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6339pub struct SessionNextCompactionStarted {
6340    pub data: SessionNextCompactionStartedData,
6341    #[serde(default, skip_serializing_if = "Option::is_none")]
6342    pub durable: Option<SessionStatus2Durable>,
6343    pub id: String,
6344    #[serde(default, skip_serializing_if = "Option::is_none")]
6345    pub location: Option<LocationRef>,
6346    #[serde(default, skip_serializing_if = "Option::is_none")]
6347    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6348    #[serde(rename = "type", default, skip_serializing)]
6349    pub type_: String,
6350}
6351
6352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6353pub struct SessionNextCompactionStartedData {
6354    #[serde(rename = "messageID")]
6355    pub message_id: String,
6356    pub reason: String,
6357    #[serde(rename = "sessionID")]
6358    pub session_id: String,
6359    pub timestamp: f64,
6360}
6361
6362#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6363pub struct SessionNextContextUpdated {
6364    pub data: SessionNextContextUpdatedData,
6365    #[serde(default, skip_serializing_if = "Option::is_none")]
6366    pub durable: Option<SessionStatus2Durable>,
6367    pub id: String,
6368    #[serde(default, skip_serializing_if = "Option::is_none")]
6369    pub location: Option<LocationRef>,
6370    #[serde(default, skip_serializing_if = "Option::is_none")]
6371    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6372    #[serde(rename = "type", default, skip_serializing)]
6373    pub type_: String,
6374}
6375
6376#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6377pub struct SessionNextContextUpdatedData {
6378    #[serde(rename = "messageID")]
6379    pub message_id: String,
6380    #[serde(rename = "sessionID")]
6381    pub session_id: String,
6382    pub text: String,
6383    pub timestamp: f64,
6384}
6385
6386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6387pub struct SessionNextModelSwitched {
6388    pub data: SessionNextModelSwitchedData,
6389    #[serde(default, skip_serializing_if = "Option::is_none")]
6390    pub durable: Option<SessionStatus2Durable>,
6391    pub id: String,
6392    #[serde(default, skip_serializing_if = "Option::is_none")]
6393    pub location: Option<LocationRef>,
6394    #[serde(default, skip_serializing_if = "Option::is_none")]
6395    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6396    #[serde(rename = "type", default, skip_serializing)]
6397    pub type_: String,
6398}
6399
6400#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6401pub struct SessionNextModelSwitchedData {
6402    #[serde(rename = "messageID")]
6403    pub message_id: String,
6404    pub model: ModelRef,
6405    #[serde(rename = "sessionID")]
6406    pub session_id: String,
6407    pub timestamp: f64,
6408}
6409
6410#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6411pub struct SessionNextMoved {
6412    pub data: SessionNextMovedData,
6413    #[serde(default, skip_serializing_if = "Option::is_none")]
6414    pub durable: Option<SessionStatus2Durable>,
6415    pub id: String,
6416    #[serde(default, skip_serializing_if = "Option::is_none")]
6417    pub location: Option<LocationRef>,
6418    #[serde(default, skip_serializing_if = "Option::is_none")]
6419    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6420    #[serde(rename = "type", default, skip_serializing)]
6421    pub type_: String,
6422}
6423
6424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6425pub struct SessionNextMovedData {
6426    pub location: LocationRef,
6427    #[serde(rename = "sessionID")]
6428    pub session_id: String,
6429    #[serde(default, skip_serializing_if = "Option::is_none")]
6430    pub subdirectory: Option<String>,
6431    pub timestamp: f64,
6432}
6433
6434#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6435pub struct SessionNextPromptAdmitted {
6436    pub data: SessionNextPromptedData,
6437    #[serde(default, skip_serializing_if = "Option::is_none")]
6438    pub durable: Option<SessionStatus2Durable>,
6439    pub id: String,
6440    #[serde(default, skip_serializing_if = "Option::is_none")]
6441    pub location: Option<LocationRef>,
6442    #[serde(default, skip_serializing_if = "Option::is_none")]
6443    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6444    #[serde(rename = "type", default, skip_serializing)]
6445    pub type_: String,
6446}
6447
6448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6449pub struct SessionNextPrompted {
6450    pub data: SessionNextPromptedData,
6451    #[serde(default, skip_serializing_if = "Option::is_none")]
6452    pub durable: Option<SessionStatus2Durable>,
6453    pub id: String,
6454    #[serde(default, skip_serializing_if = "Option::is_none")]
6455    pub location: Option<LocationRef>,
6456    #[serde(default, skip_serializing_if = "Option::is_none")]
6457    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6458    #[serde(rename = "type", default, skip_serializing)]
6459    pub type_: String,
6460}
6461
6462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6463pub struct SessionNextPromptedData {
6464    pub delivery: String,
6465    #[serde(rename = "messageID")]
6466    pub message_id: String,
6467    pub prompt: Prompt,
6468    #[serde(rename = "sessionID")]
6469    pub session_id: String,
6470    pub timestamp: f64,
6471}
6472
6473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6474pub struct SessionNextReasoningDelta {
6475    pub data: SessionNextReasoningDeltaData,
6476    #[serde(default, skip_serializing_if = "Option::is_none")]
6477    pub durable: Option<SessionStatus2Durable>,
6478    pub id: String,
6479    #[serde(default, skip_serializing_if = "Option::is_none")]
6480    pub location: Option<LocationRef>,
6481    #[serde(default, skip_serializing_if = "Option::is_none")]
6482    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6483    #[serde(rename = "type", default, skip_serializing)]
6484    pub type_: String,
6485}
6486
6487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6488pub struct SessionNextReasoningDeltaData {
6489    #[serde(rename = "assistantMessageID")]
6490    pub assistant_message_id: String,
6491    pub delta: String,
6492    #[serde(rename = "reasoningID")]
6493    pub reasoning_id: String,
6494    #[serde(rename = "sessionID")]
6495    pub session_id: String,
6496    pub timestamp: f64,
6497}
6498
6499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6500pub struct SessionNextReasoningEnded {
6501    pub data: SessionNextReasoningEndedData,
6502    #[serde(default, skip_serializing_if = "Option::is_none")]
6503    pub durable: Option<SessionStatus2Durable>,
6504    pub id: String,
6505    #[serde(default, skip_serializing_if = "Option::is_none")]
6506    pub location: Option<LocationRef>,
6507    #[serde(default, skip_serializing_if = "Option::is_none")]
6508    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6509    #[serde(rename = "type", default, skip_serializing)]
6510    pub type_: String,
6511}
6512
6513#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6514pub struct SessionNextReasoningEndedData {
6515    #[serde(rename = "assistantMessageID")]
6516    pub assistant_message_id: String,
6517    #[serde(
6518        rename = "providerMetadata",
6519        default,
6520        skip_serializing_if = "Option::is_none"
6521    )]
6522    pub provider_metadata: Option<LLMProviderMetadata>,
6523    #[serde(rename = "reasoningID")]
6524    pub reasoning_id: String,
6525    #[serde(rename = "sessionID")]
6526    pub session_id: String,
6527    pub text: String,
6528    pub timestamp: f64,
6529}
6530
6531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6532pub struct SessionNextReasoningStarted {
6533    pub data: SessionNextReasoningStartedData,
6534    #[serde(default, skip_serializing_if = "Option::is_none")]
6535    pub durable: Option<SessionStatus2Durable>,
6536    pub id: String,
6537    #[serde(default, skip_serializing_if = "Option::is_none")]
6538    pub location: Option<LocationRef>,
6539    #[serde(default, skip_serializing_if = "Option::is_none")]
6540    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6541    #[serde(rename = "type", default, skip_serializing)]
6542    pub type_: String,
6543}
6544
6545#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6546pub struct SessionNextReasoningStartedData {
6547    #[serde(rename = "assistantMessageID")]
6548    pub assistant_message_id: String,
6549    #[serde(
6550        rename = "providerMetadata",
6551        default,
6552        skip_serializing_if = "Option::is_none"
6553    )]
6554    pub provider_metadata: Option<LLMProviderMetadata>,
6555    #[serde(rename = "reasoningID")]
6556    pub reasoning_id: String,
6557    #[serde(rename = "sessionID")]
6558    pub session_id: String,
6559    pub timestamp: f64,
6560}
6561
6562#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6563pub struct SessionNextRetried {
6564    pub data: SessionNextRetriedData,
6565    #[serde(default, skip_serializing_if = "Option::is_none")]
6566    pub durable: Option<SessionStatus2Durable>,
6567    pub id: String,
6568    #[serde(default, skip_serializing_if = "Option::is_none")]
6569    pub location: Option<LocationRef>,
6570    #[serde(default, skip_serializing_if = "Option::is_none")]
6571    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6572    #[serde(rename = "type", default, skip_serializing)]
6573    pub type_: String,
6574}
6575
6576#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6577pub struct SessionNextRetriedData {
6578    pub attempt: f64,
6579    pub error: SessionNextRetryError,
6580    #[serde(rename = "sessionID")]
6581    pub session_id: String,
6582    pub timestamp: f64,
6583}
6584
6585#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6586pub struct SessionNextRetryError {
6587    #[serde(rename = "isRetryable")]
6588    pub is_retryable: bool,
6589    pub message: String,
6590    #[serde(default, skip_serializing_if = "Option::is_none")]
6591    pub metadata: Option<std::collections::BTreeMap<String, String>>,
6592    #[serde(
6593        rename = "responseBody",
6594        default,
6595        skip_serializing_if = "Option::is_none"
6596    )]
6597    pub response_body: Option<String>,
6598    #[serde(
6599        rename = "responseHeaders",
6600        default,
6601        skip_serializing_if = "Option::is_none"
6602    )]
6603    pub response_headers: Option<std::collections::BTreeMap<String, String>>,
6604    #[serde(
6605        rename = "statusCode",
6606        default,
6607        skip_serializing_if = "Option::is_none"
6608    )]
6609    pub status_code: Option<f64>,
6610}
6611
6612#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6613pub struct SessionNextRevertCleared {
6614    pub data: SessionNextRevertClearedData,
6615    #[serde(default, skip_serializing_if = "Option::is_none")]
6616    pub durable: Option<SessionStatus2Durable>,
6617    pub id: String,
6618    #[serde(default, skip_serializing_if = "Option::is_none")]
6619    pub location: Option<LocationRef>,
6620    #[serde(default, skip_serializing_if = "Option::is_none")]
6621    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6622    #[serde(rename = "type", default, skip_serializing)]
6623    pub type_: String,
6624}
6625
6626#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6627pub struct SessionNextRevertClearedData {
6628    #[serde(rename = "sessionID")]
6629    pub session_id: String,
6630    pub timestamp: f64,
6631}
6632
6633#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6634pub struct SessionNextRevertCommitted {
6635    pub data: SessionNextRevertCommittedData,
6636    #[serde(default, skip_serializing_if = "Option::is_none")]
6637    pub durable: Option<SessionStatus2Durable>,
6638    pub id: String,
6639    #[serde(default, skip_serializing_if = "Option::is_none")]
6640    pub location: Option<LocationRef>,
6641    #[serde(default, skip_serializing_if = "Option::is_none")]
6642    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6643    #[serde(rename = "type", default, skip_serializing)]
6644    pub type_: String,
6645}
6646
6647#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6648pub struct SessionNextRevertCommittedData {
6649    #[serde(rename = "messageID")]
6650    pub message_id: String,
6651    #[serde(rename = "sessionID")]
6652    pub session_id: String,
6653    pub timestamp: f64,
6654}
6655
6656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6657pub struct SessionNextRevertStaged {
6658    pub data: SessionNextRevertStagedData,
6659    #[serde(default, skip_serializing_if = "Option::is_none")]
6660    pub durable: Option<SessionStatus2Durable>,
6661    pub id: String,
6662    #[serde(default, skip_serializing_if = "Option::is_none")]
6663    pub location: Option<LocationRef>,
6664    #[serde(default, skip_serializing_if = "Option::is_none")]
6665    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6666    #[serde(rename = "type", default, skip_serializing)]
6667    pub type_: String,
6668}
6669
6670#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6671pub struct SessionNextRevertStagedData {
6672    pub revert: RevertState,
6673    #[serde(rename = "sessionID")]
6674    pub session_id: String,
6675    pub timestamp: f64,
6676}
6677
6678#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6679pub struct SessionNextShellEnded {
6680    pub data: SessionNextShellEndedData,
6681    #[serde(default, skip_serializing_if = "Option::is_none")]
6682    pub durable: Option<SessionStatus2Durable>,
6683    pub id: String,
6684    #[serde(default, skip_serializing_if = "Option::is_none")]
6685    pub location: Option<LocationRef>,
6686    #[serde(default, skip_serializing_if = "Option::is_none")]
6687    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6688    #[serde(rename = "type", default, skip_serializing)]
6689    pub type_: String,
6690}
6691
6692#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6693pub struct SessionNextShellEndedData {
6694    #[serde(rename = "callID")]
6695    pub call_id: String,
6696    pub output: String,
6697    #[serde(rename = "sessionID")]
6698    pub session_id: String,
6699    pub timestamp: f64,
6700}
6701
6702#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6703pub struct SessionNextShellStarted {
6704    pub data: SessionNextShellStartedData,
6705    #[serde(default, skip_serializing_if = "Option::is_none")]
6706    pub durable: Option<SessionStatus2Durable>,
6707    pub id: String,
6708    #[serde(default, skip_serializing_if = "Option::is_none")]
6709    pub location: Option<LocationRef>,
6710    #[serde(default, skip_serializing_if = "Option::is_none")]
6711    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6712    #[serde(rename = "type", default, skip_serializing)]
6713    pub type_: String,
6714}
6715
6716#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6717pub struct SessionNextShellStartedData {
6718    #[serde(rename = "callID")]
6719    pub call_id: String,
6720    pub command: String,
6721    #[serde(rename = "messageID")]
6722    pub message_id: String,
6723    #[serde(rename = "sessionID")]
6724    pub session_id: String,
6725    pub timestamp: f64,
6726}
6727
6728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6729pub struct SessionNextStepEnded {
6730    pub data: SessionNextStepEndedData,
6731    #[serde(default, skip_serializing_if = "Option::is_none")]
6732    pub durable: Option<SessionStatus2Durable>,
6733    pub id: String,
6734    #[serde(default, skip_serializing_if = "Option::is_none")]
6735    pub location: Option<LocationRef>,
6736    #[serde(default, skip_serializing_if = "Option::is_none")]
6737    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6738    #[serde(rename = "type", default, skip_serializing)]
6739    pub type_: String,
6740}
6741
6742#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6743pub struct SessionNextStepEndedData {
6744    #[serde(rename = "assistantMessageID")]
6745    pub assistant_message_id: String,
6746    pub cost: f64,
6747    #[serde(default, skip_serializing_if = "Option::is_none")]
6748    pub files: Option<Vec<String>>,
6749    pub finish: String,
6750    #[serde(rename = "sessionID")]
6751    pub session_id: String,
6752    #[serde(default, skip_serializing_if = "Option::is_none")]
6753    pub snapshot: Option<String>,
6754    pub timestamp: f64,
6755    pub tokens: SessionNextStepEndedDataTokens,
6756}
6757
6758#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6759pub struct SessionNextStepEndedDataTokens {
6760    pub cache: SessionNextStepEndedDataTokensCache,
6761    pub input: f64,
6762    pub output: f64,
6763    pub reasoning: f64,
6764}
6765
6766#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6767pub struct SessionNextStepEndedDataTokensCache {
6768    pub read: f64,
6769    pub write: f64,
6770}
6771
6772#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6773pub struct SessionNextStepFailed {
6774    pub data: SessionNextStepFailedData,
6775    #[serde(default, skip_serializing_if = "Option::is_none")]
6776    pub durable: Option<SessionStatus2Durable>,
6777    pub id: String,
6778    #[serde(default, skip_serializing_if = "Option::is_none")]
6779    pub location: Option<LocationRef>,
6780    #[serde(default, skip_serializing_if = "Option::is_none")]
6781    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6782    #[serde(rename = "type", default, skip_serializing)]
6783    pub type_: String,
6784}
6785
6786#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6787pub struct SessionNextStepFailedData {
6788    #[serde(rename = "assistantMessageID")]
6789    pub assistant_message_id: String,
6790    pub error: SessionErrorUnknown,
6791    #[serde(rename = "sessionID")]
6792    pub session_id: String,
6793    pub timestamp: f64,
6794}
6795
6796#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6797pub struct SessionNextStepStarted {
6798    pub data: SessionNextStepStartedData,
6799    #[serde(default, skip_serializing_if = "Option::is_none")]
6800    pub durable: Option<SessionStatus2Durable>,
6801    pub id: String,
6802    #[serde(default, skip_serializing_if = "Option::is_none")]
6803    pub location: Option<LocationRef>,
6804    #[serde(default, skip_serializing_if = "Option::is_none")]
6805    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6806    #[serde(rename = "type", default, skip_serializing)]
6807    pub type_: String,
6808}
6809
6810#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6811pub struct SessionNextStepStartedData {
6812    pub agent: String,
6813    #[serde(rename = "assistantMessageID")]
6814    pub assistant_message_id: String,
6815    pub model: ModelRef,
6816    #[serde(rename = "sessionID")]
6817    pub session_id: String,
6818    #[serde(default, skip_serializing_if = "Option::is_none")]
6819    pub snapshot: Option<String>,
6820    pub timestamp: f64,
6821}
6822
6823#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6824pub struct SessionNextSynthetic {
6825    pub data: SessionNextContextUpdatedData,
6826    #[serde(default, skip_serializing_if = "Option::is_none")]
6827    pub durable: Option<SessionStatus2Durable>,
6828    pub id: String,
6829    #[serde(default, skip_serializing_if = "Option::is_none")]
6830    pub location: Option<LocationRef>,
6831    #[serde(default, skip_serializing_if = "Option::is_none")]
6832    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6833    #[serde(rename = "type", default, skip_serializing)]
6834    pub type_: String,
6835}
6836
6837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6838pub struct SessionNextTextDelta {
6839    pub data: SessionNextTextDeltaData,
6840    #[serde(default, skip_serializing_if = "Option::is_none")]
6841    pub durable: Option<SessionStatus2Durable>,
6842    pub id: String,
6843    #[serde(default, skip_serializing_if = "Option::is_none")]
6844    pub location: Option<LocationRef>,
6845    #[serde(default, skip_serializing_if = "Option::is_none")]
6846    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6847    #[serde(rename = "type", default, skip_serializing)]
6848    pub type_: String,
6849}
6850
6851#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6852pub struct SessionNextTextDeltaData {
6853    #[serde(rename = "assistantMessageID")]
6854    pub assistant_message_id: String,
6855    pub delta: String,
6856    #[serde(rename = "sessionID")]
6857    pub session_id: String,
6858    #[serde(rename = "textID")]
6859    pub text_id: String,
6860    pub timestamp: f64,
6861}
6862
6863#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6864pub struct SessionNextTextEnded {
6865    pub data: SessionNextTextEndedData,
6866    #[serde(default, skip_serializing_if = "Option::is_none")]
6867    pub durable: Option<SessionStatus2Durable>,
6868    pub id: String,
6869    #[serde(default, skip_serializing_if = "Option::is_none")]
6870    pub location: Option<LocationRef>,
6871    #[serde(default, skip_serializing_if = "Option::is_none")]
6872    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6873    #[serde(rename = "type", default, skip_serializing)]
6874    pub type_: String,
6875}
6876
6877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6878pub struct SessionNextTextEndedData {
6879    #[serde(rename = "assistantMessageID")]
6880    pub assistant_message_id: String,
6881    #[serde(rename = "sessionID")]
6882    pub session_id: String,
6883    pub text: String,
6884    #[serde(rename = "textID")]
6885    pub text_id: String,
6886    pub timestamp: f64,
6887}
6888
6889#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6890pub struct SessionNextTextStarted {
6891    pub data: SessionNextTextStartedData,
6892    #[serde(default, skip_serializing_if = "Option::is_none")]
6893    pub durable: Option<SessionStatus2Durable>,
6894    pub id: String,
6895    #[serde(default, skip_serializing_if = "Option::is_none")]
6896    pub location: Option<LocationRef>,
6897    #[serde(default, skip_serializing_if = "Option::is_none")]
6898    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6899    #[serde(rename = "type", default, skip_serializing)]
6900    pub type_: String,
6901}
6902
6903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6904pub struct SessionNextTextStartedData {
6905    #[serde(rename = "assistantMessageID")]
6906    pub assistant_message_id: String,
6907    #[serde(rename = "sessionID")]
6908    pub session_id: String,
6909    #[serde(rename = "textID")]
6910    pub text_id: String,
6911    pub timestamp: f64,
6912}
6913
6914#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6915pub struct SessionNextToolCalled {
6916    pub data: SessionNextToolCalledData,
6917    #[serde(default, skip_serializing_if = "Option::is_none")]
6918    pub durable: Option<SessionStatus2Durable>,
6919    pub id: String,
6920    #[serde(default, skip_serializing_if = "Option::is_none")]
6921    pub location: Option<LocationRef>,
6922    #[serde(default, skip_serializing_if = "Option::is_none")]
6923    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6924    #[serde(rename = "type", default, skip_serializing)]
6925    pub type_: String,
6926}
6927
6928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6929pub struct SessionNextToolCalledData {
6930    #[serde(rename = "assistantMessageID")]
6931    pub assistant_message_id: String,
6932    #[serde(rename = "callID")]
6933    pub call_id: String,
6934    pub input: serde_json::Map<String, serde_json::Value>,
6935    pub provider: SessionNextToolFailedDataProvider,
6936    #[serde(rename = "sessionID")]
6937    pub session_id: String,
6938    pub timestamp: f64,
6939    pub tool: String,
6940}
6941
6942#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6943pub struct SessionNextToolFailed {
6944    pub data: SessionNextToolFailedData,
6945    #[serde(default, skip_serializing_if = "Option::is_none")]
6946    pub durable: Option<SessionStatus2Durable>,
6947    pub id: String,
6948    #[serde(default, skip_serializing_if = "Option::is_none")]
6949    pub location: Option<LocationRef>,
6950    #[serde(default, skip_serializing_if = "Option::is_none")]
6951    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6952    #[serde(rename = "type", default, skip_serializing)]
6953    pub type_: String,
6954}
6955
6956#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6957pub struct SessionNextToolFailedData {
6958    #[serde(rename = "assistantMessageID")]
6959    pub assistant_message_id: String,
6960    #[serde(rename = "callID")]
6961    pub call_id: String,
6962    pub error: SessionErrorUnknown,
6963    pub provider: SessionNextToolFailedDataProvider,
6964    #[serde(default, skip_serializing_if = "Option::is_none")]
6965    pub result: Option<serde_json::Value>,
6966    #[serde(rename = "sessionID")]
6967    pub session_id: String,
6968    pub timestamp: f64,
6969}
6970
6971#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6972pub struct SessionNextToolFailedDataProvider {
6973    pub executed: bool,
6974    #[serde(default, skip_serializing_if = "Option::is_none")]
6975    pub metadata: Option<LLMProviderMetadata>,
6976}
6977
6978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6979pub struct SessionNextToolInputDelta {
6980    pub data: SessionNextToolInputDeltaData,
6981    #[serde(default, skip_serializing_if = "Option::is_none")]
6982    pub durable: Option<SessionStatus2Durable>,
6983    pub id: String,
6984    #[serde(default, skip_serializing_if = "Option::is_none")]
6985    pub location: Option<LocationRef>,
6986    #[serde(default, skip_serializing_if = "Option::is_none")]
6987    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6988    #[serde(rename = "type", default, skip_serializing)]
6989    pub type_: String,
6990}
6991
6992#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6993pub struct SessionNextToolInputDeltaData {
6994    #[serde(rename = "assistantMessageID")]
6995    pub assistant_message_id: String,
6996    #[serde(rename = "callID")]
6997    pub call_id: String,
6998    pub delta: String,
6999    #[serde(rename = "sessionID")]
7000    pub session_id: String,
7001    pub timestamp: f64,
7002}
7003
7004#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7005pub struct SessionNextToolInputEnded {
7006    pub data: SessionNextToolInputEndedData,
7007    #[serde(default, skip_serializing_if = "Option::is_none")]
7008    pub durable: Option<SessionStatus2Durable>,
7009    pub id: String,
7010    #[serde(default, skip_serializing_if = "Option::is_none")]
7011    pub location: Option<LocationRef>,
7012    #[serde(default, skip_serializing_if = "Option::is_none")]
7013    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7014    #[serde(rename = "type", default, skip_serializing)]
7015    pub type_: String,
7016}
7017
7018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7019pub struct SessionNextToolInputEndedData {
7020    #[serde(rename = "assistantMessageID")]
7021    pub assistant_message_id: String,
7022    #[serde(rename = "callID")]
7023    pub call_id: String,
7024    #[serde(rename = "sessionID")]
7025    pub session_id: String,
7026    pub text: String,
7027    pub timestamp: f64,
7028}
7029
7030#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7031pub struct SessionNextToolInputStarted {
7032    pub data: SessionNextToolInputStartedData,
7033    #[serde(default, skip_serializing_if = "Option::is_none")]
7034    pub durable: Option<SessionStatus2Durable>,
7035    pub id: String,
7036    #[serde(default, skip_serializing_if = "Option::is_none")]
7037    pub location: Option<LocationRef>,
7038    #[serde(default, skip_serializing_if = "Option::is_none")]
7039    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7040    #[serde(rename = "type", default, skip_serializing)]
7041    pub type_: String,
7042}
7043
7044#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7045pub struct SessionNextToolInputStartedData {
7046    #[serde(rename = "assistantMessageID")]
7047    pub assistant_message_id: String,
7048    #[serde(rename = "callID")]
7049    pub call_id: String,
7050    pub name: String,
7051    #[serde(rename = "sessionID")]
7052    pub session_id: String,
7053    pub timestamp: f64,
7054}
7055
7056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7057pub struct SessionNextToolProgress {
7058    pub data: SessionNextToolProgressData,
7059    #[serde(default, skip_serializing_if = "Option::is_none")]
7060    pub durable: Option<SessionStatus2Durable>,
7061    pub id: String,
7062    #[serde(default, skip_serializing_if = "Option::is_none")]
7063    pub location: Option<LocationRef>,
7064    #[serde(default, skip_serializing_if = "Option::is_none")]
7065    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7066    #[serde(rename = "type", default, skip_serializing)]
7067    pub type_: String,
7068}
7069
7070#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7071pub struct SessionNextToolProgressData {
7072    #[serde(rename = "assistantMessageID")]
7073    pub assistant_message_id: String,
7074    #[serde(rename = "callID")]
7075    pub call_id: String,
7076    pub content: Vec<LLMToolContent>,
7077    #[serde(rename = "sessionID")]
7078    pub session_id: String,
7079    pub structured: serde_json::Map<String, serde_json::Value>,
7080    pub timestamp: f64,
7081}
7082
7083#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7084pub struct SessionNextToolSuccess {
7085    pub data: SessionNextToolSuccessData,
7086    #[serde(default, skip_serializing_if = "Option::is_none")]
7087    pub durable: Option<SessionStatus2Durable>,
7088    pub id: String,
7089    #[serde(default, skip_serializing_if = "Option::is_none")]
7090    pub location: Option<LocationRef>,
7091    #[serde(default, skip_serializing_if = "Option::is_none")]
7092    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7093    #[serde(rename = "type", default, skip_serializing)]
7094    pub type_: String,
7095}
7096
7097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7098pub struct SessionNextToolSuccessData {
7099    #[serde(rename = "assistantMessageID")]
7100    pub assistant_message_id: String,
7101    #[serde(rename = "callID")]
7102    pub call_id: String,
7103    pub content: Vec<LLMToolContent>,
7104    #[serde(
7105        rename = "outputPaths",
7106        default,
7107        skip_serializing_if = "Option::is_none"
7108    )]
7109    pub output_paths: Option<Vec<String>>,
7110    pub provider: SessionNextToolFailedDataProvider,
7111    #[serde(default, skip_serializing_if = "Option::is_none")]
7112    pub result: Option<serde_json::Value>,
7113    #[serde(rename = "sessionID")]
7114    pub session_id: String,
7115    pub structured: serde_json::Map<String, serde_json::Value>,
7116    pub timestamp: f64,
7117}
7118
7119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7120pub struct SessionNotFoundError {
7121    pub _tag: String,
7122    pub message: String,
7123    #[serde(rename = "sessionID")]
7124    pub session_id: String,
7125}
7126
7127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7128pub struct SessionRevert {
7129    #[serde(default, skip_serializing_if = "Option::is_none")]
7130    pub diff: Option<String>,
7131    #[serde(rename = "messageID")]
7132    pub message_id: String,
7133    #[serde(rename = "partID", default, skip_serializing_if = "Option::is_none")]
7134    pub part_id: Option<String>,
7135    #[serde(default, skip_serializing_if = "Option::is_none")]
7136    pub snapshot: Option<String>,
7137}
7138
7139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7140pub struct SessionShare {
7141    pub url: String,
7142}
7143
7144#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7145#[serde(tag = "type")]
7146pub enum SessionStatus {
7147    #[serde(rename = "idle")]
7148    Idle,
7149    #[serde(rename = "retry")]
7150    Retry {
7151        #[serde(default, skip_serializing_if = "Option::is_none")]
7152        action: Option<SessionStatusRetryAction>,
7153        attempt: u64,
7154        message: String,
7155        next: u64,
7156    },
7157    #[serde(rename = "busy")]
7158    Busy,
7159}
7160
7161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7162pub struct SessionStatus2Data {
7163    #[serde(rename = "sessionID")]
7164    pub session_id: String,
7165    pub status: SessionStatus,
7166}
7167
7168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7169pub struct SessionStatus2Durable {
7170    #[serde(rename = "aggregateID")]
7171    pub aggregate_id: String,
7172    pub seq: i64,
7173    pub version: i64,
7174}
7175
7176#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7177pub struct SessionStatusRetryAction {
7178    pub label: String,
7179    #[serde(default, skip_serializing_if = "Option::is_none")]
7180    pub link: Option<String>,
7181    pub message: String,
7182    pub provider: String,
7183    pub reason: String,
7184    pub title: String,
7185}
7186
7187#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7188pub struct SessionSummary {
7189    pub additions: f64,
7190    pub deletions: f64,
7191    #[serde(default, skip_serializing_if = "Option::is_none")]
7192    pub diffs: Option<Vec<SnapshotFileDiff>>,
7193    pub files: f64,
7194}
7195
7196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7197pub struct SessionTime {
7198    #[serde(default, skip_serializing_if = "Option::is_none")]
7199    pub archived: Option<f64>,
7200    #[serde(default, skip_serializing_if = "Option::is_none")]
7201    pub compacting: Option<u64>,
7202    pub created: u64,
7203    pub updated: u64,
7204}
7205
7206#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7207pub struct SessionUpdated {
7208    pub data: SessionCreatedData,
7209    #[serde(default, skip_serializing_if = "Option::is_none")]
7210    pub durable: Option<SessionStatus2Durable>,
7211    pub id: String,
7212    #[serde(default, skip_serializing_if = "Option::is_none")]
7213    pub location: Option<LocationRef>,
7214    #[serde(default, skip_serializing_if = "Option::is_none")]
7215    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7216    #[serde(rename = "type", default, skip_serializing)]
7217    pub type_: String,
7218}
7219
7220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7221pub struct SessionV2Info {
7222    #[serde(default, skip_serializing_if = "Option::is_none")]
7223    pub agent: Option<String>,
7224    pub cost: f64,
7225    pub id: String,
7226    pub location: LocationRef,
7227    #[serde(default, skip_serializing_if = "Option::is_none")]
7228    pub model: Option<ModelRef>,
7229    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
7230    pub parent_id: Option<String>,
7231    #[serde(rename = "projectID")]
7232    pub project_id: String,
7233    #[serde(default, skip_serializing_if = "Option::is_none")]
7234    pub revert: Option<RevertState>,
7235    #[serde(default, skip_serializing_if = "Option::is_none")]
7236    pub subpath: Option<String>,
7237    pub time: SessionV2InfoTime,
7238    pub title: String,
7239    pub tokens: SessionNextStepEndedDataTokens,
7240}
7241
7242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7243pub struct SessionV2InfoTime {
7244    #[serde(default, skip_serializing_if = "Option::is_none")]
7245    pub archived: Option<f64>,
7246    pub created: f64,
7247    pub updated: f64,
7248}
7249
7250#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7251pub struct SessionsResponse {
7252    pub cursor: SessionsResponseCursor,
7253    pub data: Vec<SessionV2Info>,
7254}
7255
7256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7257pub struct SessionsResponseCursor {
7258    #[serde(default, skip_serializing_if = "Option::is_none")]
7259    pub next: Option<String>,
7260    #[serde(default, skip_serializing_if = "Option::is_none")]
7261    pub previous: Option<String>,
7262}
7263
7264#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7265pub struct SkillV2DirectorySource {
7266    pub path: String,
7267    #[serde(rename = "type", default, skip_serializing)]
7268    pub type_: String,
7269}
7270
7271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7272pub struct SkillV2EmbeddedSource {
7273    pub skill: SkillV2Info,
7274    #[serde(rename = "type", default, skip_serializing)]
7275    pub type_: String,
7276}
7277
7278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7279pub struct SkillV2Info {
7280    pub content: String,
7281    #[serde(default, skip_serializing_if = "Option::is_none")]
7282    pub description: Option<String>,
7283    pub location: String,
7284    pub name: String,
7285    #[serde(default, skip_serializing_if = "Option::is_none")]
7286    pub slash: Option<bool>,
7287}
7288
7289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7290#[serde(tag = "type")]
7291pub enum SkillV2Source {
7292    #[serde(rename = "directory")]
7293    Directory(SkillV2DirectorySource),
7294    #[serde(rename = "url")]
7295    Url(SkillV2UrlSource),
7296    #[serde(rename = "embedded")]
7297    Embedded(SkillV2EmbeddedSource),
7298}
7299
7300#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7301pub struct SkillV2UrlSource {
7302    #[serde(rename = "type", default, skip_serializing)]
7303    pub type_: String,
7304    pub url: String,
7305}
7306
7307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7308pub struct SnapshotFileDiff {
7309    pub additions: f64,
7310    pub deletions: f64,
7311    #[serde(default, skip_serializing_if = "Option::is_none")]
7312    pub file: Option<String>,
7313    #[serde(default, skip_serializing_if = "Option::is_none")]
7314    pub patch: Option<String>,
7315    #[serde(default, skip_serializing_if = "Option::is_none")]
7316    pub status: Option<String>,
7317}
7318
7319#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7320pub struct SnapshotPart {
7321    pub id: String,
7322    #[serde(rename = "messageID")]
7323    pub message_id: String,
7324    #[serde(rename = "sessionID")]
7325    pub session_id: String,
7326    pub snapshot: String,
7327    #[serde(rename = "type", default, skip_serializing)]
7328    pub type_: String,
7329}
7330
7331#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7332pub struct StepFinishPart {
7333    pub cost: f64,
7334    pub id: String,
7335    #[serde(rename = "messageID")]
7336    pub message_id: String,
7337    pub reason: String,
7338    #[serde(rename = "sessionID")]
7339    pub session_id: String,
7340    #[serde(default, skip_serializing_if = "Option::is_none")]
7341    pub snapshot: Option<String>,
7342    pub tokens: StepFinishPartTokens,
7343    #[serde(rename = "type", default, skip_serializing)]
7344    pub type_: String,
7345}
7346
7347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7348pub struct StepFinishPartTokens {
7349    pub cache: SessionNextStepEndedDataTokensCache,
7350    pub input: f64,
7351    pub output: f64,
7352    pub reasoning: f64,
7353    #[serde(default, skip_serializing_if = "Option::is_none")]
7354    pub total: Option<f64>,
7355}
7356
7357#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7358pub struct StepStartPart {
7359    pub id: String,
7360    #[serde(rename = "messageID")]
7361    pub message_id: String,
7362    #[serde(rename = "sessionID")]
7363    pub session_id: String,
7364    #[serde(default, skip_serializing_if = "Option::is_none")]
7365    pub snapshot: Option<String>,
7366    #[serde(rename = "type", default, skip_serializing)]
7367    pub type_: String,
7368}
7369
7370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7371pub struct StructuredOutputError {
7372    pub data: StructuredOutputErrorData,
7373    #[serde(default, skip_serializing)]
7374    pub name: String,
7375}
7376
7377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7378pub struct StructuredOutputErrorData {
7379    pub message: String,
7380    pub retries: u64,
7381}
7382
7383#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7384pub struct SubtaskPart {
7385    pub agent: String,
7386    #[serde(default, skip_serializing_if = "Option::is_none")]
7387    pub command: Option<String>,
7388    pub description: String,
7389    pub id: String,
7390    #[serde(rename = "messageID")]
7391    pub message_id: String,
7392    #[serde(default, skip_serializing_if = "Option::is_none")]
7393    pub model: Option<SubtaskPartInputModel>,
7394    pub prompt: String,
7395    #[serde(rename = "sessionID")]
7396    pub session_id: String,
7397    #[serde(rename = "type", default, skip_serializing)]
7398    pub type_: String,
7399}
7400
7401#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7402pub struct SubtaskPartInput {
7403    pub agent: String,
7404    #[serde(default, skip_serializing_if = "Option::is_none")]
7405    pub command: Option<String>,
7406    pub description: String,
7407    #[serde(default, skip_serializing_if = "Option::is_none")]
7408    pub id: Option<String>,
7409    #[serde(default, skip_serializing_if = "Option::is_none")]
7410    pub model: Option<SubtaskPartInputModel>,
7411    pub prompt: String,
7412    #[serde(rename = "type", default, skip_serializing)]
7413    pub type_: String,
7414}
7415
7416#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7417pub struct SubtaskPartInputModel {
7418    #[serde(rename = "modelID")]
7419    pub model_id: String,
7420    #[serde(rename = "providerID")]
7421    pub provider_id: String,
7422}
7423
7424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7425pub struct Symbol {
7426    pub kind: u64,
7427    pub location: SymbolLocation,
7428    pub name: String,
7429}
7430
7431#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7432pub struct SymbolLocation {
7433    pub range: Range,
7434    pub uri: String,
7435}
7436
7437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7438pub struct SymbolSource {
7439    pub kind: u64,
7440    pub name: String,
7441    pub path: String,
7442    pub range: Range,
7443    pub text: FilePartSourceText,
7444    #[serde(rename = "type", default, skip_serializing)]
7445    pub type_: String,
7446}
7447
7448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7449pub struct SyncEventMessagePartRemoved {
7450    pub id: String,
7451    #[serde(rename = "syncEvent")]
7452    pub sync_event: SyncEventMessagePartRemovedSyncEvent,
7453    #[serde(rename = "type")]
7454    pub type_: String,
7455}
7456
7457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7458pub struct SyncEventMessagePartRemovedSyncEvent {
7459    #[serde(rename = "aggregateID")]
7460    pub aggregate_id: String,
7461    pub data: MessagePartRemovedData,
7462    pub id: String,
7463    pub seq: f64,
7464    #[serde(rename = "type")]
7465    pub type_: String,
7466}
7467
7468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7469pub struct SyncEventMessagePartUpdated {
7470    pub id: String,
7471    #[serde(rename = "syncEvent")]
7472    pub sync_event: SyncEventMessagePartUpdatedSyncEvent,
7473    #[serde(rename = "type")]
7474    pub type_: String,
7475}
7476
7477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7478pub struct SyncEventMessagePartUpdatedSyncEvent {
7479    #[serde(rename = "aggregateID")]
7480    pub aggregate_id: String,
7481    pub data: MessagePartUpdatedData,
7482    pub id: String,
7483    pub seq: f64,
7484    #[serde(rename = "type")]
7485    pub type_: String,
7486}
7487
7488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7489pub struct SyncEventMessageRemoved {
7490    pub id: String,
7491    #[serde(rename = "syncEvent")]
7492    pub sync_event: SyncEventMessageRemovedSyncEvent,
7493    #[serde(rename = "type")]
7494    pub type_: String,
7495}
7496
7497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7498pub struct SyncEventMessageRemovedSyncEvent {
7499    #[serde(rename = "aggregateID")]
7500    pub aggregate_id: String,
7501    pub data: MessageRemovedData,
7502    pub id: String,
7503    pub seq: f64,
7504    #[serde(rename = "type")]
7505    pub type_: String,
7506}
7507
7508#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7509pub struct SyncEventMessageUpdated {
7510    pub id: String,
7511    #[serde(rename = "syncEvent")]
7512    pub sync_event: SyncEventMessageUpdatedSyncEvent,
7513    #[serde(rename = "type")]
7514    pub type_: String,
7515}
7516
7517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7518pub struct SyncEventMessageUpdatedSyncEvent {
7519    #[serde(rename = "aggregateID")]
7520    pub aggregate_id: String,
7521    pub data: MessageUpdatedData,
7522    pub id: String,
7523    pub seq: f64,
7524    #[serde(rename = "type")]
7525    pub type_: String,
7526}
7527
7528#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7529pub struct SyncEventSessionCreated {
7530    pub id: String,
7531    #[serde(rename = "syncEvent")]
7532    pub sync_event: SyncEventSessionCreatedSyncEvent,
7533    #[serde(rename = "type")]
7534    pub type_: String,
7535}
7536
7537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7538pub struct SyncEventSessionCreatedSyncEvent {
7539    #[serde(rename = "aggregateID")]
7540    pub aggregate_id: String,
7541    pub data: SessionCreatedData,
7542    pub id: String,
7543    pub seq: f64,
7544    #[serde(rename = "type")]
7545    pub type_: String,
7546}
7547
7548#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7549pub struct SyncEventSessionDeleted {
7550    pub id: String,
7551    #[serde(rename = "syncEvent")]
7552    pub sync_event: SyncEventSessionDeletedSyncEvent,
7553    #[serde(rename = "type")]
7554    pub type_: String,
7555}
7556
7557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7558pub struct SyncEventSessionDeletedSyncEvent {
7559    #[serde(rename = "aggregateID")]
7560    pub aggregate_id: String,
7561    pub data: SessionCreatedData,
7562    pub id: String,
7563    pub seq: f64,
7564    #[serde(rename = "type")]
7565    pub type_: String,
7566}
7567
7568#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7569pub struct SyncEventSessionNextAgentSwitched {
7570    pub id: String,
7571    #[serde(rename = "syncEvent")]
7572    pub sync_event: SyncEventSessionNextAgentSwitchedSyncEvent,
7573    #[serde(rename = "type")]
7574    pub type_: String,
7575}
7576
7577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7578pub struct SyncEventSessionNextAgentSwitchedSyncEvent {
7579    #[serde(rename = "aggregateID")]
7580    pub aggregate_id: String,
7581    pub data: SessionNextAgentSwitchedData,
7582    pub id: String,
7583    pub seq: f64,
7584    #[serde(rename = "type")]
7585    pub type_: String,
7586}
7587
7588#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7589pub struct SyncEventSessionNextCompactionEnded {
7590    pub id: String,
7591    #[serde(rename = "syncEvent")]
7592    pub sync_event: SyncEventSessionNextCompactionEndedSyncEvent,
7593    #[serde(rename = "type")]
7594    pub type_: String,
7595}
7596
7597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7598pub struct SyncEventSessionNextCompactionEndedSyncEvent {
7599    #[serde(rename = "aggregateID")]
7600    pub aggregate_id: String,
7601    pub data: SessionNextCompactionEndedData,
7602    pub id: String,
7603    pub seq: f64,
7604    #[serde(rename = "type")]
7605    pub type_: String,
7606}
7607
7608#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7609pub struct SyncEventSessionNextCompactionStarted {
7610    pub id: String,
7611    #[serde(rename = "syncEvent")]
7612    pub sync_event: SyncEventSessionNextCompactionStartedSyncEvent,
7613    #[serde(rename = "type")]
7614    pub type_: String,
7615}
7616
7617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7618pub struct SyncEventSessionNextCompactionStartedSyncEvent {
7619    #[serde(rename = "aggregateID")]
7620    pub aggregate_id: String,
7621    pub data: SessionNextCompactionStartedData,
7622    pub id: String,
7623    pub seq: f64,
7624    #[serde(rename = "type")]
7625    pub type_: String,
7626}
7627
7628#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7629pub struct SyncEventSessionNextContextUpdated {
7630    pub id: String,
7631    #[serde(rename = "syncEvent")]
7632    pub sync_event: SyncEventSessionNextContextUpdatedSyncEvent,
7633    #[serde(rename = "type")]
7634    pub type_: String,
7635}
7636
7637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7638pub struct SyncEventSessionNextContextUpdatedSyncEvent {
7639    #[serde(rename = "aggregateID")]
7640    pub aggregate_id: String,
7641    pub data: SessionNextContextUpdatedData,
7642    pub id: String,
7643    pub seq: f64,
7644    #[serde(rename = "type")]
7645    pub type_: String,
7646}
7647
7648#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7649pub struct SyncEventSessionNextModelSwitched {
7650    pub id: String,
7651    #[serde(rename = "syncEvent")]
7652    pub sync_event: SyncEventSessionNextModelSwitchedSyncEvent,
7653    #[serde(rename = "type")]
7654    pub type_: String,
7655}
7656
7657#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7658pub struct SyncEventSessionNextModelSwitchedSyncEvent {
7659    #[serde(rename = "aggregateID")]
7660    pub aggregate_id: String,
7661    pub data: SessionNextModelSwitchedData,
7662    pub id: String,
7663    pub seq: f64,
7664    #[serde(rename = "type")]
7665    pub type_: String,
7666}
7667
7668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7669pub struct SyncEventSessionNextMoved {
7670    pub id: String,
7671    #[serde(rename = "syncEvent")]
7672    pub sync_event: SyncEventSessionNextMovedSyncEvent,
7673    #[serde(rename = "type")]
7674    pub type_: String,
7675}
7676
7677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7678pub struct SyncEventSessionNextMovedSyncEvent {
7679    #[serde(rename = "aggregateID")]
7680    pub aggregate_id: String,
7681    pub data: SessionNextMovedData,
7682    pub id: String,
7683    pub seq: f64,
7684    #[serde(rename = "type")]
7685    pub type_: String,
7686}
7687
7688#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7689pub struct SyncEventSessionNextPromptAdmitted {
7690    pub id: String,
7691    #[serde(rename = "syncEvent")]
7692    pub sync_event: SyncEventSessionNextPromptAdmittedSyncEvent,
7693    #[serde(rename = "type")]
7694    pub type_: String,
7695}
7696
7697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7698pub struct SyncEventSessionNextPromptAdmittedSyncEvent {
7699    #[serde(rename = "aggregateID")]
7700    pub aggregate_id: String,
7701    pub data: SessionNextPromptedData,
7702    pub id: String,
7703    pub seq: f64,
7704    #[serde(rename = "type")]
7705    pub type_: String,
7706}
7707
7708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7709pub struct SyncEventSessionNextPrompted {
7710    pub id: String,
7711    #[serde(rename = "syncEvent")]
7712    pub sync_event: SyncEventSessionNextPromptedSyncEvent,
7713    #[serde(rename = "type")]
7714    pub type_: String,
7715}
7716
7717#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7718pub struct SyncEventSessionNextPromptedSyncEvent {
7719    #[serde(rename = "aggregateID")]
7720    pub aggregate_id: String,
7721    pub data: SessionNextPromptedData,
7722    pub id: String,
7723    pub seq: f64,
7724    #[serde(rename = "type")]
7725    pub type_: String,
7726}
7727
7728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7729pub struct SyncEventSessionNextReasoningEnded {
7730    pub id: String,
7731    #[serde(rename = "syncEvent")]
7732    pub sync_event: SyncEventSessionNextReasoningEndedSyncEvent,
7733    #[serde(rename = "type")]
7734    pub type_: String,
7735}
7736
7737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7738pub struct SyncEventSessionNextReasoningEndedSyncEvent {
7739    #[serde(rename = "aggregateID")]
7740    pub aggregate_id: String,
7741    pub data: SessionNextReasoningEndedData,
7742    pub id: String,
7743    pub seq: f64,
7744    #[serde(rename = "type")]
7745    pub type_: String,
7746}
7747
7748#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7749pub struct SyncEventSessionNextReasoningStarted {
7750    pub id: String,
7751    #[serde(rename = "syncEvent")]
7752    pub sync_event: SyncEventSessionNextReasoningStartedSyncEvent,
7753    #[serde(rename = "type")]
7754    pub type_: String,
7755}
7756
7757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7758pub struct SyncEventSessionNextReasoningStartedSyncEvent {
7759    #[serde(rename = "aggregateID")]
7760    pub aggregate_id: String,
7761    pub data: SessionNextReasoningStartedData,
7762    pub id: String,
7763    pub seq: f64,
7764    #[serde(rename = "type")]
7765    pub type_: String,
7766}
7767
7768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7769pub struct SyncEventSessionNextRetried {
7770    pub id: String,
7771    #[serde(rename = "syncEvent")]
7772    pub sync_event: SyncEventSessionNextRetriedSyncEvent,
7773    #[serde(rename = "type")]
7774    pub type_: String,
7775}
7776
7777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7778pub struct SyncEventSessionNextRetriedSyncEvent {
7779    #[serde(rename = "aggregateID")]
7780    pub aggregate_id: String,
7781    pub data: SessionNextRetriedData,
7782    pub id: String,
7783    pub seq: f64,
7784    #[serde(rename = "type")]
7785    pub type_: String,
7786}
7787
7788#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7789pub struct SyncEventSessionNextRevertCleared {
7790    pub id: String,
7791    #[serde(rename = "syncEvent")]
7792    pub sync_event: SyncEventSessionNextRevertClearedSyncEvent,
7793    #[serde(rename = "type")]
7794    pub type_: String,
7795}
7796
7797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7798pub struct SyncEventSessionNextRevertClearedSyncEvent {
7799    #[serde(rename = "aggregateID")]
7800    pub aggregate_id: String,
7801    pub data: SessionNextRevertClearedData,
7802    pub id: String,
7803    pub seq: f64,
7804    #[serde(rename = "type")]
7805    pub type_: String,
7806}
7807
7808#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7809pub struct SyncEventSessionNextRevertCommitted {
7810    pub id: String,
7811    #[serde(rename = "syncEvent")]
7812    pub sync_event: SyncEventSessionNextRevertCommittedSyncEvent,
7813    #[serde(rename = "type")]
7814    pub type_: String,
7815}
7816
7817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7818pub struct SyncEventSessionNextRevertCommittedSyncEvent {
7819    #[serde(rename = "aggregateID")]
7820    pub aggregate_id: String,
7821    pub data: SessionNextRevertCommittedData,
7822    pub id: String,
7823    pub seq: f64,
7824    #[serde(rename = "type")]
7825    pub type_: String,
7826}
7827
7828#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7829pub struct SyncEventSessionNextRevertStaged {
7830    pub id: String,
7831    #[serde(rename = "syncEvent")]
7832    pub sync_event: SyncEventSessionNextRevertStagedSyncEvent,
7833    #[serde(rename = "type")]
7834    pub type_: String,
7835}
7836
7837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7838pub struct SyncEventSessionNextRevertStagedSyncEvent {
7839    #[serde(rename = "aggregateID")]
7840    pub aggregate_id: String,
7841    pub data: SessionNextRevertStagedData,
7842    pub id: String,
7843    pub seq: f64,
7844    #[serde(rename = "type")]
7845    pub type_: String,
7846}
7847
7848#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7849pub struct SyncEventSessionNextShellEnded {
7850    pub id: String,
7851    #[serde(rename = "syncEvent")]
7852    pub sync_event: SyncEventSessionNextShellEndedSyncEvent,
7853    #[serde(rename = "type")]
7854    pub type_: String,
7855}
7856
7857#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7858pub struct SyncEventSessionNextShellEndedSyncEvent {
7859    #[serde(rename = "aggregateID")]
7860    pub aggregate_id: String,
7861    pub data: SessionNextShellEndedData,
7862    pub id: String,
7863    pub seq: f64,
7864    #[serde(rename = "type")]
7865    pub type_: String,
7866}
7867
7868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7869pub struct SyncEventSessionNextShellStarted {
7870    pub id: String,
7871    #[serde(rename = "syncEvent")]
7872    pub sync_event: SyncEventSessionNextShellStartedSyncEvent,
7873    #[serde(rename = "type")]
7874    pub type_: String,
7875}
7876
7877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7878pub struct SyncEventSessionNextShellStartedSyncEvent {
7879    #[serde(rename = "aggregateID")]
7880    pub aggregate_id: String,
7881    pub data: SessionNextShellStartedData,
7882    pub id: String,
7883    pub seq: f64,
7884    #[serde(rename = "type")]
7885    pub type_: String,
7886}
7887
7888#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7889pub struct SyncEventSessionNextStepEnded {
7890    pub id: String,
7891    #[serde(rename = "syncEvent")]
7892    pub sync_event: SyncEventSessionNextStepEndedSyncEvent,
7893    #[serde(rename = "type")]
7894    pub type_: String,
7895}
7896
7897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7898pub struct SyncEventSessionNextStepEndedSyncEvent {
7899    #[serde(rename = "aggregateID")]
7900    pub aggregate_id: String,
7901    pub data: SessionNextStepEndedData,
7902    pub id: String,
7903    pub seq: f64,
7904    #[serde(rename = "type")]
7905    pub type_: String,
7906}
7907
7908#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7909pub struct SyncEventSessionNextStepFailed {
7910    pub id: String,
7911    #[serde(rename = "syncEvent")]
7912    pub sync_event: SyncEventSessionNextStepFailedSyncEvent,
7913    #[serde(rename = "type")]
7914    pub type_: String,
7915}
7916
7917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7918pub struct SyncEventSessionNextStepFailedSyncEvent {
7919    #[serde(rename = "aggregateID")]
7920    pub aggregate_id: String,
7921    pub data: SessionNextStepFailedData,
7922    pub id: String,
7923    pub seq: f64,
7924    #[serde(rename = "type")]
7925    pub type_: String,
7926}
7927
7928#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7929pub struct SyncEventSessionNextStepStarted {
7930    pub id: String,
7931    #[serde(rename = "syncEvent")]
7932    pub sync_event: SyncEventSessionNextStepStartedSyncEvent,
7933    #[serde(rename = "type")]
7934    pub type_: String,
7935}
7936
7937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7938pub struct SyncEventSessionNextStepStartedSyncEvent {
7939    #[serde(rename = "aggregateID")]
7940    pub aggregate_id: String,
7941    pub data: SessionNextStepStartedData,
7942    pub id: String,
7943    pub seq: f64,
7944    #[serde(rename = "type")]
7945    pub type_: String,
7946}
7947
7948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7949pub struct SyncEventSessionNextSynthetic {
7950    pub id: String,
7951    #[serde(rename = "syncEvent")]
7952    pub sync_event: SyncEventSessionNextSyntheticSyncEvent,
7953    #[serde(rename = "type")]
7954    pub type_: String,
7955}
7956
7957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7958pub struct SyncEventSessionNextSyntheticSyncEvent {
7959    #[serde(rename = "aggregateID")]
7960    pub aggregate_id: String,
7961    pub data: SessionNextContextUpdatedData,
7962    pub id: String,
7963    pub seq: f64,
7964    #[serde(rename = "type")]
7965    pub type_: String,
7966}
7967
7968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7969pub struct SyncEventSessionNextTextEnded {
7970    pub id: String,
7971    #[serde(rename = "syncEvent")]
7972    pub sync_event: SyncEventSessionNextTextEndedSyncEvent,
7973    #[serde(rename = "type")]
7974    pub type_: String,
7975}
7976
7977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7978pub struct SyncEventSessionNextTextEndedSyncEvent {
7979    #[serde(rename = "aggregateID")]
7980    pub aggregate_id: String,
7981    pub data: SessionNextTextEndedData,
7982    pub id: String,
7983    pub seq: f64,
7984    #[serde(rename = "type")]
7985    pub type_: String,
7986}
7987
7988#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7989pub struct SyncEventSessionNextTextStarted {
7990    pub id: String,
7991    #[serde(rename = "syncEvent")]
7992    pub sync_event: SyncEventSessionNextTextStartedSyncEvent,
7993    #[serde(rename = "type")]
7994    pub type_: String,
7995}
7996
7997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7998pub struct SyncEventSessionNextTextStartedSyncEvent {
7999    #[serde(rename = "aggregateID")]
8000    pub aggregate_id: String,
8001    pub data: SessionNextTextStartedData,
8002    pub id: String,
8003    pub seq: f64,
8004    #[serde(rename = "type")]
8005    pub type_: String,
8006}
8007
8008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8009pub struct SyncEventSessionNextToolCalled {
8010    pub id: String,
8011    #[serde(rename = "syncEvent")]
8012    pub sync_event: SyncEventSessionNextToolCalledSyncEvent,
8013    #[serde(rename = "type")]
8014    pub type_: String,
8015}
8016
8017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8018pub struct SyncEventSessionNextToolCalledSyncEvent {
8019    #[serde(rename = "aggregateID")]
8020    pub aggregate_id: String,
8021    pub data: SessionNextToolCalledData,
8022    pub id: String,
8023    pub seq: f64,
8024    #[serde(rename = "type")]
8025    pub type_: String,
8026}
8027
8028#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8029pub struct SyncEventSessionNextToolFailed {
8030    pub id: String,
8031    #[serde(rename = "syncEvent")]
8032    pub sync_event: SyncEventSessionNextToolFailedSyncEvent,
8033    #[serde(rename = "type")]
8034    pub type_: String,
8035}
8036
8037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8038pub struct SyncEventSessionNextToolFailedSyncEvent {
8039    #[serde(rename = "aggregateID")]
8040    pub aggregate_id: String,
8041    pub data: SessionNextToolFailedData,
8042    pub id: String,
8043    pub seq: f64,
8044    #[serde(rename = "type")]
8045    pub type_: String,
8046}
8047
8048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8049pub struct SyncEventSessionNextToolInputEnded {
8050    pub id: String,
8051    #[serde(rename = "syncEvent")]
8052    pub sync_event: SyncEventSessionNextToolInputEndedSyncEvent,
8053    #[serde(rename = "type")]
8054    pub type_: String,
8055}
8056
8057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8058pub struct SyncEventSessionNextToolInputEndedSyncEvent {
8059    #[serde(rename = "aggregateID")]
8060    pub aggregate_id: String,
8061    pub data: SessionNextToolInputEndedData,
8062    pub id: String,
8063    pub seq: f64,
8064    #[serde(rename = "type")]
8065    pub type_: String,
8066}
8067
8068#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8069pub struct SyncEventSessionNextToolInputStarted {
8070    pub id: String,
8071    #[serde(rename = "syncEvent")]
8072    pub sync_event: SyncEventSessionNextToolInputStartedSyncEvent,
8073    #[serde(rename = "type")]
8074    pub type_: String,
8075}
8076
8077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8078pub struct SyncEventSessionNextToolInputStartedSyncEvent {
8079    #[serde(rename = "aggregateID")]
8080    pub aggregate_id: String,
8081    pub data: SessionNextToolInputStartedData,
8082    pub id: String,
8083    pub seq: f64,
8084    #[serde(rename = "type")]
8085    pub type_: String,
8086}
8087
8088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8089pub struct SyncEventSessionNextToolProgress {
8090    pub id: String,
8091    #[serde(rename = "syncEvent")]
8092    pub sync_event: SyncEventSessionNextToolProgressSyncEvent,
8093    #[serde(rename = "type")]
8094    pub type_: String,
8095}
8096
8097#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8098pub struct SyncEventSessionNextToolProgressSyncEvent {
8099    #[serde(rename = "aggregateID")]
8100    pub aggregate_id: String,
8101    pub data: SessionNextToolProgressData,
8102    pub id: String,
8103    pub seq: f64,
8104    #[serde(rename = "type")]
8105    pub type_: String,
8106}
8107
8108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8109pub struct SyncEventSessionNextToolSuccess {
8110    pub id: String,
8111    #[serde(rename = "syncEvent")]
8112    pub sync_event: SyncEventSessionNextToolSuccessSyncEvent,
8113    #[serde(rename = "type")]
8114    pub type_: String,
8115}
8116
8117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8118pub struct SyncEventSessionNextToolSuccessSyncEvent {
8119    #[serde(rename = "aggregateID")]
8120    pub aggregate_id: String,
8121    pub data: SessionNextToolSuccessData,
8122    pub id: String,
8123    pub seq: f64,
8124    #[serde(rename = "type")]
8125    pub type_: String,
8126}
8127
8128#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8129pub struct SyncEventSessionUpdated {
8130    pub id: String,
8131    #[serde(rename = "syncEvent")]
8132    pub sync_event: SyncEventSessionUpdatedSyncEvent,
8133    #[serde(rename = "type")]
8134    pub type_: String,
8135}
8136
8137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8138pub struct SyncEventSessionUpdatedSyncEvent {
8139    #[serde(rename = "aggregateID")]
8140    pub aggregate_id: String,
8141    pub data: SessionCreatedData,
8142    pub id: String,
8143    pub seq: f64,
8144    #[serde(rename = "type")]
8145    pub type_: String,
8146}
8147
8148#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8149pub struct TextPart {
8150    pub id: String,
8151    #[serde(default, skip_serializing_if = "Option::is_none")]
8152    pub ignored: Option<bool>,
8153    #[serde(rename = "messageID")]
8154    pub message_id: String,
8155    #[serde(default, skip_serializing_if = "Option::is_none")]
8156    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8157    #[serde(rename = "sessionID")]
8158    pub session_id: String,
8159    #[serde(default, skip_serializing_if = "Option::is_none")]
8160    pub synthetic: Option<bool>,
8161    pub text: String,
8162    #[serde(default, skip_serializing_if = "Option::is_none")]
8163    pub time: Option<TextPartInputTime>,
8164    #[serde(rename = "type", default, skip_serializing)]
8165    pub type_: String,
8166}
8167
8168#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
8169pub struct TextPartInput {
8170    #[serde(default, skip_serializing_if = "Option::is_none")]
8171    pub id: Option<String>,
8172    #[serde(default, skip_serializing_if = "Option::is_none")]
8173    pub ignored: Option<bool>,
8174    #[serde(default, skip_serializing_if = "Option::is_none")]
8175    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8176    #[serde(default, skip_serializing_if = "Option::is_none")]
8177    pub synthetic: Option<bool>,
8178    pub text: String,
8179    #[serde(default, skip_serializing_if = "Option::is_none")]
8180    pub time: Option<TextPartInputTime>,
8181    #[serde(rename = "type", default, skip_serializing)]
8182    pub type_: String,
8183}
8184
8185#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8186pub struct TextPartInputTime {
8187    #[serde(default, skip_serializing_if = "Option::is_none")]
8188    pub end: Option<u64>,
8189    pub start: u64,
8190}
8191
8192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8193pub struct Todo {
8194    pub content: String,
8195    pub priority: String,
8196    pub status: String,
8197}
8198
8199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8200pub struct TodoUpdated {
8201    pub data: TodoUpdatedData,
8202    #[serde(default, skip_serializing_if = "Option::is_none")]
8203    pub durable: Option<SessionStatus2Durable>,
8204    pub id: String,
8205    #[serde(default, skip_serializing_if = "Option::is_none")]
8206    pub location: Option<LocationRef>,
8207    #[serde(default, skip_serializing_if = "Option::is_none")]
8208    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8209    #[serde(rename = "type", default, skip_serializing)]
8210    pub type_: String,
8211}
8212
8213#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8214pub struct TodoUpdatedData {
8215    #[serde(rename = "sessionID")]
8216    pub session_id: String,
8217    pub todos: Vec<Todo>,
8218}
8219
8220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8221pub struct ToolFileContent {
8222    pub mime: String,
8223    #[serde(default, skip_serializing_if = "Option::is_none")]
8224    pub name: Option<String>,
8225    #[serde(rename = "type", default, skip_serializing)]
8226    pub type_: String,
8227    pub uri: String,
8228}
8229
8230pub type ToolIDs = Vec<String>;
8231
8232pub type ToolList = Vec<ToolListItem>;
8233
8234#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8235pub struct ToolListItem {
8236    pub description: String,
8237    pub id: String,
8238    pub parameters: serde_json::Value,
8239}
8240
8241#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8242pub struct ToolPart {
8243    #[serde(rename = "callID")]
8244    pub call_id: String,
8245    pub id: String,
8246    #[serde(rename = "messageID")]
8247    pub message_id: String,
8248    #[serde(default, skip_serializing_if = "Option::is_none")]
8249    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8250    #[serde(rename = "sessionID")]
8251    pub session_id: String,
8252    pub state: ToolState,
8253    pub tool: String,
8254    #[serde(rename = "type", default, skip_serializing)]
8255    pub type_: String,
8256}
8257
8258#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8259#[serde(tag = "status")]
8260pub enum ToolState {
8261    #[serde(rename = "pending")]
8262    Pending(ToolStatePending),
8263    #[serde(rename = "running")]
8264    Running(ToolStateRunning),
8265    #[serde(rename = "completed")]
8266    Completed(ToolStateCompleted),
8267    #[serde(rename = "error")]
8268    Error(ToolStateError),
8269}
8270
8271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8272pub struct ToolStateCompleted {
8273    #[serde(default, skip_serializing_if = "Option::is_none")]
8274    pub attachments: Option<Vec<FilePart>>,
8275    pub input: serde_json::Map<String, serde_json::Value>,
8276    pub metadata: serde_json::Map<String, serde_json::Value>,
8277    pub output: String,
8278    #[serde(default, skip_serializing)]
8279    pub status: String,
8280    pub time: ToolStateCompletedTime,
8281    pub title: String,
8282}
8283
8284#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8285pub struct ToolStateCompletedTime {
8286    #[serde(default, skip_serializing_if = "Option::is_none")]
8287    pub compacted: Option<u64>,
8288    pub end: u64,
8289    pub start: u64,
8290}
8291
8292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8293pub struct ToolStateError {
8294    pub error: String,
8295    pub input: serde_json::Map<String, serde_json::Value>,
8296    #[serde(default, skip_serializing_if = "Option::is_none")]
8297    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8298    #[serde(default, skip_serializing)]
8299    pub status: String,
8300    pub time: ToolStateErrorTime,
8301}
8302
8303#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8304pub struct ToolStateErrorTime {
8305    pub end: u64,
8306    pub start: u64,
8307}
8308
8309#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8310pub struct ToolStatePending {
8311    pub input: serde_json::Map<String, serde_json::Value>,
8312    pub raw: String,
8313    #[serde(default, skip_serializing)]
8314    pub status: String,
8315}
8316
8317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8318pub struct ToolStateRunning {
8319    pub input: serde_json::Map<String, serde_json::Value>,
8320    #[serde(default, skip_serializing_if = "Option::is_none")]
8321    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8322    #[serde(default, skip_serializing)]
8323    pub status: String,
8324    pub time: ToolStateRunningTime,
8325    #[serde(default, skip_serializing_if = "Option::is_none")]
8326    pub title: Option<String>,
8327}
8328
8329#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8330pub struct ToolStateRunningTime {
8331    pub start: u64,
8332}
8333
8334#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8335pub struct ToolTextContent {
8336    pub text: String,
8337    #[serde(rename = "type", default, skip_serializing)]
8338    pub type_: String,
8339}
8340
8341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8342pub struct TuiCommandExecute {
8343    pub data: TuiCommandExecuteData,
8344    #[serde(default, skip_serializing_if = "Option::is_none")]
8345    pub durable: Option<SessionStatus2Durable>,
8346    pub id: String,
8347    #[serde(default, skip_serializing_if = "Option::is_none")]
8348    pub location: Option<LocationRef>,
8349    #[serde(default, skip_serializing_if = "Option::is_none")]
8350    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8351    #[serde(rename = "type", default, skip_serializing)]
8352    pub type_: String,
8353}
8354
8355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8356pub struct TuiCommandExecuteData {
8357    pub command: TuiCommandExecuteDataCommand,
8358}
8359
8360#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8361pub enum TuiCommandExecuteDataCommand {
8362    SessionList,
8363    SessionNew,
8364    SessionShare,
8365    SessionInterrupt,
8366    SessionCompact,
8367    SessionPageUp,
8368    SessionPageDown,
8369    SessionLineUp,
8370    SessionLineDown,
8371    SessionHalfPageUp,
8372    SessionHalfPageDown,
8373    SessionFirst,
8374    SessionLast,
8375    PromptClear,
8376    PromptSubmit,
8377    AgentCycle,
8378    Unknown(String),
8379}
8380
8381impl TuiCommandExecuteDataCommand {
8382    pub fn as_str(&self) -> &str {
8383        match self {
8384            Self::SessionList => "session.list",
8385            Self::SessionNew => "session.new",
8386            Self::SessionShare => "session.share",
8387            Self::SessionInterrupt => "session.interrupt",
8388            Self::SessionCompact => "session.compact",
8389            Self::SessionPageUp => "session.page.up",
8390            Self::SessionPageDown => "session.page.down",
8391            Self::SessionLineUp => "session.line.up",
8392            Self::SessionLineDown => "session.line.down",
8393            Self::SessionHalfPageUp => "session.half.page.up",
8394            Self::SessionHalfPageDown => "session.half.page.down",
8395            Self::SessionFirst => "session.first",
8396            Self::SessionLast => "session.last",
8397            Self::PromptClear => "prompt.clear",
8398            Self::PromptSubmit => "prompt.submit",
8399            Self::AgentCycle => "agent.cycle",
8400            Self::Unknown(s) => s.as_str(),
8401        }
8402    }
8403}
8404
8405impl std::fmt::Display for TuiCommandExecuteDataCommand {
8406    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8407        f.write_str(self.as_str())
8408    }
8409}
8410
8411impl From<&str> for TuiCommandExecuteDataCommand {
8412    fn from(s: &str) -> Self {
8413        match s {
8414            "session.list" => Self::SessionList,
8415            "session.new" => Self::SessionNew,
8416            "session.share" => Self::SessionShare,
8417            "session.interrupt" => Self::SessionInterrupt,
8418            "session.compact" => Self::SessionCompact,
8419            "session.page.up" => Self::SessionPageUp,
8420            "session.page.down" => Self::SessionPageDown,
8421            "session.line.up" => Self::SessionLineUp,
8422            "session.line.down" => Self::SessionLineDown,
8423            "session.half.page.up" => Self::SessionHalfPageUp,
8424            "session.half.page.down" => Self::SessionHalfPageDown,
8425            "session.first" => Self::SessionFirst,
8426            "session.last" => Self::SessionLast,
8427            "prompt.clear" => Self::PromptClear,
8428            "prompt.submit" => Self::PromptSubmit,
8429            "agent.cycle" => Self::AgentCycle,
8430            other => Self::Unknown(other.to_string()),
8431        }
8432    }
8433}
8434
8435impl Serialize for TuiCommandExecuteDataCommand {
8436    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
8437        serializer.serialize_str(self.as_str())
8438    }
8439}
8440
8441impl<'de> Deserialize<'de> for TuiCommandExecuteDataCommand {
8442    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
8443        let s = String::deserialize(deserializer)?;
8444        Ok(Self::from(s.as_str()))
8445    }
8446}
8447
8448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8449pub struct TuiPromptAppend {
8450    pub data: TuiPromptAppendData,
8451    #[serde(default, skip_serializing_if = "Option::is_none")]
8452    pub durable: Option<SessionStatus2Durable>,
8453    pub id: String,
8454    #[serde(default, skip_serializing_if = "Option::is_none")]
8455    pub location: Option<LocationRef>,
8456    #[serde(default, skip_serializing_if = "Option::is_none")]
8457    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8458    #[serde(rename = "type", default, skip_serializing)]
8459    pub type_: String,
8460}
8461
8462#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8463pub struct TuiPromptAppendData {
8464    pub text: String,
8465}
8466
8467#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8468pub struct TuiSessionSelect {
8469    pub data: TuiSessionSelectData,
8470    #[serde(default, skip_serializing_if = "Option::is_none")]
8471    pub durable: Option<SessionStatus2Durable>,
8472    pub id: String,
8473    #[serde(default, skip_serializing_if = "Option::is_none")]
8474    pub location: Option<LocationRef>,
8475    #[serde(default, skip_serializing_if = "Option::is_none")]
8476    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8477    #[serde(rename = "type", default, skip_serializing)]
8478    pub type_: String,
8479}
8480
8481#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8482pub struct TuiSessionSelectData {
8483    #[serde(rename = "sessionID")]
8484    pub session_id: String,
8485}
8486
8487#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8488pub struct TuiToastShow {
8489    pub data: TuiToastShowData,
8490    #[serde(default, skip_serializing_if = "Option::is_none")]
8491    pub durable: Option<SessionStatus2Durable>,
8492    pub id: String,
8493    #[serde(default, skip_serializing_if = "Option::is_none")]
8494    pub location: Option<LocationRef>,
8495    #[serde(default, skip_serializing_if = "Option::is_none")]
8496    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8497    #[serde(rename = "type", default, skip_serializing)]
8498    pub type_: String,
8499}
8500
8501#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8502pub struct TuiToastShowData {
8503    #[serde(default, skip_serializing_if = "Option::is_none")]
8504    pub duration: Option<i64>,
8505    pub message: String,
8506    #[serde(default, skip_serializing_if = "Option::is_none")]
8507    pub title: Option<String>,
8508    pub variant: String,
8509}
8510
8511#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8512pub struct UnauthorizedError {
8513    pub _tag: String,
8514    pub message: String,
8515}
8516
8517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8518pub struct UnknownError {
8519    pub data: UnknownErrorData,
8520    #[serde(default, skip_serializing)]
8521    pub name: String,
8522}
8523
8524#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8525pub struct UnknownError1 {
8526    pub _tag: String,
8527    pub message: String,
8528    #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
8529    pub ref_: Option<String>,
8530}
8531
8532#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8533pub struct UnknownErrorData {
8534    pub message: String,
8535    #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
8536    pub ref_: Option<String>,
8537}
8538
8539#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8540pub struct UserMessage {
8541    pub agent: String,
8542    #[serde(default, skip_serializing_if = "Option::is_none")]
8543    pub format: Option<OutputFormat>,
8544    pub id: String,
8545    pub model: UserMessageModel,
8546    #[serde(default, skip_serializing)]
8547    pub role: String,
8548    #[serde(rename = "sessionID")]
8549    pub session_id: String,
8550    #[serde(default, skip_serializing_if = "Option::is_none")]
8551    pub summary: Option<UserMessageSummary>,
8552    #[serde(default, skip_serializing_if = "Option::is_none")]
8553    pub system: Option<String>,
8554    pub time: UserMessageTime,
8555    #[serde(default, skip_serializing_if = "Option::is_none")]
8556    pub tools: Option<std::collections::BTreeMap<String, bool>>,
8557}
8558
8559#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8560pub struct UserMessageModel {
8561    #[serde(rename = "modelID")]
8562    pub model_id: String,
8563    #[serde(rename = "providerID")]
8564    pub provider_id: String,
8565    #[serde(default, skip_serializing_if = "Option::is_none")]
8566    pub variant: Option<String>,
8567}
8568
8569#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8570pub struct UserMessageSummary {
8571    #[serde(default, skip_serializing_if = "Option::is_none")]
8572    pub body: Option<String>,
8573    pub diffs: Vec<SnapshotFileDiff>,
8574    #[serde(default, skip_serializing_if = "Option::is_none")]
8575    pub title: Option<String>,
8576}
8577
8578#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8579pub struct UserMessageTime {
8580    pub created: f64,
8581}
8582
8583#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8584#[serde(tag = "type")]
8585pub enum V2Event {
8586    #[serde(rename = "models-dev.refreshed")]
8587    ModelsDevRefreshed(ModelsDevRefreshed),
8588    #[serde(rename = "integration.updated")]
8589    IntegrationUpdated(IntegrationUpdated),
8590    #[serde(rename = "integration.connection.updated")]
8591    IntegrationConnectionUpdated(IntegrationConnectionUpdated),
8592    #[serde(rename = "catalog.updated")]
8593    CatalogUpdated(CatalogUpdated),
8594    #[serde(rename = "session.created")]
8595    SessionCreated(SessionCreated),
8596    #[serde(rename = "session.updated")]
8597    SessionUpdated(SessionUpdated),
8598    #[serde(rename = "session.deleted")]
8599    SessionDeleted(SessionDeleted),
8600    #[serde(rename = "message.updated")]
8601    MessageUpdated(MessageUpdated),
8602    #[serde(rename = "message.removed")]
8603    MessageRemoved(MessageRemoved),
8604    #[serde(rename = "message.part.updated")]
8605    MessagePartUpdated(MessagePartUpdated),
8606    #[serde(rename = "message.part.removed")]
8607    MessagePartRemoved(MessagePartRemoved),
8608    #[serde(rename = "session.next.agent.switched")]
8609    SessionNextAgentSwitched(SessionNextAgentSwitched),
8610    #[serde(rename = "session.next.model.switched")]
8611    SessionNextModelSwitched(SessionNextModelSwitched),
8612    #[serde(rename = "session.next.moved")]
8613    SessionNextMoved(SessionNextMoved),
8614    #[serde(rename = "session.next.prompted")]
8615    SessionNextPrompted(SessionNextPrompted),
8616    #[serde(rename = "session.next.prompt.admitted")]
8617    SessionNextPromptAdmitted(SessionNextPromptAdmitted),
8618    #[serde(rename = "session.next.context.updated")]
8619    SessionNextContextUpdated(SessionNextContextUpdated),
8620    #[serde(rename = "session.next.synthetic")]
8621    SessionNextSynthetic(SessionNextSynthetic),
8622    #[serde(rename = "session.next.shell.started")]
8623    SessionNextShellStarted(SessionNextShellStarted),
8624    #[serde(rename = "session.next.shell.ended")]
8625    SessionNextShellEnded(SessionNextShellEnded),
8626    #[serde(rename = "session.next.step.started")]
8627    SessionNextStepStarted(SessionNextStepStarted),
8628    #[serde(rename = "session.next.step.ended")]
8629    SessionNextStepEnded(SessionNextStepEnded),
8630    #[serde(rename = "session.next.step.failed")]
8631    SessionNextStepFailed(SessionNextStepFailed),
8632    #[serde(rename = "session.next.text.started")]
8633    SessionNextTextStarted(SessionNextTextStarted),
8634    #[serde(rename = "session.next.text.delta")]
8635    SessionNextTextDelta(SessionNextTextDelta),
8636    #[serde(rename = "session.next.text.ended")]
8637    SessionNextTextEnded(SessionNextTextEnded),
8638    #[serde(rename = "session.next.reasoning.started")]
8639    SessionNextReasoningStarted(SessionNextReasoningStarted),
8640    #[serde(rename = "session.next.reasoning.delta")]
8641    SessionNextReasoningDelta(SessionNextReasoningDelta),
8642    #[serde(rename = "session.next.reasoning.ended")]
8643    SessionNextReasoningEnded(SessionNextReasoningEnded),
8644    #[serde(rename = "session.next.tool.input.started")]
8645    SessionNextToolInputStarted(SessionNextToolInputStarted),
8646    #[serde(rename = "session.next.tool.input.delta")]
8647    SessionNextToolInputDelta(SessionNextToolInputDelta),
8648    #[serde(rename = "session.next.tool.input.ended")]
8649    SessionNextToolInputEnded(SessionNextToolInputEnded),
8650    #[serde(rename = "session.next.tool.called")]
8651    SessionNextToolCalled(SessionNextToolCalled),
8652    #[serde(rename = "session.next.tool.progress")]
8653    SessionNextToolProgress(SessionNextToolProgress),
8654    #[serde(rename = "session.next.tool.success")]
8655    SessionNextToolSuccess(SessionNextToolSuccess),
8656    #[serde(rename = "session.next.tool.failed")]
8657    SessionNextToolFailed(SessionNextToolFailed),
8658    #[serde(rename = "session.next.retried")]
8659    SessionNextRetried(SessionNextRetried),
8660    #[serde(rename = "session.next.compaction.started")]
8661    SessionNextCompactionStarted(SessionNextCompactionStarted),
8662    #[serde(rename = "session.next.compaction.delta")]
8663    SessionNextCompactionDelta(SessionNextCompactionDelta),
8664    #[serde(rename = "session.next.compaction.ended")]
8665    SessionNextCompactionEnded(SessionNextCompactionEnded),
8666    #[serde(rename = "session.next.revert.staged")]
8667    SessionNextRevertStaged(SessionNextRevertStaged),
8668    #[serde(rename = "session.next.revert.cleared")]
8669    SessionNextRevertCleared(SessionNextRevertCleared),
8670    #[serde(rename = "session.next.revert.committed")]
8671    SessionNextRevertCommitted(SessionNextRevertCommitted),
8672    #[serde(rename = "message.part.delta")]
8673    MessagePartDelta(MessagePartDelta),
8674    #[serde(rename = "session.diff")]
8675    SessionDiff(SessionDiff),
8676    #[serde(rename = "session.error")]
8677    SessionError(SessionError),
8678    #[serde(rename = "installation.updated")]
8679    InstallationUpdated(InstallationUpdated),
8680    #[serde(rename = "installation.update-available")]
8681    InstallationUpdateAvailable(InstallationUpdateAvailable),
8682    #[serde(rename = "file.edited")]
8683    FileEdited(FileEdited),
8684    #[serde(rename = "reference.updated")]
8685    ReferenceUpdated(ReferenceUpdated),
8686    #[serde(rename = "permission.v2.asked")]
8687    PermissionV2Asked(PermissionV2Asked),
8688    #[serde(rename = "permission.v2.replied")]
8689    PermissionV2Replied(PermissionV2Replied),
8690    #[serde(rename = "plugin.added")]
8691    PluginAdded(PluginAdded),
8692    #[serde(rename = "project.directories.updated")]
8693    ProjectDirectoriesUpdated(ProjectDirectoriesUpdated),
8694    #[serde(rename = "file.watcher.updated")]
8695    FileWatcherUpdated(FileWatcherUpdated),
8696    #[serde(rename = "pty.created")]
8697    PtyCreated(PtyCreated),
8698    #[serde(rename = "pty.updated")]
8699    PtyUpdated(PtyUpdated),
8700    #[serde(rename = "pty.exited")]
8701    PtyExited(PtyExited),
8702    #[serde(rename = "pty.deleted")]
8703    PtyDeleted(PtyDeleted),
8704    #[serde(rename = "question.v2.asked")]
8705    QuestionV2Asked(QuestionV2Asked),
8706    #[serde(rename = "question.v2.replied")]
8707    QuestionV2Replied(QuestionV2Replied),
8708    #[serde(rename = "question.v2.rejected")]
8709    QuestionV2Rejected(QuestionV2Rejected),
8710    #[serde(rename = "todo.updated")]
8711    TodoUpdated(TodoUpdated),
8712    #[serde(rename = "lsp.updated")]
8713    LspUpdated(LspUpdated),
8714    #[serde(rename = "permission.asked")]
8715    PermissionAsked(PermissionAsked),
8716    #[serde(rename = "permission.replied")]
8717    PermissionReplied(PermissionReplied),
8718    #[serde(rename = "tui.prompt.append")]
8719    TuiPromptAppend(TuiPromptAppend),
8720    #[serde(rename = "tui.command.execute")]
8721    TuiCommandExecute(TuiCommandExecute),
8722    #[serde(rename = "tui.toast.show")]
8723    TuiToastShow(TuiToastShow),
8724    #[serde(rename = "tui.session.select")]
8725    TuiSessionSelect(TuiSessionSelect),
8726    #[serde(rename = "mcp.tools.changed")]
8727    McpToolsChanged(McpToolsChanged),
8728    #[serde(rename = "mcp.browser.open.failed")]
8729    McpBrowserOpenFailed(McpBrowserOpenFailed),
8730    #[serde(rename = "command.executed")]
8731    CommandExecuted(CommandExecuted),
8732    #[serde(rename = "project.updated")]
8733    ProjectUpdated(ProjectUpdated),
8734    #[serde(rename = "session.status")]
8735    SessionStatus(SessionStatus2),
8736    #[serde(rename = "session.idle")]
8737    SessionIdle(SessionIdle),
8738    #[serde(rename = "question.asked")]
8739    QuestionAsked(QuestionAsked),
8740    #[serde(rename = "question.replied")]
8741    QuestionReplied(QuestionReplied2),
8742    #[serde(rename = "question.rejected")]
8743    QuestionRejected(QuestionRejected2),
8744    #[serde(rename = "session.compacted")]
8745    SessionCompacted(SessionCompacted),
8746    #[serde(rename = "vcs.branch.updated")]
8747    VcsBranchUpdated(VcsBranchUpdated),
8748    #[serde(rename = "workspace.ready")]
8749    WorkspaceReady(WorkspaceReady),
8750    #[serde(rename = "workspace.failed")]
8751    WorkspaceFailed(WorkspaceFailed),
8752    #[serde(rename = "workspace.status")]
8753    WorkspaceStatus(WorkspaceStatus),
8754    #[serde(rename = "worktree.ready")]
8755    WorktreeReady(WorktreeReady),
8756    #[serde(rename = "worktree.failed")]
8757    WorktreeFailed(WorktreeFailed),
8758    #[serde(rename = "server.connected")]
8759    ServerConnected(ServerConnected),
8760    #[serde(rename = "global.disposed")]
8761    GlobalDisposed(GlobalDisposed),
8762}
8763
8764#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
8765#[serde(transparent)]
8766pub struct V2EventStream(pub String);
8767
8768#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8769pub struct VcsApplyError {
8770    pub data: VcsApplyErrorData,
8771    pub name: String,
8772}
8773
8774#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8775pub struct VcsApplyErrorData {
8776    pub message: String,
8777    pub reason: String,
8778}
8779
8780#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8781pub struct VcsBranchUpdated {
8782    pub data: VcsBranchUpdatedData,
8783    #[serde(default, skip_serializing_if = "Option::is_none")]
8784    pub durable: Option<SessionStatus2Durable>,
8785    pub id: String,
8786    #[serde(default, skip_serializing_if = "Option::is_none")]
8787    pub location: Option<LocationRef>,
8788    #[serde(default, skip_serializing_if = "Option::is_none")]
8789    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8790    #[serde(rename = "type", default, skip_serializing)]
8791    pub type_: String,
8792}
8793
8794#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8795pub struct VcsBranchUpdatedData {
8796    #[serde(default, skip_serializing_if = "Option::is_none")]
8797    pub branch: Option<String>,
8798}
8799
8800#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8801pub struct VcsFileDiff {
8802    pub additions: f64,
8803    pub deletions: f64,
8804    pub file: String,
8805    #[serde(default, skip_serializing_if = "Option::is_none")]
8806    pub patch: Option<String>,
8807    #[serde(default, skip_serializing_if = "Option::is_none")]
8808    pub status: Option<String>,
8809}
8810
8811#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8812pub struct VcsFileStatus {
8813    pub additions: f64,
8814    pub deletions: f64,
8815    pub file: String,
8816    pub status: String,
8817}
8818
8819#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8820pub struct VcsInfo {
8821    #[serde(default, skip_serializing_if = "Option::is_none")]
8822    pub branch: Option<String>,
8823    #[serde(default, skip_serializing_if = "Option::is_none")]
8824    pub default_branch: Option<String>,
8825}
8826
8827#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8828pub struct WellKnownAuth {
8829    pub key: String,
8830    pub token: String,
8831    #[serde(rename = "type", default, skip_serializing)]
8832    pub type_: String,
8833}
8834
8835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8836pub struct Workspace {
8837    #[serde(default, skip_serializing_if = "Option::is_none")]
8838    pub branch: Option<String>,
8839    #[serde(default, skip_serializing_if = "Option::is_none")]
8840    pub directory: Option<String>,
8841    #[serde(default, skip_serializing_if = "Option::is_none")]
8842    pub extra: Option<serde_json::Value>,
8843    pub id: String,
8844    pub name: String,
8845    #[serde(rename = "projectID")]
8846    pub project_id: String,
8847    #[serde(rename = "timeUsed")]
8848    pub time_used: WorkspaceTimeUsed,
8849    #[serde(rename = "type")]
8850    pub type_: String,
8851}
8852
8853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8854pub struct WorkspaceCreateError {
8855    pub data: WorktreeFailedData,
8856    pub name: String,
8857}
8858
8859#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8860pub struct WorkspaceEventConnectionStatus {
8861    pub status: String,
8862    #[serde(rename = "workspaceID")]
8863    pub workspace_id: String,
8864}
8865
8866#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8867pub struct WorkspaceFailed {
8868    pub data: WorktreeFailedData,
8869    #[serde(default, skip_serializing_if = "Option::is_none")]
8870    pub durable: Option<SessionStatus2Durable>,
8871    pub id: String,
8872    #[serde(default, skip_serializing_if = "Option::is_none")]
8873    pub location: Option<LocationRef>,
8874    #[serde(default, skip_serializing_if = "Option::is_none")]
8875    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8876    #[serde(rename = "type", default, skip_serializing)]
8877    pub type_: String,
8878}
8879
8880#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8881pub struct WorkspaceReady {
8882    pub data: WorkspaceReadyData,
8883    #[serde(default, skip_serializing_if = "Option::is_none")]
8884    pub durable: Option<SessionStatus2Durable>,
8885    pub id: String,
8886    #[serde(default, skip_serializing_if = "Option::is_none")]
8887    pub location: Option<LocationRef>,
8888    #[serde(default, skip_serializing_if = "Option::is_none")]
8889    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8890    #[serde(rename = "type", default, skip_serializing)]
8891    pub type_: String,
8892}
8893
8894#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8895pub struct WorkspaceReadyData {
8896    pub name: String,
8897}
8898
8899#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8900pub struct WorkspaceStatus {
8901    pub data: WorkspaceStatusData,
8902    #[serde(default, skip_serializing_if = "Option::is_none")]
8903    pub durable: Option<SessionStatus2Durable>,
8904    pub id: String,
8905    #[serde(default, skip_serializing_if = "Option::is_none")]
8906    pub location: Option<LocationRef>,
8907    #[serde(default, skip_serializing_if = "Option::is_none")]
8908    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8909    #[serde(rename = "type", default, skip_serializing)]
8910    pub type_: String,
8911}
8912
8913#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8914pub struct WorkspaceStatusData {
8915    pub status: String,
8916    #[serde(rename = "workspaceID")]
8917    pub workspace_id: String,
8918}
8919
8920/// Untagged union: serde tries each variant in the order below.
8921#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8922#[serde(untagged)]
8923pub enum WorkspaceTimeUsed {
8924    Variant0(f64),
8925    Variant1(String),
8926    Variant2(String),
8927    Variant3(String),
8928    Variant4(String),
8929}
8930
8931#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8932pub struct WorkspaceWarpError {
8933    pub data: WorktreeFailedData,
8934    pub name: String,
8935}
8936
8937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8938pub struct Worktree {
8939    #[serde(default, skip_serializing_if = "Option::is_none")]
8940    pub branch: Option<String>,
8941    pub directory: String,
8942    pub name: String,
8943}
8944
8945#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8946pub struct WorktreeCreateInput {
8947    #[serde(default, skip_serializing_if = "Option::is_none")]
8948    pub name: Option<String>,
8949    #[serde(
8950        rename = "startCommand",
8951        default,
8952        skip_serializing_if = "Option::is_none"
8953    )]
8954    pub start_command: Option<String>,
8955}
8956
8957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8958pub struct WorktreeError {
8959    pub data: WorktreeFailedData,
8960    pub name: String,
8961}
8962
8963#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8964pub struct WorktreeFailed {
8965    pub data: WorktreeFailedData,
8966    #[serde(default, skip_serializing_if = "Option::is_none")]
8967    pub durable: Option<SessionStatus2Durable>,
8968    pub id: String,
8969    #[serde(default, skip_serializing_if = "Option::is_none")]
8970    pub location: Option<LocationRef>,
8971    #[serde(default, skip_serializing_if = "Option::is_none")]
8972    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8973    #[serde(rename = "type", default, skip_serializing)]
8974    pub type_: String,
8975}
8976
8977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8978pub struct WorktreeFailedData {
8979    pub message: String,
8980}
8981
8982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8983pub struct WorktreeReady {
8984    pub data: WorktreeReadyData,
8985    #[serde(default, skip_serializing_if = "Option::is_none")]
8986    pub durable: Option<SessionStatus2Durable>,
8987    pub id: String,
8988    #[serde(default, skip_serializing_if = "Option::is_none")]
8989    pub location: Option<LocationRef>,
8990    #[serde(default, skip_serializing_if = "Option::is_none")]
8991    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8992    #[serde(rename = "type", default, skip_serializing)]
8993    pub type_: String,
8994}
8995
8996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8997pub struct WorktreeReadyData {
8998    #[serde(default, skip_serializing_if = "Option::is_none")]
8999    pub branch: Option<String>,
9000    pub name: String,
9001}
9002
9003#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9004pub struct WorktreeRemoveInput {
9005    pub directory: String,
9006}
9007
9008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9009pub struct WorktreeResetInput {
9010    pub directory: String,
9011}
9012
9013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9014pub struct EffectHttpApiErrorBadRequest {
9015    pub _tag: String,
9016}
9017
9018#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9019pub struct EffectHttpApiErrorForbidden {
9020    pub _tag: String,
9021}
9022
9023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9024pub struct EffectHttpApiErrorInternalServerError {
9025    pub _tag: String,
9026}
9027
9028#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9029pub struct QuestionRejected2 {
9030    pub data: QuestionRejected2Data,
9031    #[serde(default, skip_serializing_if = "Option::is_none")]
9032    pub durable: Option<SessionStatus2Durable>,
9033    pub id: String,
9034    #[serde(default, skip_serializing_if = "Option::is_none")]
9035    pub location: Option<LocationRef>,
9036    #[serde(default, skip_serializing_if = "Option::is_none")]
9037    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
9038    #[serde(rename = "type", default, skip_serializing)]
9039    pub type_: String,
9040}
9041
9042#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9043pub struct QuestionReplied2 {
9044    pub data: QuestionReplied2Data,
9045    #[serde(default, skip_serializing_if = "Option::is_none")]
9046    pub durable: Option<SessionStatus2Durable>,
9047    pub id: String,
9048    #[serde(default, skip_serializing_if = "Option::is_none")]
9049    pub location: Option<LocationRef>,
9050    #[serde(default, skip_serializing_if = "Option::is_none")]
9051    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
9052    #[serde(rename = "type", default, skip_serializing)]
9053    pub type_: String,
9054}
9055
9056#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9057pub struct SessionStatus2 {
9058    pub data: SessionStatus2Data,
9059    #[serde(default, skip_serializing_if = "Option::is_none")]
9060    pub durable: Option<SessionStatus2Durable>,
9061    pub id: String,
9062    #[serde(default, skip_serializing_if = "Option::is_none")]
9063    pub location: Option<LocationRef>,
9064    #[serde(default, skip_serializing_if = "Option::is_none")]
9065    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
9066    #[serde(rename = "type", default, skip_serializing)]
9067    pub type_: String,
9068}