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(ProviderConfigModelsValueInterleavedVariant1),
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(ProviderConfigModelsValueInterleavedVariant1),
5006}
5007
5008#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5009pub struct ProviderConfigModelsValueInterleavedVariant1 {
5010    pub field: String,
5011}
5012
5013#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5014pub struct ProviderConfigModelsValueLimit {
5015    pub context: f64,
5016    #[serde(default, skip_serializing_if = "Option::is_none")]
5017    pub input: Option<f64>,
5018    pub output: f64,
5019}
5020
5021#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5022pub struct ProviderConfigModelsValueModalities {
5023    #[serde(default, skip_serializing_if = "Option::is_none")]
5024    pub input: Option<Vec<String>>,
5025    #[serde(default, skip_serializing_if = "Option::is_none")]
5026    pub output: Option<Vec<String>>,
5027}
5028
5029#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5030pub struct ProviderConfigModelsValueProvider {
5031    #[serde(default, skip_serializing_if = "Option::is_none")]
5032    pub api: Option<String>,
5033    #[serde(default, skip_serializing_if = "Option::is_none")]
5034    pub npm: Option<String>,
5035}
5036
5037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5038pub struct ProviderConfigModelsValueVariantsValue {
5039    #[serde(default, skip_serializing_if = "Option::is_none")]
5040    pub disabled: Option<bool>,
5041}
5042
5043#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5044pub struct ProviderConfigOptions {
5045    #[serde(rename = "apiKey", default, skip_serializing_if = "Option::is_none")]
5046    pub api_key: Option<String>,
5047    #[serde(rename = "baseURL", default, skip_serializing_if = "Option::is_none")]
5048    pub base_url: Option<String>,
5049    #[serde(
5050        rename = "chunkTimeout",
5051        default,
5052        skip_serializing_if = "Option::is_none"
5053    )]
5054    pub chunk_timeout: Option<i64>,
5055    #[serde(
5056        rename = "enterpriseUrl",
5057        default,
5058        skip_serializing_if = "Option::is_none"
5059    )]
5060    pub enterprise_url: Option<String>,
5061    #[serde(
5062        rename = "headerTimeout",
5063        default,
5064        skip_serializing_if = "Option::is_none"
5065    )]
5066    pub header_timeout: Option<ProviderConfigOptionsHeaderTimeout>,
5067    #[serde(
5068        rename = "setCacheKey",
5069        default,
5070        skip_serializing_if = "Option::is_none"
5071    )]
5072    pub set_cache_key: Option<bool>,
5073    #[serde(default, skip_serializing_if = "Option::is_none")]
5074    pub timeout: Option<ProviderConfigOptionsTimeout>,
5075}
5076
5077/// Timeout in milliseconds to wait for response headers. Provider integrations may set defaults. Set to false to disable timeout.
5078/// Untagged union: serde tries each variant in the order below.
5079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5080#[serde(untagged)]
5081pub enum ProviderConfigOptionsHeaderTimeout {
5082    Variant0(i64),
5083    Variant1(bool),
5084}
5085
5086/// Timeout in milliseconds for full requests to this provider. Set to false to disable timeout.
5087/// Untagged union: serde tries each variant in the order below.
5088#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5089#[serde(untagged)]
5090pub enum ProviderConfigOptionsTimeout {
5091    Variant0(i64),
5092    Variant1(bool),
5093}
5094
5095#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5096pub struct ProviderNative {
5097    pub settings: serde_json::Map<String, serde_json::Value>,
5098    #[serde(rename = "type", default, skip_serializing)]
5099    pub type_: String,
5100    #[serde(default, skip_serializing_if = "Option::is_none")]
5101    pub url: Option<String>,
5102}
5103
5104#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5105pub struct ProviderNotFoundError {
5106    pub _tag: String,
5107    pub message: String,
5108    #[serde(rename = "providerID")]
5109    pub provider_id: String,
5110}
5111
5112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5113pub struct ProviderRequest {
5114    pub body: serde_json::Map<String, serde_json::Value>,
5115    pub headers: std::collections::BTreeMap<String, String>,
5116}
5117
5118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5119pub struct ProviderV2Info {
5120    pub api: ProviderApi,
5121    #[serde(default, skip_serializing_if = "Option::is_none")]
5122    pub disabled: Option<bool>,
5123    pub id: String,
5124    #[serde(
5125        rename = "integrationID",
5126        default,
5127        skip_serializing_if = "Option::is_none"
5128    )]
5129    pub integration_id: Option<String>,
5130    pub name: String,
5131    pub request: ProviderRequest,
5132}
5133
5134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5135pub struct Pty {
5136    pub args: Vec<String>,
5137    pub command: String,
5138    pub cwd: String,
5139    #[serde(rename = "exitCode", default, skip_serializing_if = "Option::is_none")]
5140    pub exit_code: Option<u64>,
5141    pub id: String,
5142    pub pid: u64,
5143    pub status: String,
5144    pub title: String,
5145}
5146
5147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5148pub struct PtyCreated {
5149    pub data: PtyCreatedData,
5150    #[serde(default, skip_serializing_if = "Option::is_none")]
5151    pub durable: Option<SessionStatus2Durable>,
5152    pub id: String,
5153    #[serde(default, skip_serializing_if = "Option::is_none")]
5154    pub location: Option<LocationRef>,
5155    #[serde(default, skip_serializing_if = "Option::is_none")]
5156    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5157    #[serde(rename = "type", default, skip_serializing)]
5158    pub type_: String,
5159}
5160
5161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5162pub struct PtyCreatedData {
5163    pub info: Pty,
5164}
5165
5166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5167pub struct PtyDeleted {
5168    pub data: PtyDeletedData,
5169    #[serde(default, skip_serializing_if = "Option::is_none")]
5170    pub durable: Option<SessionStatus2Durable>,
5171    pub id: String,
5172    #[serde(default, skip_serializing_if = "Option::is_none")]
5173    pub location: Option<LocationRef>,
5174    #[serde(default, skip_serializing_if = "Option::is_none")]
5175    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5176    #[serde(rename = "type", default, skip_serializing)]
5177    pub type_: String,
5178}
5179
5180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5181pub struct PtyDeletedData {
5182    pub id: String,
5183}
5184
5185#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5186pub struct PtyExited {
5187    pub data: PtyExitedData,
5188    #[serde(default, skip_serializing_if = "Option::is_none")]
5189    pub durable: Option<SessionStatus2Durable>,
5190    pub id: String,
5191    #[serde(default, skip_serializing_if = "Option::is_none")]
5192    pub location: Option<LocationRef>,
5193    #[serde(default, skip_serializing_if = "Option::is_none")]
5194    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5195    #[serde(rename = "type", default, skip_serializing)]
5196    pub type_: String,
5197}
5198
5199#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5200pub struct PtyExitedData {
5201    #[serde(rename = "exitCode")]
5202    pub exit_code: u64,
5203    pub id: String,
5204}
5205
5206#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5207pub struct PtyForbiddenError {
5208    pub _tag: String,
5209    pub message: String,
5210}
5211
5212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5213pub struct PtyNotFoundError {
5214    pub _tag: String,
5215    pub message: String,
5216    #[serde(rename = "ptyID")]
5217    pub pty_id: String,
5218}
5219
5220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5221pub struct PtyTicketConnectToken {
5222    pub expires_in: i64,
5223    pub ticket: String,
5224}
5225
5226#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5227pub struct PtyUpdated {
5228    pub data: PtyCreatedData,
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
5240pub type QuestionAnswer = Vec<String>;
5241
5242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5243pub struct QuestionAsked {
5244    pub data: QuestionAskedData,
5245    #[serde(default, skip_serializing_if = "Option::is_none")]
5246    pub durable: Option<SessionStatus2Durable>,
5247    pub id: String,
5248    #[serde(default, skip_serializing_if = "Option::is_none")]
5249    pub location: Option<LocationRef>,
5250    #[serde(default, skip_serializing_if = "Option::is_none")]
5251    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5252    #[serde(rename = "type", default, skip_serializing)]
5253    pub type_: String,
5254}
5255
5256#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5257pub struct QuestionAskedData {
5258    pub id: String,
5259    pub questions: Vec<QuestionInfo>,
5260    #[serde(rename = "sessionID")]
5261    pub session_id: String,
5262    #[serde(default, skip_serializing_if = "Option::is_none")]
5263    pub tool: Option<QuestionTool>,
5264}
5265
5266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5267pub struct QuestionInfo {
5268    #[serde(default, skip_serializing_if = "Option::is_none")]
5269    pub custom: Option<bool>,
5270    pub header: String,
5271    #[serde(default, skip_serializing_if = "Option::is_none")]
5272    pub multiple: Option<bool>,
5273    pub options: Vec<QuestionOption>,
5274    pub question: String,
5275}
5276
5277#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5278pub struct QuestionNotFoundError {
5279    pub _tag: String,
5280    pub message: String,
5281    #[serde(rename = "requestID")]
5282    pub request_id: String,
5283}
5284
5285#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5286pub struct QuestionOption {
5287    pub description: String,
5288    pub label: String,
5289}
5290
5291#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5292pub struct QuestionRejected {
5293    #[serde(rename = "requestID")]
5294    pub request_id: String,
5295    #[serde(rename = "sessionID")]
5296    pub session_id: String,
5297}
5298
5299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5300pub struct QuestionRejected2Data {
5301    #[serde(rename = "requestID")]
5302    pub request_id: String,
5303    #[serde(rename = "sessionID")]
5304    pub session_id: String,
5305}
5306
5307#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5308pub struct QuestionReplied {
5309    pub answers: Vec<QuestionAnswer>,
5310    #[serde(rename = "requestID")]
5311    pub request_id: String,
5312    #[serde(rename = "sessionID")]
5313    pub session_id: String,
5314}
5315
5316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5317pub struct QuestionReplied2Data {
5318    pub answers: Vec<QuestionAnswer>,
5319    #[serde(rename = "requestID")]
5320    pub request_id: String,
5321    #[serde(rename = "sessionID")]
5322    pub session_id: String,
5323}
5324
5325#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5326pub struct QuestionRequest {
5327    pub id: String,
5328    pub questions: Vec<QuestionInfo>,
5329    #[serde(rename = "sessionID")]
5330    pub session_id: String,
5331    #[serde(default, skip_serializing_if = "Option::is_none")]
5332    pub tool: Option<QuestionTool>,
5333}
5334
5335#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5336pub struct QuestionTool {
5337    #[serde(rename = "callID")]
5338    pub call_id: String,
5339    #[serde(rename = "messageID")]
5340    pub message_id: String,
5341}
5342
5343pub type QuestionV2Answer = Vec<String>;
5344
5345#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5346pub struct QuestionV2Asked {
5347    pub data: QuestionV2AskedData,
5348    #[serde(default, skip_serializing_if = "Option::is_none")]
5349    pub durable: Option<SessionStatus2Durable>,
5350    pub id: String,
5351    #[serde(default, skip_serializing_if = "Option::is_none")]
5352    pub location: Option<LocationRef>,
5353    #[serde(default, skip_serializing_if = "Option::is_none")]
5354    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5355    #[serde(rename = "type", default, skip_serializing)]
5356    pub type_: String,
5357}
5358
5359#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5360pub struct QuestionV2AskedData {
5361    pub id: String,
5362    pub questions: Vec<QuestionV2Info>,
5363    #[serde(rename = "sessionID")]
5364    pub session_id: String,
5365    #[serde(default, skip_serializing_if = "Option::is_none")]
5366    pub tool: Option<QuestionV2Tool>,
5367}
5368
5369#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5370pub struct QuestionV2Info {
5371    #[serde(default, skip_serializing_if = "Option::is_none")]
5372    pub custom: Option<bool>,
5373    pub header: String,
5374    #[serde(default, skip_serializing_if = "Option::is_none")]
5375    pub multiple: Option<bool>,
5376    pub options: Vec<QuestionV2Option>,
5377    pub question: String,
5378}
5379
5380#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5381pub struct QuestionV2Option {
5382    pub description: String,
5383    pub label: String,
5384}
5385
5386#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5387pub struct QuestionV2Rejected {
5388    pub data: QuestionRejected2Data,
5389    #[serde(default, skip_serializing_if = "Option::is_none")]
5390    pub durable: Option<SessionStatus2Durable>,
5391    pub id: String,
5392    #[serde(default, skip_serializing_if = "Option::is_none")]
5393    pub location: Option<LocationRef>,
5394    #[serde(default, skip_serializing_if = "Option::is_none")]
5395    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5396    #[serde(rename = "type", default, skip_serializing)]
5397    pub type_: String,
5398}
5399
5400#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5401pub struct QuestionV2Replied {
5402    pub data: QuestionV2RepliedData,
5403    #[serde(default, skip_serializing_if = "Option::is_none")]
5404    pub durable: Option<SessionStatus2Durable>,
5405    pub id: String,
5406    #[serde(default, skip_serializing_if = "Option::is_none")]
5407    pub location: Option<LocationRef>,
5408    #[serde(default, skip_serializing_if = "Option::is_none")]
5409    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5410    #[serde(rename = "type", default, skip_serializing)]
5411    pub type_: String,
5412}
5413
5414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5415pub struct QuestionV2RepliedData {
5416    pub answers: Vec<QuestionV2Answer>,
5417    #[serde(rename = "requestID")]
5418    pub request_id: String,
5419    #[serde(rename = "sessionID")]
5420    pub session_id: String,
5421}
5422
5423#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5424pub struct QuestionV2Reply {
5425    pub answers: Vec<QuestionV2Answer>,
5426}
5427
5428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5429pub struct QuestionV2Request {
5430    pub id: String,
5431    pub questions: Vec<QuestionV2Info>,
5432    #[serde(rename = "sessionID")]
5433    pub session_id: String,
5434    #[serde(default, skip_serializing_if = "Option::is_none")]
5435    pub tool: Option<QuestionV2Tool>,
5436}
5437
5438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5439pub struct QuestionV2Tool {
5440    #[serde(rename = "callID")]
5441    pub call_id: String,
5442    #[serde(rename = "messageID")]
5443    pub message_id: String,
5444}
5445
5446#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5447pub struct Range {
5448    pub end: RangeStart,
5449    pub start: RangeStart,
5450}
5451
5452#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5453pub struct RangeStart {
5454    pub character: u64,
5455    pub line: u64,
5456}
5457
5458#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5459pub struct ReasoningPart {
5460    pub id: String,
5461    #[serde(rename = "messageID")]
5462    pub message_id: String,
5463    #[serde(default, skip_serializing_if = "Option::is_none")]
5464    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5465    #[serde(rename = "sessionID")]
5466    pub session_id: String,
5467    pub text: String,
5468    pub time: TextPartInputTime,
5469    #[serde(rename = "type", default, skip_serializing)]
5470    pub type_: String,
5471}
5472
5473#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5474pub struct ReferenceGitSource {
5475    #[serde(default, skip_serializing_if = "Option::is_none")]
5476    pub branch: Option<String>,
5477    #[serde(default, skip_serializing_if = "Option::is_none")]
5478    pub description: Option<String>,
5479    #[serde(default, skip_serializing_if = "Option::is_none")]
5480    pub hidden: Option<bool>,
5481    pub repository: String,
5482    #[serde(rename = "type", default, skip_serializing)]
5483    pub type_: String,
5484}
5485
5486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5487pub struct ReferenceInfo {
5488    #[serde(default, skip_serializing_if = "Option::is_none")]
5489    pub description: Option<String>,
5490    #[serde(default, skip_serializing_if = "Option::is_none")]
5491    pub hidden: Option<bool>,
5492    pub name: String,
5493    pub path: String,
5494    pub source: ReferenceSource,
5495}
5496
5497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5498pub struct ReferenceLocalSource {
5499    #[serde(default, skip_serializing_if = "Option::is_none")]
5500    pub description: Option<String>,
5501    #[serde(default, skip_serializing_if = "Option::is_none")]
5502    pub hidden: Option<bool>,
5503    pub path: String,
5504    #[serde(rename = "type", default, skip_serializing)]
5505    pub type_: String,
5506}
5507
5508#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5509#[serde(tag = "type")]
5510pub enum ReferenceSource {
5511    #[serde(rename = "local")]
5512    Local(ReferenceLocalSource),
5513    #[serde(rename = "git")]
5514    Git(ReferenceGitSource),
5515}
5516
5517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5518pub struct ReferenceUpdated {
5519    pub data: serde_json::Map<String, serde_json::Value>,
5520    #[serde(default, skip_serializing_if = "Option::is_none")]
5521    pub durable: Option<SessionStatus2Durable>,
5522    pub id: String,
5523    #[serde(default, skip_serializing_if = "Option::is_none")]
5524    pub location: Option<LocationRef>,
5525    #[serde(default, skip_serializing_if = "Option::is_none")]
5526    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5527    #[serde(rename = "type", default, skip_serializing)]
5528    pub type_: String,
5529}
5530
5531#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5532pub struct ResourceSource {
5533    #[serde(rename = "clientName")]
5534    pub client_name: String,
5535    pub text: FilePartSourceText,
5536    #[serde(rename = "type", default, skip_serializing)]
5537    pub type_: String,
5538    pub uri: String,
5539}
5540
5541#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5542pub struct RetryPart {
5543    pub attempt: u64,
5544    pub error: APIError,
5545    pub id: String,
5546    #[serde(rename = "messageID")]
5547    pub message_id: String,
5548    #[serde(rename = "sessionID")]
5549    pub session_id: String,
5550    pub time: RetryPartTime,
5551    #[serde(rename = "type", default, skip_serializing)]
5552    pub type_: String,
5553}
5554
5555#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5556pub struct RetryPartTime {
5557    pub created: u64,
5558}
5559
5560#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5561pub struct RevertState {
5562    #[serde(default, skip_serializing_if = "Option::is_none")]
5563    pub diff: Option<String>,
5564    #[serde(default, skip_serializing_if = "Option::is_none")]
5565    pub files: Option<Vec<FileDiff>>,
5566    #[serde(rename = "messageID")]
5567    pub message_id: String,
5568    #[serde(rename = "partID", default, skip_serializing_if = "Option::is_none")]
5569    pub part_id: Option<String>,
5570    #[serde(default, skip_serializing_if = "Option::is_none")]
5571    pub snapshot: Option<String>,
5572}
5573
5574/// Server configuration for opencode serve and web commands
5575#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5576pub struct ServerConfig {
5577    #[serde(default, skip_serializing_if = "Option::is_none")]
5578    pub cors: Option<Vec<String>>,
5579    #[serde(default, skip_serializing_if = "Option::is_none")]
5580    pub hostname: Option<String>,
5581    #[serde(default, skip_serializing_if = "Option::is_none")]
5582    pub mdns: Option<bool>,
5583    #[serde(
5584        rename = "mdnsDomain",
5585        default,
5586        skip_serializing_if = "Option::is_none"
5587    )]
5588    pub mdns_domain: Option<String>,
5589    #[serde(default, skip_serializing_if = "Option::is_none")]
5590    pub port: Option<i64>,
5591}
5592
5593#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5594pub struct ServerConnected {
5595    pub data: serde_json::Map<String, serde_json::Value>,
5596    #[serde(default, skip_serializing_if = "Option::is_none")]
5597    pub durable: Option<SessionStatus2Durable>,
5598    pub id: String,
5599    #[serde(default, skip_serializing_if = "Option::is_none")]
5600    pub location: Option<LocationRef>,
5601    #[serde(default, skip_serializing_if = "Option::is_none")]
5602    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5603    #[serde(rename = "type", default, skip_serializing)]
5604    pub type_: String,
5605}
5606
5607#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5608pub struct ServiceUnavailableError {
5609    pub _tag: String,
5610    pub message: String,
5611    #[serde(default, skip_serializing_if = "Option::is_none")]
5612    pub service: Option<String>,
5613}
5614
5615#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5616pub struct Session {
5617    #[serde(default, skip_serializing_if = "Option::is_none")]
5618    pub agent: Option<String>,
5619    #[serde(default, skip_serializing_if = "Option::is_none")]
5620    pub cost: Option<f64>,
5621    pub directory: String,
5622    pub id: String,
5623    #[serde(default, skip_serializing_if = "Option::is_none")]
5624    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5625    #[serde(default, skip_serializing_if = "Option::is_none")]
5626    pub model: Option<SessionCreateParamsModel>,
5627    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
5628    pub parent_id: Option<String>,
5629    #[serde(default, skip_serializing_if = "Option::is_none")]
5630    pub path: Option<String>,
5631    #[serde(default, skip_serializing_if = "Option::is_none")]
5632    pub permission: Option<PermissionRuleset>,
5633    #[serde(rename = "projectID")]
5634    pub project_id: String,
5635    #[serde(default, skip_serializing_if = "Option::is_none")]
5636    pub revert: Option<SessionRevert>,
5637    #[serde(default, skip_serializing_if = "Option::is_none")]
5638    pub share: Option<SessionShare>,
5639    pub slug: String,
5640    #[serde(default, skip_serializing_if = "Option::is_none")]
5641    pub summary: Option<SessionSummary>,
5642    pub time: SessionTime,
5643    pub title: String,
5644    #[serde(default, skip_serializing_if = "Option::is_none")]
5645    pub tokens: Option<SessionNextStepEndedDataTokens>,
5646    pub version: String,
5647    #[serde(
5648        rename = "workspaceID",
5649        default,
5650        skip_serializing_if = "Option::is_none"
5651    )]
5652    pub workspace_id: Option<String>,
5653}
5654
5655#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5656pub struct SessionActive {
5657    #[serde(rename = "type")]
5658    pub type_: String,
5659}
5660
5661#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5662pub struct SessionBusyError {
5663    pub _tag: String,
5664    pub message: String,
5665    #[serde(rename = "sessionID")]
5666    pub session_id: String,
5667}
5668
5669#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5670pub struct SessionCompacted {
5671    pub data: SessionIdleData,
5672    #[serde(default, skip_serializing_if = "Option::is_none")]
5673    pub durable: Option<SessionStatus2Durable>,
5674    pub id: String,
5675    #[serde(default, skip_serializing_if = "Option::is_none")]
5676    pub location: Option<LocationRef>,
5677    #[serde(default, skip_serializing_if = "Option::is_none")]
5678    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5679    #[serde(rename = "type", default, skip_serializing)]
5680    pub type_: String,
5681}
5682
5683#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
5684pub struct SessionCreateParams {
5685    #[serde(default, skip_serializing_if = "Option::is_none")]
5686    pub agent: Option<String>,
5687    #[serde(default, skip_serializing_if = "Option::is_none")]
5688    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5689    #[serde(default, skip_serializing_if = "Option::is_none")]
5690    pub model: Option<SessionCreateParamsModel>,
5691    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
5692    pub parent_id: Option<String>,
5693    #[serde(default, skip_serializing_if = "Option::is_none")]
5694    pub permission: Option<PermissionRuleset>,
5695    #[serde(default, skip_serializing_if = "Option::is_none")]
5696    pub title: Option<String>,
5697    #[serde(
5698        rename = "workspaceID",
5699        default,
5700        skip_serializing_if = "Option::is_none"
5701    )]
5702    pub workspace_id: Option<String>,
5703}
5704
5705#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5706pub struct SessionCreateParamsModel {
5707    pub id: String,
5708    #[serde(rename = "providerID")]
5709    pub provider_id: String,
5710    #[serde(default, skip_serializing_if = "Option::is_none")]
5711    pub variant: Option<String>,
5712}
5713
5714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5715pub struct SessionCreated {
5716    pub data: SessionCreatedData,
5717    #[serde(default, skip_serializing_if = "Option::is_none")]
5718    pub durable: Option<SessionStatus2Durable>,
5719    pub id: String,
5720    #[serde(default, skip_serializing_if = "Option::is_none")]
5721    pub location: Option<LocationRef>,
5722    #[serde(default, skip_serializing_if = "Option::is_none")]
5723    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5724    #[serde(rename = "type", default, skip_serializing)]
5725    pub type_: String,
5726}
5727
5728#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5729pub struct SessionCreatedData {
5730    pub info: Session,
5731    #[serde(rename = "sessionID")]
5732    pub session_id: String,
5733}
5734
5735#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5736pub struct SessionDeleted {
5737    pub data: SessionCreatedData,
5738    #[serde(default, skip_serializing_if = "Option::is_none")]
5739    pub durable: Option<SessionStatus2Durable>,
5740    pub id: String,
5741    #[serde(default, skip_serializing_if = "Option::is_none")]
5742    pub location: Option<LocationRef>,
5743    #[serde(default, skip_serializing_if = "Option::is_none")]
5744    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5745    #[serde(rename = "type", default, skip_serializing)]
5746    pub type_: String,
5747}
5748
5749#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5750pub struct SessionDiff {
5751    pub data: SessionDiffData,
5752    #[serde(default, skip_serializing_if = "Option::is_none")]
5753    pub durable: Option<SessionStatus2Durable>,
5754    pub id: String,
5755    #[serde(default, skip_serializing_if = "Option::is_none")]
5756    pub location: Option<LocationRef>,
5757    #[serde(default, skip_serializing_if = "Option::is_none")]
5758    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5759    #[serde(rename = "type", default, skip_serializing)]
5760    pub type_: String,
5761}
5762
5763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5764pub struct SessionDiffData {
5765    pub diff: Vec<SnapshotFileDiff>,
5766    #[serde(rename = "sessionID")]
5767    pub session_id: String,
5768}
5769
5770#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5771#[serde(tag = "type")]
5772pub enum SessionDurableEvent {
5773    #[serde(rename = "session.next.agent.switched")]
5774    SessionNextAgentSwitched(SessionNextAgentSwitched),
5775    #[serde(rename = "session.next.model.switched")]
5776    SessionNextModelSwitched(SessionNextModelSwitched),
5777    #[serde(rename = "session.next.moved")]
5778    SessionNextMoved(SessionNextMoved),
5779    #[serde(rename = "session.next.prompted")]
5780    SessionNextPrompted(SessionNextPrompted),
5781    #[serde(rename = "session.next.prompt.admitted")]
5782    SessionNextPromptAdmitted(SessionNextPromptAdmitted),
5783    #[serde(rename = "session.next.context.updated")]
5784    SessionNextContextUpdated(SessionNextContextUpdated),
5785    #[serde(rename = "session.next.synthetic")]
5786    SessionNextSynthetic(SessionNextSynthetic),
5787    #[serde(rename = "session.next.shell.started")]
5788    SessionNextShellStarted(SessionNextShellStarted),
5789    #[serde(rename = "session.next.shell.ended")]
5790    SessionNextShellEnded(SessionNextShellEnded),
5791    #[serde(rename = "session.next.step.started")]
5792    SessionNextStepStarted(SessionNextStepStarted),
5793    #[serde(rename = "session.next.step.ended")]
5794    SessionNextStepEnded(SessionNextStepEnded),
5795    #[serde(rename = "session.next.step.failed")]
5796    SessionNextStepFailed(SessionNextStepFailed),
5797    #[serde(rename = "session.next.text.started")]
5798    SessionNextTextStarted(SessionNextTextStarted),
5799    #[serde(rename = "session.next.text.ended")]
5800    SessionNextTextEnded(SessionNextTextEnded),
5801    #[serde(rename = "session.next.tool.input.started")]
5802    SessionNextToolInputStarted(SessionNextToolInputStarted),
5803    #[serde(rename = "session.next.tool.input.ended")]
5804    SessionNextToolInputEnded(SessionNextToolInputEnded),
5805    #[serde(rename = "session.next.tool.called")]
5806    SessionNextToolCalled(SessionNextToolCalled),
5807    #[serde(rename = "session.next.tool.progress")]
5808    SessionNextToolProgress(SessionNextToolProgress),
5809    #[serde(rename = "session.next.tool.success")]
5810    SessionNextToolSuccess(SessionNextToolSuccess),
5811    #[serde(rename = "session.next.tool.failed")]
5812    SessionNextToolFailed(SessionNextToolFailed),
5813    #[serde(rename = "session.next.reasoning.started")]
5814    SessionNextReasoningStarted(SessionNextReasoningStarted),
5815    #[serde(rename = "session.next.reasoning.ended")]
5816    SessionNextReasoningEnded(SessionNextReasoningEnded),
5817    #[serde(rename = "session.next.retried")]
5818    SessionNextRetried(SessionNextRetried),
5819    #[serde(rename = "session.next.compaction.started")]
5820    SessionNextCompactionStarted(SessionNextCompactionStarted),
5821    #[serde(rename = "session.next.compaction.ended")]
5822    SessionNextCompactionEnded(SessionNextCompactionEnded),
5823    #[serde(rename = "session.next.revert.staged")]
5824    SessionNextRevertStaged(SessionNextRevertStaged),
5825    #[serde(rename = "session.next.revert.cleared")]
5826    SessionNextRevertCleared(SessionNextRevertCleared),
5827    #[serde(rename = "session.next.revert.committed")]
5828    SessionNextRevertCommitted(SessionNextRevertCommitted),
5829}
5830
5831#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
5832#[serde(transparent)]
5833pub struct SessionDurableEventStream(pub String);
5834
5835#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5836pub struct SessionError {
5837    pub data: SessionErrorData,
5838    #[serde(default, skip_serializing_if = "Option::is_none")]
5839    pub durable: Option<SessionStatus2Durable>,
5840    pub id: String,
5841    #[serde(default, skip_serializing_if = "Option::is_none")]
5842    pub location: Option<LocationRef>,
5843    #[serde(default, skip_serializing_if = "Option::is_none")]
5844    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5845    #[serde(rename = "type", default, skip_serializing)]
5846    pub type_: String,
5847}
5848
5849#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5850pub struct SessionErrorData {
5851    #[serde(default, skip_serializing_if = "Option::is_none")]
5852    pub error: Option<SessionErrorDataError>,
5853    #[serde(rename = "sessionID", default, skip_serializing_if = "Option::is_none")]
5854    pub session_id: Option<String>,
5855}
5856
5857#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5858#[serde(tag = "name")]
5859pub enum SessionErrorDataError {
5860    ProviderAuthError(ProviderAuthError),
5861    UnknownError(UnknownError),
5862    MessageOutputLengthError(MessageOutputLengthError),
5863    MessageAbortedError(MessageAbortedError),
5864    StructuredOutputError(StructuredOutputError),
5865    ContextOverflowError(ContextOverflowError),
5866    ContentFilterError(ContentFilterError),
5867    APIError(APIError),
5868}
5869
5870#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5871pub struct SessionErrorUnknown {
5872    pub message: String,
5873    #[serde(rename = "type")]
5874    pub type_: String,
5875}
5876
5877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5878pub struct SessionHistory {
5879    pub data: Vec<SessionDurableEvent>,
5880    #[serde(rename = "hasMore")]
5881    pub has_more: bool,
5882}
5883
5884#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5885pub struct SessionIdle {
5886    pub data: SessionIdleData,
5887    #[serde(default, skip_serializing_if = "Option::is_none")]
5888    pub durable: Option<SessionStatus2Durable>,
5889    pub id: String,
5890    #[serde(default, skip_serializing_if = "Option::is_none")]
5891    pub location: Option<LocationRef>,
5892    #[serde(default, skip_serializing_if = "Option::is_none")]
5893    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5894    #[serde(rename = "type", default, skip_serializing)]
5895    pub type_: String,
5896}
5897
5898#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5899pub struct SessionIdleData {
5900    #[serde(rename = "sessionID")]
5901    pub session_id: String,
5902}
5903
5904#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5905pub struct SessionInputAdmitted {
5906    #[serde(rename = "admittedSeq")]
5907    pub admitted_seq: u64,
5908    pub delivery: String,
5909    pub id: String,
5910    #[serde(
5911        rename = "promotedSeq",
5912        default,
5913        skip_serializing_if = "Option::is_none"
5914    )]
5915    pub promoted_seq: Option<u64>,
5916    pub prompt: Prompt,
5917    #[serde(rename = "sessionID")]
5918    pub session_id: String,
5919    #[serde(rename = "timeCreated")]
5920    pub time_created: f64,
5921}
5922
5923#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5924#[serde(tag = "type")]
5925pub enum SessionMessage {
5926    #[serde(rename = "agent-switched")]
5927    AgentSwitched(SessionMessageAgentSwitched),
5928    #[serde(rename = "model-switched")]
5929    ModelSwitched(SessionMessageModelSwitched),
5930    #[serde(rename = "user")]
5931    User(SessionMessageUser),
5932    #[serde(rename = "synthetic")]
5933    Synthetic(SessionMessageSynthetic),
5934    #[serde(rename = "system")]
5935    System(SessionMessageSystem),
5936    #[serde(rename = "shell")]
5937    Shell(SessionMessageShell),
5938    #[serde(rename = "assistant")]
5939    Assistant(SessionMessageAssistant),
5940    #[serde(rename = "compaction")]
5941    Compaction(SessionMessageCompaction),
5942}
5943
5944#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5945pub struct SessionMessageAgentSwitched {
5946    pub agent: String,
5947    pub id: String,
5948    #[serde(default, skip_serializing_if = "Option::is_none")]
5949    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5950    pub time: SessionMessageUserTime,
5951    #[serde(rename = "type", default, skip_serializing)]
5952    pub type_: String,
5953}
5954
5955#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5956pub struct SessionMessageAssistant {
5957    pub agent: String,
5958    pub content: Vec<SessionMessageAssistantContentItem>,
5959    #[serde(default, skip_serializing_if = "Option::is_none")]
5960    pub cost: Option<f64>,
5961    #[serde(default, skip_serializing_if = "Option::is_none")]
5962    pub error: Option<SessionErrorUnknown>,
5963    #[serde(default, skip_serializing_if = "Option::is_none")]
5964    pub finish: Option<String>,
5965    pub id: String,
5966    #[serde(default, skip_serializing_if = "Option::is_none")]
5967    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
5968    pub model: ModelRef,
5969    #[serde(default, skip_serializing_if = "Option::is_none")]
5970    pub snapshot: Option<SessionMessageAssistantSnapshot>,
5971    pub time: SessionMessageShellTime,
5972    #[serde(default, skip_serializing_if = "Option::is_none")]
5973    pub tokens: Option<SessionNextStepEndedDataTokens>,
5974    #[serde(rename = "type", default, skip_serializing)]
5975    pub type_: String,
5976}
5977
5978#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5979#[serde(tag = "type")]
5980pub enum SessionMessageAssistantContentItem {
5981    #[serde(rename = "text")]
5982    Text(SessionMessageAssistantText),
5983    #[serde(rename = "reasoning")]
5984    Reasoning(SessionMessageAssistantReasoning),
5985    #[serde(rename = "tool")]
5986    Tool(SessionMessageAssistantTool),
5987}
5988
5989#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
5990pub struct SessionMessageAssistantReasoning {
5991    pub id: String,
5992    #[serde(
5993        rename = "providerMetadata",
5994        default,
5995        skip_serializing_if = "Option::is_none"
5996    )]
5997    pub provider_metadata: Option<LLMProviderMetadata>,
5998    pub text: String,
5999    #[serde(default, skip_serializing_if = "Option::is_none")]
6000    pub time: Option<SessionMessageShellTime>,
6001    #[serde(rename = "type", default, skip_serializing)]
6002    pub type_: String,
6003}
6004
6005#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6006pub struct SessionMessageAssistantSnapshot {
6007    #[serde(default, skip_serializing_if = "Option::is_none")]
6008    pub end: Option<String>,
6009    #[serde(default, skip_serializing_if = "Option::is_none")]
6010    pub files: Option<Vec<String>>,
6011    #[serde(default, skip_serializing_if = "Option::is_none")]
6012    pub start: Option<String>,
6013}
6014
6015#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6016pub struct SessionMessageAssistantText {
6017    pub id: String,
6018    pub text: String,
6019    #[serde(rename = "type", default, skip_serializing)]
6020    pub type_: String,
6021}
6022
6023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6024pub struct SessionMessageAssistantTool {
6025    pub id: String,
6026    pub name: String,
6027    #[serde(default, skip_serializing_if = "Option::is_none")]
6028    pub provider: Option<SessionMessageAssistantToolProvider>,
6029    pub state: SessionMessageAssistantToolState,
6030    pub time: SessionMessageAssistantToolTime,
6031    #[serde(rename = "type", default, skip_serializing)]
6032    pub type_: String,
6033}
6034
6035#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6036pub struct SessionMessageAssistantToolProvider {
6037    pub executed: bool,
6038    #[serde(default, skip_serializing_if = "Option::is_none")]
6039    pub metadata: Option<LLMProviderMetadata>,
6040    #[serde(
6041        rename = "resultMetadata",
6042        default,
6043        skip_serializing_if = "Option::is_none"
6044    )]
6045    pub result_metadata: Option<LLMProviderMetadata>,
6046}
6047
6048#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6049#[serde(tag = "status")]
6050pub enum SessionMessageAssistantToolState {
6051    #[serde(rename = "pending")]
6052    Pending(SessionMessageToolStatePending),
6053    #[serde(rename = "running")]
6054    Running(SessionMessageToolStateRunning),
6055    #[serde(rename = "completed")]
6056    Completed(SessionMessageToolStateCompleted),
6057    #[serde(rename = "error")]
6058    Error(SessionMessageToolStateError),
6059}
6060
6061#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6062pub struct SessionMessageAssistantToolTime {
6063    #[serde(default, skip_serializing_if = "Option::is_none")]
6064    pub completed: Option<f64>,
6065    pub created: f64,
6066    #[serde(default, skip_serializing_if = "Option::is_none")]
6067    pub pruned: Option<f64>,
6068    #[serde(default, skip_serializing_if = "Option::is_none")]
6069    pub ran: Option<f64>,
6070}
6071
6072#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6073pub struct SessionMessageCompaction {
6074    pub id: String,
6075    #[serde(default, skip_serializing_if = "Option::is_none")]
6076    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6077    pub reason: String,
6078    pub recent: String,
6079    pub summary: String,
6080    pub time: SessionMessageUserTime,
6081    #[serde(rename = "type", default, skip_serializing)]
6082    pub type_: String,
6083}
6084
6085#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6086pub struct SessionMessageModelSwitched {
6087    pub id: String,
6088    #[serde(default, skip_serializing_if = "Option::is_none")]
6089    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6090    pub model: ModelRef,
6091    pub time: SessionMessageUserTime,
6092    #[serde(rename = "type", default, skip_serializing)]
6093    pub type_: String,
6094}
6095
6096#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6097pub struct SessionMessageShell {
6098    #[serde(rename = "callID")]
6099    pub call_id: String,
6100    pub command: String,
6101    pub id: String,
6102    #[serde(default, skip_serializing_if = "Option::is_none")]
6103    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6104    pub output: String,
6105    pub time: SessionMessageShellTime,
6106    #[serde(rename = "type", default, skip_serializing)]
6107    pub type_: String,
6108}
6109
6110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6111pub struct SessionMessageShellTime {
6112    #[serde(default, skip_serializing_if = "Option::is_none")]
6113    pub completed: Option<f64>,
6114    pub created: f64,
6115}
6116
6117#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6118pub struct SessionMessageSynthetic {
6119    pub id: String,
6120    #[serde(default, skip_serializing_if = "Option::is_none")]
6121    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6122    #[serde(rename = "sessionID")]
6123    pub session_id: String,
6124    pub text: String,
6125    pub time: SessionMessageUserTime,
6126    #[serde(rename = "type", default, skip_serializing)]
6127    pub type_: String,
6128}
6129
6130#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6131pub struct SessionMessageSystem {
6132    pub id: String,
6133    #[serde(default, skip_serializing_if = "Option::is_none")]
6134    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6135    pub text: String,
6136    pub time: SessionMessageUserTime,
6137    #[serde(rename = "type", default, skip_serializing)]
6138    pub type_: String,
6139}
6140
6141#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6142pub struct SessionMessageToolStateCompleted {
6143    #[serde(default, skip_serializing_if = "Option::is_none")]
6144    pub attachments: Option<Vec<PromptFileAttachment>>,
6145    pub content: Vec<LLMToolContent>,
6146    pub input: serde_json::Map<String, serde_json::Value>,
6147    #[serde(
6148        rename = "outputPaths",
6149        default,
6150        skip_serializing_if = "Option::is_none"
6151    )]
6152    pub output_paths: Option<Vec<String>>,
6153    #[serde(default, skip_serializing_if = "Option::is_none")]
6154    pub result: Option<serde_json::Value>,
6155    #[serde(default, skip_serializing)]
6156    pub status: String,
6157    pub structured: serde_json::Map<String, serde_json::Value>,
6158}
6159
6160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6161pub struct SessionMessageToolStateError {
6162    pub content: Vec<LLMToolContent>,
6163    pub error: SessionErrorUnknown,
6164    pub input: serde_json::Map<String, serde_json::Value>,
6165    #[serde(default, skip_serializing_if = "Option::is_none")]
6166    pub result: Option<serde_json::Value>,
6167    #[serde(default, skip_serializing)]
6168    pub status: String,
6169    pub structured: serde_json::Map<String, serde_json::Value>,
6170}
6171
6172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6173pub struct SessionMessageToolStatePending {
6174    pub input: String,
6175    #[serde(default, skip_serializing)]
6176    pub status: String,
6177}
6178
6179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6180pub struct SessionMessageToolStateRunning {
6181    pub content: Vec<LLMToolContent>,
6182    pub input: serde_json::Map<String, serde_json::Value>,
6183    #[serde(default, skip_serializing)]
6184    pub status: String,
6185    pub structured: serde_json::Map<String, serde_json::Value>,
6186}
6187
6188#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6189pub struct SessionMessageUser {
6190    #[serde(default, skip_serializing_if = "Option::is_none")]
6191    pub agents: Option<Vec<PromptAgentAttachment>>,
6192    #[serde(default, skip_serializing_if = "Option::is_none")]
6193    pub files: Option<Vec<PromptFileAttachment>>,
6194    pub id: String,
6195    #[serde(default, skip_serializing_if = "Option::is_none")]
6196    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6197    pub text: String,
6198    pub time: SessionMessageUserTime,
6199    #[serde(rename = "type", default, skip_serializing)]
6200    pub type_: String,
6201}
6202
6203#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6204pub struct SessionMessageUserTime {
6205    pub created: f64,
6206}
6207
6208#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6209pub struct SessionMessagesResponse {
6210    pub cursor: SessionsResponseCursor,
6211    pub data: Vec<SessionMessage>,
6212}
6213
6214#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6215pub struct SessionNextAgentSwitched {
6216    pub data: SessionNextAgentSwitchedData,
6217    #[serde(default, skip_serializing_if = "Option::is_none")]
6218    pub durable: Option<SessionStatus2Durable>,
6219    pub id: String,
6220    #[serde(default, skip_serializing_if = "Option::is_none")]
6221    pub location: Option<LocationRef>,
6222    #[serde(default, skip_serializing_if = "Option::is_none")]
6223    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6224    #[serde(rename = "type", default, skip_serializing)]
6225    pub type_: String,
6226}
6227
6228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6229pub struct SessionNextAgentSwitchedData {
6230    pub agent: String,
6231    #[serde(rename = "messageID")]
6232    pub message_id: String,
6233    #[serde(rename = "sessionID")]
6234    pub session_id: String,
6235    pub timestamp: f64,
6236}
6237
6238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6239pub struct SessionNextCompactionDelta {
6240    pub data: SessionNextContextUpdatedData,
6241    #[serde(default, skip_serializing_if = "Option::is_none")]
6242    pub durable: Option<SessionStatus2Durable>,
6243    pub id: String,
6244    #[serde(default, skip_serializing_if = "Option::is_none")]
6245    pub location: Option<LocationRef>,
6246    #[serde(default, skip_serializing_if = "Option::is_none")]
6247    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6248    #[serde(rename = "type", default, skip_serializing)]
6249    pub type_: String,
6250}
6251
6252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6253pub struct SessionNextCompactionEnded {
6254    pub data: SessionNextCompactionEndedData,
6255    #[serde(default, skip_serializing_if = "Option::is_none")]
6256    pub durable: Option<SessionStatus2Durable>,
6257    pub id: String,
6258    #[serde(default, skip_serializing_if = "Option::is_none")]
6259    pub location: Option<LocationRef>,
6260    #[serde(default, skip_serializing_if = "Option::is_none")]
6261    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6262    #[serde(rename = "type", default, skip_serializing)]
6263    pub type_: String,
6264}
6265
6266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6267pub struct SessionNextCompactionEndedData {
6268    #[serde(rename = "messageID")]
6269    pub message_id: String,
6270    pub reason: String,
6271    pub recent: String,
6272    #[serde(rename = "sessionID")]
6273    pub session_id: String,
6274    pub text: String,
6275    pub timestamp: f64,
6276}
6277
6278#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6279pub struct SessionNextCompactionStarted {
6280    pub data: SessionNextCompactionStartedData,
6281    #[serde(default, skip_serializing_if = "Option::is_none")]
6282    pub durable: Option<SessionStatus2Durable>,
6283    pub id: String,
6284    #[serde(default, skip_serializing_if = "Option::is_none")]
6285    pub location: Option<LocationRef>,
6286    #[serde(default, skip_serializing_if = "Option::is_none")]
6287    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6288    #[serde(rename = "type", default, skip_serializing)]
6289    pub type_: String,
6290}
6291
6292#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6293pub struct SessionNextCompactionStartedData {
6294    #[serde(rename = "messageID")]
6295    pub message_id: String,
6296    pub reason: String,
6297    #[serde(rename = "sessionID")]
6298    pub session_id: String,
6299    pub timestamp: f64,
6300}
6301
6302#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6303pub struct SessionNextContextUpdated {
6304    pub data: SessionNextContextUpdatedData,
6305    #[serde(default, skip_serializing_if = "Option::is_none")]
6306    pub durable: Option<SessionStatus2Durable>,
6307    pub id: String,
6308    #[serde(default, skip_serializing_if = "Option::is_none")]
6309    pub location: Option<LocationRef>,
6310    #[serde(default, skip_serializing_if = "Option::is_none")]
6311    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6312    #[serde(rename = "type", default, skip_serializing)]
6313    pub type_: String,
6314}
6315
6316#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6317pub struct SessionNextContextUpdatedData {
6318    #[serde(rename = "messageID")]
6319    pub message_id: String,
6320    #[serde(rename = "sessionID")]
6321    pub session_id: String,
6322    pub text: String,
6323    pub timestamp: f64,
6324}
6325
6326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6327pub struct SessionNextModelSwitched {
6328    pub data: SessionNextModelSwitchedData,
6329    #[serde(default, skip_serializing_if = "Option::is_none")]
6330    pub durable: Option<SessionStatus2Durable>,
6331    pub id: String,
6332    #[serde(default, skip_serializing_if = "Option::is_none")]
6333    pub location: Option<LocationRef>,
6334    #[serde(default, skip_serializing_if = "Option::is_none")]
6335    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6336    #[serde(rename = "type", default, skip_serializing)]
6337    pub type_: String,
6338}
6339
6340#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6341pub struct SessionNextModelSwitchedData {
6342    #[serde(rename = "messageID")]
6343    pub message_id: String,
6344    pub model: ModelRef,
6345    #[serde(rename = "sessionID")]
6346    pub session_id: String,
6347    pub timestamp: f64,
6348}
6349
6350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6351pub struct SessionNextMoved {
6352    pub data: SessionNextMovedData,
6353    #[serde(default, skip_serializing_if = "Option::is_none")]
6354    pub durable: Option<SessionStatus2Durable>,
6355    pub id: String,
6356    #[serde(default, skip_serializing_if = "Option::is_none")]
6357    pub location: Option<LocationRef>,
6358    #[serde(default, skip_serializing_if = "Option::is_none")]
6359    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6360    #[serde(rename = "type", default, skip_serializing)]
6361    pub type_: String,
6362}
6363
6364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6365pub struct SessionNextMovedData {
6366    pub location: LocationRef,
6367    #[serde(rename = "sessionID")]
6368    pub session_id: String,
6369    #[serde(default, skip_serializing_if = "Option::is_none")]
6370    pub subdirectory: Option<String>,
6371    pub timestamp: f64,
6372}
6373
6374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6375pub struct SessionNextPromptAdmitted {
6376    pub data: SessionNextPromptedData,
6377    #[serde(default, skip_serializing_if = "Option::is_none")]
6378    pub durable: Option<SessionStatus2Durable>,
6379    pub id: String,
6380    #[serde(default, skip_serializing_if = "Option::is_none")]
6381    pub location: Option<LocationRef>,
6382    #[serde(default, skip_serializing_if = "Option::is_none")]
6383    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6384    #[serde(rename = "type", default, skip_serializing)]
6385    pub type_: String,
6386}
6387
6388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6389pub struct SessionNextPrompted {
6390    pub data: SessionNextPromptedData,
6391    #[serde(default, skip_serializing_if = "Option::is_none")]
6392    pub durable: Option<SessionStatus2Durable>,
6393    pub id: String,
6394    #[serde(default, skip_serializing_if = "Option::is_none")]
6395    pub location: Option<LocationRef>,
6396    #[serde(default, skip_serializing_if = "Option::is_none")]
6397    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6398    #[serde(rename = "type", default, skip_serializing)]
6399    pub type_: String,
6400}
6401
6402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6403pub struct SessionNextPromptedData {
6404    pub delivery: String,
6405    #[serde(rename = "messageID")]
6406    pub message_id: String,
6407    pub prompt: Prompt,
6408    #[serde(rename = "sessionID")]
6409    pub session_id: String,
6410    pub timestamp: f64,
6411}
6412
6413#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6414pub struct SessionNextReasoningDelta {
6415    pub data: SessionNextReasoningDeltaData,
6416    #[serde(default, skip_serializing_if = "Option::is_none")]
6417    pub durable: Option<SessionStatus2Durable>,
6418    pub id: String,
6419    #[serde(default, skip_serializing_if = "Option::is_none")]
6420    pub location: Option<LocationRef>,
6421    #[serde(default, skip_serializing_if = "Option::is_none")]
6422    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6423    #[serde(rename = "type", default, skip_serializing)]
6424    pub type_: String,
6425}
6426
6427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6428pub struct SessionNextReasoningDeltaData {
6429    #[serde(rename = "assistantMessageID")]
6430    pub assistant_message_id: String,
6431    pub delta: String,
6432    #[serde(rename = "reasoningID")]
6433    pub reasoning_id: String,
6434    #[serde(rename = "sessionID")]
6435    pub session_id: String,
6436    pub timestamp: f64,
6437}
6438
6439#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6440pub struct SessionNextReasoningEnded {
6441    pub data: SessionNextReasoningEndedData,
6442    #[serde(default, skip_serializing_if = "Option::is_none")]
6443    pub durable: Option<SessionStatus2Durable>,
6444    pub id: String,
6445    #[serde(default, skip_serializing_if = "Option::is_none")]
6446    pub location: Option<LocationRef>,
6447    #[serde(default, skip_serializing_if = "Option::is_none")]
6448    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6449    #[serde(rename = "type", default, skip_serializing)]
6450    pub type_: String,
6451}
6452
6453#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6454pub struct SessionNextReasoningEndedData {
6455    #[serde(rename = "assistantMessageID")]
6456    pub assistant_message_id: String,
6457    #[serde(
6458        rename = "providerMetadata",
6459        default,
6460        skip_serializing_if = "Option::is_none"
6461    )]
6462    pub provider_metadata: Option<LLMProviderMetadata>,
6463    #[serde(rename = "reasoningID")]
6464    pub reasoning_id: String,
6465    #[serde(rename = "sessionID")]
6466    pub session_id: String,
6467    pub text: String,
6468    pub timestamp: f64,
6469}
6470
6471#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6472pub struct SessionNextReasoningStarted {
6473    pub data: SessionNextReasoningStartedData,
6474    #[serde(default, skip_serializing_if = "Option::is_none")]
6475    pub durable: Option<SessionStatus2Durable>,
6476    pub id: String,
6477    #[serde(default, skip_serializing_if = "Option::is_none")]
6478    pub location: Option<LocationRef>,
6479    #[serde(default, skip_serializing_if = "Option::is_none")]
6480    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6481    #[serde(rename = "type", default, skip_serializing)]
6482    pub type_: String,
6483}
6484
6485#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6486pub struct SessionNextReasoningStartedData {
6487    #[serde(rename = "assistantMessageID")]
6488    pub assistant_message_id: String,
6489    #[serde(
6490        rename = "providerMetadata",
6491        default,
6492        skip_serializing_if = "Option::is_none"
6493    )]
6494    pub provider_metadata: Option<LLMProviderMetadata>,
6495    #[serde(rename = "reasoningID")]
6496    pub reasoning_id: String,
6497    #[serde(rename = "sessionID")]
6498    pub session_id: String,
6499    pub timestamp: f64,
6500}
6501
6502#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6503pub struct SessionNextRetried {
6504    pub data: SessionNextRetriedData,
6505    #[serde(default, skip_serializing_if = "Option::is_none")]
6506    pub durable: Option<SessionStatus2Durable>,
6507    pub id: String,
6508    #[serde(default, skip_serializing_if = "Option::is_none")]
6509    pub location: Option<LocationRef>,
6510    #[serde(default, skip_serializing_if = "Option::is_none")]
6511    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6512    #[serde(rename = "type", default, skip_serializing)]
6513    pub type_: String,
6514}
6515
6516#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6517pub struct SessionNextRetriedData {
6518    pub attempt: f64,
6519    pub error: SessionNextRetryError,
6520    #[serde(rename = "sessionID")]
6521    pub session_id: String,
6522    pub timestamp: f64,
6523}
6524
6525#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6526pub struct SessionNextRetryError {
6527    #[serde(rename = "isRetryable")]
6528    pub is_retryable: bool,
6529    pub message: String,
6530    #[serde(default, skip_serializing_if = "Option::is_none")]
6531    pub metadata: Option<std::collections::BTreeMap<String, String>>,
6532    #[serde(
6533        rename = "responseBody",
6534        default,
6535        skip_serializing_if = "Option::is_none"
6536    )]
6537    pub response_body: Option<String>,
6538    #[serde(
6539        rename = "responseHeaders",
6540        default,
6541        skip_serializing_if = "Option::is_none"
6542    )]
6543    pub response_headers: Option<std::collections::BTreeMap<String, String>>,
6544    #[serde(
6545        rename = "statusCode",
6546        default,
6547        skip_serializing_if = "Option::is_none"
6548    )]
6549    pub status_code: Option<f64>,
6550}
6551
6552#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6553pub struct SessionNextRevertCleared {
6554    pub data: SessionNextRevertClearedData,
6555    #[serde(default, skip_serializing_if = "Option::is_none")]
6556    pub durable: Option<SessionStatus2Durable>,
6557    pub id: String,
6558    #[serde(default, skip_serializing_if = "Option::is_none")]
6559    pub location: Option<LocationRef>,
6560    #[serde(default, skip_serializing_if = "Option::is_none")]
6561    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6562    #[serde(rename = "type", default, skip_serializing)]
6563    pub type_: String,
6564}
6565
6566#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6567pub struct SessionNextRevertClearedData {
6568    #[serde(rename = "sessionID")]
6569    pub session_id: String,
6570    pub timestamp: f64,
6571}
6572
6573#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6574pub struct SessionNextRevertCommitted {
6575    pub data: SessionNextRevertCommittedData,
6576    #[serde(default, skip_serializing_if = "Option::is_none")]
6577    pub durable: Option<SessionStatus2Durable>,
6578    pub id: String,
6579    #[serde(default, skip_serializing_if = "Option::is_none")]
6580    pub location: Option<LocationRef>,
6581    #[serde(default, skip_serializing_if = "Option::is_none")]
6582    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6583    #[serde(rename = "type", default, skip_serializing)]
6584    pub type_: String,
6585}
6586
6587#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6588pub struct SessionNextRevertCommittedData {
6589    #[serde(rename = "messageID")]
6590    pub message_id: String,
6591    #[serde(rename = "sessionID")]
6592    pub session_id: String,
6593    pub timestamp: f64,
6594}
6595
6596#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6597pub struct SessionNextRevertStaged {
6598    pub data: SessionNextRevertStagedData,
6599    #[serde(default, skip_serializing_if = "Option::is_none")]
6600    pub durable: Option<SessionStatus2Durable>,
6601    pub id: String,
6602    #[serde(default, skip_serializing_if = "Option::is_none")]
6603    pub location: Option<LocationRef>,
6604    #[serde(default, skip_serializing_if = "Option::is_none")]
6605    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6606    #[serde(rename = "type", default, skip_serializing)]
6607    pub type_: String,
6608}
6609
6610#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6611pub struct SessionNextRevertStagedData {
6612    pub revert: RevertState,
6613    #[serde(rename = "sessionID")]
6614    pub session_id: String,
6615    pub timestamp: f64,
6616}
6617
6618#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6619pub struct SessionNextShellEnded {
6620    pub data: SessionNextShellEndedData,
6621    #[serde(default, skip_serializing_if = "Option::is_none")]
6622    pub durable: Option<SessionStatus2Durable>,
6623    pub id: String,
6624    #[serde(default, skip_serializing_if = "Option::is_none")]
6625    pub location: Option<LocationRef>,
6626    #[serde(default, skip_serializing_if = "Option::is_none")]
6627    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6628    #[serde(rename = "type", default, skip_serializing)]
6629    pub type_: String,
6630}
6631
6632#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6633pub struct SessionNextShellEndedData {
6634    #[serde(rename = "callID")]
6635    pub call_id: String,
6636    pub output: String,
6637    #[serde(rename = "sessionID")]
6638    pub session_id: String,
6639    pub timestamp: f64,
6640}
6641
6642#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6643pub struct SessionNextShellStarted {
6644    pub data: SessionNextShellStartedData,
6645    #[serde(default, skip_serializing_if = "Option::is_none")]
6646    pub durable: Option<SessionStatus2Durable>,
6647    pub id: String,
6648    #[serde(default, skip_serializing_if = "Option::is_none")]
6649    pub location: Option<LocationRef>,
6650    #[serde(default, skip_serializing_if = "Option::is_none")]
6651    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6652    #[serde(rename = "type", default, skip_serializing)]
6653    pub type_: String,
6654}
6655
6656#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6657pub struct SessionNextShellStartedData {
6658    #[serde(rename = "callID")]
6659    pub call_id: String,
6660    pub command: String,
6661    #[serde(rename = "messageID")]
6662    pub message_id: String,
6663    #[serde(rename = "sessionID")]
6664    pub session_id: String,
6665    pub timestamp: f64,
6666}
6667
6668#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6669pub struct SessionNextStepEnded {
6670    pub data: SessionNextStepEndedData,
6671    #[serde(default, skip_serializing_if = "Option::is_none")]
6672    pub durable: Option<SessionStatus2Durable>,
6673    pub id: String,
6674    #[serde(default, skip_serializing_if = "Option::is_none")]
6675    pub location: Option<LocationRef>,
6676    #[serde(default, skip_serializing_if = "Option::is_none")]
6677    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6678    #[serde(rename = "type", default, skip_serializing)]
6679    pub type_: String,
6680}
6681
6682#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6683pub struct SessionNextStepEndedData {
6684    #[serde(rename = "assistantMessageID")]
6685    pub assistant_message_id: String,
6686    pub cost: f64,
6687    #[serde(default, skip_serializing_if = "Option::is_none")]
6688    pub files: Option<Vec<String>>,
6689    pub finish: String,
6690    #[serde(rename = "sessionID")]
6691    pub session_id: String,
6692    #[serde(default, skip_serializing_if = "Option::is_none")]
6693    pub snapshot: Option<String>,
6694    pub timestamp: f64,
6695    pub tokens: SessionNextStepEndedDataTokens,
6696}
6697
6698#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6699pub struct SessionNextStepEndedDataTokens {
6700    pub cache: SessionNextStepEndedDataTokensCache,
6701    pub input: f64,
6702    pub output: f64,
6703    pub reasoning: f64,
6704}
6705
6706#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6707pub struct SessionNextStepEndedDataTokensCache {
6708    pub read: f64,
6709    pub write: f64,
6710}
6711
6712#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6713pub struct SessionNextStepFailed {
6714    pub data: SessionNextStepFailedData,
6715    #[serde(default, skip_serializing_if = "Option::is_none")]
6716    pub durable: Option<SessionStatus2Durable>,
6717    pub id: String,
6718    #[serde(default, skip_serializing_if = "Option::is_none")]
6719    pub location: Option<LocationRef>,
6720    #[serde(default, skip_serializing_if = "Option::is_none")]
6721    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6722    #[serde(rename = "type", default, skip_serializing)]
6723    pub type_: String,
6724}
6725
6726#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6727pub struct SessionNextStepFailedData {
6728    #[serde(rename = "assistantMessageID")]
6729    pub assistant_message_id: String,
6730    pub error: SessionErrorUnknown,
6731    #[serde(rename = "sessionID")]
6732    pub session_id: String,
6733    pub timestamp: f64,
6734}
6735
6736#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6737pub struct SessionNextStepStarted {
6738    pub data: SessionNextStepStartedData,
6739    #[serde(default, skip_serializing_if = "Option::is_none")]
6740    pub durable: Option<SessionStatus2Durable>,
6741    pub id: String,
6742    #[serde(default, skip_serializing_if = "Option::is_none")]
6743    pub location: Option<LocationRef>,
6744    #[serde(default, skip_serializing_if = "Option::is_none")]
6745    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6746    #[serde(rename = "type", default, skip_serializing)]
6747    pub type_: String,
6748}
6749
6750#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6751pub struct SessionNextStepStartedData {
6752    pub agent: String,
6753    #[serde(rename = "assistantMessageID")]
6754    pub assistant_message_id: String,
6755    pub model: ModelRef,
6756    #[serde(rename = "sessionID")]
6757    pub session_id: String,
6758    #[serde(default, skip_serializing_if = "Option::is_none")]
6759    pub snapshot: Option<String>,
6760    pub timestamp: f64,
6761}
6762
6763#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6764pub struct SessionNextSynthetic {
6765    pub data: SessionNextContextUpdatedData,
6766    #[serde(default, skip_serializing_if = "Option::is_none")]
6767    pub durable: Option<SessionStatus2Durable>,
6768    pub id: String,
6769    #[serde(default, skip_serializing_if = "Option::is_none")]
6770    pub location: Option<LocationRef>,
6771    #[serde(default, skip_serializing_if = "Option::is_none")]
6772    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6773    #[serde(rename = "type", default, skip_serializing)]
6774    pub type_: String,
6775}
6776
6777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6778pub struct SessionNextTextDelta {
6779    pub data: SessionNextTextDeltaData,
6780    #[serde(default, skip_serializing_if = "Option::is_none")]
6781    pub durable: Option<SessionStatus2Durable>,
6782    pub id: String,
6783    #[serde(default, skip_serializing_if = "Option::is_none")]
6784    pub location: Option<LocationRef>,
6785    #[serde(default, skip_serializing_if = "Option::is_none")]
6786    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6787    #[serde(rename = "type", default, skip_serializing)]
6788    pub type_: String,
6789}
6790
6791#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6792pub struct SessionNextTextDeltaData {
6793    #[serde(rename = "assistantMessageID")]
6794    pub assistant_message_id: String,
6795    pub delta: String,
6796    #[serde(rename = "sessionID")]
6797    pub session_id: String,
6798    #[serde(rename = "textID")]
6799    pub text_id: String,
6800    pub timestamp: f64,
6801}
6802
6803#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6804pub struct SessionNextTextEnded {
6805    pub data: SessionNextTextEndedData,
6806    #[serde(default, skip_serializing_if = "Option::is_none")]
6807    pub durable: Option<SessionStatus2Durable>,
6808    pub id: String,
6809    #[serde(default, skip_serializing_if = "Option::is_none")]
6810    pub location: Option<LocationRef>,
6811    #[serde(default, skip_serializing_if = "Option::is_none")]
6812    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6813    #[serde(rename = "type", default, skip_serializing)]
6814    pub type_: String,
6815}
6816
6817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6818pub struct SessionNextTextEndedData {
6819    #[serde(rename = "assistantMessageID")]
6820    pub assistant_message_id: String,
6821    #[serde(rename = "sessionID")]
6822    pub session_id: String,
6823    pub text: String,
6824    #[serde(rename = "textID")]
6825    pub text_id: String,
6826    pub timestamp: f64,
6827}
6828
6829#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6830pub struct SessionNextTextStarted {
6831    pub data: SessionNextTextStartedData,
6832    #[serde(default, skip_serializing_if = "Option::is_none")]
6833    pub durable: Option<SessionStatus2Durable>,
6834    pub id: String,
6835    #[serde(default, skip_serializing_if = "Option::is_none")]
6836    pub location: Option<LocationRef>,
6837    #[serde(default, skip_serializing_if = "Option::is_none")]
6838    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6839    #[serde(rename = "type", default, skip_serializing)]
6840    pub type_: String,
6841}
6842
6843#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6844pub struct SessionNextTextStartedData {
6845    #[serde(rename = "assistantMessageID")]
6846    pub assistant_message_id: String,
6847    #[serde(rename = "sessionID")]
6848    pub session_id: String,
6849    #[serde(rename = "textID")]
6850    pub text_id: String,
6851    pub timestamp: f64,
6852}
6853
6854#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6855pub struct SessionNextToolCalled {
6856    pub data: SessionNextToolCalledData,
6857    #[serde(default, skip_serializing_if = "Option::is_none")]
6858    pub durable: Option<SessionStatus2Durable>,
6859    pub id: String,
6860    #[serde(default, skip_serializing_if = "Option::is_none")]
6861    pub location: Option<LocationRef>,
6862    #[serde(default, skip_serializing_if = "Option::is_none")]
6863    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6864    #[serde(rename = "type", default, skip_serializing)]
6865    pub type_: String,
6866}
6867
6868#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6869pub struct SessionNextToolCalledData {
6870    #[serde(rename = "assistantMessageID")]
6871    pub assistant_message_id: String,
6872    #[serde(rename = "callID")]
6873    pub call_id: String,
6874    pub input: serde_json::Map<String, serde_json::Value>,
6875    pub provider: SessionNextToolFailedDataProvider,
6876    #[serde(rename = "sessionID")]
6877    pub session_id: String,
6878    pub timestamp: f64,
6879    pub tool: String,
6880}
6881
6882#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6883pub struct SessionNextToolFailed {
6884    pub data: SessionNextToolFailedData,
6885    #[serde(default, skip_serializing_if = "Option::is_none")]
6886    pub durable: Option<SessionStatus2Durable>,
6887    pub id: String,
6888    #[serde(default, skip_serializing_if = "Option::is_none")]
6889    pub location: Option<LocationRef>,
6890    #[serde(default, skip_serializing_if = "Option::is_none")]
6891    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6892    #[serde(rename = "type", default, skip_serializing)]
6893    pub type_: String,
6894}
6895
6896#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6897pub struct SessionNextToolFailedData {
6898    #[serde(rename = "assistantMessageID")]
6899    pub assistant_message_id: String,
6900    #[serde(rename = "callID")]
6901    pub call_id: String,
6902    pub error: SessionErrorUnknown,
6903    pub provider: SessionNextToolFailedDataProvider,
6904    #[serde(default, skip_serializing_if = "Option::is_none")]
6905    pub result: Option<serde_json::Value>,
6906    #[serde(rename = "sessionID")]
6907    pub session_id: String,
6908    pub timestamp: f64,
6909}
6910
6911#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6912pub struct SessionNextToolFailedDataProvider {
6913    pub executed: bool,
6914    #[serde(default, skip_serializing_if = "Option::is_none")]
6915    pub metadata: Option<LLMProviderMetadata>,
6916}
6917
6918#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6919pub struct SessionNextToolInputDelta {
6920    pub data: SessionNextToolInputDeltaData,
6921    #[serde(default, skip_serializing_if = "Option::is_none")]
6922    pub durable: Option<SessionStatus2Durable>,
6923    pub id: String,
6924    #[serde(default, skip_serializing_if = "Option::is_none")]
6925    pub location: Option<LocationRef>,
6926    #[serde(default, skip_serializing_if = "Option::is_none")]
6927    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6928    #[serde(rename = "type", default, skip_serializing)]
6929    pub type_: String,
6930}
6931
6932#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6933pub struct SessionNextToolInputDeltaData {
6934    #[serde(rename = "assistantMessageID")]
6935    pub assistant_message_id: String,
6936    #[serde(rename = "callID")]
6937    pub call_id: String,
6938    pub delta: String,
6939    #[serde(rename = "sessionID")]
6940    pub session_id: String,
6941    pub timestamp: f64,
6942}
6943
6944#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6945pub struct SessionNextToolInputEnded {
6946    pub data: SessionNextToolInputEndedData,
6947    #[serde(default, skip_serializing_if = "Option::is_none")]
6948    pub durable: Option<SessionStatus2Durable>,
6949    pub id: String,
6950    #[serde(default, skip_serializing_if = "Option::is_none")]
6951    pub location: Option<LocationRef>,
6952    #[serde(default, skip_serializing_if = "Option::is_none")]
6953    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6954    #[serde(rename = "type", default, skip_serializing)]
6955    pub type_: String,
6956}
6957
6958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6959pub struct SessionNextToolInputEndedData {
6960    #[serde(rename = "assistantMessageID")]
6961    pub assistant_message_id: String,
6962    #[serde(rename = "callID")]
6963    pub call_id: String,
6964    #[serde(rename = "sessionID")]
6965    pub session_id: String,
6966    pub text: String,
6967    pub timestamp: f64,
6968}
6969
6970#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6971pub struct SessionNextToolInputStarted {
6972    pub data: SessionNextToolInputStartedData,
6973    #[serde(default, skip_serializing_if = "Option::is_none")]
6974    pub durable: Option<SessionStatus2Durable>,
6975    pub id: String,
6976    #[serde(default, skip_serializing_if = "Option::is_none")]
6977    pub location: Option<LocationRef>,
6978    #[serde(default, skip_serializing_if = "Option::is_none")]
6979    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
6980    #[serde(rename = "type", default, skip_serializing)]
6981    pub type_: String,
6982}
6983
6984#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6985pub struct SessionNextToolInputStartedData {
6986    #[serde(rename = "assistantMessageID")]
6987    pub assistant_message_id: String,
6988    #[serde(rename = "callID")]
6989    pub call_id: String,
6990    pub name: String,
6991    #[serde(rename = "sessionID")]
6992    pub session_id: String,
6993    pub timestamp: f64,
6994}
6995
6996#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
6997pub struct SessionNextToolProgress {
6998    pub data: SessionNextToolProgressData,
6999    #[serde(default, skip_serializing_if = "Option::is_none")]
7000    pub durable: Option<SessionStatus2Durable>,
7001    pub id: String,
7002    #[serde(default, skip_serializing_if = "Option::is_none")]
7003    pub location: Option<LocationRef>,
7004    #[serde(default, skip_serializing_if = "Option::is_none")]
7005    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7006    #[serde(rename = "type", default, skip_serializing)]
7007    pub type_: String,
7008}
7009
7010#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7011pub struct SessionNextToolProgressData {
7012    #[serde(rename = "assistantMessageID")]
7013    pub assistant_message_id: String,
7014    #[serde(rename = "callID")]
7015    pub call_id: String,
7016    pub content: Vec<LLMToolContent>,
7017    #[serde(rename = "sessionID")]
7018    pub session_id: String,
7019    pub structured: serde_json::Map<String, serde_json::Value>,
7020    pub timestamp: f64,
7021}
7022
7023#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7024pub struct SessionNextToolSuccess {
7025    pub data: SessionNextToolSuccessData,
7026    #[serde(default, skip_serializing_if = "Option::is_none")]
7027    pub durable: Option<SessionStatus2Durable>,
7028    pub id: String,
7029    #[serde(default, skip_serializing_if = "Option::is_none")]
7030    pub location: Option<LocationRef>,
7031    #[serde(default, skip_serializing_if = "Option::is_none")]
7032    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7033    #[serde(rename = "type", default, skip_serializing)]
7034    pub type_: String,
7035}
7036
7037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7038pub struct SessionNextToolSuccessData {
7039    #[serde(rename = "assistantMessageID")]
7040    pub assistant_message_id: String,
7041    #[serde(rename = "callID")]
7042    pub call_id: String,
7043    pub content: Vec<LLMToolContent>,
7044    #[serde(
7045        rename = "outputPaths",
7046        default,
7047        skip_serializing_if = "Option::is_none"
7048    )]
7049    pub output_paths: Option<Vec<String>>,
7050    pub provider: SessionNextToolFailedDataProvider,
7051    #[serde(default, skip_serializing_if = "Option::is_none")]
7052    pub result: Option<serde_json::Value>,
7053    #[serde(rename = "sessionID")]
7054    pub session_id: String,
7055    pub structured: serde_json::Map<String, serde_json::Value>,
7056    pub timestamp: f64,
7057}
7058
7059#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7060pub struct SessionNotFoundError {
7061    pub _tag: String,
7062    pub message: String,
7063    #[serde(rename = "sessionID")]
7064    pub session_id: String,
7065}
7066
7067#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7068pub struct SessionRevert {
7069    #[serde(default, skip_serializing_if = "Option::is_none")]
7070    pub diff: Option<String>,
7071    #[serde(rename = "messageID")]
7072    pub message_id: String,
7073    #[serde(rename = "partID", default, skip_serializing_if = "Option::is_none")]
7074    pub part_id: Option<String>,
7075    #[serde(default, skip_serializing_if = "Option::is_none")]
7076    pub snapshot: Option<String>,
7077}
7078
7079#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7080pub struct SessionShare {
7081    pub url: String,
7082}
7083
7084#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7085#[serde(tag = "type")]
7086pub enum SessionStatus {
7087    #[serde(rename = "idle")]
7088    Idle,
7089    #[serde(rename = "retry")]
7090    Retry {
7091        #[serde(default, skip_serializing_if = "Option::is_none")]
7092        action: Option<SessionStatusRetryAction>,
7093        attempt: u64,
7094        message: String,
7095        next: u64,
7096    },
7097    #[serde(rename = "busy")]
7098    Busy,
7099}
7100
7101#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7102pub struct SessionStatus2Data {
7103    #[serde(rename = "sessionID")]
7104    pub session_id: String,
7105    pub status: SessionStatus,
7106}
7107
7108#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7109pub struct SessionStatus2Durable {
7110    #[serde(rename = "aggregateID")]
7111    pub aggregate_id: String,
7112    pub seq: i64,
7113    pub version: i64,
7114}
7115
7116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7117pub struct SessionStatusRetryAction {
7118    pub label: String,
7119    #[serde(default, skip_serializing_if = "Option::is_none")]
7120    pub link: Option<String>,
7121    pub message: String,
7122    pub provider: String,
7123    pub reason: String,
7124    pub title: String,
7125}
7126
7127#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7128pub struct SessionSummary {
7129    pub additions: f64,
7130    pub deletions: f64,
7131    #[serde(default, skip_serializing_if = "Option::is_none")]
7132    pub diffs: Option<Vec<SnapshotFileDiff>>,
7133    pub files: f64,
7134}
7135
7136#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7137pub struct SessionTime {
7138    #[serde(default, skip_serializing_if = "Option::is_none")]
7139    pub archived: Option<f64>,
7140    #[serde(default, skip_serializing_if = "Option::is_none")]
7141    pub compacting: Option<u64>,
7142    pub created: u64,
7143    pub updated: u64,
7144}
7145
7146#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7147pub struct SessionUpdated {
7148    pub data: SessionCreatedData,
7149    #[serde(default, skip_serializing_if = "Option::is_none")]
7150    pub durable: Option<SessionStatus2Durable>,
7151    pub id: String,
7152    #[serde(default, skip_serializing_if = "Option::is_none")]
7153    pub location: Option<LocationRef>,
7154    #[serde(default, skip_serializing_if = "Option::is_none")]
7155    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
7156    #[serde(rename = "type", default, skip_serializing)]
7157    pub type_: String,
7158}
7159
7160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7161pub struct SessionV2Info {
7162    #[serde(default, skip_serializing_if = "Option::is_none")]
7163    pub agent: Option<String>,
7164    pub cost: f64,
7165    pub id: String,
7166    pub location: LocationRef,
7167    #[serde(default, skip_serializing_if = "Option::is_none")]
7168    pub model: Option<ModelRef>,
7169    #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")]
7170    pub parent_id: Option<String>,
7171    #[serde(rename = "projectID")]
7172    pub project_id: String,
7173    #[serde(default, skip_serializing_if = "Option::is_none")]
7174    pub revert: Option<RevertState>,
7175    #[serde(default, skip_serializing_if = "Option::is_none")]
7176    pub subpath: Option<String>,
7177    pub time: SessionV2InfoTime,
7178    pub title: String,
7179    pub tokens: SessionNextStepEndedDataTokens,
7180}
7181
7182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7183pub struct SessionV2InfoTime {
7184    #[serde(default, skip_serializing_if = "Option::is_none")]
7185    pub archived: Option<f64>,
7186    pub created: f64,
7187    pub updated: f64,
7188}
7189
7190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7191pub struct SessionsResponse {
7192    pub cursor: SessionsResponseCursor,
7193    pub data: Vec<SessionV2Info>,
7194}
7195
7196#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7197pub struct SessionsResponseCursor {
7198    #[serde(default, skip_serializing_if = "Option::is_none")]
7199    pub next: Option<String>,
7200    #[serde(default, skip_serializing_if = "Option::is_none")]
7201    pub previous: Option<String>,
7202}
7203
7204#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7205pub struct SkillV2DirectorySource {
7206    pub path: String,
7207    #[serde(rename = "type", default, skip_serializing)]
7208    pub type_: String,
7209}
7210
7211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7212pub struct SkillV2EmbeddedSource {
7213    pub skill: SkillV2Info,
7214    #[serde(rename = "type", default, skip_serializing)]
7215    pub type_: String,
7216}
7217
7218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7219pub struct SkillV2Info {
7220    pub content: String,
7221    #[serde(default, skip_serializing_if = "Option::is_none")]
7222    pub description: Option<String>,
7223    pub location: String,
7224    pub name: String,
7225    #[serde(default, skip_serializing_if = "Option::is_none")]
7226    pub slash: Option<bool>,
7227}
7228
7229#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7230#[serde(tag = "type")]
7231pub enum SkillV2Source {
7232    #[serde(rename = "directory")]
7233    Directory(SkillV2DirectorySource),
7234    #[serde(rename = "url")]
7235    Url(SkillV2UrlSource),
7236    #[serde(rename = "embedded")]
7237    Embedded(SkillV2EmbeddedSource),
7238}
7239
7240#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7241pub struct SkillV2UrlSource {
7242    #[serde(rename = "type", default, skip_serializing)]
7243    pub type_: String,
7244    pub url: String,
7245}
7246
7247#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7248pub struct SnapshotFileDiff {
7249    pub additions: f64,
7250    pub deletions: f64,
7251    #[serde(default, skip_serializing_if = "Option::is_none")]
7252    pub file: Option<String>,
7253    #[serde(default, skip_serializing_if = "Option::is_none")]
7254    pub patch: Option<String>,
7255    #[serde(default, skip_serializing_if = "Option::is_none")]
7256    pub status: Option<String>,
7257}
7258
7259#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7260pub struct SnapshotPart {
7261    pub id: String,
7262    #[serde(rename = "messageID")]
7263    pub message_id: String,
7264    #[serde(rename = "sessionID")]
7265    pub session_id: String,
7266    pub snapshot: String,
7267    #[serde(rename = "type", default, skip_serializing)]
7268    pub type_: String,
7269}
7270
7271#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7272pub struct StepFinishPart {
7273    pub cost: f64,
7274    pub id: String,
7275    #[serde(rename = "messageID")]
7276    pub message_id: String,
7277    pub reason: String,
7278    #[serde(rename = "sessionID")]
7279    pub session_id: String,
7280    #[serde(default, skip_serializing_if = "Option::is_none")]
7281    pub snapshot: Option<String>,
7282    pub tokens: StepFinishPartTokens,
7283    #[serde(rename = "type", default, skip_serializing)]
7284    pub type_: String,
7285}
7286
7287#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7288pub struct StepFinishPartTokens {
7289    pub cache: SessionNextStepEndedDataTokensCache,
7290    pub input: f64,
7291    pub output: f64,
7292    pub reasoning: f64,
7293    #[serde(default, skip_serializing_if = "Option::is_none")]
7294    pub total: Option<f64>,
7295}
7296
7297#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7298pub struct StepStartPart {
7299    pub id: String,
7300    #[serde(rename = "messageID")]
7301    pub message_id: String,
7302    #[serde(rename = "sessionID")]
7303    pub session_id: String,
7304    #[serde(default, skip_serializing_if = "Option::is_none")]
7305    pub snapshot: Option<String>,
7306    #[serde(rename = "type", default, skip_serializing)]
7307    pub type_: String,
7308}
7309
7310#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7311pub struct StructuredOutputError {
7312    pub data: StructuredOutputErrorData,
7313    #[serde(default, skip_serializing)]
7314    pub name: String,
7315}
7316
7317#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7318pub struct StructuredOutputErrorData {
7319    pub message: String,
7320    pub retries: u64,
7321}
7322
7323#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7324pub struct SubtaskPart {
7325    pub agent: String,
7326    #[serde(default, skip_serializing_if = "Option::is_none")]
7327    pub command: Option<String>,
7328    pub description: String,
7329    pub id: String,
7330    #[serde(rename = "messageID")]
7331    pub message_id: String,
7332    #[serde(default, skip_serializing_if = "Option::is_none")]
7333    pub model: Option<SubtaskPartInputModel>,
7334    pub prompt: String,
7335    #[serde(rename = "sessionID")]
7336    pub session_id: String,
7337    #[serde(rename = "type", default, skip_serializing)]
7338    pub type_: String,
7339}
7340
7341#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7342pub struct SubtaskPartInput {
7343    pub agent: String,
7344    #[serde(default, skip_serializing_if = "Option::is_none")]
7345    pub command: Option<String>,
7346    pub description: String,
7347    #[serde(default, skip_serializing_if = "Option::is_none")]
7348    pub id: Option<String>,
7349    #[serde(default, skip_serializing_if = "Option::is_none")]
7350    pub model: Option<SubtaskPartInputModel>,
7351    pub prompt: String,
7352    #[serde(rename = "type", default, skip_serializing)]
7353    pub type_: String,
7354}
7355
7356#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7357pub struct SubtaskPartInputModel {
7358    #[serde(rename = "modelID")]
7359    pub model_id: String,
7360    #[serde(rename = "providerID")]
7361    pub provider_id: String,
7362}
7363
7364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7365pub struct Symbol {
7366    pub kind: u64,
7367    pub location: SymbolLocation,
7368    pub name: String,
7369}
7370
7371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7372pub struct SymbolLocation {
7373    pub range: Range,
7374    pub uri: String,
7375}
7376
7377#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7378pub struct SymbolSource {
7379    pub kind: u64,
7380    pub name: String,
7381    pub path: String,
7382    pub range: Range,
7383    pub text: FilePartSourceText,
7384    #[serde(rename = "type", default, skip_serializing)]
7385    pub type_: String,
7386}
7387
7388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7389pub struct SyncEventMessagePartRemoved {
7390    pub id: String,
7391    #[serde(rename = "syncEvent")]
7392    pub sync_event: SyncEventMessagePartRemovedSyncEvent,
7393    #[serde(rename = "type")]
7394    pub type_: String,
7395}
7396
7397#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7398pub struct SyncEventMessagePartRemovedSyncEvent {
7399    #[serde(rename = "aggregateID")]
7400    pub aggregate_id: String,
7401    pub data: MessagePartRemovedData,
7402    pub id: String,
7403    pub seq: f64,
7404    #[serde(rename = "type")]
7405    pub type_: String,
7406}
7407
7408#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7409pub struct SyncEventMessagePartUpdated {
7410    pub id: String,
7411    #[serde(rename = "syncEvent")]
7412    pub sync_event: SyncEventMessagePartUpdatedSyncEvent,
7413    #[serde(rename = "type")]
7414    pub type_: String,
7415}
7416
7417#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7418pub struct SyncEventMessagePartUpdatedSyncEvent {
7419    #[serde(rename = "aggregateID")]
7420    pub aggregate_id: String,
7421    pub data: MessagePartUpdatedData,
7422    pub id: String,
7423    pub seq: f64,
7424    #[serde(rename = "type")]
7425    pub type_: String,
7426}
7427
7428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7429pub struct SyncEventMessageRemoved {
7430    pub id: String,
7431    #[serde(rename = "syncEvent")]
7432    pub sync_event: SyncEventMessageRemovedSyncEvent,
7433    #[serde(rename = "type")]
7434    pub type_: String,
7435}
7436
7437#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7438pub struct SyncEventMessageRemovedSyncEvent {
7439    #[serde(rename = "aggregateID")]
7440    pub aggregate_id: String,
7441    pub data: MessageRemovedData,
7442    pub id: String,
7443    pub seq: f64,
7444    #[serde(rename = "type")]
7445    pub type_: String,
7446}
7447
7448#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7449pub struct SyncEventMessageUpdated {
7450    pub id: String,
7451    #[serde(rename = "syncEvent")]
7452    pub sync_event: SyncEventMessageUpdatedSyncEvent,
7453    #[serde(rename = "type")]
7454    pub type_: String,
7455}
7456
7457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7458pub struct SyncEventMessageUpdatedSyncEvent {
7459    #[serde(rename = "aggregateID")]
7460    pub aggregate_id: String,
7461    pub data: MessageUpdatedData,
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 SyncEventSessionCreated {
7470    pub id: String,
7471    #[serde(rename = "syncEvent")]
7472    pub sync_event: SyncEventSessionCreatedSyncEvent,
7473    #[serde(rename = "type")]
7474    pub type_: String,
7475}
7476
7477#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7478pub struct SyncEventSessionCreatedSyncEvent {
7479    #[serde(rename = "aggregateID")]
7480    pub aggregate_id: String,
7481    pub data: SessionCreatedData,
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 SyncEventSessionDeleted {
7490    pub id: String,
7491    #[serde(rename = "syncEvent")]
7492    pub sync_event: SyncEventSessionDeletedSyncEvent,
7493    #[serde(rename = "type")]
7494    pub type_: String,
7495}
7496
7497#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7498pub struct SyncEventSessionDeletedSyncEvent {
7499    #[serde(rename = "aggregateID")]
7500    pub aggregate_id: String,
7501    pub data: SessionCreatedData,
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 SyncEventSessionNextAgentSwitched {
7510    pub id: String,
7511    #[serde(rename = "syncEvent")]
7512    pub sync_event: SyncEventSessionNextAgentSwitchedSyncEvent,
7513    #[serde(rename = "type")]
7514    pub type_: String,
7515}
7516
7517#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7518pub struct SyncEventSessionNextAgentSwitchedSyncEvent {
7519    #[serde(rename = "aggregateID")]
7520    pub aggregate_id: String,
7521    pub data: SessionNextAgentSwitchedData,
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 SyncEventSessionNextCompactionEnded {
7530    pub id: String,
7531    #[serde(rename = "syncEvent")]
7532    pub sync_event: SyncEventSessionNextCompactionEndedSyncEvent,
7533    #[serde(rename = "type")]
7534    pub type_: String,
7535}
7536
7537#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7538pub struct SyncEventSessionNextCompactionEndedSyncEvent {
7539    #[serde(rename = "aggregateID")]
7540    pub aggregate_id: String,
7541    pub data: SessionNextCompactionEndedData,
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 SyncEventSessionNextCompactionStarted {
7550    pub id: String,
7551    #[serde(rename = "syncEvent")]
7552    pub sync_event: SyncEventSessionNextCompactionStartedSyncEvent,
7553    #[serde(rename = "type")]
7554    pub type_: String,
7555}
7556
7557#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7558pub struct SyncEventSessionNextCompactionStartedSyncEvent {
7559    #[serde(rename = "aggregateID")]
7560    pub aggregate_id: String,
7561    pub data: SessionNextCompactionStartedData,
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 SyncEventSessionNextContextUpdated {
7570    pub id: String,
7571    #[serde(rename = "syncEvent")]
7572    pub sync_event: SyncEventSessionNextContextUpdatedSyncEvent,
7573    #[serde(rename = "type")]
7574    pub type_: String,
7575}
7576
7577#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7578pub struct SyncEventSessionNextContextUpdatedSyncEvent {
7579    #[serde(rename = "aggregateID")]
7580    pub aggregate_id: String,
7581    pub data: SessionNextContextUpdatedData,
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 SyncEventSessionNextModelSwitched {
7590    pub id: String,
7591    #[serde(rename = "syncEvent")]
7592    pub sync_event: SyncEventSessionNextModelSwitchedSyncEvent,
7593    #[serde(rename = "type")]
7594    pub type_: String,
7595}
7596
7597#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7598pub struct SyncEventSessionNextModelSwitchedSyncEvent {
7599    #[serde(rename = "aggregateID")]
7600    pub aggregate_id: String,
7601    pub data: SessionNextModelSwitchedData,
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 SyncEventSessionNextMoved {
7610    pub id: String,
7611    #[serde(rename = "syncEvent")]
7612    pub sync_event: SyncEventSessionNextMovedSyncEvent,
7613    #[serde(rename = "type")]
7614    pub type_: String,
7615}
7616
7617#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7618pub struct SyncEventSessionNextMovedSyncEvent {
7619    #[serde(rename = "aggregateID")]
7620    pub aggregate_id: String,
7621    pub data: SessionNextMovedData,
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 SyncEventSessionNextPromptAdmitted {
7630    pub id: String,
7631    #[serde(rename = "syncEvent")]
7632    pub sync_event: SyncEventSessionNextPromptAdmittedSyncEvent,
7633    #[serde(rename = "type")]
7634    pub type_: String,
7635}
7636
7637#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7638pub struct SyncEventSessionNextPromptAdmittedSyncEvent {
7639    #[serde(rename = "aggregateID")]
7640    pub aggregate_id: String,
7641    pub data: SessionNextPromptedData,
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 SyncEventSessionNextPrompted {
7650    pub id: String,
7651    #[serde(rename = "syncEvent")]
7652    pub sync_event: SyncEventSessionNextPromptedSyncEvent,
7653    #[serde(rename = "type")]
7654    pub type_: String,
7655}
7656
7657#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7658pub struct SyncEventSessionNextPromptedSyncEvent {
7659    #[serde(rename = "aggregateID")]
7660    pub aggregate_id: String,
7661    pub data: SessionNextPromptedData,
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 SyncEventSessionNextReasoningEnded {
7670    pub id: String,
7671    #[serde(rename = "syncEvent")]
7672    pub sync_event: SyncEventSessionNextReasoningEndedSyncEvent,
7673    #[serde(rename = "type")]
7674    pub type_: String,
7675}
7676
7677#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7678pub struct SyncEventSessionNextReasoningEndedSyncEvent {
7679    #[serde(rename = "aggregateID")]
7680    pub aggregate_id: String,
7681    pub data: SessionNextReasoningEndedData,
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 SyncEventSessionNextReasoningStarted {
7690    pub id: String,
7691    #[serde(rename = "syncEvent")]
7692    pub sync_event: SyncEventSessionNextReasoningStartedSyncEvent,
7693    #[serde(rename = "type")]
7694    pub type_: String,
7695}
7696
7697#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7698pub struct SyncEventSessionNextReasoningStartedSyncEvent {
7699    #[serde(rename = "aggregateID")]
7700    pub aggregate_id: String,
7701    pub data: SessionNextReasoningStartedData,
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 SyncEventSessionNextRetried {
7710    pub id: String,
7711    #[serde(rename = "syncEvent")]
7712    pub sync_event: SyncEventSessionNextRetriedSyncEvent,
7713    #[serde(rename = "type")]
7714    pub type_: String,
7715}
7716
7717#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7718pub struct SyncEventSessionNextRetriedSyncEvent {
7719    #[serde(rename = "aggregateID")]
7720    pub aggregate_id: String,
7721    pub data: SessionNextRetriedData,
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 SyncEventSessionNextRevertCleared {
7730    pub id: String,
7731    #[serde(rename = "syncEvent")]
7732    pub sync_event: SyncEventSessionNextRevertClearedSyncEvent,
7733    #[serde(rename = "type")]
7734    pub type_: String,
7735}
7736
7737#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7738pub struct SyncEventSessionNextRevertClearedSyncEvent {
7739    #[serde(rename = "aggregateID")]
7740    pub aggregate_id: String,
7741    pub data: SessionNextRevertClearedData,
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 SyncEventSessionNextRevertCommitted {
7750    pub id: String,
7751    #[serde(rename = "syncEvent")]
7752    pub sync_event: SyncEventSessionNextRevertCommittedSyncEvent,
7753    #[serde(rename = "type")]
7754    pub type_: String,
7755}
7756
7757#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7758pub struct SyncEventSessionNextRevertCommittedSyncEvent {
7759    #[serde(rename = "aggregateID")]
7760    pub aggregate_id: String,
7761    pub data: SessionNextRevertCommittedData,
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 SyncEventSessionNextRevertStaged {
7770    pub id: String,
7771    #[serde(rename = "syncEvent")]
7772    pub sync_event: SyncEventSessionNextRevertStagedSyncEvent,
7773    #[serde(rename = "type")]
7774    pub type_: String,
7775}
7776
7777#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7778pub struct SyncEventSessionNextRevertStagedSyncEvent {
7779    #[serde(rename = "aggregateID")]
7780    pub aggregate_id: String,
7781    pub data: SessionNextRevertStagedData,
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 SyncEventSessionNextShellEnded {
7790    pub id: String,
7791    #[serde(rename = "syncEvent")]
7792    pub sync_event: SyncEventSessionNextShellEndedSyncEvent,
7793    #[serde(rename = "type")]
7794    pub type_: String,
7795}
7796
7797#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7798pub struct SyncEventSessionNextShellEndedSyncEvent {
7799    #[serde(rename = "aggregateID")]
7800    pub aggregate_id: String,
7801    pub data: SessionNextShellEndedData,
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 SyncEventSessionNextShellStarted {
7810    pub id: String,
7811    #[serde(rename = "syncEvent")]
7812    pub sync_event: SyncEventSessionNextShellStartedSyncEvent,
7813    #[serde(rename = "type")]
7814    pub type_: String,
7815}
7816
7817#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7818pub struct SyncEventSessionNextShellStartedSyncEvent {
7819    #[serde(rename = "aggregateID")]
7820    pub aggregate_id: String,
7821    pub data: SessionNextShellStartedData,
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 SyncEventSessionNextStepEnded {
7830    pub id: String,
7831    #[serde(rename = "syncEvent")]
7832    pub sync_event: SyncEventSessionNextStepEndedSyncEvent,
7833    #[serde(rename = "type")]
7834    pub type_: String,
7835}
7836
7837#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7838pub struct SyncEventSessionNextStepEndedSyncEvent {
7839    #[serde(rename = "aggregateID")]
7840    pub aggregate_id: String,
7841    pub data: SessionNextStepEndedData,
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 SyncEventSessionNextStepFailed {
7850    pub id: String,
7851    #[serde(rename = "syncEvent")]
7852    pub sync_event: SyncEventSessionNextStepFailedSyncEvent,
7853    #[serde(rename = "type")]
7854    pub type_: String,
7855}
7856
7857#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7858pub struct SyncEventSessionNextStepFailedSyncEvent {
7859    #[serde(rename = "aggregateID")]
7860    pub aggregate_id: String,
7861    pub data: SessionNextStepFailedData,
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 SyncEventSessionNextStepStarted {
7870    pub id: String,
7871    #[serde(rename = "syncEvent")]
7872    pub sync_event: SyncEventSessionNextStepStartedSyncEvent,
7873    #[serde(rename = "type")]
7874    pub type_: String,
7875}
7876
7877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7878pub struct SyncEventSessionNextStepStartedSyncEvent {
7879    #[serde(rename = "aggregateID")]
7880    pub aggregate_id: String,
7881    pub data: SessionNextStepStartedData,
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 SyncEventSessionNextSynthetic {
7890    pub id: String,
7891    #[serde(rename = "syncEvent")]
7892    pub sync_event: SyncEventSessionNextSyntheticSyncEvent,
7893    #[serde(rename = "type")]
7894    pub type_: String,
7895}
7896
7897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7898pub struct SyncEventSessionNextSyntheticSyncEvent {
7899    #[serde(rename = "aggregateID")]
7900    pub aggregate_id: String,
7901    pub data: SessionNextContextUpdatedData,
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 SyncEventSessionNextTextEnded {
7910    pub id: String,
7911    #[serde(rename = "syncEvent")]
7912    pub sync_event: SyncEventSessionNextTextEndedSyncEvent,
7913    #[serde(rename = "type")]
7914    pub type_: String,
7915}
7916
7917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7918pub struct SyncEventSessionNextTextEndedSyncEvent {
7919    #[serde(rename = "aggregateID")]
7920    pub aggregate_id: String,
7921    pub data: SessionNextTextEndedData,
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 SyncEventSessionNextTextStarted {
7930    pub id: String,
7931    #[serde(rename = "syncEvent")]
7932    pub sync_event: SyncEventSessionNextTextStartedSyncEvent,
7933    #[serde(rename = "type")]
7934    pub type_: String,
7935}
7936
7937#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7938pub struct SyncEventSessionNextTextStartedSyncEvent {
7939    #[serde(rename = "aggregateID")]
7940    pub aggregate_id: String,
7941    pub data: SessionNextTextStartedData,
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 SyncEventSessionNextToolCalled {
7950    pub id: String,
7951    #[serde(rename = "syncEvent")]
7952    pub sync_event: SyncEventSessionNextToolCalledSyncEvent,
7953    #[serde(rename = "type")]
7954    pub type_: String,
7955}
7956
7957#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7958pub struct SyncEventSessionNextToolCalledSyncEvent {
7959    #[serde(rename = "aggregateID")]
7960    pub aggregate_id: String,
7961    pub data: SessionNextToolCalledData,
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 SyncEventSessionNextToolFailed {
7970    pub id: String,
7971    #[serde(rename = "syncEvent")]
7972    pub sync_event: SyncEventSessionNextToolFailedSyncEvent,
7973    #[serde(rename = "type")]
7974    pub type_: String,
7975}
7976
7977#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7978pub struct SyncEventSessionNextToolFailedSyncEvent {
7979    #[serde(rename = "aggregateID")]
7980    pub aggregate_id: String,
7981    pub data: SessionNextToolFailedData,
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 SyncEventSessionNextToolInputEnded {
7990    pub id: String,
7991    #[serde(rename = "syncEvent")]
7992    pub sync_event: SyncEventSessionNextToolInputEndedSyncEvent,
7993    #[serde(rename = "type")]
7994    pub type_: String,
7995}
7996
7997#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7998pub struct SyncEventSessionNextToolInputEndedSyncEvent {
7999    #[serde(rename = "aggregateID")]
8000    pub aggregate_id: String,
8001    pub data: SessionNextToolInputEndedData,
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 SyncEventSessionNextToolInputStarted {
8010    pub id: String,
8011    #[serde(rename = "syncEvent")]
8012    pub sync_event: SyncEventSessionNextToolInputStartedSyncEvent,
8013    #[serde(rename = "type")]
8014    pub type_: String,
8015}
8016
8017#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8018pub struct SyncEventSessionNextToolInputStartedSyncEvent {
8019    #[serde(rename = "aggregateID")]
8020    pub aggregate_id: String,
8021    pub data: SessionNextToolInputStartedData,
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 SyncEventSessionNextToolProgress {
8030    pub id: String,
8031    #[serde(rename = "syncEvent")]
8032    pub sync_event: SyncEventSessionNextToolProgressSyncEvent,
8033    #[serde(rename = "type")]
8034    pub type_: String,
8035}
8036
8037#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8038pub struct SyncEventSessionNextToolProgressSyncEvent {
8039    #[serde(rename = "aggregateID")]
8040    pub aggregate_id: String,
8041    pub data: SessionNextToolProgressData,
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 SyncEventSessionNextToolSuccess {
8050    pub id: String,
8051    #[serde(rename = "syncEvent")]
8052    pub sync_event: SyncEventSessionNextToolSuccessSyncEvent,
8053    #[serde(rename = "type")]
8054    pub type_: String,
8055}
8056
8057#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8058pub struct SyncEventSessionNextToolSuccessSyncEvent {
8059    #[serde(rename = "aggregateID")]
8060    pub aggregate_id: String,
8061    pub data: SessionNextToolSuccessData,
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 SyncEventSessionUpdated {
8070    pub id: String,
8071    #[serde(rename = "syncEvent")]
8072    pub sync_event: SyncEventSessionUpdatedSyncEvent,
8073    #[serde(rename = "type")]
8074    pub type_: String,
8075}
8076
8077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8078pub struct SyncEventSessionUpdatedSyncEvent {
8079    #[serde(rename = "aggregateID")]
8080    pub aggregate_id: String,
8081    pub data: SessionCreatedData,
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 TextPart {
8090    pub id: String,
8091    #[serde(default, skip_serializing_if = "Option::is_none")]
8092    pub ignored: Option<bool>,
8093    #[serde(rename = "messageID")]
8094    pub message_id: String,
8095    #[serde(default, skip_serializing_if = "Option::is_none")]
8096    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8097    #[serde(rename = "sessionID")]
8098    pub session_id: String,
8099    #[serde(default, skip_serializing_if = "Option::is_none")]
8100    pub synthetic: Option<bool>,
8101    pub text: String,
8102    #[serde(default, skip_serializing_if = "Option::is_none")]
8103    pub time: Option<TextPartInputTime>,
8104    #[serde(rename = "type", default, skip_serializing)]
8105    pub type_: String,
8106}
8107
8108#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
8109pub struct TextPartInput {
8110    #[serde(default, skip_serializing_if = "Option::is_none")]
8111    pub id: Option<String>,
8112    #[serde(default, skip_serializing_if = "Option::is_none")]
8113    pub ignored: Option<bool>,
8114    #[serde(default, skip_serializing_if = "Option::is_none")]
8115    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8116    #[serde(default, skip_serializing_if = "Option::is_none")]
8117    pub synthetic: Option<bool>,
8118    pub text: String,
8119    #[serde(default, skip_serializing_if = "Option::is_none")]
8120    pub time: Option<TextPartInputTime>,
8121    #[serde(rename = "type", default, skip_serializing)]
8122    pub type_: String,
8123}
8124
8125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8126pub struct TextPartInputTime {
8127    #[serde(default, skip_serializing_if = "Option::is_none")]
8128    pub end: Option<u64>,
8129    pub start: u64,
8130}
8131
8132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8133pub struct Todo {
8134    pub content: String,
8135    pub priority: String,
8136    pub status: String,
8137}
8138
8139#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8140pub struct TodoUpdated {
8141    pub data: TodoUpdatedData,
8142    #[serde(default, skip_serializing_if = "Option::is_none")]
8143    pub durable: Option<SessionStatus2Durable>,
8144    pub id: String,
8145    #[serde(default, skip_serializing_if = "Option::is_none")]
8146    pub location: Option<LocationRef>,
8147    #[serde(default, skip_serializing_if = "Option::is_none")]
8148    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8149    #[serde(rename = "type", default, skip_serializing)]
8150    pub type_: String,
8151}
8152
8153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8154pub struct TodoUpdatedData {
8155    #[serde(rename = "sessionID")]
8156    pub session_id: String,
8157    pub todos: Vec<Todo>,
8158}
8159
8160#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8161pub struct ToolFileContent {
8162    pub mime: String,
8163    #[serde(default, skip_serializing_if = "Option::is_none")]
8164    pub name: Option<String>,
8165    #[serde(rename = "type", default, skip_serializing)]
8166    pub type_: String,
8167    pub uri: String,
8168}
8169
8170pub type ToolIDs = Vec<String>;
8171
8172pub type ToolList = Vec<ToolListItem>;
8173
8174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8175pub struct ToolListItem {
8176    pub description: String,
8177    pub id: String,
8178    pub parameters: serde_json::Value,
8179}
8180
8181#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8182pub struct ToolPart {
8183    #[serde(rename = "callID")]
8184    pub call_id: String,
8185    pub id: String,
8186    #[serde(rename = "messageID")]
8187    pub message_id: String,
8188    #[serde(default, skip_serializing_if = "Option::is_none")]
8189    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8190    #[serde(rename = "sessionID")]
8191    pub session_id: String,
8192    pub state: ToolState,
8193    pub tool: String,
8194    #[serde(rename = "type", default, skip_serializing)]
8195    pub type_: String,
8196}
8197
8198#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8199#[serde(tag = "status")]
8200pub enum ToolState {
8201    #[serde(rename = "pending")]
8202    Pending(ToolStatePending),
8203    #[serde(rename = "running")]
8204    Running(ToolStateRunning),
8205    #[serde(rename = "completed")]
8206    Completed(ToolStateCompleted),
8207    #[serde(rename = "error")]
8208    Error(ToolStateError),
8209}
8210
8211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8212pub struct ToolStateCompleted {
8213    #[serde(default, skip_serializing_if = "Option::is_none")]
8214    pub attachments: Option<Vec<FilePart>>,
8215    pub input: serde_json::Map<String, serde_json::Value>,
8216    pub metadata: serde_json::Map<String, serde_json::Value>,
8217    pub output: String,
8218    #[serde(default, skip_serializing)]
8219    pub status: String,
8220    pub time: ToolStateCompletedTime,
8221    pub title: String,
8222}
8223
8224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8225pub struct ToolStateCompletedTime {
8226    #[serde(default, skip_serializing_if = "Option::is_none")]
8227    pub compacted: Option<u64>,
8228    pub end: u64,
8229    pub start: u64,
8230}
8231
8232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8233pub struct ToolStateError {
8234    pub error: String,
8235    pub input: serde_json::Map<String, serde_json::Value>,
8236    #[serde(default, skip_serializing_if = "Option::is_none")]
8237    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8238    #[serde(default, skip_serializing)]
8239    pub status: String,
8240    pub time: ToolStateErrorTime,
8241}
8242
8243#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8244pub struct ToolStateErrorTime {
8245    pub end: u64,
8246    pub start: u64,
8247}
8248
8249#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8250pub struct ToolStatePending {
8251    pub input: serde_json::Map<String, serde_json::Value>,
8252    pub raw: String,
8253    #[serde(default, skip_serializing)]
8254    pub status: String,
8255}
8256
8257#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8258pub struct ToolStateRunning {
8259    pub input: serde_json::Map<String, serde_json::Value>,
8260    #[serde(default, skip_serializing_if = "Option::is_none")]
8261    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8262    #[serde(default, skip_serializing)]
8263    pub status: String,
8264    pub time: ToolStateRunningTime,
8265    #[serde(default, skip_serializing_if = "Option::is_none")]
8266    pub title: Option<String>,
8267}
8268
8269#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8270pub struct ToolStateRunningTime {
8271    pub start: u64,
8272}
8273
8274#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8275pub struct ToolTextContent {
8276    pub text: String,
8277    #[serde(rename = "type", default, skip_serializing)]
8278    pub type_: String,
8279}
8280
8281#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8282pub struct TuiCommandExecute {
8283    pub data: TuiCommandExecuteData,
8284    #[serde(default, skip_serializing_if = "Option::is_none")]
8285    pub durable: Option<SessionStatus2Durable>,
8286    pub id: String,
8287    #[serde(default, skip_serializing_if = "Option::is_none")]
8288    pub location: Option<LocationRef>,
8289    #[serde(default, skip_serializing_if = "Option::is_none")]
8290    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8291    #[serde(rename = "type", default, skip_serializing)]
8292    pub type_: String,
8293}
8294
8295#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8296pub struct TuiCommandExecuteData {
8297    pub command: TuiCommandExecuteDataCommand,
8298}
8299
8300#[derive(Debug, Clone, PartialEq, Eq, Hash)]
8301pub enum TuiCommandExecuteDataCommand {
8302    SessionList,
8303    SessionNew,
8304    SessionShare,
8305    SessionInterrupt,
8306    SessionCompact,
8307    SessionPageUp,
8308    SessionPageDown,
8309    SessionLineUp,
8310    SessionLineDown,
8311    SessionHalfPageUp,
8312    SessionHalfPageDown,
8313    SessionFirst,
8314    SessionLast,
8315    PromptClear,
8316    PromptSubmit,
8317    AgentCycle,
8318    Unknown(String),
8319}
8320
8321impl TuiCommandExecuteDataCommand {
8322    pub fn as_str(&self) -> &str {
8323        match self {
8324            Self::SessionList => "session.list",
8325            Self::SessionNew => "session.new",
8326            Self::SessionShare => "session.share",
8327            Self::SessionInterrupt => "session.interrupt",
8328            Self::SessionCompact => "session.compact",
8329            Self::SessionPageUp => "session.page.up",
8330            Self::SessionPageDown => "session.page.down",
8331            Self::SessionLineUp => "session.line.up",
8332            Self::SessionLineDown => "session.line.down",
8333            Self::SessionHalfPageUp => "session.half.page.up",
8334            Self::SessionHalfPageDown => "session.half.page.down",
8335            Self::SessionFirst => "session.first",
8336            Self::SessionLast => "session.last",
8337            Self::PromptClear => "prompt.clear",
8338            Self::PromptSubmit => "prompt.submit",
8339            Self::AgentCycle => "agent.cycle",
8340            Self::Unknown(s) => s.as_str(),
8341        }
8342    }
8343}
8344
8345impl std::fmt::Display for TuiCommandExecuteDataCommand {
8346    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8347        f.write_str(self.as_str())
8348    }
8349}
8350
8351impl From<&str> for TuiCommandExecuteDataCommand {
8352    fn from(s: &str) -> Self {
8353        match s {
8354            "session.list" => Self::SessionList,
8355            "session.new" => Self::SessionNew,
8356            "session.share" => Self::SessionShare,
8357            "session.interrupt" => Self::SessionInterrupt,
8358            "session.compact" => Self::SessionCompact,
8359            "session.page.up" => Self::SessionPageUp,
8360            "session.page.down" => Self::SessionPageDown,
8361            "session.line.up" => Self::SessionLineUp,
8362            "session.line.down" => Self::SessionLineDown,
8363            "session.half.page.up" => Self::SessionHalfPageUp,
8364            "session.half.page.down" => Self::SessionHalfPageDown,
8365            "session.first" => Self::SessionFirst,
8366            "session.last" => Self::SessionLast,
8367            "prompt.clear" => Self::PromptClear,
8368            "prompt.submit" => Self::PromptSubmit,
8369            "agent.cycle" => Self::AgentCycle,
8370            other => Self::Unknown(other.to_string()),
8371        }
8372    }
8373}
8374
8375impl Serialize for TuiCommandExecuteDataCommand {
8376    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
8377        serializer.serialize_str(self.as_str())
8378    }
8379}
8380
8381impl<'de> Deserialize<'de> for TuiCommandExecuteDataCommand {
8382    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
8383        let s = String::deserialize(deserializer)?;
8384        Ok(Self::from(s.as_str()))
8385    }
8386}
8387
8388#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8389pub struct TuiPromptAppend {
8390    pub data: TuiPromptAppendData,
8391    #[serde(default, skip_serializing_if = "Option::is_none")]
8392    pub durable: Option<SessionStatus2Durable>,
8393    pub id: String,
8394    #[serde(default, skip_serializing_if = "Option::is_none")]
8395    pub location: Option<LocationRef>,
8396    #[serde(default, skip_serializing_if = "Option::is_none")]
8397    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8398    #[serde(rename = "type", default, skip_serializing)]
8399    pub type_: String,
8400}
8401
8402#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8403pub struct TuiPromptAppendData {
8404    pub text: String,
8405}
8406
8407#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8408pub struct TuiSessionSelect {
8409    pub data: TuiSessionSelectData,
8410    #[serde(default, skip_serializing_if = "Option::is_none")]
8411    pub durable: Option<SessionStatus2Durable>,
8412    pub id: String,
8413    #[serde(default, skip_serializing_if = "Option::is_none")]
8414    pub location: Option<LocationRef>,
8415    #[serde(default, skip_serializing_if = "Option::is_none")]
8416    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8417    #[serde(rename = "type", default, skip_serializing)]
8418    pub type_: String,
8419}
8420
8421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8422pub struct TuiSessionSelectData {
8423    #[serde(rename = "sessionID")]
8424    pub session_id: String,
8425}
8426
8427#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8428pub struct TuiToastShow {
8429    pub data: TuiToastShowData,
8430    #[serde(default, skip_serializing_if = "Option::is_none")]
8431    pub durable: Option<SessionStatus2Durable>,
8432    pub id: String,
8433    #[serde(default, skip_serializing_if = "Option::is_none")]
8434    pub location: Option<LocationRef>,
8435    #[serde(default, skip_serializing_if = "Option::is_none")]
8436    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8437    #[serde(rename = "type", default, skip_serializing)]
8438    pub type_: String,
8439}
8440
8441#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8442pub struct TuiToastShowData {
8443    #[serde(default, skip_serializing_if = "Option::is_none")]
8444    pub duration: Option<i64>,
8445    pub message: String,
8446    #[serde(default, skip_serializing_if = "Option::is_none")]
8447    pub title: Option<String>,
8448    pub variant: String,
8449}
8450
8451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8452pub struct UnauthorizedError {
8453    pub _tag: String,
8454    pub message: String,
8455}
8456
8457#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8458pub struct UnknownError {
8459    pub data: UnknownErrorData,
8460    #[serde(default, skip_serializing)]
8461    pub name: String,
8462}
8463
8464#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8465pub struct UnknownError1 {
8466    pub _tag: String,
8467    pub message: String,
8468    #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
8469    pub ref_: Option<String>,
8470}
8471
8472#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8473pub struct UnknownErrorData {
8474    pub message: String,
8475    #[serde(rename = "ref", default, skip_serializing_if = "Option::is_none")]
8476    pub ref_: Option<String>,
8477}
8478
8479#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8480pub struct UserMessage {
8481    pub agent: String,
8482    #[serde(default, skip_serializing_if = "Option::is_none")]
8483    pub format: Option<OutputFormat>,
8484    pub id: String,
8485    pub model: UserMessageModel,
8486    #[serde(default, skip_serializing)]
8487    pub role: String,
8488    #[serde(rename = "sessionID")]
8489    pub session_id: String,
8490    #[serde(default, skip_serializing_if = "Option::is_none")]
8491    pub summary: Option<UserMessageSummary>,
8492    #[serde(default, skip_serializing_if = "Option::is_none")]
8493    pub system: Option<String>,
8494    pub time: UserMessageTime,
8495    #[serde(default, skip_serializing_if = "Option::is_none")]
8496    pub tools: Option<std::collections::BTreeMap<String, bool>>,
8497}
8498
8499#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8500pub struct UserMessageModel {
8501    #[serde(rename = "modelID")]
8502    pub model_id: String,
8503    #[serde(rename = "providerID")]
8504    pub provider_id: String,
8505    #[serde(default, skip_serializing_if = "Option::is_none")]
8506    pub variant: Option<String>,
8507}
8508
8509#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8510pub struct UserMessageSummary {
8511    #[serde(default, skip_serializing_if = "Option::is_none")]
8512    pub body: Option<String>,
8513    pub diffs: Vec<SnapshotFileDiff>,
8514    #[serde(default, skip_serializing_if = "Option::is_none")]
8515    pub title: Option<String>,
8516}
8517
8518#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8519pub struct UserMessageTime {
8520    pub created: f64,
8521}
8522
8523#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8524#[serde(tag = "type")]
8525pub enum V2Event {
8526    #[serde(rename = "models-dev.refreshed")]
8527    ModelsDevRefreshed(ModelsDevRefreshed),
8528    #[serde(rename = "integration.updated")]
8529    IntegrationUpdated(IntegrationUpdated),
8530    #[serde(rename = "integration.connection.updated")]
8531    IntegrationConnectionUpdated(IntegrationConnectionUpdated),
8532    #[serde(rename = "catalog.updated")]
8533    CatalogUpdated(CatalogUpdated),
8534    #[serde(rename = "session.created")]
8535    SessionCreated(SessionCreated),
8536    #[serde(rename = "session.updated")]
8537    SessionUpdated(SessionUpdated),
8538    #[serde(rename = "session.deleted")]
8539    SessionDeleted(SessionDeleted),
8540    #[serde(rename = "message.updated")]
8541    MessageUpdated(MessageUpdated),
8542    #[serde(rename = "message.removed")]
8543    MessageRemoved(MessageRemoved),
8544    #[serde(rename = "message.part.updated")]
8545    MessagePartUpdated(MessagePartUpdated),
8546    #[serde(rename = "message.part.removed")]
8547    MessagePartRemoved(MessagePartRemoved),
8548    #[serde(rename = "session.next.agent.switched")]
8549    SessionNextAgentSwitched(SessionNextAgentSwitched),
8550    #[serde(rename = "session.next.model.switched")]
8551    SessionNextModelSwitched(SessionNextModelSwitched),
8552    #[serde(rename = "session.next.moved")]
8553    SessionNextMoved(SessionNextMoved),
8554    #[serde(rename = "session.next.prompted")]
8555    SessionNextPrompted(SessionNextPrompted),
8556    #[serde(rename = "session.next.prompt.admitted")]
8557    SessionNextPromptAdmitted(SessionNextPromptAdmitted),
8558    #[serde(rename = "session.next.context.updated")]
8559    SessionNextContextUpdated(SessionNextContextUpdated),
8560    #[serde(rename = "session.next.synthetic")]
8561    SessionNextSynthetic(SessionNextSynthetic),
8562    #[serde(rename = "session.next.shell.started")]
8563    SessionNextShellStarted(SessionNextShellStarted),
8564    #[serde(rename = "session.next.shell.ended")]
8565    SessionNextShellEnded(SessionNextShellEnded),
8566    #[serde(rename = "session.next.step.started")]
8567    SessionNextStepStarted(SessionNextStepStarted),
8568    #[serde(rename = "session.next.step.ended")]
8569    SessionNextStepEnded(SessionNextStepEnded),
8570    #[serde(rename = "session.next.step.failed")]
8571    SessionNextStepFailed(SessionNextStepFailed),
8572    #[serde(rename = "session.next.text.started")]
8573    SessionNextTextStarted(SessionNextTextStarted),
8574    #[serde(rename = "session.next.text.delta")]
8575    SessionNextTextDelta(SessionNextTextDelta),
8576    #[serde(rename = "session.next.text.ended")]
8577    SessionNextTextEnded(SessionNextTextEnded),
8578    #[serde(rename = "session.next.reasoning.started")]
8579    SessionNextReasoningStarted(SessionNextReasoningStarted),
8580    #[serde(rename = "session.next.reasoning.delta")]
8581    SessionNextReasoningDelta(SessionNextReasoningDelta),
8582    #[serde(rename = "session.next.reasoning.ended")]
8583    SessionNextReasoningEnded(SessionNextReasoningEnded),
8584    #[serde(rename = "session.next.tool.input.started")]
8585    SessionNextToolInputStarted(SessionNextToolInputStarted),
8586    #[serde(rename = "session.next.tool.input.delta")]
8587    SessionNextToolInputDelta(SessionNextToolInputDelta),
8588    #[serde(rename = "session.next.tool.input.ended")]
8589    SessionNextToolInputEnded(SessionNextToolInputEnded),
8590    #[serde(rename = "session.next.tool.called")]
8591    SessionNextToolCalled(SessionNextToolCalled),
8592    #[serde(rename = "session.next.tool.progress")]
8593    SessionNextToolProgress(SessionNextToolProgress),
8594    #[serde(rename = "session.next.tool.success")]
8595    SessionNextToolSuccess(SessionNextToolSuccess),
8596    #[serde(rename = "session.next.tool.failed")]
8597    SessionNextToolFailed(SessionNextToolFailed),
8598    #[serde(rename = "session.next.retried")]
8599    SessionNextRetried(SessionNextRetried),
8600    #[serde(rename = "session.next.compaction.started")]
8601    SessionNextCompactionStarted(SessionNextCompactionStarted),
8602    #[serde(rename = "session.next.compaction.delta")]
8603    SessionNextCompactionDelta(SessionNextCompactionDelta),
8604    #[serde(rename = "session.next.compaction.ended")]
8605    SessionNextCompactionEnded(SessionNextCompactionEnded),
8606    #[serde(rename = "session.next.revert.staged")]
8607    SessionNextRevertStaged(SessionNextRevertStaged),
8608    #[serde(rename = "session.next.revert.cleared")]
8609    SessionNextRevertCleared(SessionNextRevertCleared),
8610    #[serde(rename = "session.next.revert.committed")]
8611    SessionNextRevertCommitted(SessionNextRevertCommitted),
8612    #[serde(rename = "message.part.delta")]
8613    MessagePartDelta(MessagePartDelta),
8614    #[serde(rename = "session.diff")]
8615    SessionDiff(SessionDiff),
8616    #[serde(rename = "session.error")]
8617    SessionError(SessionError),
8618    #[serde(rename = "installation.updated")]
8619    InstallationUpdated(InstallationUpdated),
8620    #[serde(rename = "installation.update-available")]
8621    InstallationUpdateAvailable(InstallationUpdateAvailable),
8622    #[serde(rename = "file.edited")]
8623    FileEdited(FileEdited),
8624    #[serde(rename = "reference.updated")]
8625    ReferenceUpdated(ReferenceUpdated),
8626    #[serde(rename = "permission.v2.asked")]
8627    PermissionV2Asked(PermissionV2Asked),
8628    #[serde(rename = "permission.v2.replied")]
8629    PermissionV2Replied(PermissionV2Replied),
8630    #[serde(rename = "plugin.added")]
8631    PluginAdded(PluginAdded),
8632    #[serde(rename = "project.directories.updated")]
8633    ProjectDirectoriesUpdated(ProjectDirectoriesUpdated),
8634    #[serde(rename = "file.watcher.updated")]
8635    FileWatcherUpdated(FileWatcherUpdated),
8636    #[serde(rename = "pty.created")]
8637    PtyCreated(PtyCreated),
8638    #[serde(rename = "pty.updated")]
8639    PtyUpdated(PtyUpdated),
8640    #[serde(rename = "pty.exited")]
8641    PtyExited(PtyExited),
8642    #[serde(rename = "pty.deleted")]
8643    PtyDeleted(PtyDeleted),
8644    #[serde(rename = "question.v2.asked")]
8645    QuestionV2Asked(QuestionV2Asked),
8646    #[serde(rename = "question.v2.replied")]
8647    QuestionV2Replied(QuestionV2Replied),
8648    #[serde(rename = "question.v2.rejected")]
8649    QuestionV2Rejected(QuestionV2Rejected),
8650    #[serde(rename = "todo.updated")]
8651    TodoUpdated(TodoUpdated),
8652    #[serde(rename = "lsp.updated")]
8653    LspUpdated(LspUpdated),
8654    #[serde(rename = "permission.asked")]
8655    PermissionAsked(PermissionAsked),
8656    #[serde(rename = "permission.replied")]
8657    PermissionReplied(PermissionReplied),
8658    #[serde(rename = "tui.prompt.append")]
8659    TuiPromptAppend(TuiPromptAppend),
8660    #[serde(rename = "tui.command.execute")]
8661    TuiCommandExecute(TuiCommandExecute),
8662    #[serde(rename = "tui.toast.show")]
8663    TuiToastShow(TuiToastShow),
8664    #[serde(rename = "tui.session.select")]
8665    TuiSessionSelect(TuiSessionSelect),
8666    #[serde(rename = "mcp.tools.changed")]
8667    McpToolsChanged(McpToolsChanged),
8668    #[serde(rename = "mcp.browser.open.failed")]
8669    McpBrowserOpenFailed(McpBrowserOpenFailed),
8670    #[serde(rename = "command.executed")]
8671    CommandExecuted(CommandExecuted),
8672    #[serde(rename = "project.updated")]
8673    ProjectUpdated(ProjectUpdated),
8674    #[serde(rename = "session.status")]
8675    SessionStatus(SessionStatus2),
8676    #[serde(rename = "session.idle")]
8677    SessionIdle(SessionIdle),
8678    #[serde(rename = "question.asked")]
8679    QuestionAsked(QuestionAsked),
8680    #[serde(rename = "question.replied")]
8681    QuestionReplied(QuestionReplied2),
8682    #[serde(rename = "question.rejected")]
8683    QuestionRejected(QuestionRejected2),
8684    #[serde(rename = "session.compacted")]
8685    SessionCompacted(SessionCompacted),
8686    #[serde(rename = "vcs.branch.updated")]
8687    VcsBranchUpdated(VcsBranchUpdated),
8688    #[serde(rename = "workspace.ready")]
8689    WorkspaceReady(WorkspaceReady),
8690    #[serde(rename = "workspace.failed")]
8691    WorkspaceFailed(WorkspaceFailed),
8692    #[serde(rename = "workspace.status")]
8693    WorkspaceStatus(WorkspaceStatus),
8694    #[serde(rename = "worktree.ready")]
8695    WorktreeReady(WorktreeReady),
8696    #[serde(rename = "worktree.failed")]
8697    WorktreeFailed(WorktreeFailed),
8698    #[serde(rename = "server.connected")]
8699    ServerConnected(ServerConnected),
8700    #[serde(rename = "global.disposed")]
8701    GlobalDisposed(GlobalDisposed),
8702}
8703
8704#[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
8705#[serde(transparent)]
8706pub struct V2EventStream(pub String);
8707
8708#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8709pub struct VcsApplyError {
8710    pub data: VcsApplyErrorData,
8711    pub name: String,
8712}
8713
8714#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8715pub struct VcsApplyErrorData {
8716    pub message: String,
8717    pub reason: String,
8718}
8719
8720#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8721pub struct VcsBranchUpdated {
8722    pub data: VcsBranchUpdatedData,
8723    #[serde(default, skip_serializing_if = "Option::is_none")]
8724    pub durable: Option<SessionStatus2Durable>,
8725    pub id: String,
8726    #[serde(default, skip_serializing_if = "Option::is_none")]
8727    pub location: Option<LocationRef>,
8728    #[serde(default, skip_serializing_if = "Option::is_none")]
8729    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8730    #[serde(rename = "type", default, skip_serializing)]
8731    pub type_: String,
8732}
8733
8734#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8735pub struct VcsBranchUpdatedData {
8736    #[serde(default, skip_serializing_if = "Option::is_none")]
8737    pub branch: Option<String>,
8738}
8739
8740#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8741pub struct VcsFileDiff {
8742    pub additions: f64,
8743    pub deletions: f64,
8744    pub file: String,
8745    #[serde(default, skip_serializing_if = "Option::is_none")]
8746    pub patch: Option<String>,
8747    #[serde(default, skip_serializing_if = "Option::is_none")]
8748    pub status: Option<String>,
8749}
8750
8751#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8752pub struct VcsFileStatus {
8753    pub additions: f64,
8754    pub deletions: f64,
8755    pub file: String,
8756    pub status: String,
8757}
8758
8759#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8760pub struct VcsInfo {
8761    #[serde(default, skip_serializing_if = "Option::is_none")]
8762    pub branch: Option<String>,
8763    #[serde(default, skip_serializing_if = "Option::is_none")]
8764    pub default_branch: Option<String>,
8765}
8766
8767#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8768pub struct WellKnownAuth {
8769    pub key: String,
8770    pub token: String,
8771    #[serde(rename = "type", default, skip_serializing)]
8772    pub type_: String,
8773}
8774
8775#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8776pub struct Workspace {
8777    #[serde(default, skip_serializing_if = "Option::is_none")]
8778    pub branch: Option<String>,
8779    #[serde(default, skip_serializing_if = "Option::is_none")]
8780    pub directory: Option<String>,
8781    #[serde(default, skip_serializing_if = "Option::is_none")]
8782    pub extra: Option<serde_json::Value>,
8783    pub id: String,
8784    pub name: String,
8785    #[serde(rename = "projectID")]
8786    pub project_id: String,
8787    #[serde(rename = "timeUsed")]
8788    pub time_used: WorkspaceTimeUsed,
8789    #[serde(rename = "type")]
8790    pub type_: String,
8791}
8792
8793#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8794pub struct WorkspaceCreateError {
8795    pub data: WorktreeFailedData,
8796    pub name: String,
8797}
8798
8799#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8800pub struct WorkspaceEventConnectionStatus {
8801    pub status: String,
8802    #[serde(rename = "workspaceID")]
8803    pub workspace_id: String,
8804}
8805
8806#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8807pub struct WorkspaceFailed {
8808    pub data: WorktreeFailedData,
8809    #[serde(default, skip_serializing_if = "Option::is_none")]
8810    pub durable: Option<SessionStatus2Durable>,
8811    pub id: String,
8812    #[serde(default, skip_serializing_if = "Option::is_none")]
8813    pub location: Option<LocationRef>,
8814    #[serde(default, skip_serializing_if = "Option::is_none")]
8815    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8816    #[serde(rename = "type", default, skip_serializing)]
8817    pub type_: String,
8818}
8819
8820#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8821pub struct WorkspaceReady {
8822    pub data: WorkspaceReadyData,
8823    #[serde(default, skip_serializing_if = "Option::is_none")]
8824    pub durable: Option<SessionStatus2Durable>,
8825    pub id: String,
8826    #[serde(default, skip_serializing_if = "Option::is_none")]
8827    pub location: Option<LocationRef>,
8828    #[serde(default, skip_serializing_if = "Option::is_none")]
8829    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8830    #[serde(rename = "type", default, skip_serializing)]
8831    pub type_: String,
8832}
8833
8834#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8835pub struct WorkspaceReadyData {
8836    pub name: String,
8837}
8838
8839#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8840pub struct WorkspaceStatus {
8841    pub data: WorkspaceStatusData,
8842    #[serde(default, skip_serializing_if = "Option::is_none")]
8843    pub durable: Option<SessionStatus2Durable>,
8844    pub id: String,
8845    #[serde(default, skip_serializing_if = "Option::is_none")]
8846    pub location: Option<LocationRef>,
8847    #[serde(default, skip_serializing_if = "Option::is_none")]
8848    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8849    #[serde(rename = "type", default, skip_serializing)]
8850    pub type_: String,
8851}
8852
8853#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8854pub struct WorkspaceStatusData {
8855    pub status: String,
8856    #[serde(rename = "workspaceID")]
8857    pub workspace_id: String,
8858}
8859
8860/// Untagged union: serde tries each variant in the order below.
8861#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8862#[serde(untagged)]
8863pub enum WorkspaceTimeUsed {
8864    Variant0(f64),
8865    Variant1(String),
8866    Variant2(String),
8867    Variant3(String),
8868    Variant4(String),
8869}
8870
8871#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8872pub struct WorkspaceWarpError {
8873    pub data: WorktreeFailedData,
8874    pub name: String,
8875}
8876
8877#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8878pub struct Worktree {
8879    #[serde(default, skip_serializing_if = "Option::is_none")]
8880    pub branch: Option<String>,
8881    pub directory: String,
8882    pub name: String,
8883}
8884
8885#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8886pub struct WorktreeCreateInput {
8887    #[serde(default, skip_serializing_if = "Option::is_none")]
8888    pub name: Option<String>,
8889    #[serde(
8890        rename = "startCommand",
8891        default,
8892        skip_serializing_if = "Option::is_none"
8893    )]
8894    pub start_command: Option<String>,
8895}
8896
8897#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8898pub struct WorktreeError {
8899    pub data: WorktreeFailedData,
8900    pub name: String,
8901}
8902
8903#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8904pub struct WorktreeFailed {
8905    pub data: WorktreeFailedData,
8906    #[serde(default, skip_serializing_if = "Option::is_none")]
8907    pub durable: Option<SessionStatus2Durable>,
8908    pub id: String,
8909    #[serde(default, skip_serializing_if = "Option::is_none")]
8910    pub location: Option<LocationRef>,
8911    #[serde(default, skip_serializing_if = "Option::is_none")]
8912    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8913    #[serde(rename = "type", default, skip_serializing)]
8914    pub type_: String,
8915}
8916
8917#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8918pub struct WorktreeFailedData {
8919    pub message: String,
8920}
8921
8922#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8923pub struct WorktreeReady {
8924    pub data: WorktreeReadyData,
8925    #[serde(default, skip_serializing_if = "Option::is_none")]
8926    pub durable: Option<SessionStatus2Durable>,
8927    pub id: String,
8928    #[serde(default, skip_serializing_if = "Option::is_none")]
8929    pub location: Option<LocationRef>,
8930    #[serde(default, skip_serializing_if = "Option::is_none")]
8931    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8932    #[serde(rename = "type", default, skip_serializing)]
8933    pub type_: String,
8934}
8935
8936#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8937pub struct WorktreeReadyData {
8938    #[serde(default, skip_serializing_if = "Option::is_none")]
8939    pub branch: Option<String>,
8940    pub name: String,
8941}
8942
8943#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8944pub struct WorktreeRemoveInput {
8945    pub directory: String,
8946}
8947
8948#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8949pub struct WorktreeResetInput {
8950    pub directory: String,
8951}
8952
8953#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8954pub struct EffectHttpApiErrorBadRequest {
8955    pub _tag: String,
8956}
8957
8958#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8959pub struct EffectHttpApiErrorForbidden {
8960    pub _tag: String,
8961}
8962
8963#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8964pub struct EffectHttpApiErrorInternalServerError {
8965    pub _tag: String,
8966}
8967
8968#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8969pub struct QuestionRejected2 {
8970    pub data: QuestionRejected2Data,
8971    #[serde(default, skip_serializing_if = "Option::is_none")]
8972    pub durable: Option<SessionStatus2Durable>,
8973    pub id: String,
8974    #[serde(default, skip_serializing_if = "Option::is_none")]
8975    pub location: Option<LocationRef>,
8976    #[serde(default, skip_serializing_if = "Option::is_none")]
8977    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
8978    #[serde(rename = "type", default, skip_serializing)]
8979    pub type_: String,
8980}
8981
8982#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8983pub struct QuestionReplied2 {
8984    pub data: QuestionReplied2Data,
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 SessionStatus2 {
8998    pub data: SessionStatus2Data,
8999    #[serde(default, skip_serializing_if = "Option::is_none")]
9000    pub durable: Option<SessionStatus2Durable>,
9001    pub id: String,
9002    #[serde(default, skip_serializing_if = "Option::is_none")]
9003    pub location: Option<LocationRef>,
9004    #[serde(default, skip_serializing_if = "Option::is_none")]
9005    pub metadata: Option<serde_json::Map<String, serde_json::Value>>,
9006    #[serde(rename = "type", default, skip_serializing)]
9007    pub type_: String,
9008}