Skip to main content

codex_codes/protocol_generated/
types.rs

1// AUTO-GENERATED by scripts/codegen_protocol.py — DO NOT EDIT BY HAND.
2// Run `python3 scripts/codegen_protocol.py` to regenerate.
3//
4// This module defines the wire types reachable from every method in the
5// upstream codex app-server v2 schema bundle. Hand-curated types live in
6// `protocol.rs` and `io/items.rs` and are re-exported alongside these.
7
8#![allow(
9    unused_imports,
10    non_camel_case_types,
11    clippy::large_enum_variant,
12    clippy::enum_variant_names,
13    clippy::empty_docs
14)]
15
16use serde::{Deserialize, Serialize};
17use serde_json::Value;
18
19// Hand-written / curated types that generated code can $ref into.
20use crate::io::items::{
21    AgentMessageItem, CommandExecutionItem, CommandExecutionStatus, ErrorItem, FileChangeItem,
22    FileUpdateChange, McpToolCallError, McpToolCallItem, McpToolCallResult, McpToolCallStatus,
23    PatchApplyStatus, PatchChangeKind, ReasoningItem, ThreadItem, TodoItem, TodoListItem,
24    UserMessageContent, UserMessageItem, WebSearchItem,
25};
26use crate::io::options::{
27    ApprovalMode, ModelReasoningEffort, SandboxMode, ThreadOptions, WebSearchMode,
28};
29use crate::jsonrpc::RequestId;
30use crate::protocol::{
31    AccountLoginCompletedNotification, AccountRateLimitsUpdatedNotification,
32    AgentMessageDeltaNotification, ClientInfo, CmdOutputDeltaNotification, CommandApprovalDecision,
33    CommandExecutionApprovalParams, CommandExecutionApprovalResponse, ConfigWarningNotification,
34    DeprecationNoticeNotification, ErrorNotification, FileChangeApprovalDecision,
35    FileChangeApprovalParams, FileChangeApprovalResponse, FileChangeOutputDeltaNotification,
36    FileChangePatchUpdatedNotification, FsChangedNotification, GuardianWarningNotification,
37    InitializeCapabilities, InitializeParams, InitializeResponse, ItemCompletedNotification,
38    ItemStartedNotification, McpServerOauthLoginCompletedNotification,
39    McpServerStartupStatusUpdatedNotification, PlanDeltaNotification, RateLimitWindow, RateLimits,
40    ReasoningDeltaNotification, ReasoningSummaryPartAddedNotification,
41    ReasoningTextDeltaNotification, RemoteControlStatusChangedNotification,
42    SkillsChangedNotification, ThreadArchiveParams, ThreadArchiveResponse,
43    ThreadArchivedNotification, ThreadClosedNotification, ThreadGoalClearedNotification,
44    ThreadInfo, ThreadNameUpdatedNotification, ThreadStartParams, ThreadStartResponse,
45    ThreadStartedNotification, ThreadStatus, ThreadStatusChangedNotification,
46    ThreadTokenUsageUpdatedNotification, ThreadUnarchivedNotification, TokenCounts, TokenUsage,
47    Turn, TurnCompletedNotification, TurnDiffUpdatedNotification, TurnError, TurnInterruptParams,
48    TurnInterruptResponse, TurnPlanStep, TurnPlanStepStatus, TurnPlanUpdatedNotification,
49    TurnStartParams, TurnStartResponse, TurnStartedNotification, TurnStatus, UserInput,
50    WarningNotification,
51};
52
53#[derive(Debug, Clone, Serialize, Deserialize, Default)]
54#[serde(transparent)]
55pub struct AbsolutePathBuf(pub Value);
56
57#[derive(Debug, Clone, Serialize, Deserialize)]
58#[serde(tag = "type", rename_all = "camelCase")]
59pub enum Account {
60    #[serde(rename = "apiKey")]
61    ApiKey,
62    Chatgpt {
63        email: String,
64        #[serde(rename = "planType")]
65        plan_type: PlanType,
66    },
67    #[serde(rename = "amazonBedrock")]
68    AmazonBedrock,
69}
70
71#[derive(Debug, Clone, Serialize, Deserialize)]
72#[serde(rename_all = "camelCase")]
73pub struct AccountUpdatedNotification {
74    #[serde(rename = "authMode", default, skip_serializing_if = "Option::is_none")]
75    pub auth_mode: Option<AuthMode>,
76    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
77    pub plan_type: Option<PlanType>,
78}
79
80#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
81pub enum AddCreditsNudgeCreditType {
82    #[serde(rename = "credits")]
83    Credits,
84    #[serde(rename = "usage_limit")]
85    Usage_limit,
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
89pub enum AddCreditsNudgeEmailStatus {
90    #[serde(rename = "sent")]
91    Sent,
92    #[serde(rename = "cooldown_active")]
93    Cooldown_active,
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(rename_all = "camelCase")]
98pub struct AdditionalFileSystemPermissions {
99    #[serde(default, skip_serializing_if = "Option::is_none")]
100    pub entries: Option<Vec<FileSystemSandboxEntry>>,
101    #[serde(
102        rename = "globScanMaxDepth",
103        default,
104        skip_serializing_if = "Option::is_none"
105    )]
106    pub glob_scan_max_depth: Option<i64>,
107    #[serde(default, skip_serializing_if = "Option::is_none")]
108    pub read: Option<Vec<AbsolutePathBuf>>,
109    #[serde(default, skip_serializing_if = "Option::is_none")]
110    pub write: Option<Vec<AbsolutePathBuf>>,
111}
112
113#[derive(Debug, Clone, Serialize, Deserialize)]
114#[serde(rename_all = "camelCase")]
115pub struct AdditionalNetworkPermissions {
116    #[serde(default, skip_serializing_if = "Option::is_none")]
117    pub enabled: Option<bool>,
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize, Default)]
121#[serde(transparent)]
122pub struct AgentPath(pub Value);
123
124#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(rename_all = "camelCase")]
126pub struct AnalyticsConfig {
127    #[serde(default, skip_serializing_if = "Option::is_none")]
128    pub enabled: Option<bool>,
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(rename_all = "camelCase")]
133pub struct AppBranding {
134    #[serde(default, skip_serializing_if = "Option::is_none")]
135    pub category: Option<String>,
136    #[serde(default, skip_serializing_if = "Option::is_none")]
137    pub developer: Option<String>,
138    #[serde(rename = "isDiscoverableApp")]
139    pub is_discoverable_app: bool,
140    #[serde(
141        rename = "privacyPolicy",
142        default,
143        skip_serializing_if = "Option::is_none"
144    )]
145    pub privacy_policy: Option<String>,
146    #[serde(
147        rename = "termsOfService",
148        default,
149        skip_serializing_if = "Option::is_none"
150    )]
151    pub terms_of_service: Option<String>,
152    #[serde(default, skip_serializing_if = "Option::is_none")]
153    pub website: Option<String>,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157#[serde(rename_all = "camelCase")]
158pub struct AppInfo {
159    #[serde(
160        rename = "appMetadata",
161        default,
162        skip_serializing_if = "Option::is_none"
163    )]
164    pub app_metadata: Option<AppMetadata>,
165    #[serde(default, skip_serializing_if = "Option::is_none")]
166    pub branding: Option<AppBranding>,
167    #[serde(default, skip_serializing_if = "Option::is_none")]
168    pub description: Option<String>,
169    #[serde(
170        rename = "distributionChannel",
171        default,
172        skip_serializing_if = "Option::is_none"
173    )]
174    pub distribution_channel: Option<String>,
175    #[serde()]
176    pub id: String,
177    #[serde(
178        rename = "installUrl",
179        default,
180        skip_serializing_if = "Option::is_none"
181    )]
182    pub install_url: Option<String>,
183    #[serde(
184        rename = "isAccessible",
185        default,
186        skip_serializing_if = "Option::is_none"
187    )]
188    pub is_accessible: Option<bool>,
189    #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
190    pub is_enabled: Option<bool>,
191    #[serde(default, skip_serializing_if = "Option::is_none")]
192    pub labels: Option<std::collections::BTreeMap<String, String>>,
193    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
194    pub logo_url: Option<String>,
195    #[serde(
196        rename = "logoUrlDark",
197        default,
198        skip_serializing_if = "Option::is_none"
199    )]
200    pub logo_url_dark: Option<String>,
201    #[serde()]
202    pub name: String,
203    #[serde(
204        rename = "pluginDisplayNames",
205        default,
206        skip_serializing_if = "Option::is_none"
207    )]
208    pub plugin_display_names: Option<Vec<String>>,
209}
210
211#[derive(Debug, Clone, Serialize, Deserialize)]
212#[serde(rename_all = "camelCase")]
213pub struct AppListUpdatedNotification {
214    #[serde()]
215    pub data: Vec<AppInfo>,
216}
217
218#[derive(Debug, Clone, Serialize, Deserialize)]
219#[serde(rename_all = "camelCase")]
220pub struct AppMetadata {
221    #[serde(default, skip_serializing_if = "Option::is_none")]
222    pub categories: Option<Vec<String>>,
223    #[serde(default, skip_serializing_if = "Option::is_none")]
224    pub developer: Option<String>,
225    #[serde(
226        rename = "firstPartyRequiresInstall",
227        default,
228        skip_serializing_if = "Option::is_none"
229    )]
230    pub first_party_requires_install: Option<bool>,
231    #[serde(
232        rename = "firstPartyType",
233        default,
234        skip_serializing_if = "Option::is_none"
235    )]
236    pub first_party_type: Option<String>,
237    #[serde(default, skip_serializing_if = "Option::is_none")]
238    pub review: Option<AppReview>,
239    #[serde(default, skip_serializing_if = "Option::is_none")]
240    pub screenshots: Option<Vec<AppScreenshot>>,
241    #[serde(
242        rename = "seoDescription",
243        default,
244        skip_serializing_if = "Option::is_none"
245    )]
246    pub seo_description: Option<String>,
247    #[serde(
248        rename = "showInComposerWhenUnlinked",
249        default,
250        skip_serializing_if = "Option::is_none"
251    )]
252    pub show_in_composer_when_unlinked: Option<bool>,
253    #[serde(
254        rename = "subCategories",
255        default,
256        skip_serializing_if = "Option::is_none"
257    )]
258    pub sub_categories: Option<Vec<String>>,
259    #[serde(default, skip_serializing_if = "Option::is_none")]
260    pub version: Option<String>,
261    #[serde(rename = "versionId", default, skip_serializing_if = "Option::is_none")]
262    pub version_id: Option<String>,
263    #[serde(
264        rename = "versionNotes",
265        default,
266        skip_serializing_if = "Option::is_none"
267    )]
268    pub version_notes: Option<String>,
269}
270
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(rename_all = "camelCase")]
273pub struct AppReview {
274    #[serde()]
275    pub status: String,
276}
277
278#[derive(Debug, Clone, Serialize, Deserialize)]
279#[serde(rename_all = "camelCase")]
280pub struct AppScreenshot {
281    #[serde(rename = "fileId", default, skip_serializing_if = "Option::is_none")]
282    pub file_id: Option<String>,
283    #[serde(default, skip_serializing_if = "Option::is_none")]
284    pub url: Option<String>,
285    #[serde(rename = "userPrompt")]
286    pub user_prompt: String,
287}
288
289#[derive(Debug, Clone, Serialize, Deserialize)]
290#[serde(rename_all = "camelCase")]
291pub struct AppSummary {
292    #[serde(default, skip_serializing_if = "Option::is_none")]
293    pub description: Option<String>,
294    #[serde()]
295    pub id: String,
296    #[serde(
297        rename = "installUrl",
298        default,
299        skip_serializing_if = "Option::is_none"
300    )]
301    pub install_url: Option<String>,
302    #[serde()]
303    pub name: String,
304    #[serde(rename = "needsAuth")]
305    pub needs_auth: bool,
306}
307
308#[derive(Debug, Clone, Serialize, Deserialize)]
309#[serde(rename_all = "camelCase")]
310pub struct ApplyPatchApprovalParams {
311    #[serde(rename = "callId")]
312    pub call_id: String,
313    #[serde(rename = "conversationId")]
314    pub conversation_id: ThreadId,
315    #[serde(rename = "fileChanges")]
316    pub file_changes: std::collections::BTreeMap<String, FileChange>,
317    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
318    pub grant_root: Option<String>,
319    #[serde(default, skip_serializing_if = "Option::is_none")]
320    pub reason: Option<String>,
321}
322
323#[derive(Debug, Clone, Serialize, Deserialize)]
324#[serde(rename_all = "camelCase")]
325pub struct ApplyPatchApprovalResponse {
326    #[serde()]
327    pub decision: ReviewDecision,
328}
329
330#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
331pub enum ApprovalsReviewer {
332    #[serde(rename = "user")]
333    User,
334    #[serde(rename = "auto_review")]
335    Auto_review,
336    #[serde(rename = "guardian_subagent")]
337    Guardian_subagent,
338}
339
340#[derive(Debug, Clone, Serialize, Deserialize)]
341#[serde(rename_all = "camelCase")]
342pub struct AppsListParams {
343    #[serde(default, skip_serializing_if = "Option::is_none")]
344    pub cursor: Option<String>,
345    #[serde(
346        rename = "forceRefetch",
347        default,
348        skip_serializing_if = "Option::is_none"
349    )]
350    pub force_refetch: Option<bool>,
351    #[serde(default, skip_serializing_if = "Option::is_none")]
352    pub limit: Option<i64>,
353    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
354    pub thread_id: Option<String>,
355}
356
357#[derive(Debug, Clone, Serialize, Deserialize)]
358#[serde(rename_all = "camelCase")]
359pub struct AppsListResponse {
360    #[serde()]
361    pub data: Vec<AppInfo>,
362    #[serde(
363        rename = "nextCursor",
364        default,
365        skip_serializing_if = "Option::is_none"
366    )]
367    pub next_cursor: Option<String>,
368}
369
370#[derive(Debug, Clone, Serialize, Deserialize, Default)]
371#[serde(transparent)]
372pub struct AskForApproval(pub Value);
373
374#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(rename_all = "camelCase")]
376pub struct AttestationGenerateParams {
377    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
378    pub extra: serde_json::Map<String, Value>,
379}
380
381#[derive(Debug, Clone, Serialize, Deserialize)]
382#[serde(rename_all = "camelCase")]
383pub struct AttestationGenerateResponse {
384    #[serde()]
385    pub token: String,
386}
387
388#[derive(Debug, Clone, Serialize, Deserialize, Default)]
389#[serde(transparent)]
390pub struct AuthMode(pub Value);
391
392#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
393pub enum AutoReviewDecisionSource {
394    #[serde(rename = "agent")]
395    Agent,
396}
397
398#[derive(Debug, Clone, Serialize, Deserialize)]
399#[serde(rename_all = "camelCase")]
400pub struct ByteRange {
401    #[serde()]
402    pub end: i64,
403    #[serde()]
404    pub start: i64,
405}
406
407#[derive(Debug, Clone, Serialize, Deserialize)]
408#[serde(rename_all = "camelCase")]
409pub struct CancelLoginAccountParams {
410    #[serde(rename = "loginId")]
411    pub login_id: String,
412}
413
414#[derive(Debug, Clone, Serialize, Deserialize)]
415#[serde(rename_all = "camelCase")]
416pub struct CancelLoginAccountResponse {
417    #[serde()]
418    pub status: CancelLoginAccountStatus,
419}
420
421#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
422pub enum CancelLoginAccountStatus {
423    #[serde(rename = "canceled")]
424    Canceled,
425    #[serde(rename = "notFound")]
426    NotFound,
427}
428
429#[derive(Debug, Clone, Serialize, Deserialize)]
430#[serde(rename_all = "camelCase")]
431pub struct ChatgptAuthTokensRefreshParams {
432    #[serde(
433        rename = "previousAccountId",
434        default,
435        skip_serializing_if = "Option::is_none"
436    )]
437    pub previous_account_id: Option<String>,
438    #[serde()]
439    pub reason: ChatgptAuthTokensRefreshReason,
440}
441
442#[derive(Debug, Clone, Serialize, Deserialize, Default)]
443#[serde(transparent)]
444pub struct ChatgptAuthTokensRefreshReason(pub Value);
445
446#[derive(Debug, Clone, Serialize, Deserialize)]
447#[serde(rename_all = "camelCase")]
448pub struct ChatgptAuthTokensRefreshResponse {
449    #[serde(rename = "accessToken")]
450    pub access_token: String,
451    #[serde(rename = "chatgptAccountId")]
452    pub chatgpt_account_id: String,
453    #[serde(
454        rename = "chatgptPlanType",
455        default,
456        skip_serializing_if = "Option::is_none"
457    )]
458    pub chatgpt_plan_type: Option<String>,
459}
460
461#[derive(Debug, Clone, Serialize, Deserialize, Default)]
462#[serde(transparent)]
463pub struct CodexErrorInfo(pub Value);
464
465#[derive(Debug, Clone, Serialize, Deserialize)]
466#[serde(rename_all = "camelCase")]
467pub struct CollabAgentState {
468    #[serde(default, skip_serializing_if = "Option::is_none")]
469    pub message: Option<String>,
470    #[serde()]
471    pub status: CollabAgentStatus,
472}
473
474#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
475pub enum CollabAgentStatus {
476    #[serde(rename = "pendingInit")]
477    PendingInit,
478    #[serde(rename = "running")]
479    Running,
480    #[serde(rename = "interrupted")]
481    Interrupted,
482    #[serde(rename = "completed")]
483    Completed,
484    #[serde(rename = "errored")]
485    Errored,
486    #[serde(rename = "shutdown")]
487    Shutdown,
488    #[serde(rename = "notFound")]
489    NotFound,
490}
491
492#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
493pub enum CollabAgentTool {
494    #[serde(rename = "spawnAgent")]
495    SpawnAgent,
496    #[serde(rename = "sendInput")]
497    SendInput,
498    #[serde(rename = "resumeAgent")]
499    ResumeAgent,
500    #[serde(rename = "wait")]
501    Wait,
502    #[serde(rename = "closeAgent")]
503    CloseAgent,
504}
505
506#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
507pub enum CollabAgentToolCallStatus {
508    #[serde(rename = "inProgress")]
509    InProgress,
510    #[serde(rename = "completed")]
511    Completed,
512    #[serde(rename = "failed")]
513    Failed,
514}
515
516#[derive(Debug, Clone, Serialize, Deserialize)]
517#[serde(tag = "type", rename_all = "camelCase")]
518pub enum CommandAction {
519    Read {
520        command: String,
521        name: String,
522        path: AbsolutePathBuf,
523    },
524    #[serde(rename = "listFiles")]
525    ListFiles {
526        command: String,
527        #[serde(default, skip_serializing_if = "Option::is_none")]
528        path: Option<String>,
529    },
530    Search {
531        command: String,
532        #[serde(default, skip_serializing_if = "Option::is_none")]
533        path: Option<String>,
534        #[serde(default, skip_serializing_if = "Option::is_none")]
535        query: Option<String>,
536    },
537    Unknown {
538        command: String,
539    },
540}
541
542#[derive(Debug, Clone, Serialize, Deserialize)]
543#[serde(rename_all = "camelCase")]
544pub struct CommandExecOutputDeltaNotification {
545    #[serde(rename = "capReached")]
546    pub cap_reached: bool,
547    #[serde(rename = "deltaBase64")]
548    pub delta_base64: String,
549    #[serde(rename = "processId")]
550    pub process_id: String,
551    #[serde()]
552    pub stream: Value,
553}
554
555#[derive(Debug, Clone, Serialize, Deserialize, Default)]
556#[serde(transparent)]
557pub struct CommandExecOutputStream(pub Value);
558
559#[derive(Debug, Clone, Serialize, Deserialize)]
560#[serde(rename_all = "camelCase")]
561pub struct CommandExecParams {
562    #[serde()]
563    pub command: Vec<String>,
564    #[serde(default, skip_serializing_if = "Option::is_none")]
565    pub cwd: Option<String>,
566    #[serde(
567        rename = "disableOutputCap",
568        default,
569        skip_serializing_if = "Option::is_none"
570    )]
571    pub disable_output_cap: Option<bool>,
572    #[serde(
573        rename = "disableTimeout",
574        default,
575        skip_serializing_if = "Option::is_none"
576    )]
577    pub disable_timeout: Option<bool>,
578    #[serde(default, skip_serializing_if = "Option::is_none")]
579    pub env: Option<std::collections::BTreeMap<String, Option<String>>>,
580    #[serde(
581        rename = "outputBytesCap",
582        default,
583        skip_serializing_if = "Option::is_none"
584    )]
585    pub output_bytes_cap: Option<i64>,
586    #[serde(rename = "processId", default, skip_serializing_if = "Option::is_none")]
587    pub process_id: Option<String>,
588    #[serde(
589        rename = "sandboxPolicy",
590        default,
591        skip_serializing_if = "Option::is_none"
592    )]
593    pub sandbox_policy: Option<SandboxPolicy>,
594    #[serde(default, skip_serializing_if = "Option::is_none")]
595    pub size: Option<CommandExecTerminalSize>,
596    #[serde(
597        rename = "streamStdin",
598        default,
599        skip_serializing_if = "Option::is_none"
600    )]
601    pub stream_stdin: Option<bool>,
602    #[serde(
603        rename = "streamStdoutStderr",
604        default,
605        skip_serializing_if = "Option::is_none"
606    )]
607    pub stream_stdout_stderr: Option<bool>,
608    #[serde(rename = "timeoutMs", default, skip_serializing_if = "Option::is_none")]
609    pub timeout_ms: Option<i64>,
610    #[serde(default, skip_serializing_if = "Option::is_none")]
611    pub tty: Option<bool>,
612}
613
614#[derive(Debug, Clone, Serialize, Deserialize)]
615#[serde(rename_all = "camelCase")]
616pub struct CommandExecResizeParams {
617    #[serde(rename = "processId")]
618    pub process_id: String,
619    #[serde()]
620    pub size: Value,
621}
622
623#[derive(Debug, Clone, Serialize, Deserialize)]
624#[serde(rename_all = "camelCase")]
625pub struct CommandExecResizeResponse {
626    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
627    pub extra: serde_json::Map<String, Value>,
628}
629
630#[derive(Debug, Clone, Serialize, Deserialize)]
631#[serde(rename_all = "camelCase")]
632pub struct CommandExecResponse {
633    #[serde(rename = "exitCode")]
634    pub exit_code: i64,
635    #[serde()]
636    pub stderr: String,
637    #[serde()]
638    pub stdout: String,
639}
640
641#[derive(Debug, Clone, Serialize, Deserialize)]
642#[serde(rename_all = "camelCase")]
643pub struct CommandExecTerminalSize {
644    #[serde()]
645    pub cols: i64,
646    #[serde()]
647    pub rows: i64,
648}
649
650#[derive(Debug, Clone, Serialize, Deserialize)]
651#[serde(rename_all = "camelCase")]
652pub struct CommandExecTerminateParams {
653    #[serde(rename = "processId")]
654    pub process_id: String,
655}
656
657#[derive(Debug, Clone, Serialize, Deserialize)]
658#[serde(rename_all = "camelCase")]
659pub struct CommandExecTerminateResponse {
660    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
661    pub extra: serde_json::Map<String, Value>,
662}
663
664#[derive(Debug, Clone, Serialize, Deserialize)]
665#[serde(rename_all = "camelCase")]
666pub struct CommandExecWriteParams {
667    #[serde(
668        rename = "closeStdin",
669        default,
670        skip_serializing_if = "Option::is_none"
671    )]
672    pub close_stdin: Option<bool>,
673    #[serde(
674        rename = "deltaBase64",
675        default,
676        skip_serializing_if = "Option::is_none"
677    )]
678    pub delta_base64: Option<String>,
679    #[serde(rename = "processId")]
680    pub process_id: String,
681}
682
683#[derive(Debug, Clone, Serialize, Deserialize)]
684#[serde(rename_all = "camelCase")]
685pub struct CommandExecWriteResponse {
686    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
687    pub extra: serde_json::Map<String, Value>,
688}
689
690#[derive(Debug, Clone, Serialize, Deserialize, Default)]
691#[serde(transparent)]
692pub struct CommandExecutionApprovalDecision(pub Value);
693
694#[derive(Debug, Clone, Serialize, Deserialize)]
695#[serde(rename_all = "camelCase")]
696pub struct CommandExecutionOutputDeltaNotification {
697    #[serde()]
698    pub delta: String,
699    #[serde(rename = "itemId")]
700    pub item_id: String,
701    #[serde(rename = "threadId")]
702    pub thread_id: String,
703    #[serde(rename = "turnId")]
704    pub turn_id: String,
705}
706
707#[derive(Debug, Clone, Serialize, Deserialize)]
708#[serde(rename_all = "camelCase")]
709pub struct CommandExecutionRequestApprovalParams {
710    #[serde(
711        rename = "approvalId",
712        default,
713        skip_serializing_if = "Option::is_none"
714    )]
715    pub approval_id: Option<String>,
716    #[serde(default, skip_serializing_if = "Option::is_none")]
717    pub command: Option<String>,
718    #[serde(
719        rename = "commandActions",
720        default,
721        skip_serializing_if = "Option::is_none"
722    )]
723    pub command_actions: Option<Vec<CommandAction>>,
724    #[serde(default, skip_serializing_if = "Option::is_none")]
725    pub cwd: Option<AbsolutePathBuf>,
726    #[serde(rename = "itemId")]
727    pub item_id: String,
728    #[serde(
729        rename = "networkApprovalContext",
730        default,
731        skip_serializing_if = "Option::is_none"
732    )]
733    pub network_approval_context: Option<NetworkApprovalContext>,
734    #[serde(
735        rename = "proposedExecpolicyAmendment",
736        default,
737        skip_serializing_if = "Option::is_none"
738    )]
739    pub proposed_execpolicy_amendment: Option<Vec<String>>,
740    #[serde(
741        rename = "proposedNetworkPolicyAmendments",
742        default,
743        skip_serializing_if = "Option::is_none"
744    )]
745    pub proposed_network_policy_amendments: Option<Vec<NetworkPolicyAmendment>>,
746    #[serde(default, skip_serializing_if = "Option::is_none")]
747    pub reason: Option<String>,
748    #[serde(rename = "startedAtMs")]
749    pub started_at_ms: i64,
750    #[serde(rename = "threadId")]
751    pub thread_id: String,
752    #[serde(rename = "turnId")]
753    pub turn_id: String,
754}
755
756#[derive(Debug, Clone, Serialize, Deserialize)]
757#[serde(rename_all = "camelCase")]
758pub struct CommandExecutionRequestApprovalResponse {
759    #[serde()]
760    pub decision: CommandExecutionApprovalDecision,
761}
762
763#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
764pub enum CommandExecutionSource {
765    #[serde(rename = "agent")]
766    Agent,
767    #[serde(rename = "userShell")]
768    UserShell,
769    #[serde(rename = "unifiedExecStartup")]
770    UnifiedExecStartup,
771    #[serde(rename = "unifiedExecInteraction")]
772    UnifiedExecInteraction,
773}
774
775#[derive(Debug, Clone, Serialize, Deserialize)]
776#[serde(rename_all = "camelCase")]
777pub struct CommandMigration {
778    #[serde()]
779    pub name: String,
780}
781
782#[derive(Debug, Clone, Serialize, Deserialize)]
783#[serde(rename_all = "camelCase")]
784pub struct Config {
785    #[serde(default, skip_serializing_if = "Option::is_none")]
786    pub analytics: Option<AnalyticsConfig>,
787    #[serde(default, skip_serializing_if = "Option::is_none")]
788    pub approval_policy: Option<AskForApproval>,
789    #[serde(default, skip_serializing_if = "Option::is_none")]
790    pub approvals_reviewer: Option<ApprovalsReviewer>,
791    #[serde(default, skip_serializing_if = "Option::is_none")]
792    pub compact_prompt: Option<String>,
793    #[serde(default, skip_serializing_if = "Option::is_none")]
794    pub desktop: Option<Value>,
795    #[serde(default, skip_serializing_if = "Option::is_none")]
796    pub developer_instructions: Option<String>,
797    #[serde(default, skip_serializing_if = "Option::is_none")]
798    pub forced_chatgpt_workspace_id: Option<ForcedChatgptWorkspaceIds>,
799    #[serde(default, skip_serializing_if = "Option::is_none")]
800    pub forced_login_method: Option<ForcedLoginMethod>,
801    #[serde(default, skip_serializing_if = "Option::is_none")]
802    pub instructions: Option<String>,
803    #[serde(default, skip_serializing_if = "Option::is_none")]
804    pub model: Option<String>,
805    #[serde(default, skip_serializing_if = "Option::is_none")]
806    pub model_auto_compact_token_limit: Option<i64>,
807    #[serde(default, skip_serializing_if = "Option::is_none")]
808    pub model_context_window: Option<i64>,
809    #[serde(default, skip_serializing_if = "Option::is_none")]
810    pub model_provider: Option<String>,
811    #[serde(default, skip_serializing_if = "Option::is_none")]
812    pub model_reasoning_effort: Option<ReasoningEffort>,
813    #[serde(default, skip_serializing_if = "Option::is_none")]
814    pub model_reasoning_summary: Option<ReasoningSummary>,
815    #[serde(default, skip_serializing_if = "Option::is_none")]
816    pub model_verbosity: Option<Verbosity>,
817    #[serde(default, skip_serializing_if = "Option::is_none")]
818    pub profile: Option<String>,
819    #[serde(default, skip_serializing_if = "Option::is_none")]
820    pub profiles: Option<std::collections::BTreeMap<String, ProfileV2>>,
821    #[serde(default, skip_serializing_if = "Option::is_none")]
822    pub review_model: Option<String>,
823    #[serde(default, skip_serializing_if = "Option::is_none")]
824    pub sandbox_mode: Option<SandboxMode>,
825    #[serde(default, skip_serializing_if = "Option::is_none")]
826    pub sandbox_workspace_write: Option<SandboxWorkspaceWrite>,
827    #[serde(default, skip_serializing_if = "Option::is_none")]
828    pub service_tier: Option<String>,
829    #[serde(default, skip_serializing_if = "Option::is_none")]
830    pub tools: Option<ToolsV2>,
831    #[serde(default, skip_serializing_if = "Option::is_none")]
832    pub web_search: Option<WebSearchMode>,
833}
834
835#[derive(Debug, Clone, Serialize, Deserialize)]
836#[serde(rename_all = "camelCase")]
837pub struct ConfigBatchWriteParams {
838    #[serde()]
839    pub edits: Vec<ConfigEdit>,
840    #[serde(
841        rename = "expectedVersion",
842        default,
843        skip_serializing_if = "Option::is_none"
844    )]
845    pub expected_version: Option<String>,
846    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
847    pub file_path: Option<String>,
848    #[serde(
849        rename = "reloadUserConfig",
850        default,
851        skip_serializing_if = "Option::is_none"
852    )]
853    pub reload_user_config: Option<bool>,
854}
855
856#[derive(Debug, Clone, Serialize, Deserialize)]
857#[serde(rename_all = "camelCase")]
858pub struct ConfigEdit {
859    #[serde(rename = "keyPath")]
860    pub key_path: String,
861    #[serde(rename = "mergeStrategy")]
862    pub merge_strategy: MergeStrategy,
863    #[serde()]
864    pub value: Value,
865}
866
867#[derive(Debug, Clone, Serialize, Deserialize)]
868#[serde(rename_all = "camelCase")]
869pub struct ConfigLayer {
870    #[serde()]
871    pub config: Value,
872    #[serde(
873        rename = "disabledReason",
874        default,
875        skip_serializing_if = "Option::is_none"
876    )]
877    pub disabled_reason: Option<String>,
878    #[serde()]
879    pub name: ConfigLayerSource,
880    #[serde()]
881    pub version: String,
882}
883
884#[derive(Debug, Clone, Serialize, Deserialize)]
885#[serde(rename_all = "camelCase")]
886pub struct ConfigLayerMetadata {
887    #[serde()]
888    pub name: ConfigLayerSource,
889    #[serde()]
890    pub version: String,
891}
892
893#[derive(Debug, Clone, Serialize, Deserialize)]
894#[serde(tag = "type", rename_all = "camelCase")]
895pub enum ConfigLayerSource {
896    Mdm {
897        domain: String,
898        key: String,
899    },
900    System {
901        file: Value,
902    },
903    User {
904        file: Value,
905        #[serde(default, skip_serializing_if = "Option::is_none")]
906        profile: Option<String>,
907    },
908    Project {
909        #[serde(rename = "dotCodexFolder")]
910        dot_codex_folder: AbsolutePathBuf,
911    },
912    #[serde(rename = "sessionFlags")]
913    SessionFlags,
914    #[serde(rename = "legacyManagedConfigTomlFromFile")]
915    LegacyManagedConfigTomlFromFile {
916        file: AbsolutePathBuf,
917    },
918    #[serde(rename = "legacyManagedConfigTomlFromMdm")]
919    LegacyManagedConfigTomlFromMdm,
920}
921
922#[derive(Debug, Clone, Serialize, Deserialize)]
923#[serde(rename_all = "camelCase")]
924pub struct ConfigReadParams {
925    #[serde(default, skip_serializing_if = "Option::is_none")]
926    pub cwd: Option<String>,
927    #[serde(
928        rename = "includeLayers",
929        default,
930        skip_serializing_if = "Option::is_none"
931    )]
932    pub include_layers: Option<bool>,
933}
934
935#[derive(Debug, Clone, Serialize, Deserialize)]
936#[serde(rename_all = "camelCase")]
937pub struct ConfigReadResponse {
938    #[serde()]
939    pub config: Config,
940    #[serde(default, skip_serializing_if = "Option::is_none")]
941    pub layers: Option<Vec<ConfigLayer>>,
942    #[serde()]
943    pub origins: std::collections::BTreeMap<String, ConfigLayerMetadata>,
944}
945
946#[derive(Debug, Clone, Serialize, Deserialize)]
947#[serde(rename_all = "camelCase")]
948pub struct ConfigRequirements {
949    #[serde(
950        rename = "allowManagedHooksOnly",
951        default,
952        skip_serializing_if = "Option::is_none"
953    )]
954    pub allow_managed_hooks_only: Option<bool>,
955    #[serde(
956        rename = "allowedApprovalPolicies",
957        default,
958        skip_serializing_if = "Option::is_none"
959    )]
960    pub allowed_approval_policies: Option<Vec<AskForApproval>>,
961    #[serde(
962        rename = "allowedSandboxModes",
963        default,
964        skip_serializing_if = "Option::is_none"
965    )]
966    pub allowed_sandbox_modes: Option<Vec<SandboxMode>>,
967    #[serde(
968        rename = "allowedWebSearchModes",
969        default,
970        skip_serializing_if = "Option::is_none"
971    )]
972    pub allowed_web_search_modes: Option<Vec<WebSearchMode>>,
973    #[serde(
974        rename = "enforceResidency",
975        default,
976        skip_serializing_if = "Option::is_none"
977    )]
978    pub enforce_residency: Option<ResidencyRequirement>,
979    #[serde(
980        rename = "featureRequirements",
981        default,
982        skip_serializing_if = "Option::is_none"
983    )]
984    pub feature_requirements: Option<std::collections::BTreeMap<String, bool>>,
985}
986
987#[derive(Debug, Clone, Serialize, Deserialize)]
988#[serde(rename_all = "camelCase")]
989pub struct ConfigRequirementsReadResponse {
990    #[serde(default, skip_serializing_if = "Option::is_none")]
991    pub requirements: Option<ConfigRequirements>,
992}
993
994#[derive(Debug, Clone, Serialize, Deserialize)]
995#[serde(rename_all = "camelCase")]
996pub struct ConfigValueWriteParams {
997    #[serde(
998        rename = "expectedVersion",
999        default,
1000        skip_serializing_if = "Option::is_none"
1001    )]
1002    pub expected_version: Option<String>,
1003    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
1004    pub file_path: Option<String>,
1005    #[serde(rename = "keyPath")]
1006    pub key_path: String,
1007    #[serde(rename = "mergeStrategy")]
1008    pub merge_strategy: MergeStrategy,
1009    #[serde()]
1010    pub value: Value,
1011}
1012
1013#[derive(Debug, Clone, Serialize, Deserialize)]
1014#[serde(rename_all = "camelCase")]
1015pub struct ConfigWriteResponse {
1016    #[serde(rename = "filePath")]
1017    pub file_path: Value,
1018    #[serde(
1019        rename = "overriddenMetadata",
1020        default,
1021        skip_serializing_if = "Option::is_none"
1022    )]
1023    pub overridden_metadata: Option<OverriddenMetadata>,
1024    #[serde()]
1025    pub status: WriteStatus,
1026    #[serde()]
1027    pub version: String,
1028}
1029
1030#[derive(Debug, Clone, Serialize, Deserialize)]
1031#[serde(rename_all = "camelCase")]
1032pub struct ContextCompactedNotification {
1033    #[serde(rename = "threadId")]
1034    pub thread_id: String,
1035    #[serde(rename = "turnId")]
1036    pub turn_id: String,
1037}
1038
1039#[derive(Debug, Clone, Serialize, Deserialize)]
1040#[serde(rename_all = "camelCase")]
1041pub struct CreditsSnapshot {
1042    #[serde(default, skip_serializing_if = "Option::is_none")]
1043    pub balance: Option<String>,
1044    #[serde(rename = "hasCredits")]
1045    pub has_credits: bool,
1046    #[serde()]
1047    pub unlimited: bool,
1048}
1049
1050#[derive(Debug, Clone, Serialize, Deserialize)]
1051#[serde(tag = "type", rename_all = "camelCase")]
1052pub enum DynamicToolCallOutputContentItem {
1053    #[serde(rename = "inputText")]
1054    InputText { text: String },
1055    #[serde(rename = "inputImage")]
1056    InputImage {
1057        #[serde(rename = "imageUrl")]
1058        image_url: String,
1059    },
1060}
1061
1062#[derive(Debug, Clone, Serialize, Deserialize)]
1063#[serde(rename_all = "camelCase")]
1064pub struct DynamicToolCallParams {
1065    #[serde()]
1066    pub arguments: Value,
1067    #[serde(rename = "callId")]
1068    pub call_id: String,
1069    #[serde(default, skip_serializing_if = "Option::is_none")]
1070    pub namespace: Option<String>,
1071    #[serde(rename = "threadId")]
1072    pub thread_id: String,
1073    #[serde()]
1074    pub tool: String,
1075    #[serde(rename = "turnId")]
1076    pub turn_id: String,
1077}
1078
1079#[derive(Debug, Clone, Serialize, Deserialize)]
1080#[serde(rename_all = "camelCase")]
1081pub struct DynamicToolCallResponse {
1082    #[serde(rename = "contentItems")]
1083    pub content_items: Vec<DynamicToolCallOutputContentItem>,
1084    #[serde()]
1085    pub success: bool,
1086}
1087
1088#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1089pub enum DynamicToolCallStatus {
1090    #[serde(rename = "inProgress")]
1091    InProgress,
1092    #[serde(rename = "completed")]
1093    Completed,
1094    #[serde(rename = "failed")]
1095    Failed,
1096}
1097
1098#[derive(Debug, Clone, Serialize, Deserialize)]
1099#[serde(rename_all = "camelCase")]
1100pub struct ExecCommandApprovalParams {
1101    #[serde(
1102        rename = "approvalId",
1103        default,
1104        skip_serializing_if = "Option::is_none"
1105    )]
1106    pub approval_id: Option<String>,
1107    #[serde(rename = "callId")]
1108    pub call_id: String,
1109    #[serde()]
1110    pub command: Vec<String>,
1111    #[serde(rename = "conversationId")]
1112    pub conversation_id: ThreadId,
1113    #[serde()]
1114    pub cwd: String,
1115    #[serde(rename = "parsedCmd")]
1116    pub parsed_cmd: Vec<ParsedCommand>,
1117    #[serde(default, skip_serializing_if = "Option::is_none")]
1118    pub reason: Option<String>,
1119}
1120
1121#[derive(Debug, Clone, Serialize, Deserialize)]
1122#[serde(rename_all = "camelCase")]
1123pub struct ExecCommandApprovalResponse {
1124    #[serde()]
1125    pub decision: ReviewDecision,
1126}
1127
1128#[derive(Debug, Clone, Serialize, Deserialize)]
1129#[serde(rename_all = "camelCase")]
1130pub struct ExperimentalFeature {
1131    #[serde(default, skip_serializing_if = "Option::is_none")]
1132    pub announcement: Option<String>,
1133    #[serde(rename = "defaultEnabled")]
1134    pub default_enabled: bool,
1135    #[serde(default, skip_serializing_if = "Option::is_none")]
1136    pub description: Option<String>,
1137    #[serde(
1138        rename = "displayName",
1139        default,
1140        skip_serializing_if = "Option::is_none"
1141    )]
1142    pub display_name: Option<String>,
1143    #[serde()]
1144    pub enabled: bool,
1145    #[serde()]
1146    pub name: String,
1147    #[serde()]
1148    pub stage: Value,
1149}
1150
1151#[derive(Debug, Clone, Serialize, Deserialize)]
1152#[serde(rename_all = "camelCase")]
1153pub struct ExperimentalFeatureEnablementSetParams {
1154    #[serde()]
1155    pub enablement: std::collections::BTreeMap<String, bool>,
1156}
1157
1158#[derive(Debug, Clone, Serialize, Deserialize)]
1159#[serde(rename_all = "camelCase")]
1160pub struct ExperimentalFeatureEnablementSetResponse {
1161    #[serde()]
1162    pub enablement: std::collections::BTreeMap<String, bool>,
1163}
1164
1165#[derive(Debug, Clone, Serialize, Deserialize)]
1166#[serde(rename_all = "camelCase")]
1167pub struct ExperimentalFeatureListParams {
1168    #[serde(default, skip_serializing_if = "Option::is_none")]
1169    pub cursor: Option<String>,
1170    #[serde(default, skip_serializing_if = "Option::is_none")]
1171    pub limit: Option<i64>,
1172}
1173
1174#[derive(Debug, Clone, Serialize, Deserialize)]
1175#[serde(rename_all = "camelCase")]
1176pub struct ExperimentalFeatureListResponse {
1177    #[serde()]
1178    pub data: Vec<ExperimentalFeature>,
1179    #[serde(
1180        rename = "nextCursor",
1181        default,
1182        skip_serializing_if = "Option::is_none"
1183    )]
1184    pub next_cursor: Option<String>,
1185}
1186
1187#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1188#[serde(transparent)]
1189pub struct ExperimentalFeatureStage(pub Value);
1190
1191#[derive(Debug, Clone, Serialize, Deserialize)]
1192#[serde(rename_all = "camelCase")]
1193pub struct ExternalAgentConfigDetectParams {
1194    #[serde(default, skip_serializing_if = "Option::is_none")]
1195    pub cwds: Option<Vec<String>>,
1196    #[serde(
1197        rename = "includeHome",
1198        default,
1199        skip_serializing_if = "Option::is_none"
1200    )]
1201    pub include_home: Option<bool>,
1202}
1203
1204#[derive(Debug, Clone, Serialize, Deserialize)]
1205#[serde(rename_all = "camelCase")]
1206pub struct ExternalAgentConfigDetectResponse {
1207    #[serde()]
1208    pub items: Vec<ExternalAgentConfigMigrationItem>,
1209}
1210
1211#[derive(Debug, Clone, Serialize, Deserialize)]
1212#[serde(rename_all = "camelCase")]
1213pub struct ExternalAgentConfigImportCompletedNotification {
1214    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1215    pub extra: serde_json::Map<String, Value>,
1216}
1217
1218#[derive(Debug, Clone, Serialize, Deserialize)]
1219#[serde(rename_all = "camelCase")]
1220pub struct ExternalAgentConfigImportParams {
1221    #[serde(rename = "migrationItems")]
1222    pub migration_items: Vec<ExternalAgentConfigMigrationItem>,
1223}
1224
1225#[derive(Debug, Clone, Serialize, Deserialize)]
1226#[serde(rename_all = "camelCase")]
1227pub struct ExternalAgentConfigImportResponse {
1228    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1229    pub extra: serde_json::Map<String, Value>,
1230}
1231
1232#[derive(Debug, Clone, Serialize, Deserialize)]
1233#[serde(rename_all = "camelCase")]
1234pub struct ExternalAgentConfigMigrationItem {
1235    #[serde(default, skip_serializing_if = "Option::is_none")]
1236    pub cwd: Option<String>,
1237    #[serde()]
1238    pub description: String,
1239    #[serde(default, skip_serializing_if = "Option::is_none")]
1240    pub details: Option<MigrationDetails>,
1241    #[serde(rename = "itemType")]
1242    pub item_type: ExternalAgentConfigMigrationItemType,
1243}
1244
1245#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1246pub enum ExternalAgentConfigMigrationItemType {
1247    #[serde(rename = "AGENTS_MD")]
1248    AGENTS_MD,
1249    #[serde(rename = "CONFIG")]
1250    CONFIG,
1251    #[serde(rename = "SKILLS")]
1252    SKILLS,
1253    #[serde(rename = "PLUGINS")]
1254    PLUGINS,
1255    #[serde(rename = "MCP_SERVER_CONFIG")]
1256    MCP_SERVER_CONFIG,
1257    #[serde(rename = "SUBAGENTS")]
1258    SUBAGENTS,
1259    #[serde(rename = "HOOKS")]
1260    HOOKS,
1261    #[serde(rename = "COMMANDS")]
1262    COMMANDS,
1263    #[serde(rename = "SESSIONS")]
1264    SESSIONS,
1265}
1266
1267#[derive(Debug, Clone, Serialize, Deserialize)]
1268#[serde(rename_all = "camelCase")]
1269pub struct FeedbackUploadParams {
1270    #[serde()]
1271    pub classification: String,
1272    #[serde(
1273        rename = "extraLogFiles",
1274        default,
1275        skip_serializing_if = "Option::is_none"
1276    )]
1277    pub extra_log_files: Option<Vec<String>>,
1278    #[serde(rename = "includeLogs")]
1279    pub include_logs: bool,
1280    #[serde(default, skip_serializing_if = "Option::is_none")]
1281    pub reason: Option<String>,
1282    #[serde(default, skip_serializing_if = "Option::is_none")]
1283    pub tags: Option<std::collections::BTreeMap<String, String>>,
1284    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
1285    pub thread_id: Option<String>,
1286}
1287
1288#[derive(Debug, Clone, Serialize, Deserialize)]
1289#[serde(rename_all = "camelCase")]
1290pub struct FeedbackUploadResponse {
1291    #[serde(rename = "threadId")]
1292    pub thread_id: String,
1293}
1294
1295#[derive(Debug, Clone, Serialize, Deserialize)]
1296#[serde(tag = "type", rename_all = "camelCase")]
1297pub enum FileChange {
1298    Add {
1299        content: String,
1300    },
1301    Delete {
1302        content: String,
1303    },
1304    Update {
1305        #[serde(default, skip_serializing_if = "Option::is_none")]
1306        move_path: Option<String>,
1307        unified_diff: String,
1308    },
1309}
1310
1311#[derive(Debug, Clone, Serialize, Deserialize)]
1312#[serde(rename_all = "camelCase")]
1313pub struct FileChangeRequestApprovalParams {
1314    #[serde(rename = "grantRoot", default, skip_serializing_if = "Option::is_none")]
1315    pub grant_root: Option<String>,
1316    #[serde(rename = "itemId")]
1317    pub item_id: String,
1318    #[serde(default, skip_serializing_if = "Option::is_none")]
1319    pub reason: Option<String>,
1320    #[serde(rename = "startedAtMs")]
1321    pub started_at_ms: i64,
1322    #[serde(rename = "threadId")]
1323    pub thread_id: String,
1324    #[serde(rename = "turnId")]
1325    pub turn_id: String,
1326}
1327
1328#[derive(Debug, Clone, Serialize, Deserialize)]
1329#[serde(rename_all = "camelCase")]
1330pub struct FileChangeRequestApprovalResponse {
1331    #[serde()]
1332    pub decision: FileChangeApprovalDecision,
1333}
1334
1335#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1336pub enum FileSystemAccessMode {
1337    #[serde(rename = "read")]
1338    Read,
1339    #[serde(rename = "write")]
1340    Write,
1341    #[serde(rename = "none")]
1342    None,
1343}
1344
1345#[derive(Debug, Clone, Serialize, Deserialize)]
1346#[serde(tag = "type", rename_all = "camelCase")]
1347pub enum FileSystemPath {
1348    Path { path: AbsolutePathBuf },
1349    Glob_pattern { pattern: String },
1350    Special { value: FileSystemSpecialPath },
1351}
1352
1353#[derive(Debug, Clone, Serialize, Deserialize)]
1354#[serde(rename_all = "camelCase")]
1355pub struct FileSystemSandboxEntry {
1356    #[serde()]
1357    pub access: FileSystemAccessMode,
1358    #[serde()]
1359    pub path: FileSystemPath,
1360}
1361
1362#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1363#[serde(transparent)]
1364pub struct FileSystemSpecialPath(pub Value);
1365
1366#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1367#[serde(transparent)]
1368pub struct ForcedChatgptWorkspaceIds(pub Value);
1369
1370#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1371pub enum ForcedLoginMethod {
1372    #[serde(rename = "chatgpt")]
1373    Chatgpt,
1374    #[serde(rename = "api")]
1375    Api,
1376}
1377
1378#[derive(Debug, Clone, Serialize, Deserialize)]
1379#[serde(rename_all = "camelCase")]
1380pub struct FsCopyParams {
1381    #[serde(rename = "destinationPath")]
1382    pub destination_path: Value,
1383    #[serde(default, skip_serializing_if = "Option::is_none")]
1384    pub recursive: Option<bool>,
1385    #[serde(rename = "sourcePath")]
1386    pub source_path: Value,
1387}
1388
1389#[derive(Debug, Clone, Serialize, Deserialize)]
1390#[serde(rename_all = "camelCase")]
1391pub struct FsCopyResponse {
1392    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1393    pub extra: serde_json::Map<String, Value>,
1394}
1395
1396#[derive(Debug, Clone, Serialize, Deserialize)]
1397#[serde(rename_all = "camelCase")]
1398pub struct FsCreateDirectoryParams {
1399    #[serde()]
1400    pub path: Value,
1401    #[serde(default, skip_serializing_if = "Option::is_none")]
1402    pub recursive: Option<bool>,
1403}
1404
1405#[derive(Debug, Clone, Serialize, Deserialize)]
1406#[serde(rename_all = "camelCase")]
1407pub struct FsCreateDirectoryResponse {
1408    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1409    pub extra: serde_json::Map<String, Value>,
1410}
1411
1412#[derive(Debug, Clone, Serialize, Deserialize)]
1413#[serde(rename_all = "camelCase")]
1414pub struct FsGetMetadataParams {
1415    #[serde()]
1416    pub path: Value,
1417}
1418
1419#[derive(Debug, Clone, Serialize, Deserialize)]
1420#[serde(rename_all = "camelCase")]
1421pub struct FsGetMetadataResponse {
1422    #[serde(rename = "createdAtMs")]
1423    pub created_at_ms: i64,
1424    #[serde(rename = "isDirectory")]
1425    pub is_directory: bool,
1426    #[serde(rename = "isFile")]
1427    pub is_file: bool,
1428    #[serde(rename = "isSymlink")]
1429    pub is_symlink: bool,
1430    #[serde(rename = "modifiedAtMs")]
1431    pub modified_at_ms: i64,
1432}
1433
1434#[derive(Debug, Clone, Serialize, Deserialize)]
1435#[serde(rename_all = "camelCase")]
1436pub struct FsReadDirectoryEntry {
1437    #[serde(rename = "fileName")]
1438    pub file_name: String,
1439    #[serde(rename = "isDirectory")]
1440    pub is_directory: bool,
1441    #[serde(rename = "isFile")]
1442    pub is_file: bool,
1443}
1444
1445#[derive(Debug, Clone, Serialize, Deserialize)]
1446#[serde(rename_all = "camelCase")]
1447pub struct FsReadDirectoryParams {
1448    #[serde()]
1449    pub path: Value,
1450}
1451
1452#[derive(Debug, Clone, Serialize, Deserialize)]
1453#[serde(rename_all = "camelCase")]
1454pub struct FsReadDirectoryResponse {
1455    #[serde()]
1456    pub entries: Vec<FsReadDirectoryEntry>,
1457}
1458
1459#[derive(Debug, Clone, Serialize, Deserialize)]
1460#[serde(rename_all = "camelCase")]
1461pub struct FsReadFileParams {
1462    #[serde()]
1463    pub path: Value,
1464}
1465
1466#[derive(Debug, Clone, Serialize, Deserialize)]
1467#[serde(rename_all = "camelCase")]
1468pub struct FsReadFileResponse {
1469    #[serde(rename = "dataBase64")]
1470    pub data_base64: String,
1471}
1472
1473#[derive(Debug, Clone, Serialize, Deserialize)]
1474#[serde(rename_all = "camelCase")]
1475pub struct FsRemoveParams {
1476    #[serde(default, skip_serializing_if = "Option::is_none")]
1477    pub force: Option<bool>,
1478    #[serde()]
1479    pub path: Value,
1480    #[serde(default, skip_serializing_if = "Option::is_none")]
1481    pub recursive: Option<bool>,
1482}
1483
1484#[derive(Debug, Clone, Serialize, Deserialize)]
1485#[serde(rename_all = "camelCase")]
1486pub struct FsRemoveResponse {
1487    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1488    pub extra: serde_json::Map<String, Value>,
1489}
1490
1491#[derive(Debug, Clone, Serialize, Deserialize)]
1492#[serde(rename_all = "camelCase")]
1493pub struct FsUnwatchParams {
1494    #[serde(rename = "watchId")]
1495    pub watch_id: String,
1496}
1497
1498#[derive(Debug, Clone, Serialize, Deserialize)]
1499#[serde(rename_all = "camelCase")]
1500pub struct FsUnwatchResponse {
1501    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1502    pub extra: serde_json::Map<String, Value>,
1503}
1504
1505#[derive(Debug, Clone, Serialize, Deserialize)]
1506#[serde(rename_all = "camelCase")]
1507pub struct FsWatchParams {
1508    #[serde()]
1509    pub path: Value,
1510    #[serde(rename = "watchId")]
1511    pub watch_id: String,
1512}
1513
1514#[derive(Debug, Clone, Serialize, Deserialize)]
1515#[serde(rename_all = "camelCase")]
1516pub struct FsWatchResponse {
1517    #[serde()]
1518    pub path: Value,
1519}
1520
1521#[derive(Debug, Clone, Serialize, Deserialize)]
1522#[serde(rename_all = "camelCase")]
1523pub struct FsWriteFileParams {
1524    #[serde(rename = "dataBase64")]
1525    pub data_base64: String,
1526    #[serde()]
1527    pub path: Value,
1528}
1529
1530#[derive(Debug, Clone, Serialize, Deserialize)]
1531#[serde(rename_all = "camelCase")]
1532pub struct FsWriteFileResponse {
1533    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
1534    pub extra: serde_json::Map<String, Value>,
1535}
1536
1537#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1538pub enum FuzzyFileSearchMatchType {
1539    #[serde(rename = "file")]
1540    File,
1541    #[serde(rename = "directory")]
1542    Directory,
1543}
1544
1545#[derive(Debug, Clone, Serialize, Deserialize)]
1546#[serde(rename_all = "camelCase")]
1547pub struct FuzzyFileSearchParams {
1548    #[serde(
1549        rename = "cancellationToken",
1550        default,
1551        skip_serializing_if = "Option::is_none"
1552    )]
1553    pub cancellation_token: Option<String>,
1554    #[serde()]
1555    pub query: String,
1556    #[serde()]
1557    pub roots: Vec<String>,
1558}
1559
1560#[derive(Debug, Clone, Serialize, Deserialize)]
1561#[serde(rename_all = "camelCase")]
1562pub struct FuzzyFileSearchResponse {
1563    #[serde()]
1564    pub files: Vec<FuzzyFileSearchResult>,
1565}
1566
1567#[derive(Debug, Clone, Serialize, Deserialize)]
1568#[serde(rename_all = "camelCase")]
1569pub struct FuzzyFileSearchResult {
1570    #[serde()]
1571    pub file_name: String,
1572    #[serde(default, skip_serializing_if = "Option::is_none")]
1573    pub indices: Option<Vec<i64>>,
1574    #[serde()]
1575    pub match_type: FuzzyFileSearchMatchType,
1576    #[serde()]
1577    pub path: String,
1578    #[serde()]
1579    pub root: String,
1580    #[serde()]
1581    pub score: i64,
1582}
1583
1584#[derive(Debug, Clone, Serialize, Deserialize)]
1585#[serde(rename_all = "camelCase")]
1586pub struct FuzzyFileSearchSessionCompletedNotification {
1587    #[serde(rename = "sessionId")]
1588    pub session_id: String,
1589}
1590
1591#[derive(Debug, Clone, Serialize, Deserialize)]
1592#[serde(rename_all = "camelCase")]
1593pub struct FuzzyFileSearchSessionUpdatedNotification {
1594    #[serde()]
1595    pub files: Vec<FuzzyFileSearchResult>,
1596    #[serde()]
1597    pub query: String,
1598    #[serde(rename = "sessionId")]
1599    pub session_id: String,
1600}
1601
1602#[derive(Debug, Clone, Serialize, Deserialize)]
1603#[serde(rename_all = "camelCase")]
1604pub struct GetAccountParams {
1605    #[serde(
1606        rename = "refreshToken",
1607        default,
1608        skip_serializing_if = "Option::is_none"
1609    )]
1610    pub refresh_token: Option<bool>,
1611}
1612
1613#[derive(Debug, Clone, Serialize, Deserialize)]
1614#[serde(rename_all = "camelCase")]
1615pub struct GetAccountRateLimitsResponse {
1616    #[serde(rename = "rateLimits")]
1617    pub rate_limits: Value,
1618    #[serde(
1619        rename = "rateLimitsByLimitId",
1620        default,
1621        skip_serializing_if = "Option::is_none"
1622    )]
1623    pub rate_limits_by_limit_id: Option<std::collections::BTreeMap<String, RateLimitSnapshot>>,
1624}
1625
1626#[derive(Debug, Clone, Serialize, Deserialize)]
1627#[serde(rename_all = "camelCase")]
1628pub struct GetAccountResponse {
1629    #[serde(default, skip_serializing_if = "Option::is_none")]
1630    pub account: Option<Account>,
1631    #[serde(rename = "requiresOpenaiAuth")]
1632    pub requires_openai_auth: bool,
1633}
1634
1635#[derive(Debug, Clone, Serialize, Deserialize)]
1636#[serde(rename_all = "camelCase")]
1637pub struct GitInfo {
1638    #[serde(default, skip_serializing_if = "Option::is_none")]
1639    pub branch: Option<String>,
1640    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
1641    pub origin_url: Option<String>,
1642    #[serde(default, skip_serializing_if = "Option::is_none")]
1643    pub sha: Option<String>,
1644}
1645
1646#[derive(Debug, Clone, Serialize, Deserialize)]
1647#[serde(rename_all = "camelCase")]
1648pub struct GrantedPermissionProfile {
1649    #[serde(
1650        rename = "fileSystem",
1651        default,
1652        skip_serializing_if = "Option::is_none"
1653    )]
1654    pub file_system: Option<AdditionalFileSystemPermissions>,
1655    #[serde(default, skip_serializing_if = "Option::is_none")]
1656    pub network: Option<AdditionalNetworkPermissions>,
1657}
1658
1659#[derive(Debug, Clone, Serialize, Deserialize)]
1660#[serde(rename_all = "camelCase")]
1661pub struct GuardianApprovalReview {
1662    #[serde(default, skip_serializing_if = "Option::is_none")]
1663    pub rationale: Option<String>,
1664    #[serde(rename = "riskLevel", default, skip_serializing_if = "Option::is_none")]
1665    pub risk_level: Option<GuardianRiskLevel>,
1666    #[serde()]
1667    pub status: GuardianApprovalReviewStatus,
1668    #[serde(
1669        rename = "userAuthorization",
1670        default,
1671        skip_serializing_if = "Option::is_none"
1672    )]
1673    pub user_authorization: Option<GuardianUserAuthorization>,
1674}
1675
1676#[derive(Debug, Clone, Serialize, Deserialize)]
1677#[serde(tag = "type", rename_all = "camelCase")]
1678pub enum GuardianApprovalReviewAction {
1679    Command {
1680        command: String,
1681        cwd: AbsolutePathBuf,
1682        source: GuardianCommandSource,
1683    },
1684    Execve {
1685        argv: Vec<String>,
1686        cwd: AbsolutePathBuf,
1687        program: String,
1688        source: GuardianCommandSource,
1689    },
1690    #[serde(rename = "applyPatch")]
1691    ApplyPatch {
1692        cwd: AbsolutePathBuf,
1693        files: Vec<AbsolutePathBuf>,
1694    },
1695    #[serde(rename = "networkAccess")]
1696    NetworkAccess {
1697        host: String,
1698        port: i64,
1699        protocol: NetworkApprovalProtocol,
1700        target: String,
1701    },
1702    #[serde(rename = "mcpToolCall")]
1703    McpToolCall {
1704        #[serde(
1705            rename = "connectorId",
1706            default,
1707            skip_serializing_if = "Option::is_none"
1708        )]
1709        connector_id: Option<String>,
1710        #[serde(
1711            rename = "connectorName",
1712            default,
1713            skip_serializing_if = "Option::is_none"
1714        )]
1715        connector_name: Option<String>,
1716        server: String,
1717        #[serde(rename = "toolName")]
1718        tool_name: String,
1719        #[serde(rename = "toolTitle", default, skip_serializing_if = "Option::is_none")]
1720        tool_title: Option<String>,
1721    },
1722    #[serde(rename = "requestPermissions")]
1723    RequestPermissions {
1724        permissions: RequestPermissionProfile,
1725        #[serde(default, skip_serializing_if = "Option::is_none")]
1726        reason: Option<String>,
1727    },
1728}
1729
1730#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1731pub enum GuardianApprovalReviewStatus {
1732    #[serde(rename = "inProgress")]
1733    InProgress,
1734    #[serde(rename = "approved")]
1735    Approved,
1736    #[serde(rename = "denied")]
1737    Denied,
1738    #[serde(rename = "timedOut")]
1739    TimedOut,
1740    #[serde(rename = "aborted")]
1741    Aborted,
1742}
1743
1744#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1745pub enum GuardianCommandSource {
1746    #[serde(rename = "shell")]
1747    Shell,
1748    #[serde(rename = "unifiedExec")]
1749    UnifiedExec,
1750}
1751
1752#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1753pub enum GuardianRiskLevel {
1754    #[serde(rename = "low")]
1755    Low,
1756    #[serde(rename = "medium")]
1757    Medium,
1758    #[serde(rename = "high")]
1759    High,
1760    #[serde(rename = "critical")]
1761    Critical,
1762}
1763
1764#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1765pub enum GuardianUserAuthorization {
1766    #[serde(rename = "unknown")]
1767    Unknown,
1768    #[serde(rename = "low")]
1769    Low,
1770    #[serde(rename = "medium")]
1771    Medium,
1772    #[serde(rename = "high")]
1773    High,
1774}
1775
1776#[derive(Debug, Clone, Serialize, Deserialize)]
1777#[serde(rename_all = "camelCase")]
1778pub struct HookCompletedNotification {
1779    #[serde()]
1780    pub run: HookRunSummary,
1781    #[serde(rename = "threadId")]
1782    pub thread_id: String,
1783    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
1784    pub turn_id: Option<String>,
1785}
1786
1787#[derive(Debug, Clone, Serialize, Deserialize)]
1788#[serde(rename_all = "camelCase")]
1789pub struct HookErrorInfo {
1790    #[serde()]
1791    pub message: String,
1792    #[serde()]
1793    pub path: String,
1794}
1795
1796#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1797pub enum HookEventName {
1798    #[serde(rename = "preToolUse")]
1799    PreToolUse,
1800    #[serde(rename = "permissionRequest")]
1801    PermissionRequest,
1802    #[serde(rename = "postToolUse")]
1803    PostToolUse,
1804    #[serde(rename = "preCompact")]
1805    PreCompact,
1806    #[serde(rename = "postCompact")]
1807    PostCompact,
1808    #[serde(rename = "sessionStart")]
1809    SessionStart,
1810    #[serde(rename = "userPromptSubmit")]
1811    UserPromptSubmit,
1812    #[serde(rename = "stop")]
1813    Stop,
1814}
1815
1816#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1817pub enum HookExecutionMode {
1818    #[serde(rename = "sync")]
1819    Sync,
1820    #[serde(rename = "async")]
1821    Async,
1822}
1823
1824#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1825pub enum HookHandlerType {
1826    #[serde(rename = "command")]
1827    Command,
1828    #[serde(rename = "prompt")]
1829    Prompt,
1830    #[serde(rename = "agent")]
1831    Agent,
1832}
1833
1834#[derive(Debug, Clone, Serialize, Deserialize)]
1835#[serde(rename_all = "camelCase")]
1836pub struct HookMetadata {
1837    #[serde(default, skip_serializing_if = "Option::is_none")]
1838    pub command: Option<String>,
1839    #[serde(rename = "currentHash")]
1840    pub current_hash: String,
1841    #[serde(rename = "displayOrder")]
1842    pub display_order: i64,
1843    #[serde()]
1844    pub enabled: bool,
1845    #[serde(rename = "eventName")]
1846    pub event_name: HookEventName,
1847    #[serde(rename = "handlerType")]
1848    pub handler_type: HookHandlerType,
1849    #[serde(rename = "isManaged")]
1850    pub is_managed: bool,
1851    #[serde()]
1852    pub key: String,
1853    #[serde(default, skip_serializing_if = "Option::is_none")]
1854    pub matcher: Option<String>,
1855    #[serde(rename = "pluginId", default, skip_serializing_if = "Option::is_none")]
1856    pub plugin_id: Option<String>,
1857    #[serde()]
1858    pub source: HookSource,
1859    #[serde(rename = "sourcePath")]
1860    pub source_path: AbsolutePathBuf,
1861    #[serde(
1862        rename = "statusMessage",
1863        default,
1864        skip_serializing_if = "Option::is_none"
1865    )]
1866    pub status_message: Option<String>,
1867    #[serde(rename = "timeoutSec")]
1868    pub timeout_sec: i64,
1869    #[serde(rename = "trustStatus")]
1870    pub trust_status: HookTrustStatus,
1871}
1872
1873#[derive(Debug, Clone, Serialize, Deserialize)]
1874#[serde(rename_all = "camelCase")]
1875pub struct HookMigration {
1876    #[serde()]
1877    pub name: String,
1878}
1879
1880#[derive(Debug, Clone, Serialize, Deserialize)]
1881#[serde(rename_all = "camelCase")]
1882pub struct HookOutputEntry {
1883    #[serde()]
1884    pub kind: HookOutputEntryKind,
1885    #[serde()]
1886    pub text: String,
1887}
1888
1889#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1890pub enum HookOutputEntryKind {
1891    #[serde(rename = "warning")]
1892    Warning,
1893    #[serde(rename = "stop")]
1894    Stop,
1895    #[serde(rename = "feedback")]
1896    Feedback,
1897    #[serde(rename = "context")]
1898    Context,
1899    #[serde(rename = "error")]
1900    Error,
1901}
1902
1903#[derive(Debug, Clone, Serialize, Deserialize)]
1904#[serde(rename_all = "camelCase")]
1905pub struct HookPromptFragment {
1906    #[serde(rename = "hookRunId")]
1907    pub hook_run_id: String,
1908    #[serde()]
1909    pub text: String,
1910}
1911
1912#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1913pub enum HookRunStatus {
1914    #[serde(rename = "running")]
1915    Running,
1916    #[serde(rename = "completed")]
1917    Completed,
1918    #[serde(rename = "failed")]
1919    Failed,
1920    #[serde(rename = "blocked")]
1921    Blocked,
1922    #[serde(rename = "stopped")]
1923    Stopped,
1924}
1925
1926#[derive(Debug, Clone, Serialize, Deserialize)]
1927#[serde(rename_all = "camelCase")]
1928pub struct HookRunSummary {
1929    #[serde(
1930        rename = "completedAt",
1931        default,
1932        skip_serializing_if = "Option::is_none"
1933    )]
1934    pub completed_at: Option<i64>,
1935    #[serde(rename = "displayOrder")]
1936    pub display_order: i64,
1937    #[serde(
1938        rename = "durationMs",
1939        default,
1940        skip_serializing_if = "Option::is_none"
1941    )]
1942    pub duration_ms: Option<i64>,
1943    #[serde()]
1944    pub entries: Vec<HookOutputEntry>,
1945    #[serde(rename = "eventName")]
1946    pub event_name: HookEventName,
1947    #[serde(rename = "executionMode")]
1948    pub execution_mode: HookExecutionMode,
1949    #[serde(rename = "handlerType")]
1950    pub handler_type: HookHandlerType,
1951    #[serde()]
1952    pub id: String,
1953    #[serde()]
1954    pub scope: HookScope,
1955    #[serde(default, skip_serializing_if = "Option::is_none")]
1956    pub source: Option<Value>,
1957    #[serde(rename = "sourcePath")]
1958    pub source_path: AbsolutePathBuf,
1959    #[serde(rename = "startedAt")]
1960    pub started_at: i64,
1961    #[serde()]
1962    pub status: HookRunStatus,
1963    #[serde(
1964        rename = "statusMessage",
1965        default,
1966        skip_serializing_if = "Option::is_none"
1967    )]
1968    pub status_message: Option<String>,
1969}
1970
1971#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1972pub enum HookScope {
1973    #[serde(rename = "thread")]
1974    Thread,
1975    #[serde(rename = "turn")]
1976    Turn,
1977}
1978
1979#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1980pub enum HookSource {
1981    #[serde(rename = "system")]
1982    System,
1983    #[serde(rename = "user")]
1984    User,
1985    #[serde(rename = "project")]
1986    Project,
1987    #[serde(rename = "mdm")]
1988    Mdm,
1989    #[serde(rename = "sessionFlags")]
1990    SessionFlags,
1991    #[serde(rename = "plugin")]
1992    Plugin,
1993    #[serde(rename = "cloudRequirements")]
1994    CloudRequirements,
1995    #[serde(rename = "legacyManagedConfigFile")]
1996    LegacyManagedConfigFile,
1997    #[serde(rename = "legacyManagedConfigMdm")]
1998    LegacyManagedConfigMdm,
1999    #[serde(rename = "unknown")]
2000    Unknown,
2001}
2002
2003#[derive(Debug, Clone, Serialize, Deserialize)]
2004#[serde(rename_all = "camelCase")]
2005pub struct HookStartedNotification {
2006    #[serde()]
2007    pub run: HookRunSummary,
2008    #[serde(rename = "threadId")]
2009    pub thread_id: String,
2010    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
2011    pub turn_id: Option<String>,
2012}
2013
2014#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2015pub enum HookTrustStatus {
2016    #[serde(rename = "managed")]
2017    Managed,
2018    #[serde(rename = "untrusted")]
2019    Untrusted,
2020    #[serde(rename = "trusted")]
2021    Trusted,
2022    #[serde(rename = "modified")]
2023    Modified,
2024}
2025
2026#[derive(Debug, Clone, Serialize, Deserialize)]
2027#[serde(rename_all = "camelCase")]
2028pub struct HooksListEntry {
2029    #[serde()]
2030    pub cwd: String,
2031    #[serde()]
2032    pub errors: Vec<HookErrorInfo>,
2033    #[serde()]
2034    pub hooks: Vec<HookMetadata>,
2035    #[serde()]
2036    pub warnings: Vec<String>,
2037}
2038
2039#[derive(Debug, Clone, Serialize, Deserialize)]
2040#[serde(rename_all = "camelCase")]
2041pub struct HooksListParams {
2042    #[serde(default, skip_serializing_if = "Option::is_none")]
2043    pub cwds: Option<Vec<String>>,
2044}
2045
2046#[derive(Debug, Clone, Serialize, Deserialize)]
2047#[serde(rename_all = "camelCase")]
2048pub struct HooksListResponse {
2049    #[serde()]
2050    pub data: Vec<HooksListEntry>,
2051}
2052
2053#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2054#[serde(transparent)]
2055pub struct InputModality(pub Value);
2056
2057#[derive(Debug, Clone, Serialize, Deserialize)]
2058#[serde(rename_all = "camelCase")]
2059pub struct ItemGuardianApprovalReviewCompletedNotification {
2060    #[serde()]
2061    pub action: GuardianApprovalReviewAction,
2062    #[serde(rename = "completedAtMs")]
2063    pub completed_at_ms: i64,
2064    #[serde(rename = "decisionSource")]
2065    pub decision_source: AutoReviewDecisionSource,
2066    #[serde()]
2067    pub review: GuardianApprovalReview,
2068    #[serde(rename = "reviewId")]
2069    pub review_id: String,
2070    #[serde(rename = "startedAtMs")]
2071    pub started_at_ms: i64,
2072    #[serde(
2073        rename = "targetItemId",
2074        default,
2075        skip_serializing_if = "Option::is_none"
2076    )]
2077    pub target_item_id: Option<String>,
2078    #[serde(rename = "threadId")]
2079    pub thread_id: String,
2080    #[serde(rename = "turnId")]
2081    pub turn_id: String,
2082}
2083
2084#[derive(Debug, Clone, Serialize, Deserialize)]
2085#[serde(rename_all = "camelCase")]
2086pub struct ItemGuardianApprovalReviewStartedNotification {
2087    #[serde()]
2088    pub action: GuardianApprovalReviewAction,
2089    #[serde()]
2090    pub review: GuardianApprovalReview,
2091    #[serde(rename = "reviewId")]
2092    pub review_id: String,
2093    #[serde(rename = "startedAtMs")]
2094    pub started_at_ms: i64,
2095    #[serde(
2096        rename = "targetItemId",
2097        default,
2098        skip_serializing_if = "Option::is_none"
2099    )]
2100    pub target_item_id: Option<String>,
2101    #[serde(rename = "threadId")]
2102    pub thread_id: String,
2103    #[serde(rename = "turnId")]
2104    pub turn_id: String,
2105}
2106
2107#[derive(Debug, Clone, Serialize, Deserialize)]
2108#[serde(rename_all = "camelCase")]
2109pub struct ListMcpServerStatusParams {
2110    #[serde(default, skip_serializing_if = "Option::is_none")]
2111    pub cursor: Option<String>,
2112    #[serde(default, skip_serializing_if = "Option::is_none")]
2113    pub detail: Option<McpServerStatusDetail>,
2114    #[serde(default, skip_serializing_if = "Option::is_none")]
2115    pub limit: Option<i64>,
2116}
2117
2118#[derive(Debug, Clone, Serialize, Deserialize)]
2119#[serde(rename_all = "camelCase")]
2120pub struct ListMcpServerStatusResponse {
2121    #[serde()]
2122    pub data: Vec<McpServerStatus>,
2123    #[serde(
2124        rename = "nextCursor",
2125        default,
2126        skip_serializing_if = "Option::is_none"
2127    )]
2128    pub next_cursor: Option<String>,
2129}
2130
2131#[derive(Debug, Clone, Serialize, Deserialize)]
2132#[serde(tag = "type", rename_all = "camelCase")]
2133pub enum LoginAccountParams {
2134    #[serde(rename = "apiKey")]
2135    ApiKey {
2136        #[serde(rename = "apiKey")]
2137        api_key: String,
2138    },
2139    Chatgpt {
2140        #[serde(
2141            rename = "codexStreamlinedLogin",
2142            default,
2143            skip_serializing_if = "Option::is_none"
2144        )]
2145        codex_streamlined_login: Option<bool>,
2146    },
2147    #[serde(rename = "chatgptDeviceCode")]
2148    ChatgptDeviceCode,
2149    #[serde(rename = "chatgptAuthTokens")]
2150    ChatgptAuthTokens {
2151        #[serde(rename = "accessToken")]
2152        access_token: String,
2153        #[serde(rename = "chatgptAccountId")]
2154        chatgpt_account_id: String,
2155        #[serde(
2156            rename = "chatgptPlanType",
2157            default,
2158            skip_serializing_if = "Option::is_none"
2159        )]
2160        chatgpt_plan_type: Option<String>,
2161    },
2162}
2163
2164#[derive(Debug, Clone, Serialize, Deserialize)]
2165#[serde(tag = "type", rename_all = "camelCase")]
2166pub enum LoginAccountResponse {
2167    #[serde(rename = "apiKey")]
2168    ApiKey,
2169    Chatgpt {
2170        #[serde(rename = "authUrl")]
2171        auth_url: String,
2172        #[serde(rename = "loginId")]
2173        login_id: String,
2174    },
2175    #[serde(rename = "chatgptDeviceCode")]
2176    ChatgptDeviceCode {
2177        #[serde(rename = "loginId")]
2178        login_id: String,
2179        #[serde(rename = "userCode")]
2180        user_code: String,
2181        #[serde(rename = "verificationUrl")]
2182        verification_url: String,
2183    },
2184    #[serde(rename = "chatgptAuthTokens")]
2185    ChatgptAuthTokens,
2186}
2187
2188#[derive(Debug, Clone, Serialize, Deserialize)]
2189#[serde(rename_all = "camelCase")]
2190pub struct LogoutAccountResponse {
2191    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2192    pub extra: serde_json::Map<String, Value>,
2193}
2194
2195#[derive(Debug, Clone, Serialize, Deserialize)]
2196#[serde(rename_all = "camelCase")]
2197pub struct MarketplaceAddParams {
2198    #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
2199    pub ref_name: Option<String>,
2200    #[serde()]
2201    pub source: String,
2202    #[serde(
2203        rename = "sparsePaths",
2204        default,
2205        skip_serializing_if = "Option::is_none"
2206    )]
2207    pub sparse_paths: Option<Vec<String>>,
2208}
2209
2210#[derive(Debug, Clone, Serialize, Deserialize)]
2211#[serde(rename_all = "camelCase")]
2212pub struct MarketplaceAddResponse {
2213    #[serde(rename = "alreadyAdded")]
2214    pub already_added: bool,
2215    #[serde(rename = "installedRoot")]
2216    pub installed_root: AbsolutePathBuf,
2217    #[serde(rename = "marketplaceName")]
2218    pub marketplace_name: String,
2219}
2220
2221#[derive(Debug, Clone, Serialize, Deserialize)]
2222#[serde(rename_all = "camelCase")]
2223pub struct MarketplaceInterface {
2224    #[serde(
2225        rename = "displayName",
2226        default,
2227        skip_serializing_if = "Option::is_none"
2228    )]
2229    pub display_name: Option<String>,
2230}
2231
2232#[derive(Debug, Clone, Serialize, Deserialize)]
2233#[serde(rename_all = "camelCase")]
2234pub struct MarketplaceLoadErrorInfo {
2235    #[serde(rename = "marketplacePath")]
2236    pub marketplace_path: AbsolutePathBuf,
2237    #[serde()]
2238    pub message: String,
2239}
2240
2241#[derive(Debug, Clone, Serialize, Deserialize)]
2242#[serde(rename_all = "camelCase")]
2243pub struct MarketplaceRemoveParams {
2244    #[serde(rename = "marketplaceName")]
2245    pub marketplace_name: String,
2246}
2247
2248#[derive(Debug, Clone, Serialize, Deserialize)]
2249#[serde(rename_all = "camelCase")]
2250pub struct MarketplaceRemoveResponse {
2251    #[serde(
2252        rename = "installedRoot",
2253        default,
2254        skip_serializing_if = "Option::is_none"
2255    )]
2256    pub installed_root: Option<AbsolutePathBuf>,
2257    #[serde(rename = "marketplaceName")]
2258    pub marketplace_name: String,
2259}
2260
2261#[derive(Debug, Clone, Serialize, Deserialize)]
2262#[serde(rename_all = "camelCase")]
2263pub struct MarketplaceUpgradeErrorInfo {
2264    #[serde(rename = "marketplaceName")]
2265    pub marketplace_name: String,
2266    #[serde()]
2267    pub message: String,
2268}
2269
2270#[derive(Debug, Clone, Serialize, Deserialize)]
2271#[serde(rename_all = "camelCase")]
2272pub struct MarketplaceUpgradeParams {
2273    #[serde(
2274        rename = "marketplaceName",
2275        default,
2276        skip_serializing_if = "Option::is_none"
2277    )]
2278    pub marketplace_name: Option<String>,
2279}
2280
2281#[derive(Debug, Clone, Serialize, Deserialize)]
2282#[serde(rename_all = "camelCase")]
2283pub struct MarketplaceUpgradeResponse {
2284    #[serde()]
2285    pub errors: Vec<MarketplaceUpgradeErrorInfo>,
2286    #[serde(rename = "selectedMarketplaces")]
2287    pub selected_marketplaces: Vec<String>,
2288    #[serde(rename = "upgradedRoots")]
2289    pub upgraded_roots: Vec<AbsolutePathBuf>,
2290}
2291
2292#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2293pub enum McpAuthStatus {
2294    #[serde(rename = "unsupported")]
2295    Unsupported,
2296    #[serde(rename = "notLoggedIn")]
2297    NotLoggedIn,
2298    #[serde(rename = "bearerToken")]
2299    BearerToken,
2300    #[serde(rename = "oAuth")]
2301    OAuth,
2302}
2303
2304#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2305pub enum McpElicitationArrayType {
2306    #[serde(rename = "array")]
2307    Array,
2308}
2309
2310#[derive(Debug, Clone, Serialize, Deserialize)]
2311#[serde(rename_all = "camelCase")]
2312pub struct McpElicitationBooleanSchema {
2313    #[serde(default, skip_serializing_if = "Option::is_none")]
2314    pub default: Option<bool>,
2315    #[serde(default, skip_serializing_if = "Option::is_none")]
2316    pub description: Option<String>,
2317    #[serde(default, skip_serializing_if = "Option::is_none")]
2318    pub title: Option<String>,
2319    #[serde(rename = "type")]
2320    pub type_: McpElicitationBooleanType,
2321}
2322
2323#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2324pub enum McpElicitationBooleanType {
2325    #[serde(rename = "boolean")]
2326    Boolean,
2327}
2328
2329#[derive(Debug, Clone, Serialize, Deserialize)]
2330#[serde(rename_all = "camelCase")]
2331pub struct McpElicitationConstOption {
2332    #[serde(rename = "const")]
2333    pub const_: String,
2334    #[serde()]
2335    pub title: String,
2336}
2337
2338#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2339#[serde(transparent)]
2340pub struct McpElicitationEnumSchema(pub Value);
2341
2342#[derive(Debug, Clone, Serialize, Deserialize)]
2343#[serde(rename_all = "camelCase")]
2344pub struct McpElicitationLegacyTitledEnumSchema {
2345    #[serde(default, skip_serializing_if = "Option::is_none")]
2346    pub default: Option<String>,
2347    #[serde(default, skip_serializing_if = "Option::is_none")]
2348    pub description: Option<String>,
2349    #[serde(rename = "enum")]
2350    pub enum_: Vec<String>,
2351    #[serde(rename = "enumNames", default, skip_serializing_if = "Option::is_none")]
2352    pub enum_names: Option<Vec<String>>,
2353    #[serde(default, skip_serializing_if = "Option::is_none")]
2354    pub title: Option<String>,
2355    #[serde(rename = "type")]
2356    pub type_: McpElicitationStringType,
2357}
2358
2359#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2360#[serde(transparent)]
2361pub struct McpElicitationMultiSelectEnumSchema(pub Value);
2362
2363#[derive(Debug, Clone, Serialize, Deserialize)]
2364#[serde(rename_all = "camelCase")]
2365pub struct McpElicitationNumberSchema {
2366    #[serde(default, skip_serializing_if = "Option::is_none")]
2367    pub default: Option<f64>,
2368    #[serde(default, skip_serializing_if = "Option::is_none")]
2369    pub description: Option<String>,
2370    #[serde(default, skip_serializing_if = "Option::is_none")]
2371    pub maximum: Option<f64>,
2372    #[serde(default, skip_serializing_if = "Option::is_none")]
2373    pub minimum: Option<f64>,
2374    #[serde(default, skip_serializing_if = "Option::is_none")]
2375    pub title: Option<String>,
2376    #[serde(rename = "type")]
2377    pub type_: McpElicitationNumberType,
2378}
2379
2380#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2381pub enum McpElicitationNumberType {
2382    #[serde(rename = "number")]
2383    Number,
2384    #[serde(rename = "integer")]
2385    Integer,
2386}
2387
2388#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2389pub enum McpElicitationObjectType {
2390    #[serde(rename = "object")]
2391    Object,
2392}
2393
2394#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2395#[serde(transparent)]
2396pub struct McpElicitationPrimitiveSchema(pub Value);
2397
2398#[derive(Debug, Clone, Serialize, Deserialize)]
2399#[serde(rename_all = "camelCase")]
2400pub struct McpElicitationSchema {
2401    #[serde(rename = "$schema", default, skip_serializing_if = "Option::is_none")]
2402    pub schema: Option<String>,
2403    #[serde()]
2404    pub properties: std::collections::BTreeMap<String, McpElicitationPrimitiveSchema>,
2405    #[serde(default, skip_serializing_if = "Option::is_none")]
2406    pub required: Option<Vec<String>>,
2407    #[serde(rename = "type")]
2408    pub type_: McpElicitationObjectType,
2409}
2410
2411#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2412#[serde(transparent)]
2413pub struct McpElicitationSingleSelectEnumSchema(pub Value);
2414
2415#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2416pub enum McpElicitationStringFormat {
2417    #[serde(rename = "email")]
2418    Email,
2419    #[serde(rename = "uri")]
2420    Uri,
2421    #[serde(rename = "date")]
2422    Date,
2423    #[serde(rename = "date-time")]
2424    Date_time,
2425}
2426
2427#[derive(Debug, Clone, Serialize, Deserialize)]
2428#[serde(rename_all = "camelCase")]
2429pub struct McpElicitationStringSchema {
2430    #[serde(default, skip_serializing_if = "Option::is_none")]
2431    pub default: Option<String>,
2432    #[serde(default, skip_serializing_if = "Option::is_none")]
2433    pub description: Option<String>,
2434    #[serde(default, skip_serializing_if = "Option::is_none")]
2435    pub format: Option<McpElicitationStringFormat>,
2436    #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
2437    pub max_length: Option<i64>,
2438    #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
2439    pub min_length: Option<i64>,
2440    #[serde(default, skip_serializing_if = "Option::is_none")]
2441    pub title: Option<String>,
2442    #[serde(rename = "type")]
2443    pub type_: McpElicitationStringType,
2444}
2445
2446#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2447pub enum McpElicitationStringType {
2448    #[serde(rename = "string")]
2449    String,
2450}
2451
2452#[derive(Debug, Clone, Serialize, Deserialize)]
2453#[serde(rename_all = "camelCase")]
2454pub struct McpElicitationTitledEnumItems {
2455    #[serde(rename = "anyOf")]
2456    pub any_of: Vec<McpElicitationConstOption>,
2457}
2458
2459#[derive(Debug, Clone, Serialize, Deserialize)]
2460#[serde(rename_all = "camelCase")]
2461pub struct McpElicitationTitledMultiSelectEnumSchema {
2462    #[serde(default, skip_serializing_if = "Option::is_none")]
2463    pub default: Option<Vec<String>>,
2464    #[serde(default, skip_serializing_if = "Option::is_none")]
2465    pub description: Option<String>,
2466    #[serde()]
2467    pub items: McpElicitationTitledEnumItems,
2468    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
2469    pub max_items: Option<i64>,
2470    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
2471    pub min_items: Option<i64>,
2472    #[serde(default, skip_serializing_if = "Option::is_none")]
2473    pub title: Option<String>,
2474    #[serde(rename = "type")]
2475    pub type_: McpElicitationArrayType,
2476}
2477
2478#[derive(Debug, Clone, Serialize, Deserialize)]
2479#[serde(rename_all = "camelCase")]
2480pub struct McpElicitationTitledSingleSelectEnumSchema {
2481    #[serde(default, skip_serializing_if = "Option::is_none")]
2482    pub default: Option<String>,
2483    #[serde(default, skip_serializing_if = "Option::is_none")]
2484    pub description: Option<String>,
2485    #[serde(rename = "oneOf")]
2486    pub one_of: Vec<McpElicitationConstOption>,
2487    #[serde(default, skip_serializing_if = "Option::is_none")]
2488    pub title: Option<String>,
2489    #[serde(rename = "type")]
2490    pub type_: McpElicitationStringType,
2491}
2492
2493#[derive(Debug, Clone, Serialize, Deserialize)]
2494#[serde(rename_all = "camelCase")]
2495pub struct McpElicitationUntitledEnumItems {
2496    #[serde(rename = "enum")]
2497    pub enum_: Vec<String>,
2498    #[serde(rename = "type")]
2499    pub type_: McpElicitationStringType,
2500}
2501
2502#[derive(Debug, Clone, Serialize, Deserialize)]
2503#[serde(rename_all = "camelCase")]
2504pub struct McpElicitationUntitledMultiSelectEnumSchema {
2505    #[serde(default, skip_serializing_if = "Option::is_none")]
2506    pub default: Option<Vec<String>>,
2507    #[serde(default, skip_serializing_if = "Option::is_none")]
2508    pub description: Option<String>,
2509    #[serde()]
2510    pub items: McpElicitationUntitledEnumItems,
2511    #[serde(rename = "maxItems", default, skip_serializing_if = "Option::is_none")]
2512    pub max_items: Option<i64>,
2513    #[serde(rename = "minItems", default, skip_serializing_if = "Option::is_none")]
2514    pub min_items: Option<i64>,
2515    #[serde(default, skip_serializing_if = "Option::is_none")]
2516    pub title: Option<String>,
2517    #[serde(rename = "type")]
2518    pub type_: McpElicitationArrayType,
2519}
2520
2521#[derive(Debug, Clone, Serialize, Deserialize)]
2522#[serde(rename_all = "camelCase")]
2523pub struct McpElicitationUntitledSingleSelectEnumSchema {
2524    #[serde(default, skip_serializing_if = "Option::is_none")]
2525    pub default: Option<String>,
2526    #[serde(default, skip_serializing_if = "Option::is_none")]
2527    pub description: Option<String>,
2528    #[serde(rename = "enum")]
2529    pub enum_: Vec<String>,
2530    #[serde(default, skip_serializing_if = "Option::is_none")]
2531    pub title: Option<String>,
2532    #[serde(rename = "type")]
2533    pub type_: McpElicitationStringType,
2534}
2535
2536#[derive(Debug, Clone, Serialize, Deserialize)]
2537#[serde(rename_all = "camelCase")]
2538pub struct McpResourceReadParams {
2539    #[serde()]
2540    pub server: String,
2541    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
2542    pub thread_id: Option<String>,
2543    #[serde()]
2544    pub uri: String,
2545}
2546
2547#[derive(Debug, Clone, Serialize, Deserialize)]
2548#[serde(rename_all = "camelCase")]
2549pub struct McpResourceReadResponse {
2550    #[serde()]
2551    pub contents: Vec<ResourceContent>,
2552}
2553
2554#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2555pub enum McpServerElicitationAction {
2556    #[serde(rename = "accept")]
2557    Accept,
2558    #[serde(rename = "decline")]
2559    Decline,
2560    #[serde(rename = "cancel")]
2561    Cancel,
2562}
2563
2564#[derive(Debug, Clone, Serialize, Deserialize)]
2565#[serde(rename_all = "camelCase")]
2566pub struct McpServerElicitationRequestParams {
2567    #[serde(rename = "serverName")]
2568    pub server_name: String,
2569    #[serde(rename = "threadId")]
2570    pub thread_id: String,
2571    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
2572    pub turn_id: Option<String>,
2573}
2574
2575#[derive(Debug, Clone, Serialize, Deserialize)]
2576#[serde(rename_all = "camelCase")]
2577pub struct McpServerElicitationRequestResponse {
2578    #[serde(default, skip_serializing_if = "Option::is_none")]
2579    pub _meta: Option<Value>,
2580    #[serde()]
2581    pub action: McpServerElicitationAction,
2582    #[serde(default, skip_serializing_if = "Option::is_none")]
2583    pub content: Option<Value>,
2584}
2585
2586#[derive(Debug, Clone, Serialize, Deserialize)]
2587#[serde(rename_all = "camelCase")]
2588pub struct McpServerMigration {
2589    #[serde()]
2590    pub name: String,
2591}
2592
2593#[derive(Debug, Clone, Serialize, Deserialize)]
2594#[serde(rename_all = "camelCase")]
2595pub struct McpServerOauthLoginParams {
2596    #[serde()]
2597    pub name: String,
2598    #[serde(default, skip_serializing_if = "Option::is_none")]
2599    pub scopes: Option<Vec<String>>,
2600    #[serde(
2601        rename = "timeoutSecs",
2602        default,
2603        skip_serializing_if = "Option::is_none"
2604    )]
2605    pub timeout_secs: Option<i64>,
2606}
2607
2608#[derive(Debug, Clone, Serialize, Deserialize)]
2609#[serde(rename_all = "camelCase")]
2610pub struct McpServerOauthLoginResponse {
2611    #[serde(rename = "authorizationUrl")]
2612    pub authorization_url: String,
2613}
2614
2615#[derive(Debug, Clone, Serialize, Deserialize)]
2616#[serde(rename_all = "camelCase")]
2617pub struct McpServerRefreshResponse {
2618    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2619    pub extra: serde_json::Map<String, Value>,
2620}
2621
2622#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2623pub enum McpServerStartupState {
2624    #[serde(rename = "starting")]
2625    Starting,
2626    #[serde(rename = "ready")]
2627    Ready,
2628    #[serde(rename = "failed")]
2629    Failed,
2630    #[serde(rename = "cancelled")]
2631    Cancelled,
2632}
2633
2634#[derive(Debug, Clone, Serialize, Deserialize)]
2635#[serde(rename_all = "camelCase")]
2636pub struct McpServerStatus {
2637    #[serde(rename = "authStatus")]
2638    pub auth_status: McpAuthStatus,
2639    #[serde()]
2640    pub name: String,
2641    #[serde(rename = "resourceTemplates")]
2642    pub resource_templates: Vec<ResourceTemplate>,
2643    #[serde()]
2644    pub resources: Vec<Resource>,
2645    #[serde()]
2646    pub tools: std::collections::BTreeMap<String, Tool>,
2647}
2648
2649#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2650pub enum McpServerStatusDetail {
2651    #[serde(rename = "full")]
2652    Full,
2653    #[serde(rename = "toolsAndAuthOnly")]
2654    ToolsAndAuthOnly,
2655}
2656
2657#[derive(Debug, Clone, Serialize, Deserialize)]
2658#[serde(rename_all = "camelCase")]
2659pub struct McpServerStatusUpdatedNotification {
2660    #[serde(default, skip_serializing_if = "Option::is_none")]
2661    pub error: Option<String>,
2662    #[serde()]
2663    pub name: String,
2664    #[serde()]
2665    pub status: McpServerStartupState,
2666}
2667
2668#[derive(Debug, Clone, Serialize, Deserialize)]
2669#[serde(rename_all = "camelCase")]
2670pub struct McpServerToolCallParams {
2671    #[serde(default, skip_serializing_if = "Option::is_none")]
2672    pub _meta: Option<Value>,
2673    #[serde(default, skip_serializing_if = "Option::is_none")]
2674    pub arguments: Option<Value>,
2675    #[serde()]
2676    pub server: String,
2677    #[serde(rename = "threadId")]
2678    pub thread_id: String,
2679    #[serde()]
2680    pub tool: String,
2681}
2682
2683#[derive(Debug, Clone, Serialize, Deserialize)]
2684#[serde(rename_all = "camelCase")]
2685pub struct McpServerToolCallResponse {
2686    #[serde(default, skip_serializing_if = "Option::is_none")]
2687    pub _meta: Option<Value>,
2688    #[serde()]
2689    pub content: Vec<Value>,
2690    #[serde(rename = "isError", default, skip_serializing_if = "Option::is_none")]
2691    pub is_error: Option<bool>,
2692    #[serde(
2693        rename = "structuredContent",
2694        default,
2695        skip_serializing_if = "Option::is_none"
2696    )]
2697    pub structured_content: Option<Value>,
2698}
2699
2700#[derive(Debug, Clone, Serialize, Deserialize)]
2701#[serde(rename_all = "camelCase")]
2702pub struct McpToolCallProgressNotification {
2703    #[serde(rename = "itemId")]
2704    pub item_id: String,
2705    #[serde()]
2706    pub message: String,
2707    #[serde(rename = "threadId")]
2708    pub thread_id: String,
2709    #[serde(rename = "turnId")]
2710    pub turn_id: String,
2711}
2712
2713#[derive(Debug, Clone, Serialize, Deserialize)]
2714#[serde(rename_all = "camelCase")]
2715pub struct MemoryCitation {
2716    #[serde()]
2717    pub entries: Vec<MemoryCitationEntry>,
2718    #[serde(rename = "threadIds")]
2719    pub thread_ids: Vec<String>,
2720}
2721
2722#[derive(Debug, Clone, Serialize, Deserialize)]
2723#[serde(rename_all = "camelCase")]
2724pub struct MemoryCitationEntry {
2725    #[serde(rename = "lineEnd")]
2726    pub line_end: i64,
2727    #[serde(rename = "lineStart")]
2728    pub line_start: i64,
2729    #[serde()]
2730    pub note: String,
2731    #[serde()]
2732    pub path: String,
2733}
2734
2735#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2736pub enum MergeStrategy {
2737    #[serde(rename = "replace")]
2738    Replace,
2739    #[serde(rename = "upsert")]
2740    Upsert,
2741}
2742
2743#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2744#[serde(transparent)]
2745pub struct MessagePhase(pub Value);
2746
2747#[derive(Debug, Clone, Serialize, Deserialize)]
2748#[serde(rename_all = "camelCase")]
2749pub struct MigrationDetails {
2750    #[serde(default, skip_serializing_if = "Option::is_none")]
2751    pub commands: Option<Vec<CommandMigration>>,
2752    #[serde(default, skip_serializing_if = "Option::is_none")]
2753    pub hooks: Option<Vec<HookMigration>>,
2754    #[serde(
2755        rename = "mcpServers",
2756        default,
2757        skip_serializing_if = "Option::is_none"
2758    )]
2759    pub mcp_servers: Option<Vec<McpServerMigration>>,
2760    #[serde(default, skip_serializing_if = "Option::is_none")]
2761    pub plugins: Option<Vec<PluginsMigration>>,
2762    #[serde(default, skip_serializing_if = "Option::is_none")]
2763    pub sessions: Option<Vec<SessionMigration>>,
2764    #[serde(default, skip_serializing_if = "Option::is_none")]
2765    pub subagents: Option<Vec<SubagentMigration>>,
2766}
2767
2768#[derive(Debug, Clone, Serialize, Deserialize)]
2769#[serde(rename_all = "camelCase")]
2770pub struct Model {
2771    #[serde(
2772        rename = "additionalSpeedTiers",
2773        default,
2774        skip_serializing_if = "Option::is_none"
2775    )]
2776    pub additional_speed_tiers: Option<Vec<String>>,
2777    #[serde(
2778        rename = "availabilityNux",
2779        default,
2780        skip_serializing_if = "Option::is_none"
2781    )]
2782    pub availability_nux: Option<ModelAvailabilityNux>,
2783    #[serde(rename = "defaultReasoningEffort")]
2784    pub default_reasoning_effort: ReasoningEffort,
2785    #[serde()]
2786    pub description: String,
2787    #[serde(rename = "displayName")]
2788    pub display_name: String,
2789    #[serde()]
2790    pub hidden: bool,
2791    #[serde()]
2792    pub id: String,
2793    #[serde(
2794        rename = "inputModalities",
2795        default,
2796        skip_serializing_if = "Option::is_none"
2797    )]
2798    pub input_modalities: Option<Vec<InputModality>>,
2799    #[serde(rename = "isDefault")]
2800    pub is_default: bool,
2801    #[serde()]
2802    pub model: String,
2803    #[serde(
2804        rename = "serviceTiers",
2805        default,
2806        skip_serializing_if = "Option::is_none"
2807    )]
2808    pub service_tiers: Option<Vec<ModelServiceTier>>,
2809    #[serde(rename = "supportedReasoningEfforts")]
2810    pub supported_reasoning_efforts: Vec<ReasoningEffortOption>,
2811    #[serde(
2812        rename = "supportsPersonality",
2813        default,
2814        skip_serializing_if = "Option::is_none"
2815    )]
2816    pub supports_personality: Option<bool>,
2817    #[serde(default, skip_serializing_if = "Option::is_none")]
2818    pub upgrade: Option<String>,
2819    #[serde(
2820        rename = "upgradeInfo",
2821        default,
2822        skip_serializing_if = "Option::is_none"
2823    )]
2824    pub upgrade_info: Option<ModelUpgradeInfo>,
2825}
2826
2827#[derive(Debug, Clone, Serialize, Deserialize)]
2828#[serde(rename_all = "camelCase")]
2829pub struct ModelAvailabilityNux {
2830    #[serde()]
2831    pub message: String,
2832}
2833
2834#[derive(Debug, Clone, Serialize, Deserialize)]
2835#[serde(rename_all = "camelCase")]
2836pub struct ModelListParams {
2837    #[serde(default, skip_serializing_if = "Option::is_none")]
2838    pub cursor: Option<String>,
2839    #[serde(
2840        rename = "includeHidden",
2841        default,
2842        skip_serializing_if = "Option::is_none"
2843    )]
2844    pub include_hidden: Option<bool>,
2845    #[serde(default, skip_serializing_if = "Option::is_none")]
2846    pub limit: Option<i64>,
2847}
2848
2849#[derive(Debug, Clone, Serialize, Deserialize)]
2850#[serde(rename_all = "camelCase")]
2851pub struct ModelListResponse {
2852    #[serde()]
2853    pub data: Vec<Model>,
2854    #[serde(
2855        rename = "nextCursor",
2856        default,
2857        skip_serializing_if = "Option::is_none"
2858    )]
2859    pub next_cursor: Option<String>,
2860}
2861
2862#[derive(Debug, Clone, Serialize, Deserialize)]
2863#[serde(rename_all = "camelCase")]
2864pub struct ModelProviderCapabilitiesReadParams {
2865    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
2866    pub extra: serde_json::Map<String, Value>,
2867}
2868
2869#[derive(Debug, Clone, Serialize, Deserialize)]
2870#[serde(rename_all = "camelCase")]
2871pub struct ModelProviderCapabilitiesReadResponse {
2872    #[serde(rename = "imageGeneration")]
2873    pub image_generation: bool,
2874    #[serde(rename = "namespaceTools")]
2875    pub namespace_tools: bool,
2876    #[serde(rename = "webSearch")]
2877    pub web_search: bool,
2878}
2879
2880#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2881pub enum ModelRerouteReason {
2882    #[serde(rename = "highRiskCyberActivity")]
2883    HighRiskCyberActivity,
2884}
2885
2886#[derive(Debug, Clone, Serialize, Deserialize)]
2887#[serde(rename_all = "camelCase")]
2888pub struct ModelReroutedNotification {
2889    #[serde(rename = "fromModel")]
2890    pub from_model: String,
2891    #[serde()]
2892    pub reason: ModelRerouteReason,
2893    #[serde(rename = "threadId")]
2894    pub thread_id: String,
2895    #[serde(rename = "toModel")]
2896    pub to_model: String,
2897    #[serde(rename = "turnId")]
2898    pub turn_id: String,
2899}
2900
2901#[derive(Debug, Clone, Serialize, Deserialize)]
2902#[serde(rename_all = "camelCase")]
2903pub struct ModelServiceTier {
2904    #[serde()]
2905    pub description: String,
2906    #[serde()]
2907    pub id: String,
2908    #[serde()]
2909    pub name: String,
2910}
2911
2912#[derive(Debug, Clone, Serialize, Deserialize)]
2913#[serde(rename_all = "camelCase")]
2914pub struct ModelUpgradeInfo {
2915    #[serde(
2916        rename = "migrationMarkdown",
2917        default,
2918        skip_serializing_if = "Option::is_none"
2919    )]
2920    pub migration_markdown: Option<String>,
2921    #[serde()]
2922    pub model: String,
2923    #[serde(rename = "modelLink", default, skip_serializing_if = "Option::is_none")]
2924    pub model_link: Option<String>,
2925    #[serde(
2926        rename = "upgradeCopy",
2927        default,
2928        skip_serializing_if = "Option::is_none"
2929    )]
2930    pub upgrade_copy: Option<String>,
2931}
2932
2933#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2934pub enum ModelVerification {
2935    #[serde(rename = "trustedAccessForCyber")]
2936    TrustedAccessForCyber,
2937}
2938
2939#[derive(Debug, Clone, Serialize, Deserialize)]
2940#[serde(rename_all = "camelCase")]
2941pub struct ModelVerificationNotification {
2942    #[serde(rename = "threadId")]
2943    pub thread_id: String,
2944    #[serde(rename = "turnId")]
2945    pub turn_id: String,
2946    #[serde()]
2947    pub verifications: Vec<ModelVerification>,
2948}
2949
2950#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2951pub enum NetworkAccess {
2952    #[serde(rename = "restricted")]
2953    Restricted,
2954    #[serde(rename = "enabled")]
2955    Enabled,
2956}
2957
2958#[derive(Debug, Clone, Serialize, Deserialize)]
2959#[serde(rename_all = "camelCase")]
2960pub struct NetworkApprovalContext {
2961    #[serde()]
2962    pub host: String,
2963    #[serde()]
2964    pub protocol: NetworkApprovalProtocol,
2965}
2966
2967#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2968pub enum NetworkApprovalProtocol {
2969    #[serde(rename = "http")]
2970    Http,
2971    #[serde(rename = "https")]
2972    Https,
2973    #[serde(rename = "socks5Tcp")]
2974    Socks5Tcp,
2975    #[serde(rename = "socks5Udp")]
2976    Socks5Udp,
2977}
2978
2979#[derive(Debug, Clone, Serialize, Deserialize)]
2980#[serde(rename_all = "camelCase")]
2981pub struct NetworkPolicyAmendment {
2982    #[serde()]
2983    pub action: NetworkPolicyRuleAction,
2984    #[serde()]
2985    pub host: String,
2986}
2987
2988#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2989pub enum NetworkPolicyRuleAction {
2990    #[serde(rename = "allow")]
2991    Allow,
2992    #[serde(rename = "deny")]
2993    Deny,
2994}
2995
2996#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2997pub enum NonSteerableTurnKind {
2998    #[serde(rename = "review")]
2999    Review,
3000    #[serde(rename = "compact")]
3001    Compact,
3002}
3003
3004#[derive(Debug, Clone, Serialize, Deserialize)]
3005#[serde(rename_all = "camelCase")]
3006pub struct OverriddenMetadata {
3007    #[serde(rename = "effectiveValue")]
3008    pub effective_value: Value,
3009    #[serde()]
3010    pub message: String,
3011    #[serde(rename = "overridingLayer")]
3012    pub overriding_layer: ConfigLayerMetadata,
3013}
3014
3015#[derive(Debug, Clone, Serialize, Deserialize)]
3016#[serde(tag = "type", rename_all = "camelCase")]
3017pub enum ParsedCommand {
3018    Read {
3019        cmd: String,
3020        name: String,
3021        path: String,
3022    },
3023    List_files {
3024        cmd: String,
3025        #[serde(default, skip_serializing_if = "Option::is_none")]
3026        path: Option<String>,
3027    },
3028    Search {
3029        cmd: String,
3030        #[serde(default, skip_serializing_if = "Option::is_none")]
3031        path: Option<String>,
3032        #[serde(default, skip_serializing_if = "Option::is_none")]
3033        query: Option<String>,
3034    },
3035    Unknown {
3036        cmd: String,
3037    },
3038}
3039
3040#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3041pub enum PermissionGrantScope {
3042    #[serde(rename = "turn")]
3043    Turn,
3044    #[serde(rename = "session")]
3045    Session,
3046}
3047
3048#[derive(Debug, Clone, Serialize, Deserialize)]
3049#[serde(rename_all = "camelCase")]
3050pub struct PermissionsRequestApprovalParams {
3051    #[serde()]
3052    pub cwd: AbsolutePathBuf,
3053    #[serde(rename = "itemId")]
3054    pub item_id: String,
3055    #[serde()]
3056    pub permissions: RequestPermissionProfile,
3057    #[serde(default, skip_serializing_if = "Option::is_none")]
3058    pub reason: Option<String>,
3059    #[serde(rename = "startedAtMs")]
3060    pub started_at_ms: i64,
3061    #[serde(rename = "threadId")]
3062    pub thread_id: String,
3063    #[serde(rename = "turnId")]
3064    pub turn_id: String,
3065}
3066
3067#[derive(Debug, Clone, Serialize, Deserialize)]
3068#[serde(rename_all = "camelCase")]
3069pub struct PermissionsRequestApprovalResponse {
3070    #[serde()]
3071    pub permissions: GrantedPermissionProfile,
3072    #[serde(default, skip_serializing_if = "Option::is_none")]
3073    pub scope: Option<Value>,
3074    #[serde(
3075        rename = "strictAutoReview",
3076        default,
3077        skip_serializing_if = "Option::is_none"
3078    )]
3079    pub strict_auto_review: Option<bool>,
3080}
3081
3082#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3083pub enum Personality {
3084    #[serde(rename = "none")]
3085    None,
3086    #[serde(rename = "friendly")]
3087    Friendly,
3088    #[serde(rename = "pragmatic")]
3089    Pragmatic,
3090}
3091
3092#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3093pub enum PlanType {
3094    #[serde(rename = "free")]
3095    Free,
3096    #[serde(rename = "go")]
3097    Go,
3098    #[serde(rename = "plus")]
3099    Plus,
3100    #[serde(rename = "pro")]
3101    Pro,
3102    #[serde(rename = "prolite")]
3103    Prolite,
3104    #[serde(rename = "team")]
3105    Team,
3106    #[serde(rename = "self_serve_business_usage_based")]
3107    Self_serve_business_usage_based,
3108    #[serde(rename = "business")]
3109    Business,
3110    #[serde(rename = "enterprise_cbp_usage_based")]
3111    Enterprise_cbp_usage_based,
3112    #[serde(rename = "enterprise")]
3113    Enterprise,
3114    #[serde(rename = "edu")]
3115    Edu,
3116    #[serde(rename = "unknown")]
3117    Unknown,
3118}
3119
3120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3121pub enum PluginAuthPolicy {
3122    #[serde(rename = "ON_INSTALL")]
3123    ON_INSTALL,
3124    #[serde(rename = "ON_USE")]
3125    ON_USE,
3126}
3127
3128#[derive(Debug, Clone, Serialize, Deserialize, Default)]
3129#[serde(transparent)]
3130pub struct PluginAvailability(pub Value);
3131
3132#[derive(Debug, Clone, Serialize, Deserialize)]
3133#[serde(rename_all = "camelCase")]
3134pub struct PluginDetail {
3135    #[serde()]
3136    pub apps: Vec<AppSummary>,
3137    #[serde(default, skip_serializing_if = "Option::is_none")]
3138    pub description: Option<String>,
3139    #[serde()]
3140    pub hooks: Vec<PluginHookSummary>,
3141    #[serde(rename = "marketplaceName")]
3142    pub marketplace_name: String,
3143    #[serde(
3144        rename = "marketplacePath",
3145        default,
3146        skip_serializing_if = "Option::is_none"
3147    )]
3148    pub marketplace_path: Option<AbsolutePathBuf>,
3149    #[serde(rename = "mcpServers")]
3150    pub mcp_servers: Vec<String>,
3151    #[serde()]
3152    pub skills: Vec<SkillSummary>,
3153    #[serde()]
3154    pub summary: PluginSummary,
3155}
3156
3157#[derive(Debug, Clone, Serialize, Deserialize)]
3158#[serde(rename_all = "camelCase")]
3159pub struct PluginHookSummary {
3160    #[serde(rename = "eventName")]
3161    pub event_name: HookEventName,
3162    #[serde()]
3163    pub key: String,
3164}
3165
3166#[derive(Debug, Clone, Serialize, Deserialize)]
3167#[serde(rename_all = "camelCase")]
3168pub struct PluginInstallParams {
3169    #[serde(
3170        rename = "marketplacePath",
3171        default,
3172        skip_serializing_if = "Option::is_none"
3173    )]
3174    pub marketplace_path: Option<AbsolutePathBuf>,
3175    #[serde(rename = "pluginName")]
3176    pub plugin_name: String,
3177    #[serde(
3178        rename = "remoteMarketplaceName",
3179        default,
3180        skip_serializing_if = "Option::is_none"
3181    )]
3182    pub remote_marketplace_name: Option<String>,
3183}
3184
3185#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3186pub enum PluginInstallPolicy {
3187    #[serde(rename = "NOT_AVAILABLE")]
3188    NOT_AVAILABLE,
3189    #[serde(rename = "AVAILABLE")]
3190    AVAILABLE,
3191    #[serde(rename = "INSTALLED_BY_DEFAULT")]
3192    INSTALLED_BY_DEFAULT,
3193}
3194
3195#[derive(Debug, Clone, Serialize, Deserialize)]
3196#[serde(rename_all = "camelCase")]
3197pub struct PluginInstallResponse {
3198    #[serde(rename = "appsNeedingAuth")]
3199    pub apps_needing_auth: Vec<AppSummary>,
3200    #[serde(rename = "authPolicy")]
3201    pub auth_policy: PluginAuthPolicy,
3202}
3203
3204#[derive(Debug, Clone, Serialize, Deserialize)]
3205#[serde(rename_all = "camelCase")]
3206pub struct PluginInterface {
3207    #[serde(
3208        rename = "brandColor",
3209        default,
3210        skip_serializing_if = "Option::is_none"
3211    )]
3212    pub brand_color: Option<String>,
3213    #[serde()]
3214    pub capabilities: Vec<String>,
3215    #[serde(default, skip_serializing_if = "Option::is_none")]
3216    pub category: Option<String>,
3217    #[serde(
3218        rename = "composerIcon",
3219        default,
3220        skip_serializing_if = "Option::is_none"
3221    )]
3222    pub composer_icon: Option<AbsolutePathBuf>,
3223    #[serde(
3224        rename = "composerIconUrl",
3225        default,
3226        skip_serializing_if = "Option::is_none"
3227    )]
3228    pub composer_icon_url: Option<String>,
3229    #[serde(
3230        rename = "defaultPrompt",
3231        default,
3232        skip_serializing_if = "Option::is_none"
3233    )]
3234    pub default_prompt: Option<Vec<String>>,
3235    #[serde(
3236        rename = "developerName",
3237        default,
3238        skip_serializing_if = "Option::is_none"
3239    )]
3240    pub developer_name: Option<String>,
3241    #[serde(
3242        rename = "displayName",
3243        default,
3244        skip_serializing_if = "Option::is_none"
3245    )]
3246    pub display_name: Option<String>,
3247    #[serde(default, skip_serializing_if = "Option::is_none")]
3248    pub logo: Option<AbsolutePathBuf>,
3249    #[serde(rename = "logoUrl", default, skip_serializing_if = "Option::is_none")]
3250    pub logo_url: Option<String>,
3251    #[serde(
3252        rename = "longDescription",
3253        default,
3254        skip_serializing_if = "Option::is_none"
3255    )]
3256    pub long_description: Option<String>,
3257    #[serde(
3258        rename = "privacyPolicyUrl",
3259        default,
3260        skip_serializing_if = "Option::is_none"
3261    )]
3262    pub privacy_policy_url: Option<String>,
3263    #[serde(rename = "screenshotUrls")]
3264    pub screenshot_urls: Vec<String>,
3265    #[serde()]
3266    pub screenshots: Vec<AbsolutePathBuf>,
3267    #[serde(
3268        rename = "shortDescription",
3269        default,
3270        skip_serializing_if = "Option::is_none"
3271    )]
3272    pub short_description: Option<String>,
3273    #[serde(
3274        rename = "termsOfServiceUrl",
3275        default,
3276        skip_serializing_if = "Option::is_none"
3277    )]
3278    pub terms_of_service_url: Option<String>,
3279    #[serde(
3280        rename = "websiteUrl",
3281        default,
3282        skip_serializing_if = "Option::is_none"
3283    )]
3284    pub website_url: Option<String>,
3285}
3286
3287#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3288pub enum PluginListMarketplaceKind {
3289    #[serde(rename = "local")]
3290    Local,
3291    #[serde(rename = "workspace-directory")]
3292    Workspace_directory,
3293    #[serde(rename = "shared-with-me")]
3294    Shared_with_me,
3295}
3296
3297#[derive(Debug, Clone, Serialize, Deserialize)]
3298#[serde(rename_all = "camelCase")]
3299pub struct PluginListParams {
3300    #[serde(default, skip_serializing_if = "Option::is_none")]
3301    pub cwds: Option<Vec<AbsolutePathBuf>>,
3302    #[serde(
3303        rename = "marketplaceKinds",
3304        default,
3305        skip_serializing_if = "Option::is_none"
3306    )]
3307    pub marketplace_kinds: Option<Vec<PluginListMarketplaceKind>>,
3308}
3309
3310#[derive(Debug, Clone, Serialize, Deserialize)]
3311#[serde(rename_all = "camelCase")]
3312pub struct PluginListResponse {
3313    #[serde(
3314        rename = "featuredPluginIds",
3315        default,
3316        skip_serializing_if = "Option::is_none"
3317    )]
3318    pub featured_plugin_ids: Option<Vec<String>>,
3319    #[serde(
3320        rename = "marketplaceLoadErrors",
3321        default,
3322        skip_serializing_if = "Option::is_none"
3323    )]
3324    pub marketplace_load_errors: Option<Vec<MarketplaceLoadErrorInfo>>,
3325    #[serde()]
3326    pub marketplaces: Vec<PluginMarketplaceEntry>,
3327}
3328
3329#[derive(Debug, Clone, Serialize, Deserialize)]
3330#[serde(rename_all = "camelCase")]
3331pub struct PluginMarketplaceEntry {
3332    #[serde(default, skip_serializing_if = "Option::is_none")]
3333    pub interface: Option<MarketplaceInterface>,
3334    #[serde()]
3335    pub name: String,
3336    #[serde(default, skip_serializing_if = "Option::is_none")]
3337    pub path: Option<AbsolutePathBuf>,
3338    #[serde()]
3339    pub plugins: Vec<PluginSummary>,
3340}
3341
3342#[derive(Debug, Clone, Serialize, Deserialize)]
3343#[serde(rename_all = "camelCase")]
3344pub struct PluginReadParams {
3345    #[serde(
3346        rename = "marketplacePath",
3347        default,
3348        skip_serializing_if = "Option::is_none"
3349    )]
3350    pub marketplace_path: Option<AbsolutePathBuf>,
3351    #[serde(rename = "pluginName")]
3352    pub plugin_name: String,
3353    #[serde(
3354        rename = "remoteMarketplaceName",
3355        default,
3356        skip_serializing_if = "Option::is_none"
3357    )]
3358    pub remote_marketplace_name: Option<String>,
3359}
3360
3361#[derive(Debug, Clone, Serialize, Deserialize)]
3362#[serde(rename_all = "camelCase")]
3363pub struct PluginReadResponse {
3364    #[serde()]
3365    pub plugin: PluginDetail,
3366}
3367
3368#[derive(Debug, Clone, Serialize, Deserialize)]
3369#[serde(rename_all = "camelCase")]
3370pub struct PluginShareCheckoutParams {
3371    #[serde(rename = "remotePluginId")]
3372    pub remote_plugin_id: String,
3373}
3374
3375#[derive(Debug, Clone, Serialize, Deserialize)]
3376#[serde(rename_all = "camelCase")]
3377pub struct PluginShareCheckoutResponse {
3378    #[serde(rename = "marketplaceName")]
3379    pub marketplace_name: String,
3380    #[serde(rename = "marketplacePath")]
3381    pub marketplace_path: AbsolutePathBuf,
3382    #[serde(rename = "pluginId")]
3383    pub plugin_id: String,
3384    #[serde(rename = "pluginName")]
3385    pub plugin_name: String,
3386    #[serde(rename = "pluginPath")]
3387    pub plugin_path: AbsolutePathBuf,
3388    #[serde(rename = "remotePluginId")]
3389    pub remote_plugin_id: String,
3390    #[serde(
3391        rename = "remoteVersion",
3392        default,
3393        skip_serializing_if = "Option::is_none"
3394    )]
3395    pub remote_version: Option<String>,
3396}
3397
3398#[derive(Debug, Clone, Serialize, Deserialize)]
3399#[serde(rename_all = "camelCase")]
3400pub struct PluginShareContext {
3401    #[serde(
3402        rename = "creatorAccountUserId",
3403        default,
3404        skip_serializing_if = "Option::is_none"
3405    )]
3406    pub creator_account_user_id: Option<String>,
3407    #[serde(
3408        rename = "creatorName",
3409        default,
3410        skip_serializing_if = "Option::is_none"
3411    )]
3412    pub creator_name: Option<String>,
3413    #[serde(default, skip_serializing_if = "Option::is_none")]
3414    pub discoverability: Option<PluginShareDiscoverability>,
3415    #[serde(rename = "remotePluginId")]
3416    pub remote_plugin_id: String,
3417    #[serde(
3418        rename = "remoteVersion",
3419        default,
3420        skip_serializing_if = "Option::is_none"
3421    )]
3422    pub remote_version: Option<String>,
3423    #[serde(
3424        rename = "sharePrincipals",
3425        default,
3426        skip_serializing_if = "Option::is_none"
3427    )]
3428    pub share_principals: Option<Vec<PluginSharePrincipal>>,
3429    #[serde(rename = "shareUrl", default, skip_serializing_if = "Option::is_none")]
3430    pub share_url: Option<String>,
3431}
3432
3433#[derive(Debug, Clone, Serialize, Deserialize)]
3434#[serde(rename_all = "camelCase")]
3435pub struct PluginShareDeleteParams {
3436    #[serde(rename = "remotePluginId")]
3437    pub remote_plugin_id: String,
3438}
3439
3440#[derive(Debug, Clone, Serialize, Deserialize)]
3441#[serde(rename_all = "camelCase")]
3442pub struct PluginShareDeleteResponse {
3443    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3444    pub extra: serde_json::Map<String, Value>,
3445}
3446
3447#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3448pub enum PluginShareDiscoverability {
3449    #[serde(rename = "LISTED")]
3450    LISTED,
3451    #[serde(rename = "UNLISTED")]
3452    UNLISTED,
3453    #[serde(rename = "PRIVATE")]
3454    PRIVATE,
3455}
3456
3457#[derive(Debug, Clone, Serialize, Deserialize)]
3458#[serde(rename_all = "camelCase")]
3459pub struct PluginShareListItem {
3460    #[serde(
3461        rename = "localPluginPath",
3462        default,
3463        skip_serializing_if = "Option::is_none"
3464    )]
3465    pub local_plugin_path: Option<AbsolutePathBuf>,
3466    #[serde()]
3467    pub plugin: PluginSummary,
3468}
3469
3470#[derive(Debug, Clone, Serialize, Deserialize)]
3471#[serde(rename_all = "camelCase")]
3472pub struct PluginShareListParams {
3473    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3474    pub extra: serde_json::Map<String, Value>,
3475}
3476
3477#[derive(Debug, Clone, Serialize, Deserialize)]
3478#[serde(rename_all = "camelCase")]
3479pub struct PluginShareListResponse {
3480    #[serde()]
3481    pub data: Vec<PluginShareListItem>,
3482}
3483
3484#[derive(Debug, Clone, Serialize, Deserialize)]
3485#[serde(rename_all = "camelCase")]
3486pub struct PluginSharePrincipal {
3487    #[serde()]
3488    pub name: String,
3489    #[serde(rename = "principalId")]
3490    pub principal_id: String,
3491    #[serde(rename = "principalType")]
3492    pub principal_type: PluginSharePrincipalType,
3493    #[serde()]
3494    pub role: PluginSharePrincipalRole,
3495}
3496
3497#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3498pub enum PluginSharePrincipalRole {
3499    #[serde(rename = "reader")]
3500    Reader,
3501    #[serde(rename = "editor")]
3502    Editor,
3503    #[serde(rename = "owner")]
3504    Owner,
3505}
3506
3507#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3508pub enum PluginSharePrincipalType {
3509    #[serde(rename = "user")]
3510    User,
3511    #[serde(rename = "group")]
3512    Group,
3513    #[serde(rename = "workspace")]
3514    Workspace,
3515}
3516
3517#[derive(Debug, Clone, Serialize, Deserialize)]
3518#[serde(rename_all = "camelCase")]
3519pub struct PluginShareSaveParams {
3520    #[serde(default, skip_serializing_if = "Option::is_none")]
3521    pub discoverability: Option<PluginShareDiscoverability>,
3522    #[serde(rename = "pluginPath")]
3523    pub plugin_path: AbsolutePathBuf,
3524    #[serde(
3525        rename = "remotePluginId",
3526        default,
3527        skip_serializing_if = "Option::is_none"
3528    )]
3529    pub remote_plugin_id: Option<String>,
3530    #[serde(
3531        rename = "shareTargets",
3532        default,
3533        skip_serializing_if = "Option::is_none"
3534    )]
3535    pub share_targets: Option<Vec<PluginShareTarget>>,
3536}
3537
3538#[derive(Debug, Clone, Serialize, Deserialize)]
3539#[serde(rename_all = "camelCase")]
3540pub struct PluginShareSaveResponse {
3541    #[serde(rename = "remotePluginId")]
3542    pub remote_plugin_id: String,
3543    #[serde(rename = "shareUrl")]
3544    pub share_url: String,
3545}
3546
3547#[derive(Debug, Clone, Serialize, Deserialize)]
3548#[serde(rename_all = "camelCase")]
3549pub struct PluginShareTarget {
3550    #[serde(rename = "principalId")]
3551    pub principal_id: String,
3552    #[serde(rename = "principalType")]
3553    pub principal_type: PluginSharePrincipalType,
3554    #[serde()]
3555    pub role: PluginShareTargetRole,
3556}
3557
3558#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3559pub enum PluginShareTargetRole {
3560    #[serde(rename = "reader")]
3561    Reader,
3562    #[serde(rename = "editor")]
3563    Editor,
3564}
3565
3566#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3567pub enum PluginShareUpdateDiscoverability {
3568    #[serde(rename = "UNLISTED")]
3569    UNLISTED,
3570    #[serde(rename = "PRIVATE")]
3571    PRIVATE,
3572}
3573
3574#[derive(Debug, Clone, Serialize, Deserialize)]
3575#[serde(rename_all = "camelCase")]
3576pub struct PluginShareUpdateTargetsParams {
3577    #[serde()]
3578    pub discoverability: PluginShareUpdateDiscoverability,
3579    #[serde(rename = "remotePluginId")]
3580    pub remote_plugin_id: String,
3581    #[serde(rename = "shareTargets")]
3582    pub share_targets: Vec<PluginShareTarget>,
3583}
3584
3585#[derive(Debug, Clone, Serialize, Deserialize)]
3586#[serde(rename_all = "camelCase")]
3587pub struct PluginShareUpdateTargetsResponse {
3588    #[serde()]
3589    pub discoverability: PluginShareDiscoverability,
3590    #[serde()]
3591    pub principals: Vec<PluginSharePrincipal>,
3592}
3593
3594#[derive(Debug, Clone, Serialize, Deserialize)]
3595#[serde(rename_all = "camelCase")]
3596pub struct PluginSkillReadParams {
3597    #[serde(rename = "remoteMarketplaceName")]
3598    pub remote_marketplace_name: String,
3599    #[serde(rename = "remotePluginId")]
3600    pub remote_plugin_id: String,
3601    #[serde(rename = "skillName")]
3602    pub skill_name: String,
3603}
3604
3605#[derive(Debug, Clone, Serialize, Deserialize)]
3606#[serde(rename_all = "camelCase")]
3607pub struct PluginSkillReadResponse {
3608    #[serde(default, skip_serializing_if = "Option::is_none")]
3609    pub contents: Option<String>,
3610}
3611
3612#[derive(Debug, Clone, Serialize, Deserialize)]
3613#[serde(tag = "type", rename_all = "camelCase")]
3614pub enum PluginSource {
3615    Local {
3616        path: AbsolutePathBuf,
3617    },
3618    Git {
3619        #[serde(default, skip_serializing_if = "Option::is_none")]
3620        path: Option<String>,
3621        #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
3622        ref_name: Option<String>,
3623        #[serde(default, skip_serializing_if = "Option::is_none")]
3624        sha: Option<String>,
3625        url: String,
3626    },
3627    Remote,
3628}
3629
3630#[derive(Debug, Clone, Serialize, Deserialize)]
3631#[serde(rename_all = "camelCase")]
3632pub struct PluginSummary {
3633    #[serde(rename = "authPolicy")]
3634    pub auth_policy: PluginAuthPolicy,
3635    #[serde(default, skip_serializing_if = "Option::is_none")]
3636    pub availability: Option<Value>,
3637    #[serde()]
3638    pub enabled: bool,
3639    #[serde()]
3640    pub id: String,
3641    #[serde(rename = "installPolicy")]
3642    pub install_policy: PluginInstallPolicy,
3643    #[serde()]
3644    pub installed: bool,
3645    #[serde(default, skip_serializing_if = "Option::is_none")]
3646    pub interface: Option<PluginInterface>,
3647    #[serde(default, skip_serializing_if = "Option::is_none")]
3648    pub keywords: Option<Vec<String>>,
3649    #[serde(
3650        rename = "localVersion",
3651        default,
3652        skip_serializing_if = "Option::is_none"
3653    )]
3654    pub local_version: Option<String>,
3655    #[serde()]
3656    pub name: String,
3657    #[serde(
3658        rename = "remotePluginId",
3659        default,
3660        skip_serializing_if = "Option::is_none"
3661    )]
3662    pub remote_plugin_id: Option<String>,
3663    #[serde(
3664        rename = "shareContext",
3665        default,
3666        skip_serializing_if = "Option::is_none"
3667    )]
3668    pub share_context: Option<PluginShareContext>,
3669    #[serde()]
3670    pub source: PluginSource,
3671}
3672
3673#[derive(Debug, Clone, Serialize, Deserialize)]
3674#[serde(rename_all = "camelCase")]
3675pub struct PluginUninstallParams {
3676    #[serde(rename = "pluginId")]
3677    pub plugin_id: String,
3678}
3679
3680#[derive(Debug, Clone, Serialize, Deserialize)]
3681#[serde(rename_all = "camelCase")]
3682pub struct PluginUninstallResponse {
3683    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
3684    pub extra: serde_json::Map<String, Value>,
3685}
3686
3687#[derive(Debug, Clone, Serialize, Deserialize)]
3688#[serde(rename_all = "camelCase")]
3689pub struct PluginsMigration {
3690    #[serde(rename = "marketplaceName")]
3691    pub marketplace_name: String,
3692    #[serde(rename = "pluginNames")]
3693    pub plugin_names: Vec<String>,
3694}
3695
3696#[derive(Debug, Clone, Serialize, Deserialize)]
3697#[serde(rename_all = "camelCase")]
3698pub struct ProcessExitedNotification {
3699    #[serde(rename = "exitCode")]
3700    pub exit_code: i64,
3701    #[serde(rename = "processHandle")]
3702    pub process_handle: String,
3703    #[serde()]
3704    pub stderr: String,
3705    #[serde(rename = "stderrCapReached")]
3706    pub stderr_cap_reached: bool,
3707    #[serde()]
3708    pub stdout: String,
3709    #[serde(rename = "stdoutCapReached")]
3710    pub stdout_cap_reached: bool,
3711}
3712
3713#[derive(Debug, Clone, Serialize, Deserialize)]
3714#[serde(rename_all = "camelCase")]
3715pub struct ProcessOutputDeltaNotification {
3716    #[serde(rename = "capReached")]
3717    pub cap_reached: bool,
3718    #[serde(rename = "deltaBase64")]
3719    pub delta_base64: String,
3720    #[serde(rename = "processHandle")]
3721    pub process_handle: String,
3722    #[serde()]
3723    pub stream: Value,
3724}
3725
3726#[derive(Debug, Clone, Serialize, Deserialize, Default)]
3727#[serde(transparent)]
3728pub struct ProcessOutputStream(pub Value);
3729
3730#[derive(Debug, Clone, Serialize, Deserialize)]
3731#[serde(rename_all = "camelCase")]
3732pub struct ProfileV2 {
3733    #[serde(default, skip_serializing_if = "Option::is_none")]
3734    pub approval_policy: Option<AskForApproval>,
3735    #[serde(default, skip_serializing_if = "Option::is_none")]
3736    pub approvals_reviewer: Option<ApprovalsReviewer>,
3737    #[serde(default, skip_serializing_if = "Option::is_none")]
3738    pub chatgpt_base_url: Option<String>,
3739    #[serde(default, skip_serializing_if = "Option::is_none")]
3740    pub model: Option<String>,
3741    #[serde(default, skip_serializing_if = "Option::is_none")]
3742    pub model_provider: Option<String>,
3743    #[serde(default, skip_serializing_if = "Option::is_none")]
3744    pub model_reasoning_effort: Option<ReasoningEffort>,
3745    #[serde(default, skip_serializing_if = "Option::is_none")]
3746    pub model_reasoning_summary: Option<ReasoningSummary>,
3747    #[serde(default, skip_serializing_if = "Option::is_none")]
3748    pub model_verbosity: Option<Verbosity>,
3749    #[serde(default, skip_serializing_if = "Option::is_none")]
3750    pub service_tier: Option<String>,
3751    #[serde(default, skip_serializing_if = "Option::is_none")]
3752    pub tools: Option<ToolsV2>,
3753    #[serde(default, skip_serializing_if = "Option::is_none")]
3754    pub web_search: Option<WebSearchMode>,
3755}
3756
3757#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3758pub enum RateLimitReachedType {
3759    #[serde(rename = "rate_limit_reached")]
3760    Rate_limit_reached,
3761    #[serde(rename = "workspace_owner_credits_depleted")]
3762    Workspace_owner_credits_depleted,
3763    #[serde(rename = "workspace_member_credits_depleted")]
3764    Workspace_member_credits_depleted,
3765    #[serde(rename = "workspace_owner_usage_limit_reached")]
3766    Workspace_owner_usage_limit_reached,
3767    #[serde(rename = "workspace_member_usage_limit_reached")]
3768    Workspace_member_usage_limit_reached,
3769}
3770
3771#[derive(Debug, Clone, Serialize, Deserialize)]
3772#[serde(rename_all = "camelCase")]
3773pub struct RateLimitSnapshot {
3774    #[serde(default, skip_serializing_if = "Option::is_none")]
3775    pub credits: Option<CreditsSnapshot>,
3776    #[serde(rename = "limitId", default, skip_serializing_if = "Option::is_none")]
3777    pub limit_id: Option<String>,
3778    #[serde(rename = "limitName", default, skip_serializing_if = "Option::is_none")]
3779    pub limit_name: Option<String>,
3780    #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
3781    pub plan_type: Option<PlanType>,
3782    #[serde(default, skip_serializing_if = "Option::is_none")]
3783    pub primary: Option<RateLimitWindow>,
3784    #[serde(
3785        rename = "rateLimitReachedType",
3786        default,
3787        skip_serializing_if = "Option::is_none"
3788    )]
3789    pub rate_limit_reached_type: Option<RateLimitReachedType>,
3790    #[serde(default, skip_serializing_if = "Option::is_none")]
3791    pub secondary: Option<RateLimitWindow>,
3792}
3793
3794#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3795pub enum RealtimeConversationVersion {
3796    #[serde(rename = "v1")]
3797    V1,
3798    #[serde(rename = "v2")]
3799    V2,
3800}
3801
3802#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3803pub enum ReasoningEffort {
3804    #[serde(rename = "none")]
3805    None,
3806    #[serde(rename = "minimal")]
3807    Minimal,
3808    #[serde(rename = "low")]
3809    Low,
3810    #[serde(rename = "medium")]
3811    Medium,
3812    #[serde(rename = "high")]
3813    High,
3814    #[serde(rename = "xhigh")]
3815    Xhigh,
3816}
3817
3818#[derive(Debug, Clone, Serialize, Deserialize)]
3819#[serde(rename_all = "camelCase")]
3820pub struct ReasoningEffortOption {
3821    #[serde()]
3822    pub description: String,
3823    #[serde(rename = "reasoningEffort")]
3824    pub reasoning_effort: ReasoningEffort,
3825}
3826
3827#[derive(Debug, Clone, Serialize, Deserialize, Default)]
3828#[serde(transparent)]
3829pub struct ReasoningSummary(pub Value);
3830
3831#[derive(Debug, Clone, Serialize, Deserialize)]
3832#[serde(rename_all = "camelCase")]
3833pub struct ReasoningSummaryTextDeltaNotification {
3834    #[serde()]
3835    pub delta: String,
3836    #[serde(rename = "itemId")]
3837    pub item_id: String,
3838    #[serde(rename = "summaryIndex")]
3839    pub summary_index: i64,
3840    #[serde(rename = "threadId")]
3841    pub thread_id: String,
3842    #[serde(rename = "turnId")]
3843    pub turn_id: String,
3844}
3845
3846#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3847pub enum RemoteControlConnectionStatus {
3848    #[serde(rename = "disabled")]
3849    Disabled,
3850    #[serde(rename = "connecting")]
3851    Connecting,
3852    #[serde(rename = "connected")]
3853    Connected,
3854    #[serde(rename = "errored")]
3855    Errored,
3856}
3857
3858#[derive(Debug, Clone, Serialize, Deserialize)]
3859#[serde(rename_all = "camelCase")]
3860pub struct RequestPermissionProfile {
3861    #[serde(
3862        rename = "fileSystem",
3863        default,
3864        skip_serializing_if = "Option::is_none"
3865    )]
3866    pub file_system: Option<AdditionalFileSystemPermissions>,
3867    #[serde(default, skip_serializing_if = "Option::is_none")]
3868    pub network: Option<AdditionalNetworkPermissions>,
3869}
3870
3871#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3872pub enum ResidencyRequirement {
3873    #[serde(rename = "us")]
3874    Us,
3875}
3876
3877#[derive(Debug, Clone, Serialize, Deserialize)]
3878#[serde(rename_all = "camelCase")]
3879pub struct Resource {
3880    #[serde(default, skip_serializing_if = "Option::is_none")]
3881    pub _meta: Option<Value>,
3882    #[serde(default, skip_serializing_if = "Option::is_none")]
3883    pub annotations: Option<Value>,
3884    #[serde(default, skip_serializing_if = "Option::is_none")]
3885    pub description: Option<String>,
3886    #[serde(default, skip_serializing_if = "Option::is_none")]
3887    pub icons: Option<Vec<Value>>,
3888    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
3889    pub mime_type: Option<String>,
3890    #[serde()]
3891    pub name: String,
3892    #[serde(default, skip_serializing_if = "Option::is_none")]
3893    pub size: Option<i64>,
3894    #[serde(default, skip_serializing_if = "Option::is_none")]
3895    pub title: Option<String>,
3896    #[serde()]
3897    pub uri: String,
3898}
3899
3900#[derive(Debug, Clone, Serialize, Deserialize, Default)]
3901#[serde(transparent)]
3902pub struct ResourceContent(pub Value);
3903
3904#[derive(Debug, Clone, Serialize, Deserialize)]
3905#[serde(rename_all = "camelCase")]
3906pub struct ResourceTemplate {
3907    #[serde(default, skip_serializing_if = "Option::is_none")]
3908    pub annotations: Option<Value>,
3909    #[serde(default, skip_serializing_if = "Option::is_none")]
3910    pub description: Option<String>,
3911    #[serde(rename = "mimeType", default, skip_serializing_if = "Option::is_none")]
3912    pub mime_type: Option<String>,
3913    #[serde()]
3914    pub name: String,
3915    #[serde(default, skip_serializing_if = "Option::is_none")]
3916    pub title: Option<String>,
3917    #[serde(rename = "uriTemplate")]
3918    pub uri_template: String,
3919}
3920
3921#[derive(Debug, Clone, Serialize, Deserialize, Default)]
3922#[serde(transparent)]
3923pub struct ReviewDecision(pub Value);
3924
3925#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3926pub enum ReviewDelivery {
3927    #[serde(rename = "inline")]
3928    Inline,
3929    #[serde(rename = "detached")]
3930    Detached,
3931}
3932
3933#[derive(Debug, Clone, Serialize, Deserialize)]
3934#[serde(rename_all = "camelCase")]
3935pub struct ReviewStartParams {
3936    #[serde(default, skip_serializing_if = "Option::is_none")]
3937    pub delivery: Option<ReviewDelivery>,
3938    #[serde()]
3939    pub target: ReviewTarget,
3940    #[serde(rename = "threadId")]
3941    pub thread_id: String,
3942}
3943
3944#[derive(Debug, Clone, Serialize, Deserialize)]
3945#[serde(rename_all = "camelCase")]
3946pub struct ReviewStartResponse {
3947    #[serde(rename = "reviewThreadId")]
3948    pub review_thread_id: String,
3949    #[serde()]
3950    pub turn: Turn,
3951}
3952
3953#[derive(Debug, Clone, Serialize, Deserialize)]
3954#[serde(tag = "type", rename_all = "camelCase")]
3955pub enum ReviewTarget {
3956    #[serde(rename = "uncommittedChanges")]
3957    UncommittedChanges,
3958    #[serde(rename = "baseBranch")]
3959    BaseBranch {
3960        branch: String,
3961    },
3962    Commit {
3963        sha: String,
3964        #[serde(default, skip_serializing_if = "Option::is_none")]
3965        title: Option<String>,
3966    },
3967    Custom {
3968        instructions: String,
3969    },
3970}
3971
3972#[derive(Debug, Clone, Serialize, Deserialize)]
3973#[serde(tag = "type", rename_all = "camelCase")]
3974pub enum SandboxPolicy {
3975    #[serde(rename = "dangerFullAccess")]
3976    DangerFullAccess,
3977    #[serde(rename = "readOnly")]
3978    ReadOnly {
3979        #[serde(
3980            rename = "networkAccess",
3981            default,
3982            skip_serializing_if = "Option::is_none"
3983        )]
3984        network_access: Option<bool>,
3985    },
3986    #[serde(rename = "externalSandbox")]
3987    ExternalSandbox {
3988        #[serde(
3989            rename = "networkAccess",
3990            default,
3991            skip_serializing_if = "Option::is_none"
3992        )]
3993        network_access: Option<Value>,
3994    },
3995    #[serde(rename = "workspaceWrite")]
3996    WorkspaceWrite {
3997        #[serde(
3998            rename = "excludeSlashTmp",
3999            default,
4000            skip_serializing_if = "Option::is_none"
4001        )]
4002        exclude_slash_tmp: Option<bool>,
4003        #[serde(
4004            rename = "excludeTmpdirEnvVar",
4005            default,
4006            skip_serializing_if = "Option::is_none"
4007        )]
4008        exclude_tmpdir_env_var: Option<bool>,
4009        #[serde(
4010            rename = "networkAccess",
4011            default,
4012            skip_serializing_if = "Option::is_none"
4013        )]
4014        network_access: Option<bool>,
4015        #[serde(
4016            rename = "writableRoots",
4017            default,
4018            skip_serializing_if = "Option::is_none"
4019        )]
4020        writable_roots: Option<Vec<AbsolutePathBuf>>,
4021    },
4022}
4023
4024#[derive(Debug, Clone, Serialize, Deserialize)]
4025#[serde(rename_all = "camelCase")]
4026pub struct SandboxWorkspaceWrite {
4027    #[serde(default, skip_serializing_if = "Option::is_none")]
4028    pub exclude_slash_tmp: Option<bool>,
4029    #[serde(default, skip_serializing_if = "Option::is_none")]
4030    pub exclude_tmpdir_env_var: Option<bool>,
4031    #[serde(default, skip_serializing_if = "Option::is_none")]
4032    pub network_access: Option<bool>,
4033    #[serde(default, skip_serializing_if = "Option::is_none")]
4034    pub writable_roots: Option<Vec<String>>,
4035}
4036
4037#[derive(Debug, Clone, Serialize, Deserialize)]
4038#[serde(rename_all = "camelCase")]
4039pub struct SendAddCreditsNudgeEmailParams {
4040    #[serde(rename = "creditType")]
4041    pub credit_type: AddCreditsNudgeCreditType,
4042}
4043
4044#[derive(Debug, Clone, Serialize, Deserialize)]
4045#[serde(rename_all = "camelCase")]
4046pub struct SendAddCreditsNudgeEmailResponse {
4047    #[serde()]
4048    pub status: AddCreditsNudgeEmailStatus,
4049}
4050
4051#[derive(Debug, Clone, Serialize, Deserialize)]
4052#[serde(rename_all = "camelCase")]
4053pub struct ServerRequestResolvedNotification {
4054    #[serde(rename = "requestId")]
4055    pub request_id: RequestId,
4056    #[serde(rename = "threadId")]
4057    pub thread_id: String,
4058}
4059
4060#[derive(Debug, Clone, Serialize, Deserialize)]
4061#[serde(rename_all = "camelCase")]
4062pub struct SessionMigration {
4063    #[serde()]
4064    pub cwd: String,
4065    #[serde()]
4066    pub path: String,
4067    #[serde(default, skip_serializing_if = "Option::is_none")]
4068    pub title: Option<String>,
4069}
4070
4071#[derive(Debug, Clone, Serialize, Deserialize, Default)]
4072#[serde(transparent)]
4073pub struct SessionSource(pub Value);
4074
4075#[derive(Debug, Clone, Serialize, Deserialize)]
4076#[serde(rename_all = "camelCase")]
4077pub struct SkillDependencies {
4078    #[serde()]
4079    pub tools: Vec<SkillToolDependency>,
4080}
4081
4082#[derive(Debug, Clone, Serialize, Deserialize)]
4083#[serde(rename_all = "camelCase")]
4084pub struct SkillErrorInfo {
4085    #[serde()]
4086    pub message: String,
4087    #[serde()]
4088    pub path: String,
4089}
4090
4091#[derive(Debug, Clone, Serialize, Deserialize)]
4092#[serde(rename_all = "camelCase")]
4093pub struct SkillInterface {
4094    #[serde(
4095        rename = "brandColor",
4096        default,
4097        skip_serializing_if = "Option::is_none"
4098    )]
4099    pub brand_color: Option<String>,
4100    #[serde(
4101        rename = "defaultPrompt",
4102        default,
4103        skip_serializing_if = "Option::is_none"
4104    )]
4105    pub default_prompt: Option<String>,
4106    #[serde(
4107        rename = "displayName",
4108        default,
4109        skip_serializing_if = "Option::is_none"
4110    )]
4111    pub display_name: Option<String>,
4112    #[serde(rename = "iconLarge", default, skip_serializing_if = "Option::is_none")]
4113    pub icon_large: Option<AbsolutePathBuf>,
4114    #[serde(rename = "iconSmall", default, skip_serializing_if = "Option::is_none")]
4115    pub icon_small: Option<AbsolutePathBuf>,
4116    #[serde(
4117        rename = "shortDescription",
4118        default,
4119        skip_serializing_if = "Option::is_none"
4120    )]
4121    pub short_description: Option<String>,
4122}
4123
4124#[derive(Debug, Clone, Serialize, Deserialize)]
4125#[serde(rename_all = "camelCase")]
4126pub struct SkillMetadata {
4127    #[serde(default, skip_serializing_if = "Option::is_none")]
4128    pub dependencies: Option<SkillDependencies>,
4129    #[serde()]
4130    pub description: String,
4131    #[serde()]
4132    pub enabled: bool,
4133    #[serde(default, skip_serializing_if = "Option::is_none")]
4134    pub interface: Option<SkillInterface>,
4135    #[serde()]
4136    pub name: String,
4137    #[serde()]
4138    pub path: AbsolutePathBuf,
4139    #[serde()]
4140    pub scope: SkillScope,
4141    #[serde(
4142        rename = "shortDescription",
4143        default,
4144        skip_serializing_if = "Option::is_none"
4145    )]
4146    pub short_description: Option<String>,
4147}
4148
4149#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4150pub enum SkillScope {
4151    #[serde(rename = "user")]
4152    User,
4153    #[serde(rename = "repo")]
4154    Repo,
4155    #[serde(rename = "system")]
4156    System,
4157    #[serde(rename = "admin")]
4158    Admin,
4159}
4160
4161#[derive(Debug, Clone, Serialize, Deserialize)]
4162#[serde(rename_all = "camelCase")]
4163pub struct SkillSummary {
4164    #[serde()]
4165    pub description: String,
4166    #[serde()]
4167    pub enabled: bool,
4168    #[serde(default, skip_serializing_if = "Option::is_none")]
4169    pub interface: Option<SkillInterface>,
4170    #[serde()]
4171    pub name: String,
4172    #[serde(default, skip_serializing_if = "Option::is_none")]
4173    pub path: Option<AbsolutePathBuf>,
4174    #[serde(
4175        rename = "shortDescription",
4176        default,
4177        skip_serializing_if = "Option::is_none"
4178    )]
4179    pub short_description: Option<String>,
4180}
4181
4182#[derive(Debug, Clone, Serialize, Deserialize)]
4183#[serde(rename_all = "camelCase")]
4184pub struct SkillToolDependency {
4185    #[serde(default, skip_serializing_if = "Option::is_none")]
4186    pub command: Option<String>,
4187    #[serde(default, skip_serializing_if = "Option::is_none")]
4188    pub description: Option<String>,
4189    #[serde(default, skip_serializing_if = "Option::is_none")]
4190    pub transport: Option<String>,
4191    #[serde(rename = "type")]
4192    pub type_: String,
4193    #[serde(default, skip_serializing_if = "Option::is_none")]
4194    pub url: Option<String>,
4195    #[serde()]
4196    pub value: String,
4197}
4198
4199#[derive(Debug, Clone, Serialize, Deserialize)]
4200#[serde(rename_all = "camelCase")]
4201pub struct SkillsConfigWriteParams {
4202    #[serde()]
4203    pub enabled: bool,
4204    #[serde(default, skip_serializing_if = "Option::is_none")]
4205    pub name: Option<String>,
4206    #[serde(default, skip_serializing_if = "Option::is_none")]
4207    pub path: Option<AbsolutePathBuf>,
4208}
4209
4210#[derive(Debug, Clone, Serialize, Deserialize)]
4211#[serde(rename_all = "camelCase")]
4212pub struct SkillsConfigWriteResponse {
4213    #[serde(rename = "effectiveEnabled")]
4214    pub effective_enabled: bool,
4215}
4216
4217#[derive(Debug, Clone, Serialize, Deserialize)]
4218#[serde(rename_all = "camelCase")]
4219pub struct SkillsListEntry {
4220    #[serde()]
4221    pub cwd: String,
4222    #[serde()]
4223    pub errors: Vec<SkillErrorInfo>,
4224    #[serde()]
4225    pub skills: Vec<SkillMetadata>,
4226}
4227
4228#[derive(Debug, Clone, Serialize, Deserialize)]
4229#[serde(rename_all = "camelCase")]
4230pub struct SkillsListParams {
4231    #[serde(default, skip_serializing_if = "Option::is_none")]
4232    pub cwds: Option<Vec<String>>,
4233    #[serde(
4234        rename = "forceReload",
4235        default,
4236        skip_serializing_if = "Option::is_none"
4237    )]
4238    pub force_reload: Option<bool>,
4239}
4240
4241#[derive(Debug, Clone, Serialize, Deserialize)]
4242#[serde(rename_all = "camelCase")]
4243pub struct SkillsListResponse {
4244    #[serde()]
4245    pub data: Vec<SkillsListEntry>,
4246}
4247
4248#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4249pub enum SortDirection {
4250    #[serde(rename = "asc")]
4251    Asc,
4252    #[serde(rename = "desc")]
4253    Desc,
4254}
4255
4256#[derive(Debug, Clone, Serialize, Deserialize, Default)]
4257#[serde(transparent)]
4258pub struct SubAgentSource(pub Value);
4259
4260#[derive(Debug, Clone, Serialize, Deserialize)]
4261#[serde(rename_all = "camelCase")]
4262pub struct SubagentMigration {
4263    #[serde()]
4264    pub name: String,
4265}
4266
4267#[derive(Debug, Clone, Serialize, Deserialize)]
4268#[serde(rename_all = "camelCase")]
4269pub struct TerminalInteractionNotification {
4270    #[serde(rename = "itemId")]
4271    pub item_id: String,
4272    #[serde(rename = "processId")]
4273    pub process_id: String,
4274    #[serde()]
4275    pub stdin: String,
4276    #[serde(rename = "threadId")]
4277    pub thread_id: String,
4278    #[serde(rename = "turnId")]
4279    pub turn_id: String,
4280}
4281
4282#[derive(Debug, Clone, Serialize, Deserialize)]
4283#[serde(rename_all = "camelCase")]
4284pub struct TextElement {
4285    #[serde(rename = "byteRange")]
4286    pub byte_range: Value,
4287    #[serde(default, skip_serializing_if = "Option::is_none")]
4288    pub placeholder: Option<String>,
4289}
4290
4291#[derive(Debug, Clone, Serialize, Deserialize)]
4292#[serde(rename_all = "camelCase")]
4293pub struct TextPosition {
4294    #[serde()]
4295    pub column: i64,
4296    #[serde()]
4297    pub line: i64,
4298}
4299
4300#[derive(Debug, Clone, Serialize, Deserialize)]
4301#[serde(rename_all = "camelCase")]
4302pub struct TextRange {
4303    #[serde()]
4304    pub end: TextPosition,
4305    #[serde()]
4306    pub start: TextPosition,
4307}
4308
4309#[derive(Debug, Clone, Serialize, Deserialize)]
4310#[serde(rename_all = "camelCase")]
4311pub struct Thread {
4312    #[serde(
4313        rename = "agentNickname",
4314        default,
4315        skip_serializing_if = "Option::is_none"
4316    )]
4317    pub agent_nickname: Option<String>,
4318    #[serde(rename = "agentRole", default, skip_serializing_if = "Option::is_none")]
4319    pub agent_role: Option<String>,
4320    #[serde(rename = "cliVersion")]
4321    pub cli_version: String,
4322    #[serde(rename = "createdAt")]
4323    pub created_at: i64,
4324    #[serde()]
4325    pub cwd: Value,
4326    #[serde()]
4327    pub ephemeral: bool,
4328    #[serde(
4329        rename = "forkedFromId",
4330        default,
4331        skip_serializing_if = "Option::is_none"
4332    )]
4333    pub forked_from_id: Option<String>,
4334    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
4335    pub git_info: Option<GitInfo>,
4336    #[serde()]
4337    pub id: String,
4338    #[serde(rename = "modelProvider")]
4339    pub model_provider: String,
4340    #[serde(default, skip_serializing_if = "Option::is_none")]
4341    pub name: Option<String>,
4342    #[serde(default, skip_serializing_if = "Option::is_none")]
4343    pub path: Option<String>,
4344    #[serde()]
4345    pub preview: String,
4346    #[serde(rename = "sessionId")]
4347    pub session_id: String,
4348    #[serde()]
4349    pub source: Value,
4350    #[serde()]
4351    pub status: Value,
4352    #[serde(
4353        rename = "threadSource",
4354        default,
4355        skip_serializing_if = "Option::is_none"
4356    )]
4357    pub thread_source: Option<ThreadSource>,
4358    #[serde()]
4359    pub turns: Vec<Turn>,
4360    #[serde(rename = "updatedAt")]
4361    pub updated_at: i64,
4362}
4363
4364#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4365pub enum ThreadActiveFlag {
4366    #[serde(rename = "waitingOnApproval")]
4367    WaitingOnApproval,
4368    #[serde(rename = "waitingOnUserInput")]
4369    WaitingOnUserInput,
4370}
4371
4372#[derive(Debug, Clone, Serialize, Deserialize)]
4373#[serde(rename_all = "camelCase")]
4374pub struct ThreadApproveGuardianDeniedActionParams {
4375    #[serde()]
4376    pub event: Value,
4377    #[serde(rename = "threadId")]
4378    pub thread_id: String,
4379}
4380
4381#[derive(Debug, Clone, Serialize, Deserialize)]
4382#[serde(rename_all = "camelCase")]
4383pub struct ThreadApproveGuardianDeniedActionResponse {
4384    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4385    pub extra: serde_json::Map<String, Value>,
4386}
4387
4388#[derive(Debug, Clone, Serialize, Deserialize)]
4389#[serde(rename_all = "camelCase")]
4390pub struct ThreadCompactStartParams {
4391    #[serde(rename = "threadId")]
4392    pub thread_id: String,
4393}
4394
4395#[derive(Debug, Clone, Serialize, Deserialize)]
4396#[serde(rename_all = "camelCase")]
4397pub struct ThreadCompactStartResponse {
4398    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4399    pub extra: serde_json::Map<String, Value>,
4400}
4401
4402#[derive(Debug, Clone, Serialize, Deserialize)]
4403#[serde(rename_all = "camelCase")]
4404pub struct ThreadForkParams {
4405    #[serde(
4406        rename = "approvalPolicy",
4407        default,
4408        skip_serializing_if = "Option::is_none"
4409    )]
4410    pub approval_policy: Option<AskForApproval>,
4411    #[serde(
4412        rename = "approvalsReviewer",
4413        default,
4414        skip_serializing_if = "Option::is_none"
4415    )]
4416    pub approvals_reviewer: Option<ApprovalsReviewer>,
4417    #[serde(
4418        rename = "baseInstructions",
4419        default,
4420        skip_serializing_if = "Option::is_none"
4421    )]
4422    pub base_instructions: Option<String>,
4423    #[serde(default, skip_serializing_if = "Option::is_none")]
4424    pub config: Option<Value>,
4425    #[serde(default, skip_serializing_if = "Option::is_none")]
4426    pub cwd: Option<String>,
4427    #[serde(
4428        rename = "developerInstructions",
4429        default,
4430        skip_serializing_if = "Option::is_none"
4431    )]
4432    pub developer_instructions: Option<String>,
4433    #[serde(default, skip_serializing_if = "Option::is_none")]
4434    pub ephemeral: Option<bool>,
4435    #[serde(default, skip_serializing_if = "Option::is_none")]
4436    pub model: Option<String>,
4437    #[serde(
4438        rename = "modelProvider",
4439        default,
4440        skip_serializing_if = "Option::is_none"
4441    )]
4442    pub model_provider: Option<String>,
4443    #[serde(default, skip_serializing_if = "Option::is_none")]
4444    pub sandbox: Option<SandboxMode>,
4445    #[serde(
4446        rename = "serviceTier",
4447        default,
4448        skip_serializing_if = "Option::is_none"
4449    )]
4450    pub service_tier: Option<String>,
4451    #[serde(rename = "threadId")]
4452    pub thread_id: String,
4453    #[serde(
4454        rename = "threadSource",
4455        default,
4456        skip_serializing_if = "Option::is_none"
4457    )]
4458    pub thread_source: Option<ThreadSource>,
4459}
4460
4461#[derive(Debug, Clone, Serialize, Deserialize)]
4462#[serde(rename_all = "camelCase")]
4463pub struct ThreadForkResponse {
4464    #[serde(rename = "approvalPolicy")]
4465    pub approval_policy: AskForApproval,
4466    #[serde(rename = "approvalsReviewer")]
4467    pub approvals_reviewer: Value,
4468    #[serde()]
4469    pub cwd: AbsolutePathBuf,
4470    #[serde(
4471        rename = "instructionSources",
4472        default,
4473        skip_serializing_if = "Option::is_none"
4474    )]
4475    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
4476    #[serde()]
4477    pub model: String,
4478    #[serde(rename = "modelProvider")]
4479    pub model_provider: String,
4480    #[serde(
4481        rename = "reasoningEffort",
4482        default,
4483        skip_serializing_if = "Option::is_none"
4484    )]
4485    pub reasoning_effort: Option<ReasoningEffort>,
4486    #[serde()]
4487    pub sandbox: Value,
4488    #[serde(
4489        rename = "serviceTier",
4490        default,
4491        skip_serializing_if = "Option::is_none"
4492    )]
4493    pub service_tier: Option<String>,
4494    #[serde()]
4495    pub thread: Thread,
4496}
4497
4498#[derive(Debug, Clone, Serialize, Deserialize)]
4499#[serde(rename_all = "camelCase")]
4500pub struct ThreadGoal {
4501    #[serde(rename = "createdAt")]
4502    pub created_at: i64,
4503    #[serde()]
4504    pub objective: String,
4505    #[serde()]
4506    pub status: ThreadGoalStatus,
4507    #[serde(rename = "threadId")]
4508    pub thread_id: String,
4509    #[serde(rename = "timeUsedSeconds")]
4510    pub time_used_seconds: i64,
4511    #[serde(
4512        rename = "tokenBudget",
4513        default,
4514        skip_serializing_if = "Option::is_none"
4515    )]
4516    pub token_budget: Option<i64>,
4517    #[serde(rename = "tokensUsed")]
4518    pub tokens_used: i64,
4519    #[serde(rename = "updatedAt")]
4520    pub updated_at: i64,
4521}
4522
4523#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4524pub enum ThreadGoalStatus {
4525    #[serde(rename = "active")]
4526    Active,
4527    #[serde(rename = "paused")]
4528    Paused,
4529    #[serde(rename = "budgetLimited")]
4530    BudgetLimited,
4531    #[serde(rename = "complete")]
4532    Complete,
4533}
4534
4535#[derive(Debug, Clone, Serialize, Deserialize)]
4536#[serde(rename_all = "camelCase")]
4537pub struct ThreadGoalUpdatedNotification {
4538    #[serde()]
4539    pub goal: ThreadGoal,
4540    #[serde(rename = "threadId")]
4541    pub thread_id: String,
4542    #[serde(rename = "turnId", default, skip_serializing_if = "Option::is_none")]
4543    pub turn_id: Option<String>,
4544}
4545
4546#[derive(Debug, Clone, Serialize, Deserialize, Default)]
4547#[serde(transparent)]
4548pub struct ThreadId(pub Value);
4549
4550#[derive(Debug, Clone, Serialize, Deserialize)]
4551#[serde(rename_all = "camelCase")]
4552pub struct ThreadInjectItemsParams {
4553    #[serde()]
4554    pub items: Vec<Value>,
4555    #[serde(rename = "threadId")]
4556    pub thread_id: String,
4557}
4558
4559#[derive(Debug, Clone, Serialize, Deserialize)]
4560#[serde(rename_all = "camelCase")]
4561pub struct ThreadInjectItemsResponse {
4562    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4563    pub extra: serde_json::Map<String, Value>,
4564}
4565
4566#[derive(Debug, Clone, Serialize, Deserialize, Default)]
4567#[serde(transparent)]
4568pub struct ThreadListCwdFilter(pub Value);
4569
4570#[derive(Debug, Clone, Serialize, Deserialize)]
4571#[serde(rename_all = "camelCase")]
4572pub struct ThreadListParams {
4573    #[serde(default, skip_serializing_if = "Option::is_none")]
4574    pub archived: Option<bool>,
4575    #[serde(default, skip_serializing_if = "Option::is_none")]
4576    pub cursor: Option<String>,
4577    #[serde(default, skip_serializing_if = "Option::is_none")]
4578    pub cwd: Option<ThreadListCwdFilter>,
4579    #[serde(default, skip_serializing_if = "Option::is_none")]
4580    pub limit: Option<i64>,
4581    #[serde(
4582        rename = "modelProviders",
4583        default,
4584        skip_serializing_if = "Option::is_none"
4585    )]
4586    pub model_providers: Option<Vec<String>>,
4587    #[serde(
4588        rename = "searchTerm",
4589        default,
4590        skip_serializing_if = "Option::is_none"
4591    )]
4592    pub search_term: Option<String>,
4593    #[serde(
4594        rename = "sortDirection",
4595        default,
4596        skip_serializing_if = "Option::is_none"
4597    )]
4598    pub sort_direction: Option<SortDirection>,
4599    #[serde(rename = "sortKey", default, skip_serializing_if = "Option::is_none")]
4600    pub sort_key: Option<ThreadSortKey>,
4601    #[serde(
4602        rename = "sourceKinds",
4603        default,
4604        skip_serializing_if = "Option::is_none"
4605    )]
4606    pub source_kinds: Option<Vec<ThreadSourceKind>>,
4607    #[serde(
4608        rename = "useStateDbOnly",
4609        default,
4610        skip_serializing_if = "Option::is_none"
4611    )]
4612    pub use_state_db_only: Option<bool>,
4613}
4614
4615#[derive(Debug, Clone, Serialize, Deserialize)]
4616#[serde(rename_all = "camelCase")]
4617pub struct ThreadListResponse {
4618    #[serde(
4619        rename = "backwardsCursor",
4620        default,
4621        skip_serializing_if = "Option::is_none"
4622    )]
4623    pub backwards_cursor: Option<String>,
4624    #[serde()]
4625    pub data: Vec<Thread>,
4626    #[serde(
4627        rename = "nextCursor",
4628        default,
4629        skip_serializing_if = "Option::is_none"
4630    )]
4631    pub next_cursor: Option<String>,
4632}
4633
4634#[derive(Debug, Clone, Serialize, Deserialize)]
4635#[serde(rename_all = "camelCase")]
4636pub struct ThreadLoadedListParams {
4637    #[serde(default, skip_serializing_if = "Option::is_none")]
4638    pub cursor: Option<String>,
4639    #[serde(default, skip_serializing_if = "Option::is_none")]
4640    pub limit: Option<i64>,
4641}
4642
4643#[derive(Debug, Clone, Serialize, Deserialize)]
4644#[serde(rename_all = "camelCase")]
4645pub struct ThreadLoadedListResponse {
4646    #[serde()]
4647    pub data: Vec<String>,
4648    #[serde(
4649        rename = "nextCursor",
4650        default,
4651        skip_serializing_if = "Option::is_none"
4652    )]
4653    pub next_cursor: Option<String>,
4654}
4655
4656#[derive(Debug, Clone, Serialize, Deserialize)]
4657#[serde(rename_all = "camelCase")]
4658pub struct ThreadMetadataGitInfoUpdateParams {
4659    #[serde(default, skip_serializing_if = "Option::is_none")]
4660    pub branch: Option<String>,
4661    #[serde(rename = "originUrl", default, skip_serializing_if = "Option::is_none")]
4662    pub origin_url: Option<String>,
4663    #[serde(default, skip_serializing_if = "Option::is_none")]
4664    pub sha: Option<String>,
4665}
4666
4667#[derive(Debug, Clone, Serialize, Deserialize)]
4668#[serde(rename_all = "camelCase")]
4669pub struct ThreadMetadataUpdateParams {
4670    #[serde(rename = "gitInfo", default, skip_serializing_if = "Option::is_none")]
4671    pub git_info: Option<ThreadMetadataGitInfoUpdateParams>,
4672    #[serde(rename = "threadId")]
4673    pub thread_id: String,
4674}
4675
4676#[derive(Debug, Clone, Serialize, Deserialize)]
4677#[serde(rename_all = "camelCase")]
4678pub struct ThreadMetadataUpdateResponse {
4679    #[serde()]
4680    pub thread: Thread,
4681}
4682
4683#[derive(Debug, Clone, Serialize, Deserialize)]
4684#[serde(rename_all = "camelCase")]
4685pub struct ThreadReadParams {
4686    #[serde(
4687        rename = "includeTurns",
4688        default,
4689        skip_serializing_if = "Option::is_none"
4690    )]
4691    pub include_turns: Option<bool>,
4692    #[serde(rename = "threadId")]
4693    pub thread_id: String,
4694}
4695
4696#[derive(Debug, Clone, Serialize, Deserialize)]
4697#[serde(rename_all = "camelCase")]
4698pub struct ThreadReadResponse {
4699    #[serde()]
4700    pub thread: Thread,
4701}
4702
4703#[derive(Debug, Clone, Serialize, Deserialize)]
4704#[serde(rename_all = "camelCase")]
4705pub struct ThreadRealtimeAudioChunk {
4706    #[serde()]
4707    pub data: String,
4708    #[serde(rename = "itemId", default, skip_serializing_if = "Option::is_none")]
4709    pub item_id: Option<String>,
4710    #[serde(rename = "numChannels")]
4711    pub num_channels: i64,
4712    #[serde(rename = "sampleRate")]
4713    pub sample_rate: i64,
4714    #[serde(
4715        rename = "samplesPerChannel",
4716        default,
4717        skip_serializing_if = "Option::is_none"
4718    )]
4719    pub samples_per_channel: Option<i64>,
4720}
4721
4722#[derive(Debug, Clone, Serialize, Deserialize)]
4723#[serde(rename_all = "camelCase")]
4724pub struct ThreadRealtimeClosedNotification {
4725    #[serde(default, skip_serializing_if = "Option::is_none")]
4726    pub reason: Option<String>,
4727    #[serde(rename = "threadId")]
4728    pub thread_id: String,
4729}
4730
4731#[derive(Debug, Clone, Serialize, Deserialize)]
4732#[serde(rename_all = "camelCase")]
4733pub struct ThreadRealtimeErrorNotification {
4734    #[serde()]
4735    pub message: String,
4736    #[serde(rename = "threadId")]
4737    pub thread_id: String,
4738}
4739
4740#[derive(Debug, Clone, Serialize, Deserialize)]
4741#[serde(rename_all = "camelCase")]
4742pub struct ThreadRealtimeItemAddedNotification {
4743    #[serde()]
4744    pub item: Value,
4745    #[serde(rename = "threadId")]
4746    pub thread_id: String,
4747}
4748
4749#[derive(Debug, Clone, Serialize, Deserialize)]
4750#[serde(rename_all = "camelCase")]
4751pub struct ThreadRealtimeOutputAudioDeltaNotification {
4752    #[serde()]
4753    pub audio: ThreadRealtimeAudioChunk,
4754    #[serde(rename = "threadId")]
4755    pub thread_id: String,
4756}
4757
4758#[derive(Debug, Clone, Serialize, Deserialize)]
4759#[serde(rename_all = "camelCase")]
4760pub struct ThreadRealtimeSdpNotification {
4761    #[serde()]
4762    pub sdp: String,
4763    #[serde(rename = "threadId")]
4764    pub thread_id: String,
4765}
4766
4767#[derive(Debug, Clone, Serialize, Deserialize)]
4768#[serde(rename_all = "camelCase")]
4769pub struct ThreadRealtimeStartedNotification {
4770    #[serde(
4771        rename = "realtimeSessionId",
4772        default,
4773        skip_serializing_if = "Option::is_none"
4774    )]
4775    pub realtime_session_id: Option<String>,
4776    #[serde(rename = "threadId")]
4777    pub thread_id: String,
4778    #[serde()]
4779    pub version: RealtimeConversationVersion,
4780}
4781
4782#[derive(Debug, Clone, Serialize, Deserialize)]
4783#[serde(rename_all = "camelCase")]
4784pub struct ThreadRealtimeTranscriptDeltaNotification {
4785    #[serde()]
4786    pub delta: String,
4787    #[serde()]
4788    pub role: String,
4789    #[serde(rename = "threadId")]
4790    pub thread_id: String,
4791}
4792
4793#[derive(Debug, Clone, Serialize, Deserialize)]
4794#[serde(rename_all = "camelCase")]
4795pub struct ThreadRealtimeTranscriptDoneNotification {
4796    #[serde()]
4797    pub role: String,
4798    #[serde()]
4799    pub text: String,
4800    #[serde(rename = "threadId")]
4801    pub thread_id: String,
4802}
4803
4804#[derive(Debug, Clone, Serialize, Deserialize)]
4805#[serde(rename_all = "camelCase")]
4806pub struct ThreadResumeParams {
4807    #[serde(
4808        rename = "approvalPolicy",
4809        default,
4810        skip_serializing_if = "Option::is_none"
4811    )]
4812    pub approval_policy: Option<AskForApproval>,
4813    #[serde(
4814        rename = "approvalsReviewer",
4815        default,
4816        skip_serializing_if = "Option::is_none"
4817    )]
4818    pub approvals_reviewer: Option<ApprovalsReviewer>,
4819    #[serde(
4820        rename = "baseInstructions",
4821        default,
4822        skip_serializing_if = "Option::is_none"
4823    )]
4824    pub base_instructions: Option<String>,
4825    #[serde(default, skip_serializing_if = "Option::is_none")]
4826    pub config: Option<Value>,
4827    #[serde(default, skip_serializing_if = "Option::is_none")]
4828    pub cwd: Option<String>,
4829    #[serde(
4830        rename = "developerInstructions",
4831        default,
4832        skip_serializing_if = "Option::is_none"
4833    )]
4834    pub developer_instructions: Option<String>,
4835    #[serde(default, skip_serializing_if = "Option::is_none")]
4836    pub model: Option<String>,
4837    #[serde(
4838        rename = "modelProvider",
4839        default,
4840        skip_serializing_if = "Option::is_none"
4841    )]
4842    pub model_provider: Option<String>,
4843    #[serde(default, skip_serializing_if = "Option::is_none")]
4844    pub personality: Option<Personality>,
4845    #[serde(default, skip_serializing_if = "Option::is_none")]
4846    pub sandbox: Option<SandboxMode>,
4847    #[serde(
4848        rename = "serviceTier",
4849        default,
4850        skip_serializing_if = "Option::is_none"
4851    )]
4852    pub service_tier: Option<String>,
4853    #[serde(rename = "threadId")]
4854    pub thread_id: String,
4855}
4856
4857#[derive(Debug, Clone, Serialize, Deserialize)]
4858#[serde(rename_all = "camelCase")]
4859pub struct ThreadResumeResponse {
4860    #[serde(rename = "approvalPolicy")]
4861    pub approval_policy: AskForApproval,
4862    #[serde(rename = "approvalsReviewer")]
4863    pub approvals_reviewer: Value,
4864    #[serde()]
4865    pub cwd: AbsolutePathBuf,
4866    #[serde(
4867        rename = "instructionSources",
4868        default,
4869        skip_serializing_if = "Option::is_none"
4870    )]
4871    pub instruction_sources: Option<Vec<AbsolutePathBuf>>,
4872    #[serde()]
4873    pub model: String,
4874    #[serde(rename = "modelProvider")]
4875    pub model_provider: String,
4876    #[serde(
4877        rename = "reasoningEffort",
4878        default,
4879        skip_serializing_if = "Option::is_none"
4880    )]
4881    pub reasoning_effort: Option<ReasoningEffort>,
4882    #[serde()]
4883    pub sandbox: Value,
4884    #[serde(
4885        rename = "serviceTier",
4886        default,
4887        skip_serializing_if = "Option::is_none"
4888    )]
4889    pub service_tier: Option<String>,
4890    #[serde()]
4891    pub thread: Thread,
4892}
4893
4894#[derive(Debug, Clone, Serialize, Deserialize)]
4895#[serde(rename_all = "camelCase")]
4896pub struct ThreadRollbackParams {
4897    #[serde(rename = "numTurns")]
4898    pub num_turns: i64,
4899    #[serde(rename = "threadId")]
4900    pub thread_id: String,
4901}
4902
4903#[derive(Debug, Clone, Serialize, Deserialize)]
4904#[serde(rename_all = "camelCase")]
4905pub struct ThreadRollbackResponse {
4906    #[serde()]
4907    pub thread: Value,
4908}
4909
4910#[derive(Debug, Clone, Serialize, Deserialize)]
4911#[serde(rename_all = "camelCase")]
4912pub struct ThreadSetNameParams {
4913    #[serde()]
4914    pub name: String,
4915    #[serde(rename = "threadId")]
4916    pub thread_id: String,
4917}
4918
4919#[derive(Debug, Clone, Serialize, Deserialize)]
4920#[serde(rename_all = "camelCase")]
4921pub struct ThreadSetNameResponse {
4922    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4923    pub extra: serde_json::Map<String, Value>,
4924}
4925
4926#[derive(Debug, Clone, Serialize, Deserialize)]
4927#[serde(rename_all = "camelCase")]
4928pub struct ThreadShellCommandParams {
4929    #[serde()]
4930    pub command: String,
4931    #[serde(rename = "threadId")]
4932    pub thread_id: String,
4933}
4934
4935#[derive(Debug, Clone, Serialize, Deserialize)]
4936#[serde(rename_all = "camelCase")]
4937pub struct ThreadShellCommandResponse {
4938    #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4939    pub extra: serde_json::Map<String, Value>,
4940}
4941
4942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4943pub enum ThreadSortKey {
4944    #[serde(rename = "created_at")]
4945    Created_at,
4946    #[serde(rename = "updated_at")]
4947    Updated_at,
4948}
4949
4950#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4951pub enum ThreadSource {
4952    #[serde(rename = "user")]
4953    User,
4954    #[serde(rename = "subagent")]
4955    Subagent,
4956    #[serde(rename = "memory_consolidation")]
4957    Memory_consolidation,
4958}
4959
4960#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4961pub enum ThreadSourceKind {
4962    #[serde(rename = "cli")]
4963    Cli,
4964    #[serde(rename = "vscode")]
4965    Vscode,
4966    #[serde(rename = "exec")]
4967    Exec,
4968    #[serde(rename = "appServer")]
4969    AppServer,
4970    #[serde(rename = "subAgent")]
4971    SubAgent,
4972    #[serde(rename = "subAgentReview")]
4973    SubAgentReview,
4974    #[serde(rename = "subAgentCompact")]
4975    SubAgentCompact,
4976    #[serde(rename = "subAgentThreadSpawn")]
4977    SubAgentThreadSpawn,
4978    #[serde(rename = "subAgentOther")]
4979    SubAgentOther,
4980    #[serde(rename = "unknown")]
4981    Unknown,
4982}
4983
4984#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
4985pub enum ThreadStartSource {
4986    #[serde(rename = "startup")]
4987    Startup,
4988    #[serde(rename = "clear")]
4989    Clear,
4990}
4991
4992#[derive(Debug, Clone, Serialize, Deserialize)]
4993#[serde(rename_all = "camelCase")]
4994pub struct ThreadTokenUsage {
4995    #[serde()]
4996    pub last: TokenUsageBreakdown,
4997    #[serde(
4998        rename = "modelContextWindow",
4999        default,
5000        skip_serializing_if = "Option::is_none"
5001    )]
5002    pub model_context_window: Option<i64>,
5003    #[serde()]
5004    pub total: TokenUsageBreakdown,
5005}
5006
5007#[derive(Debug, Clone, Serialize, Deserialize)]
5008#[serde(rename_all = "camelCase")]
5009pub struct ThreadUnarchiveParams {
5010    #[serde(rename = "threadId")]
5011    pub thread_id: String,
5012}
5013
5014#[derive(Debug, Clone, Serialize, Deserialize)]
5015#[serde(rename_all = "camelCase")]
5016pub struct ThreadUnarchiveResponse {
5017    #[serde()]
5018    pub thread: Thread,
5019}
5020
5021#[derive(Debug, Clone, Serialize, Deserialize)]
5022#[serde(rename_all = "camelCase")]
5023pub struct ThreadUnsubscribeParams {
5024    #[serde(rename = "threadId")]
5025    pub thread_id: String,
5026}
5027
5028#[derive(Debug, Clone, Serialize, Deserialize)]
5029#[serde(rename_all = "camelCase")]
5030pub struct ThreadUnsubscribeResponse {
5031    #[serde()]
5032    pub status: ThreadUnsubscribeStatus,
5033}
5034
5035#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5036pub enum ThreadUnsubscribeStatus {
5037    #[serde(rename = "notLoaded")]
5038    NotLoaded,
5039    #[serde(rename = "notSubscribed")]
5040    NotSubscribed,
5041    #[serde(rename = "unsubscribed")]
5042    Unsubscribed,
5043}
5044
5045#[derive(Debug, Clone, Serialize, Deserialize)]
5046#[serde(rename_all = "camelCase")]
5047pub struct TokenUsageBreakdown {
5048    #[serde(rename = "cachedInputTokens")]
5049    pub cached_input_tokens: i64,
5050    #[serde(rename = "inputTokens")]
5051    pub input_tokens: i64,
5052    #[serde(rename = "outputTokens")]
5053    pub output_tokens: i64,
5054    #[serde(rename = "reasoningOutputTokens")]
5055    pub reasoning_output_tokens: i64,
5056    #[serde(rename = "totalTokens")]
5057    pub total_tokens: i64,
5058}
5059
5060#[derive(Debug, Clone, Serialize, Deserialize)]
5061#[serde(rename_all = "camelCase")]
5062pub struct Tool {
5063    #[serde(default, skip_serializing_if = "Option::is_none")]
5064    pub _meta: Option<Value>,
5065    #[serde(default, skip_serializing_if = "Option::is_none")]
5066    pub annotations: Option<Value>,
5067    #[serde(default, skip_serializing_if = "Option::is_none")]
5068    pub description: Option<String>,
5069    #[serde(default, skip_serializing_if = "Option::is_none")]
5070    pub icons: Option<Vec<Value>>,
5071    #[serde(rename = "inputSchema")]
5072    pub input_schema: Value,
5073    #[serde()]
5074    pub name: String,
5075    #[serde(
5076        rename = "outputSchema",
5077        default,
5078        skip_serializing_if = "Option::is_none"
5079    )]
5080    pub output_schema: Option<Value>,
5081    #[serde(default, skip_serializing_if = "Option::is_none")]
5082    pub title: Option<String>,
5083}
5084
5085#[derive(Debug, Clone, Serialize, Deserialize)]
5086#[serde(rename_all = "camelCase")]
5087pub struct ToolRequestUserInputAnswer {
5088    #[serde()]
5089    pub answers: Vec<String>,
5090}
5091
5092#[derive(Debug, Clone, Serialize, Deserialize)]
5093#[serde(rename_all = "camelCase")]
5094pub struct ToolRequestUserInputOption {
5095    #[serde()]
5096    pub description: String,
5097    #[serde()]
5098    pub label: String,
5099}
5100
5101#[derive(Debug, Clone, Serialize, Deserialize)]
5102#[serde(rename_all = "camelCase")]
5103pub struct ToolRequestUserInputParams {
5104    #[serde(rename = "itemId")]
5105    pub item_id: String,
5106    #[serde()]
5107    pub questions: Vec<ToolRequestUserInputQuestion>,
5108    #[serde(rename = "threadId")]
5109    pub thread_id: String,
5110    #[serde(rename = "turnId")]
5111    pub turn_id: String,
5112}
5113
5114#[derive(Debug, Clone, Serialize, Deserialize)]
5115#[serde(rename_all = "camelCase")]
5116pub struct ToolRequestUserInputQuestion {
5117    #[serde()]
5118    pub header: String,
5119    #[serde()]
5120    pub id: String,
5121    #[serde(rename = "isOther", default, skip_serializing_if = "Option::is_none")]
5122    pub is_other: Option<bool>,
5123    #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
5124    pub is_secret: Option<bool>,
5125    #[serde(default, skip_serializing_if = "Option::is_none")]
5126    pub options: Option<Vec<ToolRequestUserInputOption>>,
5127    #[serde()]
5128    pub question: String,
5129}
5130
5131#[derive(Debug, Clone, Serialize, Deserialize)]
5132#[serde(rename_all = "camelCase")]
5133pub struct ToolRequestUserInputResponse {
5134    #[serde()]
5135    pub answers: std::collections::BTreeMap<String, ToolRequestUserInputAnswer>,
5136}
5137
5138#[derive(Debug, Clone, Serialize, Deserialize)]
5139#[serde(rename_all = "camelCase")]
5140pub struct ToolsV2 {
5141    #[serde(default, skip_serializing_if = "Option::is_none")]
5142    pub web_search: Option<WebSearchToolConfig>,
5143}
5144
5145#[derive(Debug, Clone, Serialize, Deserialize, Default)]
5146#[serde(transparent)]
5147pub struct TurnItemsView(pub Value);
5148
5149#[derive(Debug, Clone, Serialize, Deserialize)]
5150#[serde(rename_all = "camelCase")]
5151pub struct TurnSteerParams {
5152    #[serde(rename = "expectedTurnId")]
5153    pub expected_turn_id: String,
5154    #[serde()]
5155    pub input: Vec<UserInput>,
5156    #[serde(rename = "threadId")]
5157    pub thread_id: String,
5158}
5159
5160#[derive(Debug, Clone, Serialize, Deserialize)]
5161#[serde(rename_all = "camelCase")]
5162pub struct TurnSteerResponse {
5163    #[serde(rename = "turnId")]
5164    pub turn_id: String,
5165}
5166
5167#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5168pub enum Verbosity {
5169    #[serde(rename = "low")]
5170    Low,
5171    #[serde(rename = "medium")]
5172    Medium,
5173    #[serde(rename = "high")]
5174    High,
5175}
5176
5177#[derive(Debug, Clone, Serialize, Deserialize)]
5178#[serde(tag = "type", rename_all = "camelCase")]
5179pub enum WebSearchAction {
5180    Search {
5181        #[serde(default, skip_serializing_if = "Option::is_none")]
5182        queries: Option<Vec<String>>,
5183        #[serde(default, skip_serializing_if = "Option::is_none")]
5184        query: Option<String>,
5185    },
5186    #[serde(rename = "openPage")]
5187    OpenPage {
5188        #[serde(default, skip_serializing_if = "Option::is_none")]
5189        url: Option<String>,
5190    },
5191    #[serde(rename = "findInPage")]
5192    FindInPage {
5193        #[serde(default, skip_serializing_if = "Option::is_none")]
5194        pattern: Option<String>,
5195        #[serde(default, skip_serializing_if = "Option::is_none")]
5196        url: Option<String>,
5197    },
5198    Other,
5199}
5200
5201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5202pub enum WebSearchContextSize {
5203    #[serde(rename = "low")]
5204    Low,
5205    #[serde(rename = "medium")]
5206    Medium,
5207    #[serde(rename = "high")]
5208    High,
5209}
5210
5211#[derive(Debug, Clone, Serialize, Deserialize)]
5212#[serde(rename_all = "camelCase")]
5213pub struct WebSearchLocation {
5214    #[serde(default, skip_serializing_if = "Option::is_none")]
5215    pub city: Option<String>,
5216    #[serde(default, skip_serializing_if = "Option::is_none")]
5217    pub country: Option<String>,
5218    #[serde(default, skip_serializing_if = "Option::is_none")]
5219    pub region: Option<String>,
5220    #[serde(default, skip_serializing_if = "Option::is_none")]
5221    pub timezone: Option<String>,
5222}
5223
5224#[derive(Debug, Clone, Serialize, Deserialize)]
5225#[serde(rename_all = "camelCase")]
5226pub struct WebSearchToolConfig {
5227    #[serde(default, skip_serializing_if = "Option::is_none")]
5228    pub allowed_domains: Option<Vec<String>>,
5229    #[serde(default, skip_serializing_if = "Option::is_none")]
5230    pub context_size: Option<WebSearchContextSize>,
5231    #[serde(default, skip_serializing_if = "Option::is_none")]
5232    pub location: Option<WebSearchLocation>,
5233}
5234
5235#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5236pub enum WindowsSandboxReadiness {
5237    #[serde(rename = "ready")]
5238    Ready,
5239    #[serde(rename = "notConfigured")]
5240    NotConfigured,
5241    #[serde(rename = "updateRequired")]
5242    UpdateRequired,
5243}
5244
5245#[derive(Debug, Clone, Serialize, Deserialize)]
5246#[serde(rename_all = "camelCase")]
5247pub struct WindowsSandboxReadinessResponse {
5248    #[serde()]
5249    pub status: WindowsSandboxReadiness,
5250}
5251
5252#[derive(Debug, Clone, Serialize, Deserialize)]
5253#[serde(rename_all = "camelCase")]
5254pub struct WindowsSandboxSetupCompletedNotification {
5255    #[serde(default, skip_serializing_if = "Option::is_none")]
5256    pub error: Option<String>,
5257    #[serde()]
5258    pub mode: WindowsSandboxSetupMode,
5259    #[serde()]
5260    pub success: bool,
5261}
5262
5263#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5264pub enum WindowsSandboxSetupMode {
5265    #[serde(rename = "elevated")]
5266    Elevated,
5267    #[serde(rename = "unelevated")]
5268    Unelevated,
5269}
5270
5271#[derive(Debug, Clone, Serialize, Deserialize)]
5272#[serde(rename_all = "camelCase")]
5273pub struct WindowsSandboxSetupStartParams {
5274    #[serde(default, skip_serializing_if = "Option::is_none")]
5275    pub cwd: Option<AbsolutePathBuf>,
5276    #[serde()]
5277    pub mode: WindowsSandboxSetupMode,
5278}
5279
5280#[derive(Debug, Clone, Serialize, Deserialize)]
5281#[serde(rename_all = "camelCase")]
5282pub struct WindowsSandboxSetupStartResponse {
5283    #[serde()]
5284    pub started: bool,
5285}
5286
5287#[derive(Debug, Clone, Serialize, Deserialize)]
5288#[serde(rename_all = "camelCase")]
5289pub struct WindowsWorldWritableWarningNotification {
5290    #[serde(rename = "extraCount")]
5291    pub extra_count: i64,
5292    #[serde(rename = "failedScan")]
5293    pub failed_scan: bool,
5294    #[serde(rename = "samplePaths")]
5295    pub sample_paths: Vec<String>,
5296}
5297
5298#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5299pub enum WriteStatus {
5300    #[serde(rename = "ok")]
5301    Ok,
5302    #[serde(rename = "okOverridden")]
5303    OkOverridden,
5304}