helm_sdk/
types_gen.rs

1// AUTO-GENERATED from api/openapi/helm.openapi.yaml — DO NOT EDIT
2// Regenerate: bash scripts/sdk/gen.sh
3
4use serde::{Deserialize, Serialize};
5/*
6 * HELM Kernel API
7 *
8 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
9 *
10 * The version of the OpenAPI document: 0.5.19
11 *
12 * Generated by: https://openapi-generator.tech
13 */
14
15
16#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
17pub struct A2AAgentCard {
18    #[serde(rename = "agent_id")]
19    pub agent_id: String,
20    #[serde(rename = "name")]
21    pub name: String,
22    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
23    pub description: Option<String>,
24    #[serde(rename = "endpoint")]
25    pub endpoint: String,
26    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
27    pub provider: Option<Box<A2AAgentCardProvider>>,
28    #[serde(rename = "supported_versions")]
29    pub supported_versions: Vec<String>,
30    #[serde(rename = "skills")]
31    pub skills: Vec<A2AAgentCardSkillsInner>,
32    #[serde(rename = "auth_methods", skip_serializing_if = "Option::is_none")]
33    pub auth_methods: Option<Vec<String>>,
34    #[serde(rename = "features", skip_serializing_if = "Option::is_none")]
35    pub features: Option<Vec<String>>,
36    #[serde(rename = "defaultInputModes", skip_serializing_if = "Option::is_none")]
37    pub default_input_modes: Option<Vec<String>>,
38    #[serde(rename = "defaultOutputModes", skip_serializing_if = "Option::is_none")]
39    pub default_output_modes: Option<Vec<String>>,
40    #[serde(rename = "capabilities", skip_serializing_if = "Option::is_none")]
41    pub capabilities: Option<Box<A2AAgentCardCapabilities>>,
42    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
43    pub signature: Option<String>,
44    #[serde(rename = "content_hash", skip_serializing_if = "Option::is_none")]
45    pub content_hash: Option<String>,
46    #[serde(rename = "created_at")]
47    pub created_at: String,
48    #[serde(rename = "updated_at")]
49    pub updated_at: String,
50}
51
52impl A2AAgentCard {
53    pub fn new(agent_id: String, name: String, endpoint: String, supported_versions: Vec<String>, skills: Vec<A2AAgentCardSkillsInner>, created_at: String, updated_at: String) -> A2AAgentCard {
54        A2AAgentCard {
55            agent_id,
56            name,
57            description: None,
58            endpoint,
59            provider: None,
60            supported_versions,
61            skills,
62            auth_methods: None,
63            features: None,
64            default_input_modes: None,
65            default_output_modes: None,
66            capabilities: None,
67            signature: None,
68            content_hash: None,
69            created_at,
70            updated_at,
71        }
72    }
73}
74
75/*
76 * HELM Kernel API
77 *
78 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
79 *
80 * The version of the OpenAPI document: 0.5.19
81 *
82 * Generated by: https://openapi-generator.tech
83 */
84
85
86#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
87pub struct A2AAgentCardCapabilities {
88    #[serde(rename = "streaming", skip_serializing_if = "Option::is_none")]
89    pub streaming: Option<bool>,
90    #[serde(rename = "pushNotifications", skip_serializing_if = "Option::is_none")]
91    pub push_notifications: Option<bool>,
92    #[serde(rename = "stateTransitionHistory", skip_serializing_if = "Option::is_none")]
93    pub state_transition_history: Option<bool>,
94}
95
96impl A2AAgentCardCapabilities {
97    pub fn new() -> A2AAgentCardCapabilities {
98        A2AAgentCardCapabilities {
99            streaming: None,
100            push_notifications: None,
101            state_transition_history: None,
102        }
103    }
104}
105
106/*
107 * HELM Kernel API
108 *
109 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
110 *
111 * The version of the OpenAPI document: 0.5.19
112 *
113 * Generated by: https://openapi-generator.tech
114 */
115
116
117#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
118pub struct A2AAgentCardProvider {
119    #[serde(rename = "organization", skip_serializing_if = "Option::is_none")]
120    pub organization: Option<String>,
121    #[serde(rename = "url", skip_serializing_if = "Option::is_none")]
122    pub url: Option<String>,
123}
124
125impl A2AAgentCardProvider {
126    pub fn new() -> A2AAgentCardProvider {
127        A2AAgentCardProvider {
128            organization: None,
129            url: None,
130        }
131    }
132}
133
134/*
135 * HELM Kernel API
136 *
137 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
138 *
139 * The version of the OpenAPI document: 0.5.19
140 *
141 * Generated by: https://openapi-generator.tech
142 */
143
144
145#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
146pub struct A2AAgentCardSkillsInner {
147    #[serde(rename = "id")]
148    pub id: String,
149    #[serde(rename = "name")]
150    pub name: String,
151    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
152    pub description: Option<String>,
153    #[serde(rename = "examples", skip_serializing_if = "Option::is_none")]
154    pub examples: Option<Vec<String>>,
155    #[serde(rename = "input_modes", skip_serializing_if = "Option::is_none")]
156    pub input_modes: Option<Vec<String>>,
157    #[serde(rename = "output_modes", skip_serializing_if = "Option::is_none")]
158    pub output_modes: Option<Vec<String>>,
159}
160
161impl A2AAgentCardSkillsInner {
162    pub fn new(id: String, name: String) -> A2AAgentCardSkillsInner {
163        A2AAgentCardSkillsInner {
164            id,
165            name,
166            description: None,
167            examples: None,
168            input_modes: None,
169            output_modes: None,
170        }
171    }
172}
173
174/*
175 * HELM Kernel API
176 *
177 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
178 *
179 * The version of the OpenAPI document: 0.5.19
180 *
181 * Generated by: https://openapi-generator.tech
182 */
183
184
185#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
186pub struct AccountEntitlements {
187    #[serde(rename = "principal_id", skip_serializing_if = "Option::is_none")]
188    pub principal_id: Option<String>,
189    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
190    pub tenant_id: Option<String>,
191    #[serde(rename = "workspace_id", skip_serializing_if = "Option::is_none")]
192    pub workspace_id: Option<String>,
193    #[serde(rename = "plan", default, skip_serializing_if = "Option::is_none")]
194    pub plan: Option<Option<AccountEntitlementsPlan>>,
195    #[serde(rename = "plan_id", skip_serializing_if = "Option::is_none")]
196    pub plan_id: Option<String>,
197    #[serde(rename = "capabilities", skip_serializing_if = "Option::is_none")]
198    pub capabilities: Option<Box<EntitlementCapabilities>>,
199    #[serde(rename = "limits", skip_serializing_if = "Option::is_none")]
200    pub limits: Option<Box<EntitlementLimits>>,
201    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
202    pub source: Option<String>,
203    #[serde(rename = "updated_at", skip_serializing_if = "Option::is_none")]
204    pub updated_at: Option<String>,
205}
206
207impl AccountEntitlements {
208    pub fn new() -> AccountEntitlements {
209        AccountEntitlements {
210            principal_id: None,
211            tenant_id: None,
212            workspace_id: None,
213            plan: None,
214            plan_id: None,
215            capabilities: None,
216            limits: None,
217            source: None,
218            updated_at: None,
219        }
220    }
221}
222///
223#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
224pub enum AccountEntitlementsPlan {
225    #[serde(rename = "free")]
226    Free,
227    #[serde(rename = "individual")]
228    Individual,
229    #[serde(rename = "developer")]
230    Developer,
231    #[serde(rename = "team")]
232    Team,
233    #[serde(rename = "scale")]
234    Scale,
235    #[serde(rename = "enterprise")]
236    Enterprise,
237}
238
239impl Default for AccountEntitlementsPlan {
240    fn default() -> AccountEntitlementsPlan {
241        Self::Free
242    }
243}
244
245/*
246 * HELM Kernel API
247 *
248 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
249 *
250 * The version of the OpenAPI document: 0.5.19
251 *
252 * Generated by: https://openapi-generator.tech
253 */
254
255
256#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
257pub struct AccountSession {
258    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
259    pub session_id: Option<String>,
260    #[serde(rename = "principal_id", skip_serializing_if = "Option::is_none")]
261    pub principal_id: Option<String>,
262    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
263    pub tenant_id: Option<String>,
264    #[serde(rename = "workspace_id", skip_serializing_if = "Option::is_none")]
265    pub workspace_id: Option<String>,
266    #[serde(rename = "plan", default, skip_serializing_if = "Option::is_none")]
267    pub plan: Option<Option<AccountSessionPlan>>,
268    #[serde(rename = "plan_id", skip_serializing_if = "Option::is_none")]
269    pub plan_id: Option<String>,
270    #[serde(rename = "edition", skip_serializing_if = "Option::is_none")]
271    pub edition: Option<String>,
272    #[serde(rename = "deployment_mode", skip_serializing_if = "Option::is_none")]
273    pub deployment_mode: Option<String>,
274    #[serde(rename = "account_lifecycle", skip_serializing_if = "Option::is_none")]
275    pub account_lifecycle: Option<String>,
276    #[serde(rename = "offer_code", skip_serializing_if = "Option::is_none")]
277    pub offer_code: Option<String>,
278    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
279    pub source: Option<String>,
280    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
281    pub expires_at: Option<String>,
282}
283
284impl AccountSession {
285    pub fn new() -> AccountSession {
286        AccountSession {
287            session_id: None,
288            principal_id: None,
289            tenant_id: None,
290            workspace_id: None,
291            plan: None,
292            plan_id: None,
293            edition: None,
294            deployment_mode: None,
295            account_lifecycle: None,
296            offer_code: None,
297            source: None,
298            expires_at: None,
299        }
300    }
301}
302///
303#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
304pub enum AccountSessionPlan {
305    #[serde(rename = "free")]
306    Free,
307    #[serde(rename = "individual")]
308    Individual,
309    #[serde(rename = "developer")]
310    Developer,
311    #[serde(rename = "team")]
312    Team,
313    #[serde(rename = "scale")]
314    Scale,
315    #[serde(rename = "enterprise")]
316    Enterprise,
317}
318
319impl Default for AccountSessionPlan {
320    fn default() -> AccountSessionPlan {
321        Self::Free
322    }
323}
324
325/*
326 * HELM Kernel API
327 *
328 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
329 *
330 * The version of the OpenAPI document: 0.5.19
331 *
332 * Generated by: https://openapi-generator.tech
333 */
334
335
336#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
337pub struct AdapterMatch {
338    #[serde(rename = "adapter_id", skip_serializing_if = "Option::is_none")]
339    pub adapter_id: Option<String>,
340    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
341    pub confidence: Option<f64>,
342    #[serde(rename = "evidence", skip_serializing_if = "Option::is_none")]
343    pub evidence: Option<Vec<String>>,
344}
345
346impl AdapterMatch {
347    pub fn new() -> AdapterMatch {
348        AdapterMatch {
349            adapter_id: None,
350            confidence: None,
351            evidence: None,
352        }
353    }
354}
355
356/*
357 * HELM Kernel API
358 *
359 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
360 *
361 * The version of the OpenAPI document: 0.5.19
362 *
363 * Generated by: https://openapi-generator.tech
364 */
365
366
367#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
368pub struct AddTrustKey200Response {
369    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
370    pub status: Option<String>,
371    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
372    pub tenant_id: Option<String>,
373    #[serde(rename = "key_id", skip_serializing_if = "Option::is_none")]
374    pub key_id: Option<String>,
375}
376
377impl AddTrustKey200Response {
378    pub fn new() -> AddTrustKey200Response {
379        AddTrustKey200Response {
380            status: None,
381            tenant_id: None,
382            key_id: None,
383        }
384    }
385}
386
387/*
388 * HELM Kernel API
389 *
390 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
391 *
392 * The version of the OpenAPI document: 0.5.19
393 *
394 * Generated by: https://openapi-generator.tech
395 */
396
397
398#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
399pub struct AddTrustKeyRequest {
400    #[serde(rename = "tenant_id")]
401    pub tenant_id: String,
402    #[serde(rename = "key_id")]
403    pub key_id: String,
404    /// Hex-encoded Ed25519 public key
405    #[serde(rename = "public_key")]
406    pub public_key: String,
407}
408
409impl AddTrustKeyRequest {
410    pub fn new(tenant_id: String, key_id: String, public_key: String) -> AddTrustKeyRequest {
411        AddTrustKeyRequest {
412            tenant_id,
413            key_id,
414            public_key,
415        }
416    }
417}
418
419/*
420 * HELM Kernel API
421 *
422 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
423 *
424 * The version of the OpenAPI document: 0.5.19
425 *
426 * Generated by: https://openapi-generator.tech
427 */
428
429
430#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
431pub struct AgentIdentityProfile {
432    #[serde(rename = "agent_id", skip_serializing_if = "Option::is_none")]
433    pub agent_id: Option<String>,
434    #[serde(rename = "identity_type", skip_serializing_if = "Option::is_none")]
435    pub identity_type: Option<String>,
436    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
437    pub subject: Option<String>,
438    #[serde(rename = "issuer", skip_serializing_if = "Option::is_none")]
439    pub issuer: Option<String>,
440    #[serde(rename = "jwks_uri", skip_serializing_if = "Option::is_none")]
441    pub jwks_uri: Option<String>,
442    #[serde(rename = "spiffe_id", skip_serializing_if = "Option::is_none")]
443    pub spiffe_id: Option<String>,
444    #[serde(rename = "scopes", skip_serializing_if = "Option::is_none")]
445    pub scopes: Option<Vec<String>>,
446    #[serde(rename = "anonymous_dev_mode", skip_serializing_if = "Option::is_none")]
447    pub anonymous_dev_mode: Option<bool>,
448    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
449    pub created_at: Option<String>,
450}
451
452impl AgentIdentityProfile {
453    pub fn new() -> AgentIdentityProfile {
454        AgentIdentityProfile {
455            agent_id: None,
456            identity_type: None,
457            subject: None,
458            issuer: None,
459            jwks_uri: None,
460            spiffe_id: None,
461            scopes: None,
462            anonymous_dev_mode: None,
463            created_at: None,
464        }
465    }
466}
467
468/*
469 * HELM Kernel API
470 *
471 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
472 *
473 * The version of the OpenAPI document: 0.5.19
474 *
475 * Generated by: https://openapi-generator.tech
476 */
477
478
479#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
480pub struct ApprovalCeremony {
481    #[serde(rename = "approval_id", skip_serializing_if = "Option::is_none")]
482    pub approval_id: Option<String>,
483    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
484    pub subject: Option<String>,
485    #[serde(rename = "action", skip_serializing_if = "Option::is_none")]
486    pub action: Option<String>,
487    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
488    pub state: Option<ApprovalCeremonyState>,
489    #[serde(rename = "requested_by", skip_serializing_if = "Option::is_none")]
490    pub requested_by: Option<String>,
491    #[serde(rename = "approvers", skip_serializing_if = "Option::is_none")]
492    pub approvers: Option<Vec<String>>,
493    #[serde(rename = "quorum", skip_serializing_if = "Option::is_none")]
494    pub quorum: Option<i32>,
495    #[serde(rename = "timelock_until", skip_serializing_if = "Option::is_none")]
496    pub timelock_until: Option<String>,
497    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
498    pub expires_at: Option<String>,
499    #[serde(rename = "break_glass", skip_serializing_if = "Option::is_none")]
500    pub break_glass: Option<bool>,
501    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
502    pub reason: Option<String>,
503    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
504    pub receipt_id: Option<String>,
505    #[serde(rename = "ceremony_hash", skip_serializing_if = "Option::is_none")]
506    pub ceremony_hash: Option<String>,
507    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
508    pub created_at: Option<String>,
509    #[serde(rename = "updated_at", skip_serializing_if = "Option::is_none")]
510    pub updated_at: Option<String>,
511}
512
513impl ApprovalCeremony {
514    pub fn new() -> ApprovalCeremony {
515        ApprovalCeremony {
516            approval_id: None,
517            subject: None,
518            action: None,
519            state: None,
520            requested_by: None,
521            approvers: None,
522            quorum: None,
523            timelock_until: None,
524            expires_at: None,
525            break_glass: None,
526            reason: None,
527            receipt_id: None,
528            ceremony_hash: None,
529            created_at: None,
530            updated_at: None,
531        }
532    }
533}
534///
535#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
536pub enum ApprovalCeremonyState {
537    #[serde(rename = "pending")]
538    Pending,
539    #[serde(rename = "approved")]
540    Approved,
541    #[serde(rename = "denied")]
542    Denied,
543    #[serde(rename = "revoked")]
544    Revoked,
545    #[serde(rename = "expired")]
546    Expired,
547}
548
549impl Default for ApprovalCeremonyState {
550    fn default() -> ApprovalCeremonyState {
551        Self::Pending
552    }
553}
554
555/*
556 * HELM Kernel API
557 *
558 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
559 *
560 * The version of the OpenAPI document: 0.5.19
561 *
562 * Generated by: https://openapi-generator.tech
563 */
564
565
566#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
567pub struct ApprovalRequest {
568    /// SHA-256 hash of the intent to approve
569    #[serde(rename = "intent_hash")]
570    pub intent_hash: String,
571    /// Base64-encoded Ed25519 signature
572    #[serde(rename = "signature_b64")]
573    pub signature_b64: String,
574    /// Base64-encoded Ed25519 public key
575    #[serde(rename = "public_key_b64")]
576    pub public_key_b64: String,
577    /// Optional challenge/response for ceremony
578    #[serde(rename = "challenge_response", skip_serializing_if = "Option::is_none")]
579    pub challenge_response: Option<String>,
580}
581
582impl ApprovalRequest {
583    pub fn new(intent_hash: String, signature_b64: String, public_key_b64: String) -> ApprovalRequest {
584        ApprovalRequest {
585            intent_hash,
586            signature_b64,
587            public_key_b64,
588            challenge_response: None,
589        }
590    }
591}
592
593/*
594 * HELM Kernel API
595 *
596 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
597 *
598 * The version of the OpenAPI document: 0.5.19
599 *
600 * Generated by: https://openapi-generator.tech
601 */
602
603
604#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
605pub struct ApproveLaunchpadMcpToolsRequest {
606    #[serde(rename = "server_id")]
607    pub server_id: String,
608    #[serde(rename = "tools")]
609    pub tools: Vec<String>,
610    #[serde(rename = "ttl", skip_serializing_if = "Option::is_none")]
611    pub ttl: Option<String>,
612    #[serde(rename = "reason")]
613    pub reason: String,
614    #[serde(rename = "approver", skip_serializing_if = "Option::is_none")]
615    pub approver: Option<String>,
616}
617
618impl ApproveLaunchpadMcpToolsRequest {
619    pub fn new(server_id: String, tools: Vec<String>, reason: String) -> ApproveLaunchpadMcpToolsRequest {
620        ApproveLaunchpadMcpToolsRequest {
621            server_id,
622            tools,
623            ttl: None,
624            reason,
625            approver: None,
626        }
627    }
628}
629
630/*
631 * HELM Kernel API
632 *
633 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
634 *
635 * The version of the OpenAPI document: 0.5.19
636 *
637 * Generated by: https://openapi-generator.tech
638 */
639
640
641#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
642pub struct AssertApprovalWebAuthnChallengeRequest {
643    #[serde(rename = "challenge_id")]
644    pub challenge_id: String,
645    #[serde(rename = "actor")]
646    pub actor: String,
647    #[serde(rename = "assertion")]
648    pub assertion: String,
649    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
650    pub receipt_id: Option<String>,
651    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
652    pub reason: Option<String>,
653}
654
655impl AssertApprovalWebAuthnChallengeRequest {
656    pub fn new(challenge_id: String, actor: String, assertion: String) -> AssertApprovalWebAuthnChallengeRequest {
657        AssertApprovalWebAuthnChallengeRequest {
658            challenge_id,
659            actor,
660            assertion,
661            receipt_id: None,
662            reason: None,
663        }
664    }
665}
666
667/*
668 * HELM Kernel API
669 *
670 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
671 *
672 * The version of the OpenAPI document: 0.5.19
673 *
674 * Generated by: https://openapi-generator.tech
675 */
676
677
678#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
679pub struct AuthzHealth {
680    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
681    pub status: Option<String>,
682    #[serde(rename = "resolver", skip_serializing_if = "Option::is_none")]
683    pub resolver: Option<String>,
684    #[serde(rename = "model_id", skip_serializing_if = "Option::is_none")]
685    pub model_id: Option<String>,
686    #[serde(rename = "relationship_hash", skip_serializing_if = "Option::is_none")]
687    pub relationship_hash: Option<String>,
688    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
689    pub checked_at: Option<String>,
690}
691
692impl AuthzHealth {
693    pub fn new() -> AuthzHealth {
694        AuthzHealth {
695            status: None,
696            resolver: None,
697            model_id: None,
698            relationship_hash: None,
699            checked_at: None,
700        }
701    }
702}
703
704/*
705 * HELM Kernel API
706 *
707 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
708 *
709 * The version of the OpenAPI document: 0.5.19
710 *
711 * Generated by: https://openapi-generator.tech
712 */
713
714
715#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
716pub struct AuthzSnapshot {
717    #[serde(rename = "snapshot_id", skip_serializing_if = "Option::is_none")]
718    pub snapshot_id: Option<String>,
719    #[serde(rename = "model_id", skip_serializing_if = "Option::is_none")]
720    pub model_id: Option<String>,
721    #[serde(rename = "relationship_hash", skip_serializing_if = "Option::is_none")]
722    pub relationship_hash: Option<String>,
723    #[serde(rename = "tuple_count", skip_serializing_if = "Option::is_none")]
724    pub tuple_count: Option<i32>,
725    #[serde(rename = "resolver", skip_serializing_if = "Option::is_none")]
726    pub resolver: Option<String>,
727    #[serde(rename = "stale", skip_serializing_if = "Option::is_none")]
728    pub stale: Option<bool>,
729    #[serde(rename = "snapshot_token", skip_serializing_if = "Option::is_none")]
730    pub snapshot_token: Option<String>,
731    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
732    pub checked_at: Option<String>,
733    #[serde(rename = "snapshot_hash", skip_serializing_if = "Option::is_none")]
734    pub snapshot_hash: Option<String>,
735}
736
737impl AuthzSnapshot {
738    pub fn new() -> AuthzSnapshot {
739        AuthzSnapshot {
740            snapshot_id: None,
741            model_id: None,
742            relationship_hash: None,
743            tuple_count: None,
744            resolver: None,
745            stale: None,
746            snapshot_token: None,
747            checked_at: None,
748            snapshot_hash: None,
749        }
750    }
751}
752
753/*
754 * HELM Kernel API
755 *
756 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
757 *
758 * The version of the OpenAPI document: 0.5.19
759 *
760 * Generated by: https://openapi-generator.tech
761 */
762
763
764#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
765pub struct BindLaunchpadSecretGrantRequest {
766    #[serde(rename = "name")]
767    pub name: String,
768    #[serde(rename = "provider")]
769    pub provider: String,
770    #[serde(rename = "value_env")]
771    pub value_env: String,
772}
773
774impl BindLaunchpadSecretGrantRequest {
775    pub fn new(name: String, provider: String, value_env: String) -> BindLaunchpadSecretGrantRequest {
776        BindLaunchpadSecretGrantRequest {
777            name,
778            provider,
779            value_env,
780        }
781    }
782}
783
784/*
785 * HELM Kernel API
786 *
787 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
788 *
789 * The version of the OpenAPI document: 0.5.19
790 *
791 * Generated by: https://openapi-generator.tech
792 */
793
794
795#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
796pub struct BoundaryCapabilitySummary {
797    #[serde(rename = "capability_id", skip_serializing_if = "Option::is_none")]
798    pub capability_id: Option<String>,
799    #[serde(rename = "category", skip_serializing_if = "Option::is_none")]
800    pub category: Option<String>,
801    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
802    pub status: Option<String>,
803    #[serde(rename = "authority", skip_serializing_if = "Option::is_none")]
804    pub authority: Option<String>,
805    #[serde(rename = "public_routes", skip_serializing_if = "Option::is_none")]
806    pub public_routes: Option<Vec<String>>,
807    #[serde(rename = "cli_commands", skip_serializing_if = "Option::is_none")]
808    pub cli_commands: Option<Vec<String>>,
809    #[serde(rename = "receipt_bindings", skip_serializing_if = "Option::is_none")]
810    pub receipt_bindings: Option<Vec<String>>,
811    #[serde(rename = "conformance_level", skip_serializing_if = "Option::is_none")]
812    pub conformance_level: Option<String>,
813}
814
815impl BoundaryCapabilitySummary {
816    pub fn new() -> BoundaryCapabilitySummary {
817        BoundaryCapabilitySummary {
818            capability_id: None,
819            category: None,
820            status: None,
821            authority: None,
822            public_routes: None,
823            cli_commands: None,
824            receipt_bindings: None,
825            conformance_level: None,
826        }
827    }
828}
829
830/*
831 * HELM Kernel API
832 *
833 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
834 *
835 * The version of the OpenAPI document: 0.5.19
836 *
837 * Generated by: https://openapi-generator.tech
838 */
839
840
841#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
842pub struct BoundaryCheckpoint {
843    #[serde(rename = "checkpoint_id", skip_serializing_if = "Option::is_none")]
844    pub checkpoint_id: Option<String>,
845    #[serde(rename = "sequence", skip_serializing_if = "Option::is_none")]
846    pub sequence: Option<i64>,
847    #[serde(rename = "previous_checkpoint_hash", skip_serializing_if = "Option::is_none")]
848    pub previous_checkpoint_hash: Option<String>,
849    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
850    pub receipt_count: Option<i32>,
851    #[serde(rename = "record_count", skip_serializing_if = "Option::is_none")]
852    pub record_count: Option<i32>,
853    #[serde(rename = "root_hash", skip_serializing_if = "Option::is_none")]
854    pub root_hash: Option<String>,
855    #[serde(rename = "checkpoint_hash", skip_serializing_if = "Option::is_none")]
856    pub checkpoint_hash: Option<String>,
857    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
858    pub created_at: Option<String>,
859}
860
861impl BoundaryCheckpoint {
862    pub fn new() -> BoundaryCheckpoint {
863        BoundaryCheckpoint {
864            checkpoint_id: None,
865            sequence: None,
866            previous_checkpoint_hash: None,
867            receipt_count: None,
868            record_count: None,
869            root_hash: None,
870            checkpoint_hash: None,
871            created_at: None,
872        }
873    }
874}
875
876/*
877 * HELM Kernel API
878 *
879 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
880 *
881 * The version of the OpenAPI document: 0.5.19
882 *
883 * Generated by: https://openapi-generator.tech
884 */
885
886
887#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
888pub struct BoundaryRecordVerification {
889    #[serde(rename = "record_id", skip_serializing_if = "Option::is_none")]
890    pub record_id: Option<String>,
891    #[serde(rename = "record_hash", skip_serializing_if = "Option::is_none")]
892    pub record_hash: Option<String>,
893    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
894    pub receipt_id: Option<String>,
895    #[serde(rename = "verified", skip_serializing_if = "Option::is_none")]
896    pub verified: Option<bool>,
897    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
898    pub errors: Option<Vec<String>>,
899    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
900    pub checked_at: Option<String>,
901}
902
903impl BoundaryRecordVerification {
904    pub fn new() -> BoundaryRecordVerification {
905        BoundaryRecordVerification {
906            record_id: None,
907            record_hash: None,
908            receipt_id: None,
909            verified: None,
910            errors: None,
911            checked_at: None,
912        }
913    }
914}
915
916/*
917 * HELM Kernel API
918 *
919 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
920 *
921 * The version of the OpenAPI document: 0.5.19
922 *
923 * Generated by: https://openapi-generator.tech
924 */
925
926
927#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
928pub struct BoundaryStatus {
929    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
930    pub version: Option<String>,
931    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
932    pub status: Option<String>,
933    #[serde(rename = "receipt_store_ready", skip_serializing_if = "Option::is_none")]
934    pub receipt_store_ready: Option<bool>,
935    #[serde(rename = "signer_ready", skip_serializing_if = "Option::is_none")]
936    pub signer_ready: Option<bool>,
937    #[serde(rename = "open_approvals", skip_serializing_if = "Option::is_none")]
938    pub open_approvals: Option<i32>,
939    #[serde(rename = "quarantined_mcp_servers", skip_serializing_if = "Option::is_none")]
940    pub quarantined_mcp_servers: Option<i32>,
941    #[serde(rename = "last_checkpoint_id", skip_serializing_if = "Option::is_none")]
942    pub last_checkpoint_id: Option<String>,
943    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
944    pub checked_at: Option<String>,
945}
946
947impl BoundaryStatus {
948    pub fn new() -> BoundaryStatus {
949        BoundaryStatus {
950            version: None,
951            status: None,
952            receipt_store_ready: None,
953            signer_ready: None,
954            open_approvals: None,
955            quarantined_mcp_servers: None,
956            last_checkpoint_id: None,
957            checked_at: None,
958        }
959    }
960}
961
962/*
963 * HELM Kernel API
964 *
965 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
966 *
967 * The version of the OpenAPI document: 0.5.19
968 *
969 * Generated by: https://openapi-generator.tech
970 */
971
972
973#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
974pub struct BudgetCeiling {
975    #[serde(rename = "budget_id", skip_serializing_if = "Option::is_none")]
976    pub budget_id: Option<String>,
977    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
978    pub subject: Option<String>,
979    #[serde(rename = "window", skip_serializing_if = "Option::is_none")]
980    pub window: Option<String>,
981    #[serde(rename = "max_tool_calls", skip_serializing_if = "Option::is_none")]
982    pub max_tool_calls: Option<i32>,
983    #[serde(rename = "max_spend_minor", skip_serializing_if = "Option::is_none")]
984    pub max_spend_minor: Option<i64>,
985    #[serde(rename = "max_egress_bytes", skip_serializing_if = "Option::is_none")]
986    pub max_egress_bytes: Option<i64>,
987    #[serde(rename = "max_write_ops", skip_serializing_if = "Option::is_none")]
988    pub max_write_ops: Option<i32>,
989    #[serde(rename = "approval_required_after", skip_serializing_if = "Option::is_none")]
990    pub approval_required_after: Option<i32>,
991    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
992    pub policy_epoch: Option<String>,
993}
994
995impl BudgetCeiling {
996    pub fn new() -> BudgetCeiling {
997        BudgetCeiling {
998            budget_id: None,
999            subject: None,
1000            window: None,
1001            max_tool_calls: None,
1002            max_spend_minor: None,
1003            max_egress_bytes: None,
1004            max_write_ops: None,
1005            approval_required_after: None,
1006            policy_epoch: None,
1007        }
1008    }
1009}
1010
1011/*
1012 * HELM Kernel API
1013 *
1014 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1015 *
1016 * The version of the OpenAPI document: 0.5.19
1017 *
1018 * Generated by: https://openapi-generator.tech
1019 */
1020
1021
1022#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1023pub struct BuildStrategy {
1024    #[serde(rename = "strategy", skip_serializing_if = "Option::is_none")]
1025    pub strategy: Option<String>,
1026    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
1027    pub confidence: Option<f64>,
1028    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
1029    pub reason: Option<String>,
1030    #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
1031    pub commands: Option<Vec<Vec<String>>>,
1032    #[serde(rename = "manifest_sources", skip_serializing_if = "Option::is_none")]
1033    pub manifest_sources: Option<Vec<String>>,
1034}
1035
1036impl BuildStrategy {
1037    pub fn new() -> BuildStrategy {
1038        BuildStrategy {
1039            strategy: None,
1040            confidence: None,
1041            reason: None,
1042            commands: None,
1043            manifest_sources: None,
1044        }
1045    }
1046}
1047
1048/*
1049 * HELM Kernel API
1050 *
1051 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1052 *
1053 * The version of the OpenAPI document: 0.5.19
1054 *
1055 * Generated by: https://openapi-generator.tech
1056 */
1057
1058
1059#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1060pub struct CapabilityGraph {
1061    #[serde(rename = "capabilities", skip_serializing_if = "Option::is_none")]
1062    pub capabilities: Option<Vec<String>>,
1063    #[serde(rename = "modules", skip_serializing_if = "Option::is_none")]
1064    pub modules: Option<Vec<DetectedModule>>,
1065    #[serde(rename = "frameworks", skip_serializing_if = "Option::is_none")]
1066    pub frameworks: Option<Vec<DetectedFramework>>,
1067    #[serde(rename = "secrets", skip_serializing_if = "Option::is_none")]
1068    pub secrets: Option<Vec<SecretContract>>,
1069    #[serde(rename = "oauth", skip_serializing_if = "Option::is_none")]
1070    pub oauth: Option<Vec<OAuthRequirement>>,
1071    #[serde(rename = "ports", skip_serializing_if = "Option::is_none")]
1072    pub ports: Option<Vec<i32>>,
1073    #[serde(rename = "build_signals", skip_serializing_if = "Option::is_none")]
1074    pub build_signals: Option<Vec<String>>,
1075    #[serde(rename = "runtime_signals", skip_serializing_if = "Option::is_none")]
1076    pub runtime_signals: Option<Vec<String>>,
1077    #[serde(rename = "policy_signals", skip_serializing_if = "Option::is_none")]
1078    pub policy_signals: Option<Vec<String>>,
1079    #[serde(rename = "security_signals", skip_serializing_if = "Option::is_none")]
1080    pub security_signals: Option<Vec<String>>,
1081    #[serde(rename = "adapter_matches", skip_serializing_if = "Option::is_none")]
1082    pub adapter_matches: Option<Vec<AdapterMatch>>,
1083    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
1084    pub confidence: Option<f64>,
1085    #[serde(rename = "confidence_reason", skip_serializing_if = "Option::is_none")]
1086    pub confidence_reason: Option<String>,
1087}
1088
1089impl CapabilityGraph {
1090    pub fn new() -> CapabilityGraph {
1091        CapabilityGraph {
1092            capabilities: None,
1093            modules: None,
1094            frameworks: None,
1095            secrets: None,
1096            oauth: None,
1097            ports: None,
1098            build_signals: None,
1099            runtime_signals: None,
1100            policy_signals: None,
1101            security_signals: None,
1102            adapter_matches: None,
1103            confidence: None,
1104            confidence_reason: None,
1105        }
1106    }
1107}
1108
1109/*
1110 * HELM Kernel API
1111 *
1112 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1113 *
1114 * The version of the OpenAPI document: 0.5.19
1115 *
1116 * Generated by: https://openapi-generator.tech
1117 */
1118
1119
1120#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1121pub struct ChatCompletionRequest {
1122    #[serde(rename = "model")]
1123    pub model: String,
1124    #[serde(rename = "messages")]
1125    pub messages: Vec<ChatCompletionRequestMessagesInner>,
1126    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
1127    pub tools: Option<Vec<ChatCompletionRequestToolsInner>>,
1128    #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")]
1129    pub temperature: Option<f64>,
1130    #[serde(rename = "max_tokens", skip_serializing_if = "Option::is_none")]
1131    pub max_tokens: Option<i32>,
1132    #[serde(rename = "stream", skip_serializing_if = "Option::is_none")]
1133    pub stream: Option<bool>,
1134}
1135
1136impl ChatCompletionRequest {
1137    pub fn new(model: String, messages: Vec<ChatCompletionRequestMessagesInner>) -> ChatCompletionRequest {
1138        ChatCompletionRequest {
1139            model,
1140            messages,
1141            tools: None,
1142            temperature: None,
1143            max_tokens: None,
1144            stream: None,
1145        }
1146    }
1147}
1148
1149/*
1150 * HELM Kernel API
1151 *
1152 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1153 *
1154 * The version of the OpenAPI document: 0.5.19
1155 *
1156 * Generated by: https://openapi-generator.tech
1157 */
1158
1159
1160#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1161pub struct ChatCompletionRequestMessagesInner {
1162    #[serde(rename = "role")]
1163    pub role: ChatCompletionRequestMessagesInnerRole,
1164    #[serde(rename = "content")]
1165    pub content: String,
1166    #[serde(rename = "tool_call_id", skip_serializing_if = "Option::is_none")]
1167    pub tool_call_id: Option<String>,
1168}
1169
1170impl ChatCompletionRequestMessagesInner {
1171    pub fn new(role: ChatCompletionRequestMessagesInnerRole, content: String) -> ChatCompletionRequestMessagesInner {
1172        ChatCompletionRequestMessagesInner {
1173            role,
1174            content,
1175            tool_call_id: None,
1176        }
1177    }
1178}
1179///
1180#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1181pub enum ChatCompletionRequestMessagesInnerRole {
1182    #[serde(rename = "system")]
1183    System,
1184    #[serde(rename = "user")]
1185    User,
1186    #[serde(rename = "assistant")]
1187    Assistant,
1188    #[serde(rename = "tool")]
1189    Tool,
1190}
1191
1192impl Default for ChatCompletionRequestMessagesInnerRole {
1193    fn default() -> ChatCompletionRequestMessagesInnerRole {
1194        Self::System
1195    }
1196}
1197
1198/*
1199 * HELM Kernel API
1200 *
1201 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1202 *
1203 * The version of the OpenAPI document: 0.5.19
1204 *
1205 * Generated by: https://openapi-generator.tech
1206 */
1207
1208
1209#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1210pub struct ChatCompletionRequestToolsInner {
1211    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
1212    pub r#type: Option<ChatCompletionRequestToolsInnerType>,
1213    #[serde(rename = "function", skip_serializing_if = "Option::is_none")]
1214    pub function: Option<Box<ChatCompletionRequestToolsInnerFunction>>,
1215}
1216
1217impl ChatCompletionRequestToolsInner {
1218    pub fn new() -> ChatCompletionRequestToolsInner {
1219        ChatCompletionRequestToolsInner {
1220            r#type: None,
1221            function: None,
1222        }
1223    }
1224}
1225///
1226#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1227pub enum ChatCompletionRequestToolsInnerType {
1228    #[serde(rename = "function")]
1229    Function,
1230}
1231
1232impl Default for ChatCompletionRequestToolsInnerType {
1233    fn default() -> ChatCompletionRequestToolsInnerType {
1234        Self::Function
1235    }
1236}
1237
1238/*
1239 * HELM Kernel API
1240 *
1241 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1242 *
1243 * The version of the OpenAPI document: 0.5.19
1244 *
1245 * Generated by: https://openapi-generator.tech
1246 */
1247
1248
1249#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1250pub struct ChatCompletionRequestToolsInnerFunction {
1251    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
1252    pub name: Option<String>,
1253    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
1254    pub description: Option<String>,
1255    #[serde(rename = "parameters", skip_serializing_if = "Option::is_none")]
1256    pub parameters: Option<serde_json::Value>,
1257}
1258
1259impl ChatCompletionRequestToolsInnerFunction {
1260    pub fn new() -> ChatCompletionRequestToolsInnerFunction {
1261        ChatCompletionRequestToolsInnerFunction {
1262            name: None,
1263            description: None,
1264            parameters: None,
1265        }
1266    }
1267}
1268
1269/*
1270 * HELM Kernel API
1271 *
1272 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1273 *
1274 * The version of the OpenAPI document: 0.5.19
1275 *
1276 * Generated by: https://openapi-generator.tech
1277 */
1278
1279
1280#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1281pub struct ChatCompletionResponse {
1282    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
1283    pub id: Option<String>,
1284    #[serde(rename = "object", skip_serializing_if = "Option::is_none")]
1285    pub object: Option<String>,
1286    #[serde(rename = "created", skip_serializing_if = "Option::is_none")]
1287    pub created: Option<i32>,
1288    #[serde(rename = "model", skip_serializing_if = "Option::is_none")]
1289    pub model: Option<String>,
1290    #[serde(rename = "choices", skip_serializing_if = "Option::is_none")]
1291    pub choices: Option<Vec<ChatCompletionResponseChoicesInner>>,
1292    #[serde(rename = "usage", skip_serializing_if = "Option::is_none")]
1293    pub usage: Option<Box<ChatCompletionResponseUsage>>,
1294}
1295
1296impl ChatCompletionResponse {
1297    pub fn new() -> ChatCompletionResponse {
1298        ChatCompletionResponse {
1299            id: None,
1300            object: None,
1301            created: None,
1302            model: None,
1303            choices: None,
1304            usage: None,
1305        }
1306    }
1307}
1308
1309/*
1310 * HELM Kernel API
1311 *
1312 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1313 *
1314 * The version of the OpenAPI document: 0.5.19
1315 *
1316 * Generated by: https://openapi-generator.tech
1317 */
1318
1319
1320#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1321pub struct ChatCompletionResponseChoicesInner {
1322    #[serde(rename = "index", skip_serializing_if = "Option::is_none")]
1323    pub index: Option<i32>,
1324    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
1325    pub message: Option<Box<ChatCompletionResponseChoicesInnerMessage>>,
1326    #[serde(rename = "finish_reason", skip_serializing_if = "Option::is_none")]
1327    pub finish_reason: Option<String>,
1328}
1329
1330impl ChatCompletionResponseChoicesInner {
1331    pub fn new() -> ChatCompletionResponseChoicesInner {
1332        ChatCompletionResponseChoicesInner {
1333            index: None,
1334            message: None,
1335            finish_reason: None,
1336        }
1337    }
1338}
1339
1340/*
1341 * HELM Kernel API
1342 *
1343 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1344 *
1345 * The version of the OpenAPI document: 0.5.19
1346 *
1347 * Generated by: https://openapi-generator.tech
1348 */
1349
1350
1351#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1352pub struct ChatCompletionResponseChoicesInnerMessage {
1353    #[serde(rename = "role", skip_serializing_if = "Option::is_none")]
1354    pub role: Option<String>,
1355    #[serde(rename = "content", default, skip_serializing_if = "Option::is_none")]
1356    pub content: Option<Option<String>>,
1357    #[serde(rename = "tool_calls", skip_serializing_if = "Option::is_none")]
1358    pub tool_calls: Option<Vec<ChatCompletionResponseChoicesInnerMessageToolCallsInner>>,
1359}
1360
1361impl ChatCompletionResponseChoicesInnerMessage {
1362    pub fn new() -> ChatCompletionResponseChoicesInnerMessage {
1363        ChatCompletionResponseChoicesInnerMessage {
1364            role: None,
1365            content: None,
1366            tool_calls: None,
1367        }
1368    }
1369}
1370
1371/*
1372 * HELM Kernel API
1373 *
1374 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1375 *
1376 * The version of the OpenAPI document: 0.5.19
1377 *
1378 * Generated by: https://openapi-generator.tech
1379 */
1380
1381
1382#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1383pub struct ChatCompletionResponseChoicesInnerMessageToolCallsInner {
1384    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
1385    pub id: Option<String>,
1386    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
1387    pub r#type: Option<String>,
1388    #[serde(rename = "function", skip_serializing_if = "Option::is_none")]
1389    pub function: Option<Box<ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction>>,
1390}
1391
1392impl ChatCompletionResponseChoicesInnerMessageToolCallsInner {
1393    pub fn new() -> ChatCompletionResponseChoicesInnerMessageToolCallsInner {
1394        ChatCompletionResponseChoicesInnerMessageToolCallsInner {
1395            id: None,
1396            r#type: None,
1397            function: None,
1398        }
1399    }
1400}
1401
1402/*
1403 * HELM Kernel API
1404 *
1405 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1406 *
1407 * The version of the OpenAPI document: 0.5.19
1408 *
1409 * Generated by: https://openapi-generator.tech
1410 */
1411
1412
1413#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1414pub struct ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
1415    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
1416    pub name: Option<String>,
1417    #[serde(rename = "arguments", skip_serializing_if = "Option::is_none")]
1418    pub arguments: Option<String>,
1419}
1420
1421impl ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
1422    pub fn new() -> ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
1423        ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
1424            name: None,
1425            arguments: None,
1426        }
1427    }
1428}
1429
1430/*
1431 * HELM Kernel API
1432 *
1433 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1434 *
1435 * The version of the OpenAPI document: 0.5.19
1436 *
1437 * Generated by: https://openapi-generator.tech
1438 */
1439
1440
1441#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1442pub struct ChatCompletionResponseUsage {
1443    #[serde(rename = "prompt_tokens", skip_serializing_if = "Option::is_none")]
1444    pub prompt_tokens: Option<i32>,
1445    #[serde(rename = "completion_tokens", skip_serializing_if = "Option::is_none")]
1446    pub completion_tokens: Option<i32>,
1447    #[serde(rename = "total_tokens", skip_serializing_if = "Option::is_none")]
1448    pub total_tokens: Option<i32>,
1449}
1450
1451impl ChatCompletionResponseUsage {
1452    pub fn new() -> ChatCompletionResponseUsage {
1453        ChatCompletionResponseUsage {
1454            prompt_tokens: None,
1455            completion_tokens: None,
1456            total_tokens: None,
1457        }
1458    }
1459}
1460
1461/*
1462 * HELM Kernel API
1463 *
1464 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1465 *
1466 * The version of the OpenAPI document: 0.5.19
1467 *
1468 * Generated by: https://openapi-generator.tech
1469 */
1470
1471
1472#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1473pub struct CoexistenceCapabilityManifest {
1474    #[serde(rename = "manifest_id", skip_serializing_if = "Option::is_none")]
1475    pub manifest_id: Option<String>,
1476    #[serde(rename = "authority", skip_serializing_if = "Option::is_none")]
1477    pub authority: Option<String>,
1478    #[serde(rename = "boundary_role", skip_serializing_if = "Option::is_none")]
1479    pub boundary_role: Option<String>,
1480    #[serde(rename = "supported_inputs", skip_serializing_if = "Option::is_none")]
1481    pub supported_inputs: Option<Vec<String>>,
1482    #[serde(rename = "export_surfaces", skip_serializing_if = "Option::is_none")]
1483    pub export_surfaces: Option<Vec<String>>,
1484    #[serde(rename = "receipt_bindings", skip_serializing_if = "Option::is_none")]
1485    pub receipt_bindings: Option<Vec<String>>,
1486    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
1487    pub generated_at: Option<String>,
1488}
1489
1490impl CoexistenceCapabilityManifest {
1491    pub fn new() -> CoexistenceCapabilityManifest {
1492        CoexistenceCapabilityManifest {
1493            manifest_id: None,
1494            authority: None,
1495            boundary_role: None,
1496            supported_inputs: None,
1497            export_surfaces: None,
1498            receipt_bindings: None,
1499            generated_at: None,
1500        }
1501    }
1502}
1503
1504/*
1505 * HELM Kernel API
1506 *
1507 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1508 *
1509 * The version of the OpenAPI document: 0.5.19
1510 *
1511 * Generated by: https://openapi-generator.tech
1512 */
1513
1514
1515#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1516pub struct ConformanceRequest {
1517    #[serde(rename = "level")]
1518    pub level: ConformanceRequestLevel,
1519    #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
1520    pub profile: Option<String>,
1521}
1522
1523impl ConformanceRequest {
1524    pub fn new(level: ConformanceRequestLevel) -> ConformanceRequest {
1525        ConformanceRequest {
1526            level,
1527            profile: None,
1528        }
1529    }
1530}
1531///
1532#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1533pub enum ConformanceRequestLevel {
1534    #[serde(rename = "L1")]
1535    L1,
1536    #[serde(rename = "L2")]
1537    L2,
1538}
1539
1540impl Default for ConformanceRequestLevel {
1541    fn default() -> ConformanceRequestLevel {
1542        Self::L1
1543    }
1544}
1545
1546/*
1547 * HELM Kernel API
1548 *
1549 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1550 *
1551 * The version of the OpenAPI document: 0.5.19
1552 *
1553 * Generated by: https://openapi-generator.tech
1554 */
1555
1556
1557#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1558pub struct ConformanceResult {
1559    #[serde(rename = "report_id", skip_serializing_if = "Option::is_none")]
1560    pub report_id: Option<String>,
1561    #[serde(rename = "level", skip_serializing_if = "Option::is_none")]
1562    pub level: Option<String>,
1563    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
1564    pub verdict: Option<ConformanceResultVerdict>,
1565    #[serde(rename = "gates", skip_serializing_if = "Option::is_none")]
1566    pub gates: Option<i32>,
1567    #[serde(rename = "failed", skip_serializing_if = "Option::is_none")]
1568    pub failed: Option<i32>,
1569    #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
1570    pub details: Option<std::collections::HashMap<String, String>>,
1571}
1572
1573impl ConformanceResult {
1574    pub fn new() -> ConformanceResult {
1575        ConformanceResult {
1576            report_id: None,
1577            level: None,
1578            verdict: None,
1579            gates: None,
1580            failed: None,
1581            details: None,
1582        }
1583    }
1584}
1585///
1586#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1587pub enum ConformanceResultVerdict {
1588    #[serde(rename = "PASS")]
1589    Pass,
1590    #[serde(rename = "FAIL")]
1591    Fail,
1592}
1593
1594impl Default for ConformanceResultVerdict {
1595    fn default() -> ConformanceResultVerdict {
1596        Self::Pass
1597    }
1598}
1599
1600/*
1601 * HELM Kernel API
1602 *
1603 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1604 *
1605 * The version of the OpenAPI document: 0.5.19
1606 *
1607 * Generated by: https://openapi-generator.tech
1608 */
1609
1610
1611#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1612pub struct ConsoleBootstrap {
1613    #[serde(rename = "version")]
1614    pub version: Box<VersionInfo>,
1615    #[serde(rename = "workspace")]
1616    pub workspace: Box<ConsoleBootstrapWorkspace>,
1617    #[serde(rename = "health")]
1618    pub health: Box<ConsoleBootstrapHealth>,
1619    #[serde(rename = "counts")]
1620    pub counts: Box<ConsoleBootstrapCounts>,
1621    #[serde(rename = "receipts")]
1622    pub receipts: Vec<Receipt>,
1623    #[serde(rename = "conformance")]
1624    pub conformance: Box<ConsoleBootstrapConformance>,
1625    #[serde(rename = "mcp")]
1626    pub mcp: Box<ConsoleBootstrapMcp>,
1627}
1628
1629impl ConsoleBootstrap {
1630    pub fn new(version: VersionInfo, workspace: ConsoleBootstrapWorkspace, health: ConsoleBootstrapHealth, counts: ConsoleBootstrapCounts, receipts: Vec<Receipt>, conformance: ConsoleBootstrapConformance, mcp: ConsoleBootstrapMcp) -> ConsoleBootstrap {
1631        ConsoleBootstrap {
1632            version: Box::new(version),
1633            workspace: Box::new(workspace),
1634            health: Box::new(health),
1635            counts: Box::new(counts),
1636            receipts,
1637            conformance: Box::new(conformance),
1638            mcp: Box::new(mcp),
1639        }
1640    }
1641}
1642
1643/*
1644 * HELM Kernel API
1645 *
1646 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1647 *
1648 * The version of the OpenAPI document: 0.5.19
1649 *
1650 * Generated by: https://openapi-generator.tech
1651 */
1652
1653
1654#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1655pub struct ConsoleBootstrapConformance {
1656    #[serde(rename = "level")]
1657    pub level: String,
1658    #[serde(rename = "status")]
1659    pub status: String,
1660    #[serde(rename = "report_id", skip_serializing_if = "Option::is_none")]
1661    pub report_id: Option<String>,
1662}
1663
1664impl ConsoleBootstrapConformance {
1665    pub fn new(level: String, status: String) -> ConsoleBootstrapConformance {
1666        ConsoleBootstrapConformance {
1667            level,
1668            status,
1669            report_id: None,
1670        }
1671    }
1672}
1673
1674/*
1675 * HELM Kernel API
1676 *
1677 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1678 *
1679 * The version of the OpenAPI document: 0.5.19
1680 *
1681 * Generated by: https://openapi-generator.tech
1682 */
1683
1684
1685#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1686pub struct ConsoleBootstrapCounts {
1687    #[serde(rename = "receipts")]
1688    pub receipts: i32,
1689    #[serde(rename = "pending_approvals")]
1690    pub pending_approvals: i32,
1691    #[serde(rename = "open_incidents")]
1692    pub open_incidents: i32,
1693    #[serde(rename = "mcp_tools")]
1694    pub mcp_tools: i32,
1695}
1696
1697impl ConsoleBootstrapCounts {
1698    pub fn new(receipts: i32, pending_approvals: i32, open_incidents: i32, mcp_tools: i32) -> ConsoleBootstrapCounts {
1699        ConsoleBootstrapCounts {
1700            receipts,
1701            pending_approvals,
1702            open_incidents,
1703            mcp_tools,
1704        }
1705    }
1706}
1707
1708/*
1709 * HELM Kernel API
1710 *
1711 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1712 *
1713 * The version of the OpenAPI document: 0.5.19
1714 *
1715 * Generated by: https://openapi-generator.tech
1716 */
1717
1718
1719#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1720pub struct ConsoleBootstrapHealth {
1721    #[serde(rename = "kernel")]
1722    pub kernel: String,
1723    #[serde(rename = "policy")]
1724    pub policy: String,
1725    #[serde(rename = "store")]
1726    pub store: String,
1727    #[serde(rename = "conformance")]
1728    pub conformance: String,
1729}
1730
1731impl ConsoleBootstrapHealth {
1732    pub fn new(kernel: String, policy: String, store: String, conformance: String) -> ConsoleBootstrapHealth {
1733        ConsoleBootstrapHealth {
1734            kernel,
1735            policy,
1736            store,
1737            conformance,
1738        }
1739    }
1740}
1741
1742/*
1743 * HELM Kernel API
1744 *
1745 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1746 *
1747 * The version of the OpenAPI document: 0.5.19
1748 *
1749 * Generated by: https://openapi-generator.tech
1750 */
1751
1752
1753#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1754pub struct ConsoleBootstrapMcp {
1755    #[serde(rename = "authorization")]
1756    pub authorization: String,
1757    #[serde(rename = "scopes")]
1758    pub scopes: Vec<String>,
1759}
1760
1761impl ConsoleBootstrapMcp {
1762    pub fn new(authorization: String, scopes: Vec<String>) -> ConsoleBootstrapMcp {
1763        ConsoleBootstrapMcp {
1764            authorization,
1765            scopes,
1766        }
1767    }
1768}
1769
1770/*
1771 * HELM Kernel API
1772 *
1773 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1774 *
1775 * The version of the OpenAPI document: 0.5.19
1776 *
1777 * Generated by: https://openapi-generator.tech
1778 */
1779
1780
1781#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1782pub struct ConsoleBootstrapWorkspace {
1783    #[serde(rename = "organization")]
1784    pub organization: String,
1785    #[serde(rename = "project")]
1786    pub project: String,
1787    #[serde(rename = "environment")]
1788    pub environment: String,
1789    #[serde(rename = "mode")]
1790    pub mode: String,
1791}
1792
1793impl ConsoleBootstrapWorkspace {
1794    pub fn new(organization: String, project: String, environment: String, mode: String) -> ConsoleBootstrapWorkspace {
1795        ConsoleBootstrapWorkspace {
1796            organization,
1797            project,
1798            environment,
1799            mode,
1800        }
1801    }
1802}
1803
1804/*
1805 * HELM Kernel API
1806 *
1807 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1808 *
1809 * The version of the OpenAPI document: 0.5.19
1810 *
1811 * Generated by: https://openapi-generator.tech
1812 */
1813
1814
1815#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1816pub struct ConsoleCapabilities {
1817    #[serde(rename = "entitlements")]
1818    pub entitlements: Vec<String>,
1819    #[serde(rename = "version")]
1820    pub version: String,
1821    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
1822    pub source: Option<String>,
1823    #[serde(rename = "tier_gate", skip_serializing_if = "Option::is_none")]
1824    pub tier_gate: Option<String>,
1825}
1826
1827impl ConsoleCapabilities {
1828    pub fn new(entitlements: Vec<String>, version: String) -> ConsoleCapabilities {
1829        ConsoleCapabilities {
1830            entitlements,
1831            version,
1832            source: None,
1833            tier_gate: None,
1834        }
1835    }
1836}
1837
1838/*
1839 * HELM Kernel API
1840 *
1841 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1842 *
1843 * The version of the OpenAPI document: 0.5.19
1844 *
1845 * Generated by: https://openapi-generator.tech
1846 */
1847
1848
1849#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1850pub struct ConsoleDiagnostics {
1851    #[serde(rename = "generated_at")]
1852    pub generated_at: String,
1853    #[serde(rename = "runtime")]
1854    pub runtime: std::collections::HashMap<String, serde_json::Value>,
1855    #[serde(rename = "access")]
1856    pub access: std::collections::HashMap<String, serde_json::Value>,
1857    #[serde(rename = "stores")]
1858    pub stores: Vec<ConsoleStoreDiagnostic>,
1859    #[serde(rename = "routes")]
1860    pub routes: Vec<ConsoleRouteDiagnostic>,
1861}
1862
1863impl ConsoleDiagnostics {
1864    pub fn new(generated_at: String, runtime: std::collections::HashMap<String, serde_json::Value>, access: std::collections::HashMap<String, serde_json::Value>, stores: Vec<ConsoleStoreDiagnostic>, routes: Vec<ConsoleRouteDiagnostic>) -> ConsoleDiagnostics {
1865        ConsoleDiagnostics {
1866            generated_at,
1867            runtime,
1868            access,
1869            stores,
1870            routes,
1871        }
1872    }
1873}
1874
1875/*
1876 * HELM Kernel API
1877 *
1878 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1879 *
1880 * The version of the OpenAPI document: 0.5.19
1881 *
1882 * Generated by: https://openapi-generator.tech
1883 */
1884
1885
1886#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1887pub struct ConsoleRouteDiagnostic {
1888    #[serde(rename = "method")]
1889    pub method: String,
1890    #[serde(rename = "path")]
1891    pub path: String,
1892    #[serde(rename = "mux_pattern", skip_serializing_if = "Option::is_none")]
1893    pub mux_pattern: Option<String>,
1894    #[serde(rename = "auth")]
1895    pub auth: String,
1896    #[serde(rename = "rate_limit", skip_serializing_if = "Option::is_none")]
1897    pub rate_limit: Option<String>,
1898    #[serde(rename = "contract_status")]
1899    pub contract_status: String,
1900    #[serde(rename = "operation_id")]
1901    pub operation_id: String,
1902    #[serde(rename = "owner")]
1903    pub owner: String,
1904    #[serde(rename = "group")]
1905    pub group: String,
1906    #[serde(rename = "ui_coverage", skip_serializing_if = "Option::is_none")]
1907    pub ui_coverage: Option<String>,
1908    #[serde(rename = "unsupported_reason", skip_serializing_if = "Option::is_none")]
1909    pub unsupported_reason: Option<String>,
1910}
1911
1912impl ConsoleRouteDiagnostic {
1913    pub fn new(method: String, path: String, auth: String, contract_status: String, operation_id: String, owner: String, group: String) -> ConsoleRouteDiagnostic {
1914        ConsoleRouteDiagnostic {
1915            method,
1916            path,
1917            mux_pattern: None,
1918            auth,
1919            rate_limit: None,
1920            contract_status,
1921            operation_id,
1922            owner,
1923            group,
1924            ui_coverage: None,
1925            unsupported_reason: None,
1926        }
1927    }
1928}
1929
1930/*
1931 * HELM Kernel API
1932 *
1933 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1934 *
1935 * The version of the OpenAPI document: 0.5.19
1936 *
1937 * Generated by: https://openapi-generator.tech
1938 */
1939
1940
1941#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1942pub struct ConsoleStoreDiagnostic {
1943    #[serde(rename = "id")]
1944    pub id: String,
1945    #[serde(rename = "label")]
1946    pub label: String,
1947    #[serde(rename = "status")]
1948    pub status: String,
1949    #[serde(rename = "backend")]
1950    pub backend: String,
1951    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
1952    pub source: Option<String>,
1953    #[serde(rename = "path", skip_serializing_if = "Option::is_none")]
1954    pub path: Option<String>,
1955    #[serde(rename = "detail", skip_serializing_if = "Option::is_none")]
1956    pub detail: Option<String>,
1957}
1958
1959impl ConsoleStoreDiagnostic {
1960    pub fn new(id: String, label: String, status: String, backend: String) -> ConsoleStoreDiagnostic {
1961        ConsoleStoreDiagnostic {
1962            id,
1963            label,
1964            status,
1965            backend,
1966            source: None,
1967            path: None,
1968            detail: None,
1969        }
1970    }
1971}
1972
1973/*
1974 * HELM Kernel API
1975 *
1976 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
1977 *
1978 * The version of the OpenAPI document: 0.5.19
1979 *
1980 * Generated by: https://openapi-generator.tech
1981 */
1982
1983
1984#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1985pub struct ConsoleSurfaceRef {
1986    #[serde(rename = "id")]
1987    pub id: String,
1988    #[serde(rename = "label", skip_serializing_if = "Option::is_none")]
1989    pub label: Option<String>,
1990    #[serde(rename = "group", skip_serializing_if = "Option::is_none")]
1991    pub group: Option<String>,
1992    #[serde(rename = "source")]
1993    pub source: String,
1994    #[serde(rename = "auth", skip_serializing_if = "Option::is_none")]
1995    pub auth: Option<String>,
1996    #[serde(rename = "contract_status", skip_serializing_if = "Option::is_none")]
1997    pub contract_status: Option<String>,
1998    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
1999    pub status: Option<String>,
2000    #[serde(rename = "unsupported_reason", skip_serializing_if = "Option::is_none")]
2001    pub unsupported_reason: Option<String>,
2002    #[serde(rename = "routes", skip_serializing_if = "Option::is_none")]
2003    pub routes: Option<Vec<ConsoleRouteDiagnostic>>,
2004}
2005
2006impl ConsoleSurfaceRef {
2007    pub fn new(id: String, source: String) -> ConsoleSurfaceRef {
2008        ConsoleSurfaceRef {
2009            id,
2010            label: None,
2011            group: None,
2012            source,
2013            auth: None,
2014            contract_status: None,
2015            status: None,
2016            unsupported_reason: None,
2017            routes: None,
2018        }
2019    }
2020}
2021
2022/*
2023 * HELM Kernel API
2024 *
2025 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2026 *
2027 * The version of the OpenAPI document: 0.5.19
2028 *
2029 * Generated by: https://openapi-generator.tech
2030 */
2031
2032
2033#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2034pub struct ConsoleSurfaceState {
2035    #[serde(rename = "id")]
2036    pub id: String,
2037    #[serde(rename = "status")]
2038    pub status: String,
2039    #[serde(rename = "source")]
2040    pub source: String,
2041    #[serde(rename = "generated_at")]
2042    pub generated_at: String,
2043    #[serde(rename = "summary", skip_serializing_if = "Option::is_none")]
2044    pub summary: Option<std::collections::HashMap<String, serde_json::Value>>,
2045    #[serde(rename = "records", skip_serializing_if = "Option::is_none")]
2046    pub records: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
2047}
2048
2049impl ConsoleSurfaceState {
2050    pub fn new(id: String, status: String, source: String, generated_at: String) -> ConsoleSurfaceState {
2051        ConsoleSurfaceState {
2052            id,
2053            status,
2054            source,
2055            generated_at,
2056            summary: None,
2057            records: None,
2058        }
2059    }
2060}
2061
2062/*
2063 * HELM Kernel API
2064 *
2065 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2066 *
2067 * The version of the OpenAPI document: 0.5.19
2068 *
2069 * Generated by: https://openapi-generator.tech
2070 */
2071
2072
2073#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2074pub struct CreateApprovalWebAuthnChallengeRequest {
2075    #[serde(rename = "method", skip_serializing_if = "Option::is_none")]
2076    pub method: Option<String>,
2077    #[serde(rename = "ttl_ms", skip_serializing_if = "Option::is_none")]
2078    pub ttl_ms: Option<i32>,
2079}
2080
2081impl CreateApprovalWebAuthnChallengeRequest {
2082    pub fn new() -> CreateApprovalWebAuthnChallengeRequest {
2083        CreateApprovalWebAuthnChallengeRequest {
2084            method: None,
2085            ttl_ms: None,
2086        }
2087    }
2088}
2089
2090/*
2091 * HELM Kernel API
2092 *
2093 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2094 *
2095 * The version of the OpenAPI document: 0.5.19
2096 *
2097 * Generated by: https://openapi-generator.tech
2098 */
2099
2100
2101#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2102pub struct CreateLaunchpadImport202Response {
2103    #[serde(rename = "import")]
2104    pub import: Box<LaunchpadImportRecord>,
2105    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
2106    pub cli_equivalent: Option<String>,
2107}
2108
2109impl CreateLaunchpadImport202Response {
2110    pub fn new(import: LaunchpadImportRecord) -> CreateLaunchpadImport202Response {
2111        CreateLaunchpadImport202Response {
2112            import: Box::new(import),
2113            cli_equivalent: None,
2114        }
2115    }
2116}
2117
2118/*
2119 * HELM Kernel API
2120 *
2121 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2122 *
2123 * The version of the OpenAPI document: 0.5.19
2124 *
2125 * Generated by: https://openapi-generator.tech
2126 */
2127
2128
2129#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2130pub struct CreateSandboxGrantRequest {
2131    #[serde(rename = "runtime", skip_serializing_if = "Option::is_none")]
2132    pub runtime: Option<String>,
2133    #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
2134    pub profile: Option<String>,
2135    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
2136    pub image_digest: Option<String>,
2137    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
2138    pub policy_epoch: Option<String>,
2139}
2140
2141impl CreateSandboxGrantRequest {
2142    pub fn new() -> CreateSandboxGrantRequest {
2143        CreateSandboxGrantRequest {
2144            runtime: None,
2145            profile: None,
2146            image_digest: None,
2147            policy_epoch: None,
2148        }
2149    }
2150}
2151
2152/*
2153 * HELM Kernel API
2154 *
2155 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2156 *
2157 * The version of the OpenAPI document: 0.5.19
2158 *
2159 * Generated by: https://openapi-generator.tech
2160 */
2161
2162
2163#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2164pub struct DecisionRecord {
2165    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
2166    pub id: Option<String>,
2167    #[serde(rename = "action", skip_serializing_if = "Option::is_none")]
2168    pub action: Option<String>,
2169    #[serde(rename = "resource", skip_serializing_if = "Option::is_none")]
2170    pub resource: Option<String>,
2171    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
2172    pub verdict: Option<String>,
2173    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
2174    pub reason: Option<String>,
2175    #[serde(rename = "policy_version", skip_serializing_if = "Option::is_none")]
2176    pub policy_version: Option<String>,
2177    #[serde(rename = "policy_decision_hash", skip_serializing_if = "Option::is_none")]
2178    pub policy_decision_hash: Option<String>,
2179    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
2180    pub signature: Option<String>,
2181}
2182
2183impl DecisionRecord {
2184    pub fn new() -> DecisionRecord {
2185        DecisionRecord {
2186            id: None,
2187            action: None,
2188            resource: None,
2189            verdict: None,
2190            reason: None,
2191            policy_version: None,
2192            policy_decision_hash: None,
2193            signature: None,
2194        }
2195    }
2196}
2197
2198/*
2199 * HELM Kernel API
2200 *
2201 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2202 *
2203 * The version of the OpenAPI document: 0.5.19
2204 *
2205 * Generated by: https://openapi-generator.tech
2206 */
2207
2208
2209#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2210pub struct DecisionRequest {
2211    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
2212    pub principal: Option<String>,
2213    #[serde(rename = "action")]
2214    pub action: String,
2215    #[serde(rename = "resource")]
2216    pub resource: String,
2217    #[serde(rename = "context", skip_serializing_if = "Option::is_none")]
2218    pub context: Option<std::collections::HashMap<String, serde_json::Value>>,
2219}
2220
2221impl DecisionRequest {
2222    pub fn new(action: String, resource: String) -> DecisionRequest {
2223        DecisionRequest {
2224            principal: None,
2225            action,
2226            resource,
2227            context: None,
2228        }
2229    }
2230}
2231
2232/*
2233 * HELM Kernel API
2234 *
2235 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2236 *
2237 * The version of the OpenAPI document: 0.5.19
2238 *
2239 * Generated by: https://openapi-generator.tech
2240 */
2241
2242
2243#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2244pub struct DetectedFramework {
2245    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
2246    pub id: Option<String>,
2247    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
2248    pub name: Option<String>,
2249    #[serde(rename = "confidence", skip_serializing_if = "Option::is_none")]
2250    pub confidence: Option<f64>,
2251    #[serde(rename = "evidence", skip_serializing_if = "Option::is_none")]
2252    pub evidence: Option<Vec<String>>,
2253}
2254
2255impl DetectedFramework {
2256    pub fn new() -> DetectedFramework {
2257        DetectedFramework {
2258            id: None,
2259            name: None,
2260            confidence: None,
2261            evidence: None,
2262        }
2263    }
2264}
2265
2266/*
2267 * HELM Kernel API
2268 *
2269 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2270 *
2271 * The version of the OpenAPI document: 0.5.19
2272 *
2273 * Generated by: https://openapi-generator.tech
2274 */
2275
2276
2277#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2278pub struct DetectedModule {
2279    #[serde(rename = "path", skip_serializing_if = "Option::is_none")]
2280    pub path: Option<String>,
2281    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
2282    pub kind: Option<String>,
2283    #[serde(rename = "manifests", skip_serializing_if = "Option::is_none")]
2284    pub manifests: Option<Vec<String>>,
2285    #[serde(rename = "entrypoints", skip_serializing_if = "Option::is_none")]
2286    pub entrypoints: Option<Vec<String>>,
2287    #[serde(rename = "build_strategy", skip_serializing_if = "Option::is_none")]
2288    pub build_strategy: Option<String>,
2289}
2290
2291impl DetectedModule {
2292    pub fn new() -> DetectedModule {
2293        DetectedModule {
2294            path: None,
2295            kind: None,
2296            manifests: None,
2297            entrypoints: None,
2298            build_strategy: None,
2299        }
2300    }
2301}
2302
2303/*
2304 * HELM Kernel API
2305 *
2306 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2307 *
2308 * The version of the OpenAPI document: 0.5.19
2309 *
2310 * Generated by: https://openapi-generator.tech
2311 */
2312
2313
2314/// Effect : An effect submitted for governance evaluation
2315#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2316pub struct Effect {
2317    /// Category of the effect (file_read, api_call, exec, etc.)
2318    #[serde(rename = "effect_type")]
2319    pub effect_type: String,
2320    /// Unique identifier for this effect instance
2321    #[serde(rename = "effect_id")]
2322    pub effect_id: String,
2323    /// Effect-specific parameters
2324    #[serde(rename = "params")]
2325    pub params: std::collections::HashMap<String, serde_json::Value>,
2326    /// Optional budget to charge against
2327    #[serde(rename = "budget_id", skip_serializing_if = "Option::is_none")]
2328    pub budget_id: Option<String>,
2329}
2330
2331impl Effect {
2332    /// An effect submitted for governance evaluation
2333    pub fn new(effect_type: String, effect_id: String, params: std::collections::HashMap<String, serde_json::Value>) -> Effect {
2334        Effect {
2335            effect_type,
2336            effect_id,
2337            params,
2338            budget_id: None,
2339        }
2340    }
2341}
2342
2343/*
2344 * HELM Kernel API
2345 *
2346 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2347 *
2348 * The version of the OpenAPI document: 0.5.19
2349 *
2350 * Generated by: https://openapi-generator.tech
2351 */
2352
2353
2354/// EffectBoundary : The boundary contract for submitting effects to the kernel
2355#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2356pub struct EffectBoundary {
2357    #[serde(rename = "effect")]
2358    pub effect: Box<Effect>,
2359    /// Agent/user identity (e.g. agent:analyst)
2360    #[serde(rename = "principal")]
2361    pub principal: String,
2362    /// Additional context (jurisdiction, industry, budget state)
2363    #[serde(rename = "context", skip_serializing_if = "Option::is_none")]
2364    pub context: Option<std::collections::HashMap<String, serde_json::Value>>,
2365}
2366
2367impl EffectBoundary {
2368    /// The boundary contract for submitting effects to the kernel
2369    pub fn new(effect: Effect, principal: String) -> EffectBoundary {
2370        EffectBoundary {
2371            effect: Box::new(effect),
2372            principal,
2373            context: None,
2374        }
2375    }
2376}
2377
2378/*
2379 * HELM Kernel API
2380 *
2381 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2382 *
2383 * The version of the OpenAPI document: 0.5.19
2384 *
2385 * Generated by: https://openapi-generator.tech
2386 */
2387
2388
2389#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2390pub struct EntitlementCapabilities {
2391    #[serde(rename = "demo_launch", skip_serializing_if = "Option::is_none")]
2392    pub demo_launch: Option<bool>,
2393    #[serde(rename = "local_launch", skip_serializing_if = "Option::is_none")]
2394    pub local_launch: Option<bool>,
2395    #[serde(rename = "cloud_launch", skip_serializing_if = "Option::is_none")]
2396    pub cloud_launch: Option<bool>,
2397    #[serde(rename = "custom_policy", skip_serializing_if = "Option::is_none")]
2398    pub custom_policy: Option<bool>,
2399    #[serde(rename = "bring_own_secrets", skip_serializing_if = "Option::is_none")]
2400    pub bring_own_secrets: Option<bool>,
2401    #[serde(rename = "evidence_export", skip_serializing_if = "Option::is_none")]
2402    pub evidence_export: Option<bool>,
2403    #[serde(rename = "offline_verify", skip_serializing_if = "Option::is_none")]
2404    pub offline_verify: Option<bool>,
2405    #[serde(rename = "team_admin", skip_serializing_if = "Option::is_none")]
2406    pub team_admin: Option<bool>,
2407    #[serde(rename = "sso", skip_serializing_if = "Option::is_none")]
2408    pub sso: Option<bool>,
2409    #[serde(rename = "legal_hold", skip_serializing_if = "Option::is_none")]
2410    pub legal_hold: Option<bool>,
2411    #[serde(rename = "certified_connectors", skip_serializing_if = "Option::is_none")]
2412    pub certified_connectors: Option<bool>,
2413    #[serde(rename = "enterprise_retention", skip_serializing_if = "Option::is_none")]
2414    pub enterprise_retention: Option<bool>,
2415}
2416
2417impl EntitlementCapabilities {
2418    pub fn new() -> EntitlementCapabilities {
2419        EntitlementCapabilities {
2420            demo_launch: None,
2421            local_launch: None,
2422            cloud_launch: None,
2423            custom_policy: None,
2424            bring_own_secrets: None,
2425            evidence_export: None,
2426            offline_verify: None,
2427            team_admin: None,
2428            sso: None,
2429            legal_hold: None,
2430            certified_connectors: None,
2431            enterprise_retention: None,
2432        }
2433    }
2434}
2435
2436/*
2437 * HELM Kernel API
2438 *
2439 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2440 *
2441 * The version of the OpenAPI document: 0.5.19
2442 *
2443 * Generated by: https://openapi-generator.tech
2444 */
2445
2446
2447#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2448pub struct EntitlementDecision {
2449    #[serde(rename = "allowed", skip_serializing_if = "Option::is_none")]
2450    pub allowed: Option<bool>,
2451    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
2452    pub user_state: Option<EntitlementDecisionUserState>,
2453    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
2454    pub required_capability: Option<String>,
2455    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
2456    pub reason_code: Option<String>,
2457    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
2458    pub reason: Option<String>,
2459    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
2460    pub upgrade_reason: Option<String>,
2461    #[serde(rename = "limit", skip_serializing_if = "Option::is_none")]
2462    pub limit: Option<i64>,
2463    #[serde(rename = "used", skip_serializing_if = "Option::is_none")]
2464    pub used: Option<i64>,
2465    #[serde(rename = "remaining", skip_serializing_if = "Option::is_none")]
2466    pub remaining: Option<i64>,
2467    #[serde(rename = "decision_ref", skip_serializing_if = "Option::is_none")]
2468    pub decision_ref: Option<String>,
2469    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
2470    pub source: Option<String>,
2471    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
2472    pub expires_at: Option<String>,
2473}
2474
2475impl EntitlementDecision {
2476    pub fn new() -> EntitlementDecision {
2477        EntitlementDecision {
2478            allowed: None,
2479            user_state: None,
2480            required_capability: None,
2481            reason_code: None,
2482            reason: None,
2483            upgrade_reason: None,
2484            limit: None,
2485            used: None,
2486            remaining: None,
2487            decision_ref: None,
2488            source: None,
2489            expires_at: None,
2490        }
2491    }
2492}
2493///
2494#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2495pub enum EntitlementDecisionUserState {
2496    #[serde(rename = "available")]
2497    Available,
2498    #[serde(rename = "needs_setup")]
2499    NeedsSetup,
2500    #[serde(rename = "upgrade_required")]
2501    UpgradeRequired,
2502    #[serde(rename = "enterprise_controlled")]
2503    EnterpriseControlled,
2504    #[serde(rename = "blocked")]
2505    Blocked,
2506    #[serde(rename = "unsupported")]
2507    Unsupported,
2508}
2509
2510impl Default for EntitlementDecisionUserState {
2511    fn default() -> EntitlementDecisionUserState {
2512        Self::Available
2513    }
2514}
2515
2516/*
2517 * HELM Kernel API
2518 *
2519 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2520 *
2521 * The version of the OpenAPI document: 0.5.19
2522 *
2523 * Generated by: https://openapi-generator.tech
2524 */
2525
2526
2527#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2528pub struct EntitlementDecisionRequest {
2529    #[serde(rename = "principal_id", skip_serializing_if = "Option::is_none")]
2530    pub principal_id: Option<String>,
2531    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
2532    pub tenant_id: Option<String>,
2533    #[serde(rename = "workspace_id", skip_serializing_if = "Option::is_none")]
2534    pub workspace_id: Option<String>,
2535    #[serde(rename = "action")]
2536    pub action: String,
2537    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
2538    pub app_id: Option<String>,
2539    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
2540    pub substrate_id: Option<String>,
2541    #[serde(rename = "target", skip_serializing_if = "Option::is_none")]
2542    pub target: Option<String>,
2543    #[serde(rename = "current_usage", skip_serializing_if = "Option::is_none")]
2544    pub current_usage: Option<Box<EntitlementDecisionRequestCurrentUsage>>,
2545    #[serde(rename = "run_id", skip_serializing_if = "Option::is_none")]
2546    pub run_id: Option<String>,
2547}
2548
2549impl EntitlementDecisionRequest {
2550    pub fn new(action: String) -> EntitlementDecisionRequest {
2551        EntitlementDecisionRequest {
2552            principal_id: None,
2553            tenant_id: None,
2554            workspace_id: None,
2555            action,
2556            app_id: None,
2557            substrate_id: None,
2558            target: None,
2559            current_usage: None,
2560            run_id: None,
2561        }
2562    }
2563}
2564
2565/*
2566 * HELM Kernel API
2567 *
2568 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2569 *
2570 * The version of the OpenAPI document: 0.5.19
2571 *
2572 * Generated by: https://openapi-generator.tech
2573 */
2574
2575
2576#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2577pub struct EntitlementDecisionRequestCurrentUsage {
2578    #[serde(rename = "monthly_launches", default, skip_serializing_if = "Option::is_none")]
2579    pub monthly_launches: Option<Option<serde_json::Value>>,
2580    #[serde(rename = "concurrent_runs", default, skip_serializing_if = "Option::is_none")]
2581    pub concurrent_runs: Option<Option<serde_json::Value>>,
2582    #[serde(rename = "cloud_targets", default, skip_serializing_if = "Option::is_none")]
2583    pub cloud_targets: Option<Option<serde_json::Value>>,
2584}
2585
2586impl EntitlementDecisionRequestCurrentUsage {
2587    pub fn new() -> EntitlementDecisionRequestCurrentUsage {
2588        EntitlementDecisionRequestCurrentUsage {
2589            monthly_launches: None,
2590            concurrent_runs: None,
2591            cloud_targets: None,
2592        }
2593    }
2594}
2595
2596/*
2597 * HELM Kernel API
2598 *
2599 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2600 *
2601 * The version of the OpenAPI document: 0.5.19
2602 *
2603 * Generated by: https://openapi-generator.tech
2604 */
2605
2606
2607#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2608pub struct EntitlementLimits {
2609    #[serde(rename = "monthly_launches", default, skip_serializing_if = "Option::is_none")]
2610    pub monthly_launches: Option<Option<serde_json::Value>>,
2611    #[serde(rename = "concurrent_runs", default, skip_serializing_if = "Option::is_none")]
2612    pub concurrent_runs: Option<Option<serde_json::Value>>,
2613    #[serde(rename = "retention_days", default, skip_serializing_if = "Option::is_none")]
2614    pub retention_days: Option<Option<serde_json::Value>>,
2615    #[serde(rename = "max_cloud_targets", default, skip_serializing_if = "Option::is_none")]
2616    pub max_cloud_targets: Option<Option<serde_json::Value>>,
2617    #[serde(rename = "evidence_export_mb", default, skip_serializing_if = "Option::is_none")]
2618    pub evidence_export_mb: Option<Option<serde_json::Value>>,
2619    #[serde(rename = "connector_certification_scope", skip_serializing_if = "Option::is_none")]
2620    pub connector_certification_scope: Option<String>,
2621}
2622
2623impl EntitlementLimits {
2624    pub fn new() -> EntitlementLimits {
2625        EntitlementLimits {
2626            monthly_launches: None,
2627            concurrent_runs: None,
2628            retention_days: None,
2629            max_cloud_targets: None,
2630            evidence_export_mb: None,
2631            connector_certification_scope: None,
2632        }
2633    }
2634}
2635
2636/*
2637 * HELM Kernel API
2638 *
2639 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2640 *
2641 * The version of the OpenAPI document: 0.5.19
2642 *
2643 * Generated by: https://openapi-generator.tech
2644 */
2645
2646
2647#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2648pub struct EnvExposurePolicy {
2649    #[serde(rename = "mode")]
2650    pub mode: EnvExposurePolicyMode,
2651    #[serde(rename = "names", skip_serializing_if = "Option::is_none")]
2652    pub names: Option<Vec<String>>,
2653    #[serde(rename = "names_hash", skip_serializing_if = "Option::is_none")]
2654    pub names_hash: Option<String>,
2655    #[serde(rename = "redacted", skip_serializing_if = "Option::is_none")]
2656    pub redacted: Option<bool>,
2657}
2658
2659impl EnvExposurePolicy {
2660    pub fn new(mode: EnvExposurePolicyMode) -> EnvExposurePolicy {
2661        EnvExposurePolicy {
2662            mode,
2663            names: None,
2664            names_hash: None,
2665            redacted: None,
2666        }
2667    }
2668}
2669///
2670#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2671pub enum EnvExposurePolicyMode {
2672    #[serde(rename = "deny-all")]
2673    DenyAll,
2674    #[serde(rename = "allowlist")]
2675    Allowlist,
2676    #[serde(rename = "redacted")]
2677    Redacted,
2678}
2679
2680impl Default for EnvExposurePolicyMode {
2681    fn default() -> EnvExposurePolicyMode {
2682        Self::DenyAll
2683    }
2684}
2685
2686/*
2687 * HELM Kernel API
2688 *
2689 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2690 *
2691 * The version of the OpenAPI document: 0.5.19
2692 *
2693 * Generated by: https://openapi-generator.tech
2694 */
2695
2696
2697#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2698pub struct EvidenceEnvelopeExportRequest {
2699    #[serde(rename = "manifest_id")]
2700    pub manifest_id: String,
2701    #[serde(rename = "envelope")]
2702    pub envelope: EvidenceEnvelopeExportRequestEnvelope,
2703    /// HELM-native EvidencePack root hash.
2704    #[serde(rename = "native_evidence_hash")]
2705    pub native_evidence_hash: String,
2706    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
2707    pub subject: Option<String>,
2708    /// Must be true for experimental SCITT or COSE exports.
2709    #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")]
2710    pub experimental: Option<bool>,
2711}
2712
2713impl EvidenceEnvelopeExportRequest {
2714    pub fn new(manifest_id: String, envelope: EvidenceEnvelopeExportRequestEnvelope, native_evidence_hash: String) -> EvidenceEnvelopeExportRequest {
2715        EvidenceEnvelopeExportRequest {
2716            manifest_id,
2717            envelope,
2718            native_evidence_hash,
2719            subject: None,
2720            experimental: None,
2721        }
2722    }
2723}
2724///
2725#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2726pub enum EvidenceEnvelopeExportRequestEnvelope {
2727    #[serde(rename = "dsse")]
2728    Dsse,
2729    #[serde(rename = "jws")]
2730    Jws,
2731    #[serde(rename = "in-toto")]
2732    InToto,
2733    #[serde(rename = "slsa")]
2734    Slsa,
2735    #[serde(rename = "sigstore")]
2736    Sigstore,
2737    #[serde(rename = "scitt")]
2738    Scitt,
2739    #[serde(rename = "cose")]
2740    Cose,
2741}
2742
2743impl Default for EvidenceEnvelopeExportRequestEnvelope {
2744    fn default() -> EvidenceEnvelopeExportRequestEnvelope {
2745        Self::Dsse
2746    }
2747}
2748
2749/*
2750 * HELM Kernel API
2751 *
2752 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2753 *
2754 * The version of the OpenAPI document: 0.5.19
2755 *
2756 * Generated by: https://openapi-generator.tech
2757 */
2758
2759
2760#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2761pub struct EvidenceEnvelopeManifest {
2762    #[serde(rename = "manifest_id")]
2763    pub manifest_id: String,
2764    #[serde(rename = "envelope")]
2765    pub envelope: EvidenceEnvelopeManifestEnvelope,
2766    #[serde(rename = "native_evidence_hash")]
2767    pub native_evidence_hash: String,
2768    #[serde(rename = "native_authority")]
2769    pub native_authority: bool,
2770    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
2771    pub subject: Option<String>,
2772    #[serde(rename = "statement_hash", skip_serializing_if = "Option::is_none")]
2773    pub statement_hash: Option<String>,
2774    #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")]
2775    pub experimental: Option<bool>,
2776    #[serde(rename = "created_at")]
2777    pub created_at: String,
2778    #[serde(rename = "manifest_hash", skip_serializing_if = "Option::is_none")]
2779    pub manifest_hash: Option<String>,
2780}
2781
2782impl EvidenceEnvelopeManifest {
2783    pub fn new(manifest_id: String, envelope: EvidenceEnvelopeManifestEnvelope, native_evidence_hash: String, native_authority: bool, created_at: String) -> EvidenceEnvelopeManifest {
2784        EvidenceEnvelopeManifest {
2785            manifest_id,
2786            envelope,
2787            native_evidence_hash,
2788            native_authority,
2789            subject: None,
2790            statement_hash: None,
2791            experimental: None,
2792            created_at,
2793            manifest_hash: None,
2794        }
2795    }
2796}
2797///
2798#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2799pub enum EvidenceEnvelopeManifestEnvelope {
2800    #[serde(rename = "dsse")]
2801    Dsse,
2802    #[serde(rename = "jws")]
2803    Jws,
2804    #[serde(rename = "in-toto")]
2805    InToto,
2806    #[serde(rename = "slsa")]
2807    Slsa,
2808    #[serde(rename = "sigstore")]
2809    Sigstore,
2810    #[serde(rename = "scitt")]
2811    Scitt,
2812    #[serde(rename = "cose")]
2813    Cose,
2814}
2815
2816impl Default for EvidenceEnvelopeManifestEnvelope {
2817    fn default() -> EvidenceEnvelopeManifestEnvelope {
2818        Self::Dsse
2819    }
2820}
2821
2822/*
2823 * HELM Kernel API
2824 *
2825 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2826 *
2827 * The version of the OpenAPI document: 0.5.19
2828 *
2829 * Generated by: https://openapi-generator.tech
2830 */
2831
2832
2833#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2834pub struct EvidenceEnvelopeVerification {
2835    #[serde(rename = "manifest_id", skip_serializing_if = "Option::is_none")]
2836    pub manifest_id: Option<String>,
2837    #[serde(rename = "manifest_hash", skip_serializing_if = "Option::is_none")]
2838    pub manifest_hash: Option<String>,
2839    #[serde(rename = "native_evidence_hash", skip_serializing_if = "Option::is_none")]
2840    pub native_evidence_hash: Option<String>,
2841    #[serde(rename = "verified", skip_serializing_if = "Option::is_none")]
2842    pub verified: Option<bool>,
2843    #[serde(rename = "authoritative", skip_serializing_if = "Option::is_none")]
2844    pub authoritative: Option<bool>,
2845    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
2846    pub errors: Option<Vec<String>>,
2847    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
2848    pub checked_at: Option<String>,
2849}
2850
2851impl EvidenceEnvelopeVerification {
2852    pub fn new() -> EvidenceEnvelopeVerification {
2853        EvidenceEnvelopeVerification {
2854            manifest_id: None,
2855            manifest_hash: None,
2856            native_evidence_hash: None,
2857            verified: None,
2858            authoritative: None,
2859            errors: None,
2860            checked_at: None,
2861        }
2862    }
2863}
2864
2865/*
2866 * HELM Kernel API
2867 *
2868 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2869 *
2870 * The version of the OpenAPI document: 0.5.19
2871 *
2872 * Generated by: https://openapi-generator.tech
2873 */
2874
2875
2876#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2877pub struct ExecutionBoundaryRecord {
2878    #[serde(rename = "record_id", skip_serializing_if = "Option::is_none")]
2879    pub record_id: Option<String>,
2880    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
2881    pub verdict: Option<ExecutionBoundaryRecordVerdict>,
2882    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
2883    pub reason_code: Option<String>,
2884    #[serde(rename = "tool_name", skip_serializing_if = "Option::is_none")]
2885    pub tool_name: Option<String>,
2886    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
2887    pub args_hash: Option<String>,
2888    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
2889    pub policy_epoch: Option<String>,
2890    #[serde(rename = "mcp_server_id", skip_serializing_if = "Option::is_none")]
2891    pub mcp_server_id: Option<String>,
2892    #[serde(rename = "oauth_resource", skip_serializing_if = "Option::is_none")]
2893    pub oauth_resource: Option<String>,
2894    #[serde(rename = "oauth_scopes", skip_serializing_if = "Option::is_none")]
2895    pub oauth_scopes: Option<Vec<String>>,
2896    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
2897    pub sandbox_grant_hash: Option<String>,
2898    #[serde(rename = "authz_snapshot_hash", skip_serializing_if = "Option::is_none")]
2899    pub authz_snapshot_hash: Option<String>,
2900    #[serde(rename = "approval_receipt_id", skip_serializing_if = "Option::is_none")]
2901    pub approval_receipt_id: Option<String>,
2902    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
2903    pub receipt_id: Option<String>,
2904    #[serde(rename = "record_hash", skip_serializing_if = "Option::is_none")]
2905    pub record_hash: Option<String>,
2906    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
2907    pub created_at: Option<String>,
2908}
2909
2910impl ExecutionBoundaryRecord {
2911    pub fn new() -> ExecutionBoundaryRecord {
2912        ExecutionBoundaryRecord {
2913            record_id: None,
2914            verdict: None,
2915            reason_code: None,
2916            tool_name: None,
2917            args_hash: None,
2918            policy_epoch: None,
2919            mcp_server_id: None,
2920            oauth_resource: None,
2921            oauth_scopes: None,
2922            sandbox_grant_hash: None,
2923            authz_snapshot_hash: None,
2924            approval_receipt_id: None,
2925            receipt_id: None,
2926            record_hash: None,
2927            created_at: None,
2928        }
2929    }
2930}
2931///
2932#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2933pub enum ExecutionBoundaryRecordVerdict {
2934    #[serde(rename = "ALLOW")]
2935    Allow,
2936    #[serde(rename = "DENY")]
2937    Deny,
2938    #[serde(rename = "ESCALATE")]
2939    Escalate,
2940}
2941
2942impl Default for ExecutionBoundaryRecordVerdict {
2943    fn default() -> ExecutionBoundaryRecordVerdict {
2944        Self::Allow
2945    }
2946}
2947
2948/*
2949 * HELM Kernel API
2950 *
2951 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2952 *
2953 * The version of the OpenAPI document: 0.5.19
2954 *
2955 * Generated by: https://openapi-generator.tech
2956 */
2957
2958
2959#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2960pub struct ExportRequest {
2961    /// Session to export (omit for all)
2962    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
2963    pub session_id: Option<String>,
2964    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
2965    pub format: Option<ExportRequestFormat>,
2966}
2967
2968impl ExportRequest {
2969    pub fn new() -> ExportRequest {
2970        ExportRequest {
2971            session_id: None,
2972            format: None,
2973        }
2974    }
2975}
2976///
2977#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2978pub enum ExportRequestFormat {
2979    #[serde(rename = "tar.gz")]
2980    TarPeriodGz,
2981}
2982
2983impl Default for ExportRequestFormat {
2984    fn default() -> ExportRequestFormat {
2985        Self::TarPeriodGz
2986    }
2987}
2988
2989/*
2990 * HELM Kernel API
2991 *
2992 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
2993 *
2994 * The version of the OpenAPI document: 0.5.19
2995 *
2996 * Generated by: https://openapi-generator.tech
2997 */
2998
2999
3000#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3001pub struct FilesystemPreopen {
3002    #[serde(rename = "path")]
3003    pub path: String,
3004    #[serde(rename = "mode")]
3005    pub mode: FilesystemPreopenMode,
3006    #[serde(rename = "content_hash", skip_serializing_if = "Option::is_none")]
3007    pub content_hash: Option<String>,
3008}
3009
3010impl FilesystemPreopen {
3011    pub fn new(path: String, mode: FilesystemPreopenMode) -> FilesystemPreopen {
3012        FilesystemPreopen {
3013            path,
3014            mode,
3015            content_hash: None,
3016        }
3017    }
3018}
3019///
3020#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3021pub enum FilesystemPreopenMode {
3022    #[serde(rename = "ro")]
3023    Ro,
3024    #[serde(rename = "rw")]
3025    Rw,
3026}
3027
3028impl Default for FilesystemPreopenMode {
3029    fn default() -> FilesystemPreopenMode {
3030        Self::Ro
3031    }
3032}
3033
3034/*
3035 * HELM Kernel API
3036 *
3037 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3038 *
3039 * The version of the OpenAPI document: 0.5.19
3040 *
3041 * Generated by: https://openapi-generator.tech
3042 */
3043
3044
3045#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3046pub struct FrameworkAdapter {
3047    #[serde(rename = "apiVersion", skip_serializing_if = "Option::is_none")]
3048    pub api_version: Option<String>,
3049    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
3050    pub kind: Option<String>,
3051    #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
3052    pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
3053    #[serde(rename = "match", skip_serializing_if = "Option::is_none")]
3054    pub r#match: Option<std::collections::HashMap<String, serde_json::Value>>,
3055    #[serde(rename = "capabilities", default, skip_serializing_if = "Option::is_none")]
3056    pub capabilities: Option<Option<serde_json::Value>>,
3057    #[serde(rename = "entrypoints", skip_serializing_if = "Option::is_none")]
3058    pub entrypoints: Option<std::collections::HashMap<String, serde_json::Value>>,
3059    #[serde(rename = "build", skip_serializing_if = "Option::is_none")]
3060    pub build: Option<std::collections::HashMap<String, serde_json::Value>>,
3061}
3062
3063impl FrameworkAdapter {
3064    pub fn new() -> FrameworkAdapter {
3065        FrameworkAdapter {
3066            api_version: None,
3067            kind: None,
3068            metadata: None,
3069            r#match: None,
3070            capabilities: None,
3071            entrypoints: None,
3072            build: None,
3073        }
3074    }
3075}
3076
3077/*
3078 * HELM Kernel API
3079 *
3080 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3081 *
3082 * The version of the OpenAPI document: 0.5.19
3083 *
3084 * Generated by: https://openapi-generator.tech
3085 */
3086
3087
3088#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3089pub struct GeneratedAppSpecCandidate {
3090    #[serde(rename = "candidate_id")]
3091    pub candidate_id: String,
3092    #[serde(rename = "trusted")]
3093    pub trusted: bool,
3094    #[serde(rename = "app_spec")]
3095    pub app_spec: Box<LaunchpadApp>,
3096    #[serde(rename = "promotion_requirements")]
3097    pub promotion_requirements: Vec<String>,
3098}
3099
3100impl GeneratedAppSpecCandidate {
3101    pub fn new(candidate_id: String, trusted: bool, app_spec: LaunchpadApp, promotion_requirements: Vec<String>) -> GeneratedAppSpecCandidate {
3102        GeneratedAppSpecCandidate {
3103            candidate_id,
3104            trusted,
3105            app_spec: Box::new(app_spec),
3106            promotion_requirements,
3107        }
3108    }
3109}
3110
3111/*
3112 * HELM Kernel API
3113 *
3114 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3115 *
3116 * The version of the OpenAPI document: 0.5.19
3117 *
3118 * Generated by: https://openapi-generator.tech
3119 */
3120
3121
3122#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3123pub struct GetAgentUiRuntimeInfo200Response {
3124    #[serde(rename = "runtime")]
3125    pub runtime: String,
3126    #[serde(rename = "protocol", deserialize_with = "Option::deserialize")]
3127    pub protocol: Option<serde_json::Value>,
3128    #[serde(rename = "transport", deserialize_with = "Option::deserialize")]
3129    pub transport: Option<serde_json::Value>,
3130    #[serde(rename = "tools", deserialize_with = "Option::deserialize")]
3131    pub tools: Option<serde_json::Value>,
3132}
3133
3134impl GetAgentUiRuntimeInfo200Response {
3135    pub fn new(runtime: String, protocol: Option<serde_json::Value>, transport: Option<serde_json::Value>, tools: Option<serde_json::Value>) -> GetAgentUiRuntimeInfo200Response {
3136        GetAgentUiRuntimeInfo200Response {
3137            runtime,
3138            protocol,
3139            transport,
3140            tools,
3141        }
3142    }
3143}
3144
3145/*
3146 * HELM Kernel API
3147 *
3148 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3149 *
3150 * The version of the OpenAPI document: 0.5.19
3151 *
3152 * Generated by: https://openapi-generator.tech
3153 */
3154
3155
3156#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3157pub struct GetLaunchpadImport200Response {
3158    #[serde(rename = "import")]
3159    pub import: Box<LaunchpadImportRecord>,
3160}
3161
3162impl GetLaunchpadImport200Response {
3163    pub fn new(import: LaunchpadImportRecord) -> GetLaunchpadImport200Response {
3164        GetLaunchpadImport200Response {
3165            import: Box::new(import),
3166        }
3167    }
3168}
3169
3170/*
3171 * HELM Kernel API
3172 *
3173 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3174 *
3175 * The version of the OpenAPI document: 0.5.19
3176 *
3177 * Generated by: https://openapi-generator.tech
3178 */
3179
3180
3181#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3182pub struct GetLaunchpadMatrix200Response {
3183    #[serde(rename = "matrix")]
3184    pub matrix: Vec<LaunchpadMatrixCell>,
3185}
3186
3187impl GetLaunchpadMatrix200Response {
3188    pub fn new(matrix: Vec<LaunchpadMatrixCell>) -> GetLaunchpadMatrix200Response {
3189        GetLaunchpadMatrix200Response {
3190            matrix,
3191        }
3192    }
3193}
3194
3195/*
3196 * HELM Kernel API
3197 *
3198 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3199 *
3200 * The version of the OpenAPI document: 0.5.19
3201 *
3202 * Generated by: https://openapi-generator.tech
3203 */
3204
3205
3206#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3207pub struct GetPublicDemoHealth200Response {
3208    #[serde(rename = "version")]
3209    pub version: String,
3210    #[serde(rename = "commit")]
3211    pub commit: String,
3212    #[serde(rename = "helm_ai_kernel_version")]
3213    pub helm_ai_kernel_version: String,
3214    #[serde(rename = "status")]
3215    pub status: String,
3216    #[serde(rename = "build_time")]
3217    pub build_time: String,
3218    #[serde(rename = "git_sha")]
3219    pub git_sha: String,
3220    #[serde(rename = "deployment_id")]
3221    pub deployment_id: String,
3222}
3223
3224impl GetPublicDemoHealth200Response {
3225    pub fn new(version: String, commit: String, helm_ai_kernel_version: String, status: String, build_time: String, git_sha: String, deployment_id: String) -> GetPublicDemoHealth200Response {
3226        GetPublicDemoHealth200Response {
3227            version,
3228            commit,
3229            helm_ai_kernel_version,
3230            status,
3231            build_time,
3232            git_sha,
3233            deployment_id,
3234        }
3235    }
3236}
3237
3238/*
3239 * HELM Kernel API
3240 *
3241 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3242 *
3243 * The version of the OpenAPI document: 0.5.19
3244 *
3245 * Generated by: https://openapi-generator.tech
3246 */
3247
3248
3249/// GovernanceDecision : PDP decision for an effect
3250#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3251pub struct GovernanceDecision {
3252    #[serde(rename = "decision_id")]
3253    pub decision_id: String,
3254    #[serde(rename = "effect_id")]
3255    pub effect_id: String,
3256    #[serde(rename = "verdict")]
3257    pub verdict: GovernanceDecisionVerdict,
3258    /// Null for ALLOW. Registered code from reason-codes-v1.json for DENY/ESCALATE.
3259    #[serde(rename = "reason_code", default, skip_serializing_if = "Option::is_none")]
3260    pub reason_code: Option<Option<String>>,
3261    #[serde(rename = "receipt", skip_serializing_if = "Option::is_none")]
3262    pub receipt: Option<Box<Receipt>>,
3263    /// Names of policy bundles active during evaluation
3264    #[serde(rename = "active_packs", skip_serializing_if = "Option::is_none")]
3265    pub active_packs: Option<Vec<String>>,
3266}
3267
3268impl GovernanceDecision {
3269    /// PDP decision for an effect
3270    pub fn new(decision_id: String, effect_id: String, verdict: GovernanceDecisionVerdict) -> GovernanceDecision {
3271        GovernanceDecision {
3272            decision_id,
3273            effect_id,
3274            verdict,
3275            reason_code: None,
3276            receipt: None,
3277            active_packs: None,
3278        }
3279    }
3280}
3281///
3282#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3283pub enum GovernanceDecisionVerdict {
3284    #[serde(rename = "ALLOW")]
3285    Allow,
3286    #[serde(rename = "DENY")]
3287    Deny,
3288    #[serde(rename = "ESCALATE")]
3289    Escalate,
3290}
3291
3292impl Default for GovernanceDecisionVerdict {
3293    fn default() -> GovernanceDecisionVerdict {
3294        Self::Allow
3295    }
3296}
3297
3298/*
3299 * HELM Kernel API
3300 *
3301 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3302 *
3303 * The version of the OpenAPI document: 0.5.19
3304 *
3305 * Generated by: https://openapi-generator.tech
3306 */
3307
3308
3309#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3310pub struct GroundedActionRef {
3311    #[serde(rename = "grounded_action_id")]
3312    pub grounded_action_id: String,
3313    #[serde(rename = "screenshot_hash")]
3314    pub screenshot_hash: String,
3315    #[serde(rename = "dom_or_ax_snapshot_hash")]
3316    pub dom_or_ax_snapshot_hash: String,
3317    #[serde(rename = "target_ref")]
3318    pub target_ref: String,
3319    #[serde(rename = "bbox_or_element_id")]
3320    pub bbox_or_element_id: String,
3321    #[serde(rename = "action_type")]
3322    pub action_type: GroundedActionRefActionType,
3323    #[serde(rename = "precondition")]
3324    pub precondition: String,
3325    #[serde(rename = "postcondition")]
3326    pub postcondition: String,
3327    #[serde(rename = "postcondition_ref")]
3328    pub postcondition_ref: String,
3329    #[serde(rename = "verification_scope_ref")]
3330    pub verification_scope_ref: String,
3331    #[serde(rename = "policy_hash")]
3332    pub policy_hash: String,
3333    #[serde(rename = "proof_graph_node_ref")]
3334    pub proof_graph_node_ref: String,
3335    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
3336    pub sandbox_grant_hash: Option<String>,
3337    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
3338    pub created_at: Option<String>,
3339    #[serde(rename = "grounding_hash", skip_serializing_if = "Option::is_none")]
3340    pub grounding_hash: Option<String>,
3341}
3342
3343impl GroundedActionRef {
3344    pub fn new(grounded_action_id: String, screenshot_hash: String, dom_or_ax_snapshot_hash: String, target_ref: String, bbox_or_element_id: String, action_type: GroundedActionRefActionType, precondition: String, postcondition: String, postcondition_ref: String, verification_scope_ref: String, policy_hash: String, proof_graph_node_ref: String) -> GroundedActionRef {
3345        GroundedActionRef {
3346            grounded_action_id,
3347            screenshot_hash,
3348            dom_or_ax_snapshot_hash,
3349            target_ref,
3350            bbox_or_element_id,
3351            action_type,
3352            precondition,
3353            postcondition,
3354            postcondition_ref,
3355            verification_scope_ref,
3356            policy_hash,
3357            proof_graph_node_ref,
3358            sandbox_grant_hash: None,
3359            created_at: None,
3360            grounding_hash: None,
3361        }
3362    }
3363}
3364///
3365#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3366pub enum GroundedActionRefActionType {
3367    #[serde(rename = "click")]
3368    Click,
3369    #[serde(rename = "type")]
3370    Type,
3371    #[serde(rename = "select")]
3372    Select,
3373    #[serde(rename = "submit")]
3374    Submit,
3375    #[serde(rename = "navigate")]
3376    Navigate,
3377}
3378
3379impl Default for GroundedActionRefActionType {
3380    fn default() -> GroundedActionRefActionType {
3381        Self::Click
3382    }
3383}
3384
3385/*
3386 * HELM Kernel API
3387 *
3388 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3389 *
3390 * The version of the OpenAPI document: 0.5.19
3391 *
3392 * Generated by: https://openapi-generator.tech
3393 */
3394
3395
3396#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3397pub struct GuiActionReceipt {
3398    #[serde(rename = "receipt_id")]
3399    pub receipt_id: String,
3400    #[serde(rename = "grounded_action_ref")]
3401    pub grounded_action_ref: String,
3402    #[serde(rename = "screenshot_hash")]
3403    pub screenshot_hash: String,
3404    #[serde(rename = "dom_or_ax_snapshot_hash")]
3405    pub dom_or_ax_snapshot_hash: String,
3406    #[serde(rename = "target_ref")]
3407    pub target_ref: String,
3408    #[serde(rename = "bbox_or_element_id")]
3409    pub bbox_or_element_id: String,
3410    #[serde(rename = "action_type")]
3411    pub action_type: GuiActionReceiptActionType,
3412    #[serde(rename = "precondition")]
3413    pub precondition: String,
3414    #[serde(rename = "postcondition")]
3415    pub postcondition: String,
3416    #[serde(rename = "postcondition_ref")]
3417    pub postcondition_ref: String,
3418    #[serde(rename = "postcondition_verified")]
3419    pub postcondition_verified: bool,
3420    #[serde(rename = "verification_scope_ref")]
3421    pub verification_scope_ref: String,
3422    #[serde(rename = "policy_hash")]
3423    pub policy_hash: String,
3424    #[serde(rename = "proof_graph_node_ref")]
3425    pub proof_graph_node_ref: String,
3426    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
3427    pub sandbox_grant_hash: Option<String>,
3428    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
3429    pub created_at: Option<String>,
3430    #[serde(rename = "receipt_hash", skip_serializing_if = "Option::is_none")]
3431    pub receipt_hash: Option<String>,
3432}
3433
3434impl GuiActionReceipt {
3435    pub fn new(receipt_id: String, grounded_action_ref: String, screenshot_hash: String, dom_or_ax_snapshot_hash: String, target_ref: String, bbox_or_element_id: String, action_type: GuiActionReceiptActionType, precondition: String, postcondition: String, postcondition_ref: String, postcondition_verified: bool, verification_scope_ref: String, policy_hash: String, proof_graph_node_ref: String) -> GuiActionReceipt {
3436        GuiActionReceipt {
3437            receipt_id,
3438            grounded_action_ref,
3439            screenshot_hash,
3440            dom_or_ax_snapshot_hash,
3441            target_ref,
3442            bbox_or_element_id,
3443            action_type,
3444            precondition,
3445            postcondition,
3446            postcondition_ref,
3447            postcondition_verified,
3448            verification_scope_ref,
3449            policy_hash,
3450            proof_graph_node_ref,
3451            sandbox_grant_hash: None,
3452            created_at: None,
3453            receipt_hash: None,
3454        }
3455    }
3456}
3457///
3458#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3459pub enum GuiActionReceiptActionType {
3460    #[serde(rename = "click")]
3461    Click,
3462    #[serde(rename = "type")]
3463    Type,
3464    #[serde(rename = "select")]
3465    Select,
3466    #[serde(rename = "submit")]
3467    Submit,
3468    #[serde(rename = "navigate")]
3469    Navigate,
3470}
3471
3472impl Default for GuiActionReceiptActionType {
3473    fn default() -> GuiActionReceiptActionType {
3474        Self::Click
3475    }
3476}
3477
3478/*
3479 * HELM Kernel API
3480 *
3481 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3482 *
3483 * The version of the OpenAPI document: 0.5.19
3484 *
3485 * Generated by: https://openapi-generator.tech
3486 */
3487
3488
3489#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3490pub struct HarnessChangeContract {
3491    #[serde(rename = "change_contract_id")]
3492    pub change_contract_id: String,
3493    #[serde(rename = "component_modified")]
3494    pub component_modified: HarnessChangeContractComponentModified,
3495    #[serde(rename = "failure_mode_targeted")]
3496    pub failure_mode_targeted: String,
3497    #[serde(rename = "predicted_improvement")]
3498    pub predicted_improvement: String,
3499    #[serde(rename = "invariants_preserved")]
3500    pub invariants_preserved: Vec<String>,
3501    #[serde(rename = "safety_properties")]
3502    pub safety_properties: Vec<String>,
3503    #[serde(rename = "regression_suite_refs")]
3504    pub regression_suite_refs: Vec<String>,
3505    #[serde(rename = "simulation_evidence_refs", skip_serializing_if = "Option::is_none")]
3506    pub simulation_evidence_refs: Option<Vec<String>>,
3507    #[serde(rename = "canary_scope", skip_serializing_if = "Option::is_none")]
3508    pub canary_scope: Option<std::collections::HashMap<String, serde_json::Value>>,
3509    #[serde(rename = "rollback_plan")]
3510    pub rollback_plan: std::collections::HashMap<String, serde_json::Value>,
3511    #[serde(rename = "approval_required")]
3512    pub approval_required: bool,
3513    #[serde(rename = "activation_receipt_ref", skip_serializing_if = "Option::is_none")]
3514    pub activation_receipt_ref: Option<String>,
3515    #[serde(rename = "created_at")]
3516    pub created_at: String,
3517    #[serde(rename = "contract_hash", skip_serializing_if = "Option::is_none")]
3518    pub contract_hash: Option<String>,
3519}
3520
3521impl HarnessChangeContract {
3522    pub fn new(change_contract_id: String, component_modified: HarnessChangeContractComponentModified, failure_mode_targeted: String, predicted_improvement: String, invariants_preserved: Vec<String>, safety_properties: Vec<String>, regression_suite_refs: Vec<String>, rollback_plan: std::collections::HashMap<String, serde_json::Value>, approval_required: bool, created_at: String) -> HarnessChangeContract {
3523        HarnessChangeContract {
3524            change_contract_id,
3525            component_modified,
3526            failure_mode_targeted,
3527            predicted_improvement,
3528            invariants_preserved,
3529            safety_properties,
3530            regression_suite_refs,
3531            simulation_evidence_refs: None,
3532            canary_scope: None,
3533            rollback_plan,
3534            approval_required,
3535            activation_receipt_ref: None,
3536            created_at,
3537            contract_hash: None,
3538        }
3539    }
3540}
3541///
3542#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3543pub enum HarnessChangeContractComponentModified {
3544    #[serde(rename = "connector_contract")]
3545    ConnectorContract,
3546    #[serde(rename = "tool_schema")]
3547    ToolSchema,
3548    #[serde(rename = "sandbox_grant")]
3549    SandboxGrant,
3550    #[serde(rename = "mcp_approval")]
3551    McpApproval,
3552    #[serde(rename = "policy_overlay")]
3553    PolicyOverlay,
3554    #[serde(rename = "verifier")]
3555    Verifier,
3556    #[serde(rename = "evidence_template")]
3557    EvidenceTemplate,
3558    #[serde(rename = "routing_rule")]
3559    RoutingRule,
3560}
3561
3562impl Default for HarnessChangeContractComponentModified {
3563    fn default() -> HarnessChangeContractComponentModified {
3564        Self::ConnectorContract
3565    }
3566}
3567
3568/*
3569 * HELM Kernel API
3570 *
3571 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3572 *
3573 * The version of the OpenAPI document: 0.5.19
3574 *
3575 * Generated by: https://openapi-generator.tech
3576 */
3577
3578
3579#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3580pub struct HarnessTrace {
3581    #[serde(rename = "trace_id")]
3582    pub trace_id: String,
3583    #[serde(rename = "plan_hash")]
3584    pub plan_hash: String,
3585    #[serde(rename = "context_refs", skip_serializing_if = "Option::is_none")]
3586    pub context_refs: Option<Vec<String>>,
3587    #[serde(rename = "memory_reads", skip_serializing_if = "Option::is_none")]
3588    pub memory_reads: Option<Vec<String>>,
3589    #[serde(rename = "memory_writes", skip_serializing_if = "Option::is_none")]
3590    pub memory_writes: Option<Vec<String>>,
3591    #[serde(rename = "tool_schema_hashes", skip_serializing_if = "Option::is_none")]
3592    pub tool_schema_hashes: Option<Vec<String>>,
3593    #[serde(rename = "permission_requests", skip_serializing_if = "Option::is_none")]
3594    pub permission_requests: Option<Vec<String>>,
3595    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
3596    pub sandbox_grant_hash: Option<String>,
3597    #[serde(rename = "mcp_approval_ref", skip_serializing_if = "Option::is_none")]
3598    pub mcp_approval_ref: Option<String>,
3599    #[serde(rename = "connector_contract_hash", skip_serializing_if = "Option::is_none")]
3600    pub connector_contract_hash: Option<String>,
3601    #[serde(rename = "policy_hash")]
3602    pub policy_hash: String,
3603    #[serde(rename = "cpi_output_hash", skip_serializing_if = "Option::is_none")]
3604    pub cpi_output_hash: Option<String>,
3605    #[serde(rename = "verifier_outputs", skip_serializing_if = "Option::is_none")]
3606    pub verifier_outputs: Option<Vec<String>>,
3607    #[serde(rename = "human_interventions", skip_serializing_if = "Option::is_none")]
3608    pub human_interventions: Option<Vec<String>>,
3609    #[serde(rename = "state_updates", skip_serializing_if = "Option::is_none")]
3610    pub state_updates: Option<Vec<String>>,
3611    #[serde(rename = "receipt_refs")]
3612    pub receipt_refs: Vec<String>,
3613    #[serde(rename = "created_at")]
3614    pub created_at: String,
3615    #[serde(rename = "trace_hash", skip_serializing_if = "Option::is_none")]
3616    pub trace_hash: Option<String>,
3617}
3618
3619impl HarnessTrace {
3620    pub fn new(trace_id: String, plan_hash: String, policy_hash: String, receipt_refs: Vec<String>, created_at: String) -> HarnessTrace {
3621        HarnessTrace {
3622            trace_id,
3623            plan_hash,
3624            context_refs: None,
3625            memory_reads: None,
3626            memory_writes: None,
3627            tool_schema_hashes: None,
3628            permission_requests: None,
3629            sandbox_grant_hash: None,
3630            mcp_approval_ref: None,
3631            connector_contract_hash: None,
3632            policy_hash,
3633            cpi_output_hash: None,
3634            verifier_outputs: None,
3635            human_interventions: None,
3636            state_updates: None,
3637            receipt_refs,
3638            created_at,
3639            trace_hash: None,
3640        }
3641    }
3642}
3643
3644/*
3645 * HELM Kernel API
3646 *
3647 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3648 *
3649 * The version of the OpenAPI document: 0.5.19
3650 *
3651 * Generated by: https://openapi-generator.tech
3652 */
3653
3654
3655#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3656pub struct HealthCheck200Response {
3657    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
3658    pub status: Option<String>,
3659    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
3660    pub version: Option<String>,
3661}
3662
3663impl HealthCheck200Response {
3664    pub fn new() -> HealthCheck200Response {
3665        HealthCheck200Response {
3666            status: None,
3667            version: None,
3668        }
3669    }
3670}
3671
3672/*
3673 * HELM Kernel API
3674 *
3675 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3676 *
3677 * The version of the OpenAPI document: 0.5.19
3678 *
3679 * Generated by: https://openapi-generator.tech
3680 */
3681
3682
3683#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3684pub struct HelmError {
3685    #[serde(rename = "error")]
3686    pub error: Box<HelmErrorError>,
3687}
3688
3689impl HelmError {
3690    pub fn new(error: HelmErrorError) -> HelmError {
3691        HelmError {
3692            error: Box::new(error),
3693        }
3694    }
3695}
3696
3697/*
3698 * HELM Kernel API
3699 *
3700 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3701 *
3702 * The version of the OpenAPI document: 0.5.19
3703 *
3704 * Generated by: https://openapi-generator.tech
3705 */
3706
3707
3708#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3709pub struct HelmErrorError {
3710    /// Human-readable error message
3711    #[serde(rename = "message")]
3712    pub message: String,
3713    #[serde(rename = "type")]
3714    pub r#type: HelmErrorErrorType,
3715    /// Machine-readable error code
3716    #[serde(rename = "code")]
3717    pub code: String,
3718    /// HELM-specific reason code
3719    #[serde(rename = "reason_code")]
3720    pub reason_code: HelmErrorErrorReasonCode,
3721    /// Additional error context
3722    #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
3723    pub details: Option<std::collections::HashMap<String, serde_json::Value>>,
3724}
3725
3726impl HelmErrorError {
3727    pub fn new(message: String, r#type: HelmErrorErrorType, code: String, reason_code: HelmErrorErrorReasonCode) -> HelmErrorError {
3728        HelmErrorError {
3729            message,
3730            r#type,
3731            code,
3732            reason_code,
3733            details: None,
3734        }
3735    }
3736}
3737///
3738#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3739pub enum HelmErrorErrorType {
3740    #[serde(rename = "invalid_request")]
3741    InvalidRequest,
3742    #[serde(rename = "authentication_error")]
3743    AuthenticationError,
3744    #[serde(rename = "permission_denied")]
3745    PermissionDenied,
3746    #[serde(rename = "not_found")]
3747    NotFound,
3748    #[serde(rename = "internal_error")]
3749    InternalError,
3750}
3751
3752impl Default for HelmErrorErrorType {
3753    fn default() -> HelmErrorErrorType {
3754        Self::InvalidRequest
3755    }
3756}
3757/// HELM-specific reason code
3758#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
3759pub enum HelmErrorErrorReasonCode {
3760    #[serde(rename = "DENY_TOOL_NOT_FOUND")]
3761    DenyToolNotFound,
3762    #[serde(rename = "DENY_SCHEMA_MISMATCH")]
3763    DenySchemaMismatch,
3764    #[serde(rename = "DENY_OUTPUT_DRIFT")]
3765    DenyOutputDrift,
3766    #[serde(rename = "DENY_BUDGET_EXCEEDED")]
3767    DenyBudgetExceeded,
3768    #[serde(rename = "DENY_APPROVAL_REQUIRED")]
3769    DenyApprovalRequired,
3770    #[serde(rename = "DENY_APPROVAL_TIMEOUT")]
3771    DenyApprovalTimeout,
3772    #[serde(rename = "DENY_SANDBOX_TRAP")]
3773    DenySandboxTrap,
3774    #[serde(rename = "DENY_GAS_EXHAUSTION")]
3775    DenyGasExhaustion,
3776    #[serde(rename = "DENY_TIME_LIMIT")]
3777    DenyTimeLimit,
3778    #[serde(rename = "DENY_MEMORY_LIMIT")]
3779    DenyMemoryLimit,
3780    #[serde(rename = "DENY_POLICY_VIOLATION")]
3781    DenyPolicyViolation,
3782    #[serde(rename = "DENY_TRUST_KEY_REVOKED")]
3783    DenyTrustKeyRevoked,
3784    #[serde(rename = "DENY_IDEMPOTENCY_DUPLICATE")]
3785    DenyIdempotencyDuplicate,
3786    #[serde(rename = "ERROR_INTERNAL")]
3787    ErrorInternal,
3788}
3789
3790impl Default for HelmErrorErrorReasonCode {
3791    fn default() -> HelmErrorErrorReasonCode {
3792        Self::DenyToolNotFound
3793    }
3794}
3795
3796/*
3797 * HELM Kernel API
3798 *
3799 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3800 *
3801 * The version of the OpenAPI document: 0.5.19
3802 *
3803 * Generated by: https://openapi-generator.tech
3804 */
3805
3806
3807#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3808pub struct ImportEvidenceLedger {
3809    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
3810    pub status: Option<String>,
3811    #[serde(rename = "receipt_refs", skip_serializing_if = "Option::is_none")]
3812    pub receipt_refs: Option<Vec<String>>,
3813    #[serde(rename = "evidence_pack_refs", skip_serializing_if = "Option::is_none")]
3814    pub evidence_pack_refs: Option<Vec<String>>,
3815    #[serde(rename = "sbom_ref", skip_serializing_if = "Option::is_none")]
3816    pub sbom_ref: Option<String>,
3817    #[serde(rename = "vulnerability_scan_ref", skip_serializing_if = "Option::is_none")]
3818    pub vulnerability_scan_ref: Option<String>,
3819    #[serde(rename = "provenance_ref", skip_serializing_if = "Option::is_none")]
3820    pub provenance_ref: Option<String>,
3821    #[serde(rename = "license_ref", skip_serializing_if = "Option::is_none")]
3822    pub license_ref: Option<String>,
3823    #[serde(rename = "policy_refs", skip_serializing_if = "Option::is_none")]
3824    pub policy_refs: Option<Vec<String>>,
3825    #[serde(rename = "offline_verify_command", skip_serializing_if = "Option::is_none")]
3826    pub offline_verify_command: Option<String>,
3827}
3828
3829impl ImportEvidenceLedger {
3830    pub fn new() -> ImportEvidenceLedger {
3831        ImportEvidenceLedger {
3832            status: None,
3833            receipt_refs: None,
3834            evidence_pack_refs: None,
3835            sbom_ref: None,
3836            vulnerability_scan_ref: None,
3837            provenance_ref: None,
3838            license_ref: None,
3839            policy_refs: None,
3840            offline_verify_command: None,
3841        }
3842    }
3843}
3844
3845/*
3846 * HELM Kernel API
3847 *
3848 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3849 *
3850 * The version of the OpenAPI document: 0.5.19
3851 *
3852 * Generated by: https://openapi-generator.tech
3853 */
3854
3855
3856#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3857pub struct ImportPreflightResult {
3858    #[serde(rename = "import_id")]
3859    pub import_id: String,
3860    #[serde(rename = "status")]
3861    pub status: String,
3862    #[serde(rename = "checks")]
3863    pub checks: Vec<PreflightCheck>,
3864    #[serde(rename = "blocked_reasons", skip_serializing_if = "Option::is_none")]
3865    pub blocked_reasons: Option<Vec<String>>,
3866    #[serde(rename = "evidence_ledger")]
3867    pub evidence_ledger: Box<ImportEvidenceLedger>,
3868}
3869
3870impl ImportPreflightResult {
3871    pub fn new(import_id: String, status: String, checks: Vec<PreflightCheck>, evidence_ledger: ImportEvidenceLedger) -> ImportPreflightResult {
3872        ImportPreflightResult {
3873            import_id,
3874            status,
3875            checks,
3876            blocked_reasons: None,
3877            evidence_ledger: Box::new(evidence_ledger),
3878        }
3879    }
3880}
3881
3882/*
3883 * HELM Kernel API
3884 *
3885 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3886 *
3887 * The version of the OpenAPI document: 0.5.19
3888 *
3889 * Generated by: https://openapi-generator.tech
3890 */
3891
3892
3893#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3894pub struct LaunchRecipe {
3895    #[serde(rename = "import_id")]
3896    pub import_id: String,
3897    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
3898    pub generated_at: Option<String>,
3899    #[serde(rename = "detection_order")]
3900    pub detection_order: Vec<String>,
3901    #[serde(rename = "build_strategy")]
3902    pub build_strategy: Box<BuildStrategy>,
3903    #[serde(rename = "target_plans")]
3904    pub target_plans: Vec<TargetPlan>,
3905    #[serde(rename = "generated_app_specs")]
3906    pub generated_app_specs: Vec<GeneratedAppSpecCandidate>,
3907    #[serde(rename = "promotion_state")]
3908    pub promotion_state: String,
3909    #[serde(rename = "promotion_requirements", skip_serializing_if = "Option::is_none")]
3910    pub promotion_requirements: Option<Vec<String>>,
3911    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
3912    pub cli_equivalent: Option<String>,
3913}
3914
3915impl LaunchRecipe {
3916    pub fn new(import_id: String, detection_order: Vec<String>, build_strategy: BuildStrategy, target_plans: Vec<TargetPlan>, generated_app_specs: Vec<GeneratedAppSpecCandidate>, promotion_state: String) -> LaunchRecipe {
3917        LaunchRecipe {
3918            import_id,
3919            generated_at: None,
3920            detection_order,
3921            build_strategy: Box::new(build_strategy),
3922            target_plans,
3923            generated_app_specs,
3924            promotion_state,
3925            promotion_requirements: None,
3926            cli_equivalent: None,
3927        }
3928    }
3929}
3930
3931/*
3932 * HELM Kernel API
3933 *
3934 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
3935 *
3936 * The version of the OpenAPI document: 0.5.19
3937 *
3938 * Generated by: https://openapi-generator.tech
3939 */
3940
3941
3942#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
3943pub struct LaunchpadApp {
3944    #[serde(rename = "id")]
3945    pub id: String,
3946    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
3947    pub app_id: Option<String>,
3948    #[serde(rename = "name")]
3949    pub name: String,
3950    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
3951    pub version: Option<String>,
3952    #[serde(rename = "oci_ref", skip_serializing_if = "Option::is_none")]
3953    pub oci_ref: Option<String>,
3954    #[serde(rename = "immutable_digest", skip_serializing_if = "Option::is_none")]
3955    pub immutable_digest: Option<String>,
3956    #[serde(rename = "oss_supported", skip_serializing_if = "Option::is_none")]
3957    pub oss_supported: Option<bool>,
3958    #[serde(rename = "availability", skip_serializing_if = "Option::is_none")]
3959    pub availability: Option<String>,
3960    #[serde(rename = "redistribution", skip_serializing_if = "Option::is_none")]
3961    pub redistribution: Option<String>,
3962    #[serde(rename = "install_strategy", skip_serializing_if = "Option::is_none")]
3963    pub install_strategy: Option<String>,
3964    #[serde(rename = "risk_class", skip_serializing_if = "Option::is_none")]
3965    pub risk_class: Option<String>,
3966    #[serde(rename = "blocked_reason", skip_serializing_if = "Option::is_none")]
3967    pub blocked_reason: Option<String>,
3968    #[serde(rename = "required_secrets", skip_serializing_if = "Option::is_none")]
3969    pub required_secrets: Option<Vec<String>>,
3970    #[serde(rename = "model_gateway_env", skip_serializing_if = "Option::is_none")]
3971    pub model_gateway_env: Option<Vec<String>>,
3972    #[serde(rename = "declared_capabilities", skip_serializing_if = "Option::is_none")]
3973    pub declared_capabilities: Option<Vec<String>>,
3974    #[serde(rename = "mcp_servers", skip_serializing_if = "Option::is_none")]
3975    pub mcp_servers: Option<Vec<LaunchpadMcpServer>>,
3976    #[serde(rename = "filesystem_needs", skip_serializing_if = "Option::is_none")]
3977    pub filesystem_needs: Option<Vec<String>>,
3978    #[serde(rename = "network_needs", skip_serializing_if = "Option::is_none")]
3979    pub network_needs: Option<Vec<String>>,
3980    #[serde(rename = "healthcheck", skip_serializing_if = "Option::is_none")]
3981    pub healthcheck: Option<std::collections::HashMap<String, serde_json::Value>>,
3982    #[serde(rename = "teardown_recipe", skip_serializing_if = "Option::is_none")]
3983    pub teardown_recipe: Option<std::collections::HashMap<String, serde_json::Value>>,
3984    #[serde(rename = "evidence_profile", skip_serializing_if = "Option::is_none")]
3985    pub evidence_profile: Option<std::collections::HashMap<String, serde_json::Value>>,
3986    #[serde(rename = "policy_ref", skip_serializing_if = "Option::is_none")]
3987    pub policy_ref: Option<String>,
3988    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
3989    pub user_state: Option<String>,
3990    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
3991    pub required_capability: Option<String>,
3992    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
3993    pub upgrade_reason: Option<String>,
3994    #[serde(rename = "entitlement_decision", skip_serializing_if = "Option::is_none")]
3995    pub entitlement_decision: Option<Box<EntitlementDecision>>,
3996    #[serde(rename = "action_states", skip_serializing_if = "Option::is_none")]
3997    pub action_states: Option<std::collections::HashMap<String, EntitlementDecision>>,
3998    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
3999    pub status: Option<Box<LaunchpadAppStatus>>,
4000}
4001
4002impl LaunchpadApp {
4003    pub fn new(id: String, name: String) -> LaunchpadApp {
4004        LaunchpadApp {
4005            id,
4006            app_id: None,
4007            name,
4008            version: None,
4009            oci_ref: None,
4010            immutable_digest: None,
4011            oss_supported: None,
4012            availability: None,
4013            redistribution: None,
4014            install_strategy: None,
4015            risk_class: None,
4016            blocked_reason: None,
4017            required_secrets: None,
4018            model_gateway_env: None,
4019            declared_capabilities: None,
4020            mcp_servers: None,
4021            filesystem_needs: None,
4022            network_needs: None,
4023            healthcheck: None,
4024            teardown_recipe: None,
4025            evidence_profile: None,
4026            policy_ref: None,
4027            user_state: None,
4028            required_capability: None,
4029            upgrade_reason: None,
4030            entitlement_decision: None,
4031            action_states: None,
4032            status: None,
4033        }
4034    }
4035}
4036
4037/*
4038 * HELM Kernel API
4039 *
4040 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4041 *
4042 * The version of the OpenAPI document: 0.5.19
4043 *
4044 * Generated by: https://openapi-generator.tech
4045 */
4046
4047
4048#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4049pub struct LaunchpadAppStatus {
4050    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
4051    pub state: Option<String>,
4052    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
4053    pub verdict: Option<String>,
4054    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
4055    pub reason_code: Option<String>,
4056    #[serde(rename = "human_summary", skip_serializing_if = "Option::is_none")]
4057    pub human_summary: Option<String>,
4058    #[serde(rename = "missing_secrets", skip_serializing_if = "Option::is_none")]
4059    pub missing_secrets: Option<Vec<String>>,
4060    #[serde(rename = "quarantined_mcp", skip_serializing_if = "Option::is_none")]
4061    pub quarantined_mcp: Option<i32>,
4062    #[serde(rename = "last_run_id", skip_serializing_if = "Option::is_none")]
4063    pub last_run_id: Option<String>,
4064    #[serde(rename = "last_evidencepack_ref", skip_serializing_if = "Option::is_none")]
4065    pub last_evidencepack_ref: Option<String>,
4066    #[serde(rename = "proof_status", skip_serializing_if = "Option::is_none")]
4067    pub proof_status: Option<String>,
4068}
4069
4070impl LaunchpadAppStatus {
4071    pub fn new() -> LaunchpadAppStatus {
4072        LaunchpadAppStatus {
4073            state: None,
4074            verdict: None,
4075            reason_code: None,
4076            human_summary: None,
4077            missing_secrets: None,
4078            quarantined_mcp: None,
4079            last_run_id: None,
4080            last_evidencepack_ref: None,
4081            proof_status: None,
4082        }
4083    }
4084}
4085
4086/*
4087 * HELM Kernel API
4088 *
4089 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4090 *
4091 * The version of the OpenAPI document: 0.5.19
4092 *
4093 * Generated by: https://openapi-generator.tech
4094 */
4095
4096
4097#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4098pub struct LaunchpadFixAction {
4099    #[serde(rename = "label", skip_serializing_if = "Option::is_none")]
4100    pub label: Option<String>,
4101    #[serde(rename = "cli", skip_serializing_if = "Option::is_none")]
4102    pub cli: Option<String>,
4103    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
4104    pub description: Option<String>,
4105}
4106
4107impl LaunchpadFixAction {
4108    pub fn new() -> LaunchpadFixAction {
4109        LaunchpadFixAction {
4110            label: None,
4111            cli: None,
4112            description: None,
4113        }
4114    }
4115}
4116
4117/*
4118 * HELM Kernel API
4119 *
4120 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4121 *
4122 * The version of the OpenAPI document: 0.5.19
4123 *
4124 * Generated by: https://openapi-generator.tech
4125 */
4126
4127
4128#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4129pub struct LaunchpadGateResult {
4130    #[serde(rename = "id")]
4131    pub id: String,
4132    #[serde(rename = "group")]
4133    pub group: String,
4134    #[serde(rename = "label")]
4135    pub label: String,
4136    #[serde(rename = "verdict")]
4137    pub verdict: String,
4138    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
4139    pub reason_code: Option<String>,
4140    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
4141    pub receipt_ref: Option<String>,
4142    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
4143    pub proofgraph_node: Option<String>,
4144    #[serde(rename = "evidence_refs", skip_serializing_if = "Option::is_none")]
4145    pub evidence_refs: Option<Vec<String>>,
4146    #[serde(rename = "summary", skip_serializing_if = "Option::is_none")]
4147    pub summary: Option<String>,
4148    #[serde(rename = "why", skip_serializing_if = "Option::is_none")]
4149    pub why: Option<String>,
4150    #[serde(rename = "proof_status")]
4151    pub proof_status: String,
4152    #[serde(rename = "raw_detail_ref", skip_serializing_if = "Option::is_none")]
4153    pub raw_detail_ref: Option<String>,
4154    #[serde(rename = "raw_proof_ref", skip_serializing_if = "Option::is_none")]
4155    pub raw_proof_ref: Option<String>,
4156    #[serde(rename = "receipt_required", skip_serializing_if = "Option::is_none")]
4157    pub receipt_required: Option<bool>,
4158    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
4159    pub cli_equivalent: Option<String>,
4160    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
4161    pub fix_actions: Option<Vec<LaunchpadFixAction>>,
4162}
4163
4164impl LaunchpadGateResult {
4165    pub fn new(id: String, group: String, label: String, verdict: String, proof_status: String) -> LaunchpadGateResult {
4166        LaunchpadGateResult {
4167            id,
4168            group,
4169            label,
4170            verdict,
4171            reason_code: None,
4172            receipt_ref: None,
4173            proofgraph_node: None,
4174            evidence_refs: None,
4175            summary: None,
4176            why: None,
4177            proof_status,
4178            raw_detail_ref: None,
4179            raw_proof_ref: None,
4180            receipt_required: None,
4181            cli_equivalent: None,
4182            fix_actions: None,
4183        }
4184    }
4185}
4186
4187/*
4188 * HELM Kernel API
4189 *
4190 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4191 *
4192 * The version of the OpenAPI document: 0.5.19
4193 *
4194 * Generated by: https://openapi-generator.tech
4195 */
4196
4197
4198#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4199pub struct LaunchpadImportRecord {
4200    #[serde(rename = "id")]
4201    pub id: String,
4202    #[serde(rename = "state")]
4203    pub state: LaunchpadImportRecordState,
4204    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
4205    pub created_at: Option<String>,
4206    #[serde(rename = "updated_at", skip_serializing_if = "Option::is_none")]
4207    pub updated_at: Option<String>,
4208    #[serde(rename = "request")]
4209    pub request: Box<LaunchpadImportRequest>,
4210    #[serde(rename = "source_snapshot")]
4211    pub source_snapshot: Box<SourceSnapshot>,
4212    #[serde(rename = "capability_graph")]
4213    pub capability_graph: Box<CapabilityGraph>,
4214    #[serde(rename = "launch_recipe")]
4215    pub launch_recipe: Box<LaunchRecipe>,
4216    #[serde(rename = "preflight", skip_serializing_if = "Option::is_none")]
4217    pub preflight: Option<Box<ImportPreflightResult>>,
4218    #[serde(rename = "evidence_ledger")]
4219    pub evidence_ledger: Box<ImportEvidenceLedger>,
4220}
4221
4222impl LaunchpadImportRecord {
4223    pub fn new(id: String, state: LaunchpadImportRecordState, request: LaunchpadImportRequest, source_snapshot: SourceSnapshot, capability_graph: CapabilityGraph, launch_recipe: LaunchRecipe, evidence_ledger: ImportEvidenceLedger) -> LaunchpadImportRecord {
4224        LaunchpadImportRecord {
4225            id,
4226            state,
4227            created_at: None,
4228            updated_at: None,
4229            request: Box::new(request),
4230            source_snapshot: Box::new(source_snapshot),
4231            capability_graph: Box::new(capability_graph),
4232            launch_recipe: Box::new(launch_recipe),
4233            preflight: None,
4234            evidence_ledger: Box::new(evidence_ledger),
4235        }
4236    }
4237}
4238///
4239#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
4240pub enum LaunchpadImportRecordState {
4241    #[serde(rename = "IMPORTED")]
4242    Imported,
4243    #[serde(rename = "PREFLIGHTED")]
4244    Preflighted,
4245    #[serde(rename = "PROMOTABLE")]
4246    Promotable,
4247    #[serde(rename = "BLOCKED")]
4248    Blocked,
4249    #[serde(rename = "LAUNCHED")]
4250    Launched,
4251    #[serde(rename = "TORN_DOWN")]
4252    TornDown,
4253}
4254
4255impl Default for LaunchpadImportRecordState {
4256    fn default() -> LaunchpadImportRecordState {
4257        Self::Imported
4258    }
4259}
4260
4261/*
4262 * HELM Kernel API
4263 *
4264 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4265 *
4266 * The version of the OpenAPI document: 0.5.19
4267 *
4268 * Generated by: https://openapi-generator.tech
4269 */
4270
4271
4272#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4273pub struct LaunchpadImportRequest {
4274    #[serde(rename = "repo_url")]
4275    pub repo_url: String,
4276    #[serde(rename = "ref", skip_serializing_if = "Option::is_none")]
4277    pub r#ref: Option<String>,
4278    #[serde(rename = "desired_target", skip_serializing_if = "Option::is_none")]
4279    pub desired_target: Option<String>,
4280}
4281
4282impl LaunchpadImportRequest {
4283    pub fn new(repo_url: String) -> LaunchpadImportRequest {
4284        LaunchpadImportRequest {
4285            repo_url,
4286            r#ref: None,
4287            desired_target: None,
4288        }
4289    }
4290}
4291
4292/*
4293 * HELM Kernel API
4294 *
4295 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4296 *
4297 * The version of the OpenAPI document: 0.5.19
4298 *
4299 * Generated by: https://openapi-generator.tech
4300 */
4301
4302
4303#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4304pub struct LaunchpadMatrixCell {
4305    #[serde(rename = "app_id")]
4306    pub app_id: String,
4307    #[serde(rename = "substrate_id")]
4308    pub substrate_id: String,
4309    #[serde(rename = "launchable")]
4310    pub launchable: bool,
4311    #[serde(rename = "verdict")]
4312    pub verdict: String,
4313    #[serde(rename = "reason")]
4314    pub reason: String,
4315    #[serde(rename = "availability")]
4316    pub availability: String,
4317    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
4318    pub user_state: Option<String>,
4319    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
4320    pub required_capability: Option<String>,
4321    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
4322    pub upgrade_reason: Option<String>,
4323    #[serde(rename = "entitlement_decision", skip_serializing_if = "Option::is_none")]
4324    pub entitlement_decision: Option<Box<EntitlementDecision>>,
4325    #[serde(rename = "action_states", skip_serializing_if = "Option::is_none")]
4326    pub action_states: Option<std::collections::HashMap<String, EntitlementDecision>>,
4327}
4328
4329impl LaunchpadMatrixCell {
4330    pub fn new(app_id: String, substrate_id: String, launchable: bool, verdict: String, reason: String, availability: String) -> LaunchpadMatrixCell {
4331        LaunchpadMatrixCell {
4332            app_id,
4333            substrate_id,
4334            launchable,
4335            verdict,
4336            reason,
4337            availability,
4338            user_state: None,
4339            required_capability: None,
4340            upgrade_reason: None,
4341            entitlement_decision: None,
4342            action_states: None,
4343        }
4344    }
4345}
4346
4347/*
4348 * HELM Kernel API
4349 *
4350 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4351 *
4352 * The version of the OpenAPI document: 0.5.19
4353 *
4354 * Generated by: https://openapi-generator.tech
4355 */
4356
4357
4358#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4359pub struct LaunchpadMcpServer {
4360    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
4361    pub id: Option<String>,
4362    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
4363    pub endpoint: Option<String>,
4364    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
4365    pub transport: Option<String>,
4366    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
4367    pub status: Option<String>,
4368    #[serde(rename = "risk_class", skip_serializing_if = "Option::is_none")]
4369    pub risk_class: Option<String>,
4370    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
4371    pub tools: Option<Vec<String>>,
4372    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
4373    pub receipt_ref: Option<String>,
4374}
4375
4376impl LaunchpadMcpServer {
4377    pub fn new() -> LaunchpadMcpServer {
4378        LaunchpadMcpServer {
4379            id: None,
4380            endpoint: None,
4381            transport: None,
4382            status: None,
4383            risk_class: None,
4384            tools: None,
4385            receipt_ref: None,
4386        }
4387    }
4388}
4389
4390/*
4391 * HELM Kernel API
4392 *
4393 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4394 *
4395 * The version of the OpenAPI document: 0.5.19
4396 *
4397 * Generated by: https://openapi-generator.tech
4398 */
4399
4400
4401#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4402pub struct LaunchpadPlanRequest {
4403    #[serde(rename = "app_id")]
4404    pub app_id: String,
4405    #[serde(rename = "substrate_id")]
4406    pub substrate_id: String,
4407    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
4408    pub principal: Option<String>,
4409}
4410
4411impl LaunchpadPlanRequest {
4412    pub fn new(app_id: String, substrate_id: String) -> LaunchpadPlanRequest {
4413        LaunchpadPlanRequest {
4414            app_id,
4415            substrate_id,
4416            principal: None,
4417        }
4418    }
4419}
4420
4421/*
4422 * HELM Kernel API
4423 *
4424 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4425 *
4426 * The version of the OpenAPI document: 0.5.19
4427 *
4428 * Generated by: https://openapi-generator.tech
4429 */
4430
4431
4432#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4433pub struct LaunchpadPlanResponse {
4434    #[serde(rename = "launch_id", skip_serializing_if = "Option::is_none")]
4435    pub launch_id: Option<String>,
4436    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
4437    pub app_id: Option<String>,
4438    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
4439    pub substrate_id: Option<String>,
4440    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
4441    pub state: Option<String>,
4442    #[serde(rename = "kernel_verdict", skip_serializing_if = "Option::is_none")]
4443    pub kernel_verdict: Option<String>,
4444    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
4445    pub reason: Option<String>,
4446    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
4447    pub reason_code: Option<String>,
4448    #[serde(rename = "plan_hash", skip_serializing_if = "Option::is_none")]
4449    pub plan_hash: Option<String>,
4450    #[serde(rename = "user_state", skip_serializing_if = "Option::is_none")]
4451    pub user_state: Option<String>,
4452    #[serde(rename = "required_capability", skip_serializing_if = "Option::is_none")]
4453    pub required_capability: Option<String>,
4454    #[serde(rename = "upgrade_reason", skip_serializing_if = "Option::is_none")]
4455    pub upgrade_reason: Option<String>,
4456    #[serde(rename = "entitlement_decision", skip_serializing_if = "Option::is_none")]
4457    pub entitlement_decision: Option<Box<EntitlementDecision>>,
4458    #[serde(rename = "action_states", skip_serializing_if = "Option::is_none")]
4459    pub action_states: Option<std::collections::HashMap<String, EntitlementDecision>>,
4460}
4461
4462impl LaunchpadPlanResponse {
4463    pub fn new() -> LaunchpadPlanResponse {
4464        LaunchpadPlanResponse {
4465            launch_id: None,
4466            app_id: None,
4467            substrate_id: None,
4468            state: None,
4469            kernel_verdict: None,
4470            reason: None,
4471            reason_code: None,
4472            plan_hash: None,
4473            user_state: None,
4474            required_capability: None,
4475            upgrade_reason: None,
4476            entitlement_decision: None,
4477            action_states: None,
4478        }
4479    }
4480}
4481
4482/*
4483 * HELM Kernel API
4484 *
4485 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4486 *
4487 * The version of the OpenAPI document: 0.5.19
4488 *
4489 * Generated by: https://openapi-generator.tech
4490 */
4491
4492
4493#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4494pub struct LaunchpadPolicySimulation {
4495    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
4496    pub app_id: Option<String>,
4497    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
4498    pub verdict: Option<String>,
4499    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
4500    pub reason_code: Option<String>,
4501    #[serde(rename = "plain_english", skip_serializing_if = "Option::is_none")]
4502    pub plain_english: Option<String>,
4503    #[serde(rename = "structured", skip_serializing_if = "Option::is_none")]
4504    pub structured: Option<std::collections::HashMap<String, serde_json::Value>>,
4505    #[serde(rename = "diff", skip_serializing_if = "Option::is_none")]
4506    pub diff: Option<Vec<String>>,
4507    #[serde(rename = "raw", skip_serializing_if = "Option::is_none")]
4508    pub raw: Option<std::collections::HashMap<String, serde_json::Value>>,
4509    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
4510    pub receipt_ref: Option<String>,
4511    #[serde(rename = "proof_status", skip_serializing_if = "Option::is_none")]
4512    pub proof_status: Option<String>,
4513    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
4514    pub cli_equivalent: Option<String>,
4515    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
4516    pub fix_actions: Option<Vec<LaunchpadFixAction>>,
4517}
4518
4519impl LaunchpadPolicySimulation {
4520    pub fn new() -> LaunchpadPolicySimulation {
4521        LaunchpadPolicySimulation {
4522            app_id: None,
4523            verdict: None,
4524            reason_code: None,
4525            plain_english: None,
4526            structured: None,
4527            diff: None,
4528            raw: None,
4529            receipt_ref: None,
4530            proof_status: None,
4531            cli_equivalent: None,
4532            fix_actions: None,
4533        }
4534    }
4535}
4536
4537/*
4538 * HELM Kernel API
4539 *
4540 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4541 *
4542 * The version of the OpenAPI document: 0.5.19
4543 *
4544 * Generated by: https://openapi-generator.tech
4545 */
4546
4547
4548#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4549pub struct LaunchpadRun {
4550    #[serde(rename = "launch_id", skip_serializing_if = "Option::is_none")]
4551    pub launch_id: Option<String>,
4552    #[serde(rename = "run_id", skip_serializing_if = "Option::is_none")]
4553    pub run_id: Option<String>,
4554    #[serde(rename = "app_id", skip_serializing_if = "Option::is_none")]
4555    pub app_id: Option<String>,
4556    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
4557    pub substrate_id: Option<String>,
4558    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
4559    pub state: Option<String>,
4560    #[serde(rename = "kernel_verdict", skip_serializing_if = "Option::is_none")]
4561    pub kernel_verdict: Option<String>,
4562    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
4563    pub reason: Option<String>,
4564    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
4565    pub reason_code: Option<String>,
4566    #[serde(rename = "plan_hash", skip_serializing_if = "Option::is_none")]
4567    pub plan_hash: Option<String>,
4568    #[serde(rename = "launchplan_hash", skip_serializing_if = "Option::is_none")]
4569    pub launchplan_hash: Option<String>,
4570    #[serde(rename = "install_receipt_ref", skip_serializing_if = "Option::is_none")]
4571    pub install_receipt_ref: Option<String>,
4572    #[serde(rename = "launch_receipt_ref", skip_serializing_if = "Option::is_none")]
4573    pub launch_receipt_ref: Option<String>,
4574    #[serde(rename = "health_receipt_ref", skip_serializing_if = "Option::is_none")]
4575    pub health_receipt_ref: Option<String>,
4576    #[serde(rename = "teardown_receipt_ref", skip_serializing_if = "Option::is_none")]
4577    pub teardown_receipt_ref: Option<String>,
4578    #[serde(rename = "evidence_pack_refs", skip_serializing_if = "Option::is_none")]
4579    pub evidence_pack_refs: Option<Vec<String>>,
4580    #[serde(rename = "secret_grant_refs", skip_serializing_if = "Option::is_none")]
4581    pub secret_grant_refs: Option<Vec<String>>,
4582    #[serde(rename = "start_receipt_refs", skip_serializing_if = "Option::is_none")]
4583    pub start_receipt_refs: Option<Vec<String>>,
4584    #[serde(rename = "verification_command", skip_serializing_if = "Option::is_none")]
4585    pub verification_command: Option<String>,
4586    #[serde(rename = "teardown_command", skip_serializing_if = "Option::is_none")]
4587    pub teardown_command: Option<String>,
4588    #[serde(rename = "runtime_handles", skip_serializing_if = "Option::is_none")]
4589    pub runtime_handles: Option<std::collections::HashMap<String, serde_json::Value>>,
4590}
4591
4592impl LaunchpadRun {
4593    pub fn new() -> LaunchpadRun {
4594        LaunchpadRun {
4595            launch_id: None,
4596            run_id: None,
4597            app_id: None,
4598            substrate_id: None,
4599            state: None,
4600            kernel_verdict: None,
4601            reason: None,
4602            reason_code: None,
4603            plan_hash: None,
4604            launchplan_hash: None,
4605            install_receipt_ref: None,
4606            launch_receipt_ref: None,
4607            health_receipt_ref: None,
4608            teardown_receipt_ref: None,
4609            evidence_pack_refs: None,
4610            secret_grant_refs: None,
4611            start_receipt_refs: None,
4612            verification_command: None,
4613            teardown_command: None,
4614            runtime_handles: None,
4615        }
4616    }
4617}
4618
4619/*
4620 * HELM Kernel API
4621 *
4622 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4623 *
4624 * The version of the OpenAPI document: 0.5.19
4625 *
4626 * Generated by: https://openapi-generator.tech
4627 */
4628
4629
4630#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4631pub struct LaunchpadRunDetail {
4632    #[serde(rename = "run")]
4633    pub run: Box<LaunchpadRun>,
4634    #[serde(rename = "app", skip_serializing_if = "Option::is_none")]
4635    pub app: Option<Box<LaunchpadApp>>,
4636    #[serde(rename = "instance")]
4637    pub instance: Box<LaunchpadRuntimeInstance>,
4638    #[serde(rename = "gates")]
4639    pub gates: Vec<LaunchpadGateResult>,
4640    #[serde(rename = "events")]
4641    pub events: Vec<LaunchpadRunEvent>,
4642    #[serde(rename = "offline_verification", skip_serializing_if = "Option::is_none")]
4643    pub offline_verification: Option<std::collections::HashMap<String, serde_json::Value>>,
4644}
4645
4646impl LaunchpadRunDetail {
4647    pub fn new(run: LaunchpadRun, instance: LaunchpadRuntimeInstance, gates: Vec<LaunchpadGateResult>, events: Vec<LaunchpadRunEvent>) -> LaunchpadRunDetail {
4648        LaunchpadRunDetail {
4649            run: Box::new(run),
4650            app: None,
4651            instance: Box::new(instance),
4652            gates,
4653            events,
4654            offline_verification: None,
4655        }
4656    }
4657}
4658
4659/*
4660 * HELM Kernel API
4661 *
4662 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4663 *
4664 * The version of the OpenAPI document: 0.5.19
4665 *
4666 * Generated by: https://openapi-generator.tech
4667 */
4668
4669
4670#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4671pub struct LaunchpadRunEvent {
4672    #[serde(rename = "run_id")]
4673    pub run_id: String,
4674    #[serde(rename = "stage")]
4675    pub stage: String,
4676    #[serde(rename = "verdict")]
4677    pub verdict: String,
4678    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
4679    pub reason_code: Option<String>,
4680    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
4681    pub receipt_ref: Option<String>,
4682    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
4683    pub proofgraph_node: Option<String>,
4684    #[serde(rename = "evidence_refs", skip_serializing_if = "Option::is_none")]
4685    pub evidence_refs: Option<Vec<String>>,
4686    #[serde(rename = "raw_payload_ref", skip_serializing_if = "Option::is_none")]
4687    pub raw_payload_ref: Option<String>,
4688    #[serde(rename = "human_summary", skip_serializing_if = "Option::is_none")]
4689    pub human_summary: Option<String>,
4690    #[serde(rename = "why", skip_serializing_if = "Option::is_none")]
4691    pub why: Option<String>,
4692    #[serde(rename = "proof_status")]
4693    pub proof_status: String,
4694    #[serde(rename = "receipt_required", skip_serializing_if = "Option::is_none")]
4695    pub receipt_required: Option<bool>,
4696    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
4697    pub cli_equivalent: Option<String>,
4698    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
4699    pub fix_actions: Option<Vec<LaunchpadFixAction>>,
4700    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
4701    pub created_at: Option<String>,
4702}
4703
4704impl LaunchpadRunEvent {
4705    pub fn new(run_id: String, stage: String, verdict: String, proof_status: String) -> LaunchpadRunEvent {
4706        LaunchpadRunEvent {
4707            run_id,
4708            stage,
4709            verdict,
4710            reason_code: None,
4711            receipt_ref: None,
4712            proofgraph_node: None,
4713            evidence_refs: None,
4714            raw_payload_ref: None,
4715            human_summary: None,
4716            why: None,
4717            proof_status,
4718            receipt_required: None,
4719            cli_equivalent: None,
4720            fix_actions: None,
4721            created_at: None,
4722        }
4723    }
4724}
4725
4726/*
4727 * HELM Kernel API
4728 *
4729 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4730 *
4731 * The version of the OpenAPI document: 0.5.19
4732 *
4733 * Generated by: https://openapi-generator.tech
4734 */
4735
4736
4737#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4738pub struct LaunchpadRuntimeInstance {
4739    #[serde(rename = "run_id")]
4740    pub run_id: String,
4741    #[serde(rename = "container_id", skip_serializing_if = "Option::is_none")]
4742    pub container_id: Option<String>,
4743    #[serde(rename = "launchplan_hash", skip_serializing_if = "Option::is_none")]
4744    pub launchplan_hash: Option<String>,
4745    #[serde(rename = "state")]
4746    pub state: String,
4747    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
4748    pub verdict: Option<String>,
4749    #[serde(rename = "active_grants", skip_serializing_if = "Option::is_none")]
4750    pub active_grants: Option<Vec<String>>,
4751    #[serde(rename = "receipt_refs", skip_serializing_if = "Option::is_none")]
4752    pub receipt_refs: Option<Vec<String>>,
4753    #[serde(rename = "evidencepack_ref", skip_serializing_if = "Option::is_none")]
4754    pub evidencepack_ref: Option<String>,
4755    #[serde(rename = "offline_verify_command", skip_serializing_if = "Option::is_none")]
4756    pub offline_verify_command: Option<String>,
4757    #[serde(rename = "teardown_command", skip_serializing_if = "Option::is_none")]
4758    pub teardown_command: Option<String>,
4759    #[serde(rename = "sandbox_grant", skip_serializing_if = "Option::is_none")]
4760    pub sandbox_grant: Option<Box<LaunchpadSandboxGrant>>,
4761    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
4762    pub cli_equivalent: Option<String>,
4763}
4764
4765impl LaunchpadRuntimeInstance {
4766    pub fn new(run_id: String, state: String) -> LaunchpadRuntimeInstance {
4767        LaunchpadRuntimeInstance {
4768            run_id,
4769            container_id: None,
4770            launchplan_hash: None,
4771            state,
4772            verdict: None,
4773            active_grants: None,
4774            receipt_refs: None,
4775            evidencepack_ref: None,
4776            offline_verify_command: None,
4777            teardown_command: None,
4778            sandbox_grant: None,
4779            cli_equivalent: None,
4780        }
4781    }
4782}
4783
4784/*
4785 * HELM Kernel API
4786 *
4787 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4788 *
4789 * The version of the OpenAPI document: 0.5.19
4790 *
4791 * Generated by: https://openapi-generator.tech
4792 */
4793
4794
4795#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4796pub struct LaunchpadSandboxGrant {
4797    #[serde(rename = "backend_profile", skip_serializing_if = "Option::is_none")]
4798    pub backend_profile: Option<String>,
4799    #[serde(rename = "runtime", skip_serializing_if = "Option::is_none")]
4800    pub runtime: Option<String>,
4801    #[serde(rename = "runtime_version", skip_serializing_if = "Option::is_none")]
4802    pub runtime_version: Option<String>,
4803    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
4804    pub image_digest: Option<String>,
4805    #[serde(rename = "filesystem_preopens", skip_serializing_if = "Option::is_none")]
4806    pub filesystem_preopens: Option<Vec<String>>,
4807    #[serde(rename = "network_policy", skip_serializing_if = "Option::is_none")]
4808    pub network_policy: Option<Vec<String>>,
4809    #[serde(rename = "env", skip_serializing_if = "Option::is_none")]
4810    pub env: Option<Vec<String>>,
4811    #[serde(rename = "resource_limits", skip_serializing_if = "Option::is_none")]
4812    pub resource_limits: Option<std::collections::HashMap<String, String>>,
4813    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
4814    pub policy_epoch: Option<String>,
4815    #[serde(rename = "grant_hash", skip_serializing_if = "Option::is_none")]
4816    pub grant_hash: Option<String>,
4817    #[serde(rename = "proof_status", skip_serializing_if = "Option::is_none")]
4818    pub proof_status: Option<String>,
4819}
4820
4821impl LaunchpadSandboxGrant {
4822    pub fn new() -> LaunchpadSandboxGrant {
4823        LaunchpadSandboxGrant {
4824            backend_profile: None,
4825            runtime: None,
4826            runtime_version: None,
4827            image_digest: None,
4828            filesystem_preopens: None,
4829            network_policy: None,
4830            env: None,
4831            resource_limits: None,
4832            policy_epoch: None,
4833            grant_hash: None,
4834            proof_status: None,
4835        }
4836    }
4837}
4838
4839/*
4840 * HELM Kernel API
4841 *
4842 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4843 *
4844 * The version of the OpenAPI document: 0.5.19
4845 *
4846 * Generated by: https://openapi-generator.tech
4847 */
4848
4849
4850#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4851pub struct LaunchpadSecretGrant {
4852    #[serde(rename = "name")]
4853    pub name: String,
4854    #[serde(rename = "required", skip_serializing_if = "Option::is_none")]
4855    pub required: Option<bool>,
4856    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
4857    pub provider: Option<String>,
4858    #[serde(rename = "scope", skip_serializing_if = "Option::is_none")]
4859    pub scope: Option<String>,
4860    #[serde(rename = "status")]
4861    pub status: String,
4862    #[serde(rename = "launch_impact", skip_serializing_if = "Option::is_none")]
4863    pub launch_impact: Option<String>,
4864    #[serde(rename = "grant_ref", skip_serializing_if = "Option::is_none")]
4865    pub grant_ref: Option<String>,
4866    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
4867    pub receipt_ref: Option<String>,
4868    #[serde(rename = "value_env", skip_serializing_if = "Option::is_none")]
4869    pub value_env: Option<String>,
4870}
4871
4872impl LaunchpadSecretGrant {
4873    pub fn new(name: String, status: String) -> LaunchpadSecretGrant {
4874        LaunchpadSecretGrant {
4875            name,
4876            required: None,
4877            provider: None,
4878            scope: None,
4879            status,
4880            launch_impact: None,
4881            grant_ref: None,
4882            receipt_ref: None,
4883            value_env: None,
4884        }
4885    }
4886}
4887
4888/*
4889 * HELM Kernel API
4890 *
4891 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4892 *
4893 * The version of the OpenAPI document: 0.5.19
4894 *
4895 * Generated by: https://openapi-generator.tech
4896 */
4897
4898
4899#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4900pub struct LaunchpadSubstrate {
4901    #[serde(rename = "id")]
4902    pub id: String,
4903    #[serde(rename = "name")]
4904    pub name: String,
4905    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
4906    pub kind: Option<String>,
4907    #[serde(rename = "availability", skip_serializing_if = "Option::is_none")]
4908    pub availability: Option<String>,
4909    #[serde(rename = "default_dry_run", skip_serializing_if = "Option::is_none")]
4910    pub default_dry_run: Option<bool>,
4911    #[serde(rename = "blocked_reason", skip_serializing_if = "Option::is_none")]
4912    pub blocked_reason: Option<String>,
4913}
4914
4915impl LaunchpadSubstrate {
4916    pub fn new(id: String, name: String) -> LaunchpadSubstrate {
4917        LaunchpadSubstrate {
4918            id,
4919            name,
4920            kind: None,
4921            availability: None,
4922            default_dry_run: None,
4923            blocked_reason: None,
4924        }
4925    }
4926}
4927
4928/*
4929 * HELM Kernel API
4930 *
4931 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4932 *
4933 * The version of the OpenAPI document: 0.5.19
4934 *
4935 * Generated by: https://openapi-generator.tech
4936 */
4937
4938
4939#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4940pub struct ListConsoleSurfaces200Response {
4941    #[serde(rename = "surfaces", skip_serializing_if = "Option::is_none")]
4942    pub surfaces: Option<Vec<ConsoleSurfaceRef>>,
4943}
4944
4945impl ListConsoleSurfaces200Response {
4946    pub fn new() -> ListConsoleSurfaces200Response {
4947        ListConsoleSurfaces200Response {
4948            surfaces: None,
4949        }
4950    }
4951}
4952
4953/*
4954 * HELM Kernel API
4955 *
4956 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4957 *
4958 * The version of the OpenAPI document: 0.5.19
4959 *
4960 * Generated by: https://openapi-generator.tech
4961 */
4962
4963
4964#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4965pub struct ListLaunchpadApps200Response {
4966    #[serde(rename = "apps")]
4967    pub apps: Vec<LaunchpadApp>,
4968}
4969
4970impl ListLaunchpadApps200Response {
4971    pub fn new(apps: Vec<LaunchpadApp>) -> ListLaunchpadApps200Response {
4972        ListLaunchpadApps200Response {
4973            apps,
4974        }
4975    }
4976}
4977
4978/*
4979 * HELM Kernel API
4980 *
4981 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
4982 *
4983 * The version of the OpenAPI document: 0.5.19
4984 *
4985 * Generated by: https://openapi-generator.tech
4986 */
4987
4988
4989#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
4990pub struct ListLaunchpadImports200Response {
4991    #[serde(rename = "imports")]
4992    pub imports: Vec<LaunchpadImportRecord>,
4993    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
4994    pub cli_equivalent: Option<String>,
4995}
4996
4997impl ListLaunchpadImports200Response {
4998    pub fn new(imports: Vec<LaunchpadImportRecord>) -> ListLaunchpadImports200Response {
4999        ListLaunchpadImports200Response {
5000            imports,
5001            cli_equivalent: None,
5002        }
5003    }
5004}
5005
5006/*
5007 * HELM Kernel API
5008 *
5009 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5010 *
5011 * The version of the OpenAPI document: 0.5.19
5012 *
5013 * Generated by: https://openapi-generator.tech
5014 */
5015
5016
5017#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5018pub struct ListLaunchpadRunEvents200Response {
5019    #[serde(rename = "events", skip_serializing_if = "Option::is_none")]
5020    pub events: Option<Vec<LaunchpadRunEvent>>,
5021}
5022
5023impl ListLaunchpadRunEvents200Response {
5024    pub fn new() -> ListLaunchpadRunEvents200Response {
5025        ListLaunchpadRunEvents200Response {
5026            events: None,
5027        }
5028    }
5029}
5030
5031/*
5032 * HELM Kernel API
5033 *
5034 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5035 *
5036 * The version of the OpenAPI document: 0.5.19
5037 *
5038 * Generated by: https://openapi-generator.tech
5039 */
5040
5041
5042#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5043pub struct ListLaunchpadRuns200Response {
5044    #[serde(rename = "runs", skip_serializing_if = "Option::is_none")]
5045    pub runs: Option<Vec<LaunchpadRun>>,
5046    #[serde(rename = "instances", skip_serializing_if = "Option::is_none")]
5047    pub instances: Option<Vec<LaunchpadRuntimeInstance>>,
5048}
5049
5050impl ListLaunchpadRuns200Response {
5051    pub fn new() -> ListLaunchpadRuns200Response {
5052        ListLaunchpadRuns200Response {
5053            runs: None,
5054            instances: None,
5055        }
5056    }
5057}
5058
5059/*
5060 * HELM Kernel API
5061 *
5062 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5063 *
5064 * The version of the OpenAPI document: 0.5.19
5065 *
5066 * Generated by: https://openapi-generator.tech
5067 */
5068
5069
5070#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5071pub struct ListLaunchpadSecretGrants200Response {
5072    #[serde(rename = "secrets", skip_serializing_if = "Option::is_none")]
5073    pub secrets: Option<Vec<LaunchpadSecretGrant>>,
5074}
5075
5076impl ListLaunchpadSecretGrants200Response {
5077    pub fn new() -> ListLaunchpadSecretGrants200Response {
5078        ListLaunchpadSecretGrants200Response {
5079            secrets: None,
5080        }
5081    }
5082}
5083
5084/*
5085 * HELM Kernel API
5086 *
5087 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5088 *
5089 * The version of the OpenAPI document: 0.5.19
5090 *
5091 * Generated by: https://openapi-generator.tech
5092 */
5093
5094
5095#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5096pub struct ListLaunchpadSubstrates200Response {
5097    #[serde(rename = "substrates")]
5098    pub substrates: Vec<LaunchpadSubstrate>,
5099}
5100
5101impl ListLaunchpadSubstrates200Response {
5102    pub fn new(substrates: Vec<LaunchpadSubstrate>) -> ListLaunchpadSubstrates200Response {
5103        ListLaunchpadSubstrates200Response {
5104            substrates,
5105        }
5106    }
5107}
5108
5109/*
5110 * HELM Kernel API
5111 *
5112 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5113 *
5114 * The version of the OpenAPI document: 0.5.19
5115 *
5116 * Generated by: https://openapi-generator.tech
5117 */
5118
5119
5120#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5121pub struct LocalConsoleRuntimeConfig {
5122    #[serde(rename = "api_base_url")]
5123    pub api_base_url: String,
5124    #[serde(rename = "local_mode")]
5125    pub local_mode: bool,
5126    #[serde(rename = "start_onboarding")]
5127    pub start_onboarding: bool,
5128    #[serde(rename = "tenant_id")]
5129    pub tenant_id: String,
5130    #[serde(rename = "principal_id")]
5131    pub principal_id: String,
5132    #[serde(rename = "profile")]
5133    pub profile: LocalConsoleRuntimeConfigProfile,
5134    #[serde(rename = "entitlements")]
5135    pub entitlements: Vec<LocalConsoleRuntimeConfigEntitlements>,
5136}
5137
5138impl LocalConsoleRuntimeConfig {
5139    pub fn new(api_base_url: String, local_mode: bool, start_onboarding: bool, tenant_id: String, principal_id: String, profile: LocalConsoleRuntimeConfigProfile, entitlements: Vec<LocalConsoleRuntimeConfigEntitlements>) -> LocalConsoleRuntimeConfig {
5140        LocalConsoleRuntimeConfig {
5141            api_base_url,
5142            local_mode,
5143            start_onboarding,
5144            tenant_id,
5145            principal_id,
5146            profile,
5147            entitlements,
5148        }
5149    }
5150}
5151///
5152#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5153pub enum LocalConsoleRuntimeConfigProfile {
5154    #[serde(rename = "claude")]
5155    Claude,
5156    #[serde(rename = "codex")]
5157    Codex,
5158    #[serde(rename = "mcp")]
5159    Mcp,
5160    #[serde(rename = "openai-compatible")]
5161    OpenaiCompatible,
5162}
5163
5164impl Default for LocalConsoleRuntimeConfigProfile {
5165    fn default() -> LocalConsoleRuntimeConfigProfile {
5166        Self::Claude
5167    }
5168}
5169///
5170#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5171pub enum LocalConsoleRuntimeConfigEntitlements {
5172    #[serde(rename = "OSS_CORE")]
5173    OssCore,
5174}
5175
5176impl Default for LocalConsoleRuntimeConfigEntitlements {
5177    fn default() -> LocalConsoleRuntimeConfigEntitlements {
5178        Self::OssCore
5179    }
5180}
5181
5182/*
5183 * HELM Kernel API
5184 *
5185 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5186 *
5187 * The version of the OpenAPI document: 0.5.19
5188 *
5189 * Generated by: https://openapi-generator.tech
5190 */
5191
5192
5193#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5194pub struct LocalSessionExchangeRequest {
5195    #[serde(rename = "token")]
5196    pub token: String,
5197}
5198
5199impl LocalSessionExchangeRequest {
5200    pub fn new(token: String) -> LocalSessionExchangeRequest {
5201        LocalSessionExchangeRequest {
5202            token,
5203        }
5204    }
5205}
5206
5207/*
5208 * HELM Kernel API
5209 *
5210 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5211 *
5212 * The version of the OpenAPI document: 0.5.19
5213 *
5214 * Generated by: https://openapi-generator.tech
5215 */
5216
5217
5218#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5219pub struct LocalSessionExchangeResponse {
5220    #[serde(rename = "session_token")]
5221    pub session_token: String,
5222    #[serde(rename = "tenant_id")]
5223    pub tenant_id: String,
5224    #[serde(rename = "principal_id")]
5225    pub principal_id: String,
5226    #[serde(rename = "principal")]
5227    pub principal: String,
5228    #[serde(rename = "expires_at")]
5229    pub expires_at: String,
5230    #[serde(rename = "entitlements")]
5231    pub entitlements: Vec<LocalSessionExchangeResponseEntitlements>,
5232}
5233
5234impl LocalSessionExchangeResponse {
5235    pub fn new(session_token: String, tenant_id: String, principal_id: String, principal: String, expires_at: String, entitlements: Vec<LocalSessionExchangeResponseEntitlements>) -> LocalSessionExchangeResponse {
5236        LocalSessionExchangeResponse {
5237            session_token,
5238            tenant_id,
5239            principal_id,
5240            principal,
5241            expires_at,
5242            entitlements,
5243        }
5244    }
5245}
5246///
5247#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5248pub enum LocalSessionExchangeResponseEntitlements {
5249    #[serde(rename = "OSS_CORE")]
5250    OssCore,
5251}
5252
5253impl Default for LocalSessionExchangeResponseEntitlements {
5254    fn default() -> LocalSessionExchangeResponseEntitlements {
5255        Self::OssCore
5256    }
5257}
5258
5259/*
5260 * HELM Kernel API
5261 *
5262 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5263 *
5264 * The version of the OpenAPI document: 0.5.19
5265 *
5266 * Generated by: https://openapi-generator.tech
5267 */
5268
5269
5270#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5271pub struct McpAuthorizationProfile {
5272    #[serde(rename = "profile_id", skip_serializing_if = "Option::is_none")]
5273    pub profile_id: Option<String>,
5274    #[serde(rename = "protocol_version", skip_serializing_if = "Option::is_none")]
5275    pub protocol_version: Option<String>,
5276    #[serde(rename = "resource", skip_serializing_if = "Option::is_none")]
5277    pub resource: Option<String>,
5278    #[serde(rename = "authorization_servers", skip_serializing_if = "Option::is_none")]
5279    pub authorization_servers: Option<Vec<String>>,
5280    #[serde(rename = "scopes_supported", skip_serializing_if = "Option::is_none")]
5281    pub scopes_supported: Option<Vec<String>>,
5282    #[serde(rename = "tool_scopes", skip_serializing_if = "Option::is_none")]
5283    pub tool_scopes: Option<std::collections::HashMap<String, serde_json::Value>>,
5284    #[serde(rename = "required_audience", skip_serializing_if = "Option::is_none")]
5285    pub required_audience: Option<String>,
5286    #[serde(rename = "stale_after", skip_serializing_if = "Option::is_none")]
5287    pub stale_after: Option<String>,
5288    #[serde(rename = "profile_hash", skip_serializing_if = "Option::is_none")]
5289    pub profile_hash: Option<String>,
5290}
5291
5292impl McpAuthorizationProfile {
5293    pub fn new() -> McpAuthorizationProfile {
5294        McpAuthorizationProfile {
5295            profile_id: None,
5296            protocol_version: None,
5297            resource: None,
5298            authorization_servers: None,
5299            scopes_supported: None,
5300            tool_scopes: None,
5301            required_audience: None,
5302            stale_after: None,
5303            profile_hash: None,
5304        }
5305    }
5306}
5307
5308/*
5309 * HELM Kernel API
5310 *
5311 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5312 *
5313 * The version of the OpenAPI document: 0.5.19
5314 *
5315 * Generated by: https://openapi-generator.tech
5316 */
5317
5318
5319#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5320pub struct McpAuthorizeCallRequest {
5321    #[serde(rename = "server_id")]
5322    pub server_id: String,
5323    #[serde(rename = "tool_name")]
5324    pub tool_name: String,
5325    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
5326    pub args_hash: Option<String>,
5327    #[serde(rename = "granted_scopes", skip_serializing_if = "Option::is_none")]
5328    pub granted_scopes: Option<Vec<String>>,
5329    #[serde(rename = "pinned_schema_hash", skip_serializing_if = "Option::is_none")]
5330    pub pinned_schema_hash: Option<String>,
5331    #[serde(rename = "tool_schema", skip_serializing_if = "Option::is_none")]
5332    pub tool_schema: Option<std::collections::HashMap<String, serde_json::Value>>,
5333    #[serde(rename = "output_schema", skip_serializing_if = "Option::is_none")]
5334    pub output_schema: Option<std::collections::HashMap<String, serde_json::Value>>,
5335    #[serde(rename = "oauth_resource", skip_serializing_if = "Option::is_none")]
5336    pub oauth_resource: Option<String>,
5337    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
5338    pub receipt_id: Option<String>,
5339}
5340
5341impl McpAuthorizeCallRequest {
5342    pub fn new(server_id: String, tool_name: String) -> McpAuthorizeCallRequest {
5343        McpAuthorizeCallRequest {
5344            server_id,
5345            tool_name,
5346            args_hash: None,
5347            granted_scopes: None,
5348            pinned_schema_hash: None,
5349            tool_schema: None,
5350            output_schema: None,
5351            oauth_resource: None,
5352            receipt_id: None,
5353        }
5354    }
5355}
5356
5357/*
5358 * HELM Kernel API
5359 *
5360 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5361 *
5362 * The version of the OpenAPI document: 0.5.19
5363 *
5364 * Generated by: https://openapi-generator.tech
5365 */
5366
5367
5368#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5369pub struct McpCapabilityManifest {
5370    #[serde(rename = "server_name", skip_serializing_if = "Option::is_none")]
5371    pub server_name: Option<String>,
5372    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
5373    pub version: Option<String>,
5374    #[serde(rename = "governance", skip_serializing_if = "Option::is_none")]
5375    pub governance: Option<String>,
5376    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
5377    pub tools: Option<Vec<McpToolRef>>,
5378}
5379
5380impl McpCapabilityManifest {
5381    pub fn new() -> McpCapabilityManifest {
5382        McpCapabilityManifest {
5383            server_name: None,
5384            version: None,
5385            governance: None,
5386            tools: None,
5387        }
5388    }
5389}
5390
5391/*
5392 * HELM Kernel API
5393 *
5394 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5395 *
5396 * The version of the OpenAPI document: 0.5.19
5397 *
5398 * Generated by: https://openapi-generator.tech
5399 */
5400
5401
5402#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5403pub struct McpProtectedResourceMetadata {
5404    #[serde(rename = "resource", skip_serializing_if = "Option::is_none")]
5405    pub resource: Option<String>,
5406    #[serde(rename = "authorization_servers", skip_serializing_if = "Option::is_none")]
5407    pub authorization_servers: Option<Vec<String>>,
5408    #[serde(rename = "scopes_supported", skip_serializing_if = "Option::is_none")]
5409    pub scopes_supported: Option<Vec<String>>,
5410    #[serde(rename = "bearer_methods_supported", skip_serializing_if = "Option::is_none")]
5411    pub bearer_methods_supported: Option<Vec<String>>,
5412    #[serde(rename = "resource_documentation", skip_serializing_if = "Option::is_none")]
5413    pub resource_documentation: Option<String>,
5414}
5415
5416impl McpProtectedResourceMetadata {
5417    pub fn new() -> McpProtectedResourceMetadata {
5418        McpProtectedResourceMetadata {
5419            resource: None,
5420            authorization_servers: None,
5421            scopes_supported: None,
5422            bearer_methods_supported: None,
5423            resource_documentation: None,
5424        }
5425    }
5426}
5427
5428/*
5429 * HELM Kernel API
5430 *
5431 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5432 *
5433 * The version of the OpenAPI document: 0.5.19
5434 *
5435 * Generated by: https://openapi-generator.tech
5436 */
5437
5438
5439#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5440pub struct McpQuarantineRecord {
5441    #[serde(rename = "server_id")]
5442    pub server_id: String,
5443    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
5444    pub name: Option<String>,
5445    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
5446    pub transport: Option<String>,
5447    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
5448    pub endpoint: Option<String>,
5449    #[serde(rename = "tool_names", skip_serializing_if = "Option::is_none")]
5450    pub tool_names: Option<Vec<String>>,
5451    #[serde(rename = "risk")]
5452    pub risk: McpQuarantineRecordRisk,
5453    #[serde(rename = "state")]
5454    pub state: McpQuarantineRecordState,
5455    #[serde(rename = "discovered_at")]
5456    pub discovered_at: String,
5457    #[serde(rename = "approved_at", skip_serializing_if = "Option::is_none")]
5458    pub approved_at: Option<String>,
5459    #[serde(rename = "approved_by", skip_serializing_if = "Option::is_none")]
5460    pub approved_by: Option<String>,
5461    #[serde(rename = "approval_receipt_id", skip_serializing_if = "Option::is_none")]
5462    pub approval_receipt_id: Option<String>,
5463    #[serde(rename = "revoked_at", skip_serializing_if = "Option::is_none")]
5464    pub revoked_at: Option<String>,
5465    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
5466    pub expires_at: Option<String>,
5467    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
5468    pub reason: Option<String>,
5469}
5470
5471impl McpQuarantineRecord {
5472    pub fn new(server_id: String, risk: McpQuarantineRecordRisk, state: McpQuarantineRecordState, discovered_at: String) -> McpQuarantineRecord {
5473        McpQuarantineRecord {
5474            server_id,
5475            name: None,
5476            transport: None,
5477            endpoint: None,
5478            tool_names: None,
5479            risk,
5480            state,
5481            discovered_at,
5482            approved_at: None,
5483            approved_by: None,
5484            approval_receipt_id: None,
5485            revoked_at: None,
5486            expires_at: None,
5487            reason: None,
5488        }
5489    }
5490}
5491///
5492#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5493pub enum McpQuarantineRecordRisk {
5494    #[serde(rename = "unknown")]
5495    Unknown,
5496    #[serde(rename = "low")]
5497    Low,
5498    #[serde(rename = "medium")]
5499    Medium,
5500    #[serde(rename = "high")]
5501    High,
5502    #[serde(rename = "critical")]
5503    Critical,
5504}
5505
5506impl Default for McpQuarantineRecordRisk {
5507    fn default() -> McpQuarantineRecordRisk {
5508        Self::Unknown
5509    }
5510}
5511///
5512#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5513pub enum McpQuarantineRecordState {
5514    #[serde(rename = "discovered")]
5515    Discovered,
5516    #[serde(rename = "quarantined")]
5517    Quarantined,
5518    #[serde(rename = "approved")]
5519    Approved,
5520    #[serde(rename = "revoked")]
5521    Revoked,
5522    #[serde(rename = "expired")]
5523    Expired,
5524}
5525
5526impl Default for McpQuarantineRecordState {
5527    fn default() -> McpQuarantineRecordState {
5528        Self::Discovered
5529    }
5530}
5531
5532/*
5533 * HELM Kernel API
5534 *
5535 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5536 *
5537 * The version of the OpenAPI document: 0.5.19
5538 *
5539 * Generated by: https://openapi-generator.tech
5540 */
5541
5542
5543#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5544pub struct McpRegistryApprovalRequest {
5545    #[serde(rename = "server_id")]
5546    pub server_id: String,
5547    #[serde(rename = "approver_id")]
5548    pub approver_id: String,
5549    #[serde(rename = "approval_receipt_id")]
5550    pub approval_receipt_id: String,
5551    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
5552    pub reason: Option<String>,
5553}
5554
5555impl McpRegistryApprovalRequest {
5556    pub fn new(server_id: String, approver_id: String, approval_receipt_id: String) -> McpRegistryApprovalRequest {
5557        McpRegistryApprovalRequest {
5558            server_id,
5559            approver_id,
5560            approval_receipt_id,
5561            reason: None,
5562        }
5563    }
5564}
5565
5566/*
5567 * HELM Kernel API
5568 *
5569 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5570 *
5571 * The version of the OpenAPI document: 0.5.19
5572 *
5573 * Generated by: https://openapi-generator.tech
5574 */
5575
5576
5577#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5578pub struct McpRegistryDiscoverRequest {
5579    #[serde(rename = "server_id")]
5580    pub server_id: String,
5581    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
5582    pub name: Option<String>,
5583    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
5584    pub transport: Option<String>,
5585    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
5586    pub endpoint: Option<String>,
5587    #[serde(rename = "tool_names", skip_serializing_if = "Option::is_none")]
5588    pub tool_names: Option<Vec<String>>,
5589    #[serde(rename = "risk", skip_serializing_if = "Option::is_none")]
5590    pub risk: Option<McpRegistryDiscoverRequestRisk>,
5591    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
5592    pub reason: Option<String>,
5593}
5594
5595impl McpRegistryDiscoverRequest {
5596    pub fn new(server_id: String) -> McpRegistryDiscoverRequest {
5597        McpRegistryDiscoverRequest {
5598            server_id,
5599            name: None,
5600            transport: None,
5601            endpoint: None,
5602            tool_names: None,
5603            risk: None,
5604            reason: None,
5605        }
5606    }
5607}
5608///
5609#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5610pub enum McpRegistryDiscoverRequestRisk {
5611    #[serde(rename = "unknown")]
5612    Unknown,
5613    #[serde(rename = "low")]
5614    Low,
5615    #[serde(rename = "medium")]
5616    Medium,
5617    #[serde(rename = "high")]
5618    High,
5619    #[serde(rename = "critical")]
5620    Critical,
5621}
5622
5623impl Default for McpRegistryDiscoverRequestRisk {
5624    fn default() -> McpRegistryDiscoverRequestRisk {
5625        Self::Unknown
5626    }
5627}
5628
5629/*
5630 * HELM Kernel API
5631 *
5632 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5633 *
5634 * The version of the OpenAPI document: 0.5.19
5635 *
5636 * Generated by: https://openapi-generator.tech
5637 */
5638
5639
5640#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5641pub struct McpRemoteDiscovery {
5642    #[serde(rename = "server_name", skip_serializing_if = "Option::is_none")]
5643    pub server_name: Option<String>,
5644    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
5645    pub version: Option<String>,
5646    #[serde(rename = "capabilities_url", skip_serializing_if = "Option::is_none")]
5647    pub capabilities_url: Option<String>,
5648    #[serde(rename = "execute_url", skip_serializing_if = "Option::is_none")]
5649    pub execute_url: Option<String>,
5650    #[serde(rename = "mcp_endpoint", skip_serializing_if = "Option::is_none")]
5651    pub mcp_endpoint: Option<String>,
5652    #[serde(rename = "supported_protocol_versions", skip_serializing_if = "Option::is_none")]
5653    pub supported_protocol_versions: Option<Vec<String>>,
5654    #[serde(rename = "auth_mode", skip_serializing_if = "Option::is_none")]
5655    pub auth_mode: Option<String>,
5656    #[serde(rename = "governance", skip_serializing_if = "Option::is_none")]
5657    pub governance: Option<String>,
5658}
5659
5660impl McpRemoteDiscovery {
5661    pub fn new() -> McpRemoteDiscovery {
5662        McpRemoteDiscovery {
5663            server_name: None,
5664            version: None,
5665            capabilities_url: None,
5666            execute_url: None,
5667            mcp_endpoint: None,
5668            supported_protocol_versions: None,
5669            auth_mode: None,
5670            governance: None,
5671        }
5672    }
5673}
5674
5675/*
5676 * HELM Kernel API
5677 *
5678 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5679 *
5680 * The version of the OpenAPI document: 0.5.19
5681 *
5682 * Generated by: https://openapi-generator.tech
5683 */
5684
5685
5686#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5687pub struct McpScanRequest {
5688    #[serde(rename = "server_id")]
5689    pub server_id: String,
5690    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
5691    pub name: Option<String>,
5692    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
5693    pub transport: Option<String>,
5694    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
5695    pub endpoint: Option<String>,
5696    #[serde(rename = "tool_names", skip_serializing_if = "Option::is_none")]
5697    pub tool_names: Option<Vec<String>>,
5698    #[serde(rename = "manifest", skip_serializing_if = "Option::is_none")]
5699    pub manifest: Option<std::collections::HashMap<String, serde_json::Value>>,
5700}
5701
5702impl McpScanRequest {
5703    pub fn new(server_id: String) -> McpScanRequest {
5704        McpScanRequest {
5705            server_id,
5706            name: None,
5707            transport: None,
5708            endpoint: None,
5709            tool_names: None,
5710            manifest: None,
5711        }
5712    }
5713}
5714
5715/*
5716 * HELM Kernel API
5717 *
5718 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5719 *
5720 * The version of the OpenAPI document: 0.5.19
5721 *
5722 * Generated by: https://openapi-generator.tech
5723 */
5724
5725
5726#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5727pub struct McpScanResult {
5728    #[serde(rename = "server_id", skip_serializing_if = "Option::is_none")]
5729    pub server_id: Option<String>,
5730    #[serde(rename = "risk", skip_serializing_if = "Option::is_none")]
5731    pub risk: Option<String>,
5732    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
5733    pub state: Option<String>,
5734    #[serde(rename = "tool_count", skip_serializing_if = "Option::is_none")]
5735    pub tool_count: Option<i32>,
5736    #[serde(rename = "findings", skip_serializing_if = "Option::is_none")]
5737    pub findings: Option<Vec<String>>,
5738    #[serde(rename = "recommended_action", skip_serializing_if = "Option::is_none")]
5739    pub recommended_action: Option<String>,
5740    #[serde(rename = "quarantine_record_id", skip_serializing_if = "Option::is_none")]
5741    pub quarantine_record_id: Option<String>,
5742    #[serde(rename = "requires_approval", skip_serializing_if = "Option::is_none")]
5743    pub requires_approval: Option<bool>,
5744    #[serde(rename = "schema_pin_required", skip_serializing_if = "Option::is_none")]
5745    pub schema_pin_required: Option<bool>,
5746    #[serde(rename = "authorization_needed", skip_serializing_if = "Option::is_none")]
5747    pub authorization_needed: Option<bool>,
5748    #[serde(rename = "scanned_at", skip_serializing_if = "Option::is_none")]
5749    pub scanned_at: Option<String>,
5750}
5751
5752impl McpScanResult {
5753    pub fn new() -> McpScanResult {
5754        McpScanResult {
5755            server_id: None,
5756            risk: None,
5757            state: None,
5758            tool_count: None,
5759            findings: None,
5760            recommended_action: None,
5761            quarantine_record_id: None,
5762            requires_approval: None,
5763            schema_pin_required: None,
5764            authorization_needed: None,
5765            scanned_at: None,
5766        }
5767    }
5768}
5769
5770/*
5771 * HELM Kernel API
5772 *
5773 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5774 *
5775 * The version of the OpenAPI document: 0.5.19
5776 *
5777 * Generated by: https://openapi-generator.tech
5778 */
5779
5780
5781#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5782pub struct McpToolCallRequest {
5783    #[serde(rename = "method")]
5784    pub method: String,
5785    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
5786    pub params: Option<std::collections::HashMap<String, serde_json::Value>>,
5787}
5788
5789impl McpToolCallRequest {
5790    pub fn new(method: String) -> McpToolCallRequest {
5791        McpToolCallRequest {
5792            method,
5793            params: None,
5794        }
5795    }
5796}
5797
5798/*
5799 * HELM Kernel API
5800 *
5801 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5802 *
5803 * The version of the OpenAPI document: 0.5.19
5804 *
5805 * Generated by: https://openapi-generator.tech
5806 */
5807
5808
5809#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5810pub struct McpToolCallResponse {
5811    #[serde(rename = "result", skip_serializing_if = "Option::is_none")]
5812    pub result: Option<Box<McpToolCallResponseResult>>,
5813    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
5814    pub error: Option<String>,
5815    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
5816    pub reason_code: Option<String>,
5817    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
5818    pub args_hash: Option<String>,
5819    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
5820    pub proofgraph_node: Option<String>,
5821    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
5822    pub receipt_id: Option<String>,
5823}
5824
5825impl McpToolCallResponse {
5826    pub fn new() -> McpToolCallResponse {
5827        McpToolCallResponse {
5828            result: None,
5829            error: None,
5830            reason_code: None,
5831            args_hash: None,
5832            proofgraph_node: None,
5833            receipt_id: None,
5834        }
5835    }
5836}
5837
5838/*
5839 * HELM Kernel API
5840 *
5841 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5842 *
5843 * The version of the OpenAPI document: 0.5.19
5844 *
5845 * Generated by: https://openapi-generator.tech
5846 */
5847
5848
5849/// McpToolCallResponseResult : Tool output payload
5850/// Tool output payload
5851#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5852#[serde(untagged)]
5853pub enum McpToolCallResponseResult {
5854    String(String),
5855    Object(std::collections::HashMap<String, serde_json::Value>),
5856}
5857
5858impl Default for McpToolCallResponseResult {
5859    fn default() -> Self {
5860        Self::String(Default::default())
5861    }
5862}
5863
5864/*
5865 * HELM Kernel API
5866 *
5867 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5868 *
5869 * The version of the OpenAPI document: 0.5.19
5870 *
5871 * Generated by: https://openapi-generator.tech
5872 */
5873
5874
5875#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5876pub struct McpToolRef {
5877    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
5878    pub name: Option<String>,
5879    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
5880    pub description: Option<String>,
5881    #[serde(rename = "server_id", skip_serializing_if = "Option::is_none")]
5882    pub server_id: Option<String>,
5883    #[serde(rename = "schema", skip_serializing_if = "Option::is_none")]
5884    pub schema: Option<std::collections::HashMap<String, serde_json::Value>>,
5885}
5886
5887impl McpToolRef {
5888    pub fn new() -> McpToolRef {
5889        McpToolRef {
5890            name: None,
5891            description: None,
5892            server_id: None,
5893            schema: None,
5894        }
5895    }
5896}
5897
5898/*
5899 * HELM Kernel API
5900 *
5901 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5902 *
5903 * The version of the OpenAPI document: 0.5.19
5904 *
5905 * Generated by: https://openapi-generator.tech
5906 */
5907
5908
5909#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5910pub struct McpjsonrpcError {
5911    #[serde(rename = "code", skip_serializing_if = "Option::is_none")]
5912    pub code: Option<i32>,
5913    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
5914    pub message: Option<String>,
5915}
5916
5917impl McpjsonrpcError {
5918    pub fn new() -> McpjsonrpcError {
5919        McpjsonrpcError {
5920            code: None,
5921            message: None,
5922        }
5923    }
5924}
5925
5926/*
5927 * HELM Kernel API
5928 *
5929 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5930 *
5931 * The version of the OpenAPI document: 0.5.19
5932 *
5933 * Generated by: https://openapi-generator.tech
5934 */
5935
5936
5937#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
5938pub struct McpjsonrpcRequest {
5939    #[serde(rename = "jsonrpc")]
5940    pub jsonrpc: McpjsonrpcRequestJsonrpc,
5941    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
5942    pub id: Option<Box<McpjsonrpcRequestId>>,
5943    #[serde(rename = "method")]
5944    pub method: String,
5945    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
5946    pub params: Option<std::collections::HashMap<String, serde_json::Value>>,
5947}
5948
5949impl McpjsonrpcRequest {
5950    pub fn new(jsonrpc: McpjsonrpcRequestJsonrpc, method: String) -> McpjsonrpcRequest {
5951        McpjsonrpcRequest {
5952            jsonrpc,
5953            id: None,
5954            method,
5955            params: None,
5956        }
5957    }
5958}
5959///
5960#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
5961pub enum McpjsonrpcRequestJsonrpc {
5962    #[serde(rename = "2.0")]
5963    Variant2Period0,
5964}
5965
5966impl Default for McpjsonrpcRequestJsonrpc {
5967    fn default() -> McpjsonrpcRequestJsonrpc {
5968        Self::Variant2Period0
5969    }
5970}
5971
5972/*
5973 * HELM Kernel API
5974 *
5975 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
5976 *
5977 * The version of the OpenAPI document: 0.5.19
5978 *
5979 * Generated by: https://openapi-generator.tech
5980 */
5981
5982
5983/// McpjsonrpcRequestId : Request identifier. Omit for notifications.
5984/// Request identifier. Omit for notifications.
5985#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5986#[serde(untagged)]
5987pub enum McpjsonrpcRequestId {
5988    String(String),
5989    Integer(i32),
5990}
5991
5992impl Default for McpjsonrpcRequestId {
5993    fn default() -> Self {
5994        Self::String(Default::default())
5995    }
5996}
5997
5998/*
5999 * HELM Kernel API
6000 *
6001 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6002 *
6003 * The version of the OpenAPI document: 0.5.19
6004 *
6005 * Generated by: https://openapi-generator.tech
6006 */
6007
6008
6009#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6010pub struct McpjsonrpcResponse {
6011    #[serde(rename = "jsonrpc", skip_serializing_if = "Option::is_none")]
6012    pub jsonrpc: Option<McpjsonrpcResponseJsonrpc>,
6013    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
6014    pub id: Option<Box<McpjsonrpcResponseId>>,
6015    #[serde(rename = "result", skip_serializing_if = "Option::is_none")]
6016    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
6017    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
6018    pub error: Option<Box<McpjsonrpcError>>,
6019}
6020
6021impl McpjsonrpcResponse {
6022    pub fn new() -> McpjsonrpcResponse {
6023        McpjsonrpcResponse {
6024            jsonrpc: None,
6025            id: None,
6026            result: None,
6027            error: None,
6028        }
6029    }
6030}
6031///
6032#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6033pub enum McpjsonrpcResponseJsonrpc {
6034    #[serde(rename = "2.0")]
6035    Variant2Period0,
6036}
6037
6038impl Default for McpjsonrpcResponseJsonrpc {
6039    fn default() -> McpjsonrpcResponseJsonrpc {
6040        Self::Variant2Period0
6041    }
6042}
6043
6044/*
6045 * HELM Kernel API
6046 *
6047 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6048 *
6049 * The version of the OpenAPI document: 0.5.19
6050 *
6051 * Generated by: https://openapi-generator.tech
6052 */
6053
6054
6055#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6056#[serde(untagged)]
6057pub enum McpjsonrpcResponseId {
6058    String(String),
6059    Integer(i32),
6060}
6061
6062impl Default for McpjsonrpcResponseId {
6063    fn default() -> Self {
6064        Self::String(Default::default())
6065    }
6066}
6067
6068/*
6069 * HELM Kernel API
6070 *
6071 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6072 *
6073 * The version of the OpenAPI document: 0.5.19
6074 *
6075 * Generated by: https://openapi-generator.tech
6076 */
6077
6078
6079#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6080pub struct NegativeBoundaryVector {
6081    #[serde(rename = "id")]
6082    pub id: String,
6083    #[serde(rename = "category")]
6084    pub category: String,
6085    #[serde(rename = "trigger")]
6086    pub trigger: String,
6087    #[serde(rename = "expected_verdict")]
6088    pub expected_verdict: NegativeBoundaryVectorExpectedVerdict,
6089    #[serde(rename = "expected_reason_code")]
6090    pub expected_reason_code: String,
6091    #[serde(rename = "must_emit_receipt")]
6092    pub must_emit_receipt: bool,
6093    #[serde(rename = "must_not_dispatch")]
6094    pub must_not_dispatch: bool,
6095    #[serde(rename = "must_bind_evidence", skip_serializing_if = "Option::is_none")]
6096    pub must_bind_evidence: Option<Vec<String>>,
6097}
6098
6099impl NegativeBoundaryVector {
6100    pub fn new(id: String, category: String, trigger: String, expected_verdict: NegativeBoundaryVectorExpectedVerdict, expected_reason_code: String, must_emit_receipt: bool, must_not_dispatch: bool) -> NegativeBoundaryVector {
6101        NegativeBoundaryVector {
6102            id,
6103            category,
6104            trigger,
6105            expected_verdict,
6106            expected_reason_code,
6107            must_emit_receipt,
6108            must_not_dispatch,
6109            must_bind_evidence: None,
6110        }
6111    }
6112}
6113///
6114#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6115pub enum NegativeBoundaryVectorExpectedVerdict {
6116    #[serde(rename = "ALLOW")]
6117    Allow,
6118    #[serde(rename = "DENY")]
6119    Deny,
6120    #[serde(rename = "ESCALATE")]
6121    Escalate,
6122}
6123
6124impl Default for NegativeBoundaryVectorExpectedVerdict {
6125    fn default() -> NegativeBoundaryVectorExpectedVerdict {
6126        Self::Allow
6127    }
6128}
6129
6130/*
6131 * HELM Kernel API
6132 *
6133 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6134 *
6135 * The version of the OpenAPI document: 0.5.19
6136 *
6137 * Generated by: https://openapi-generator.tech
6138 */
6139
6140
6141#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6142pub struct NetworkGrant {
6143    #[serde(rename = "mode")]
6144    pub mode: NetworkGrantMode,
6145    #[serde(rename = "destinations", skip_serializing_if = "Option::is_none")]
6146    pub destinations: Option<Vec<String>>,
6147    #[serde(rename = "cidrs", skip_serializing_if = "Option::is_none")]
6148    pub cidrs: Option<Vec<String>>,
6149}
6150
6151impl NetworkGrant {
6152    pub fn new(mode: NetworkGrantMode) -> NetworkGrant {
6153        NetworkGrant {
6154            mode,
6155            destinations: None,
6156            cidrs: None,
6157        }
6158    }
6159}
6160///
6161#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6162pub enum NetworkGrantMode {
6163    #[serde(rename = "deny-all")]
6164    DenyAll,
6165    #[serde(rename = "allowlist")]
6166    Allowlist,
6167}
6168
6169impl Default for NetworkGrantMode {
6170    fn default() -> NetworkGrantMode {
6171        Self::DenyAll
6172    }
6173}
6174
6175/*
6176 * HELM Kernel API
6177 *
6178 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6179 *
6180 * The version of the OpenAPI document: 0.5.19
6181 *
6182 * Generated by: https://openapi-generator.tech
6183 */
6184
6185
6186#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6187pub struct OAuthRequirement {
6188    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
6189    pub provider: Option<String>,
6190    #[serde(rename = "scopes", skip_serializing_if = "Option::is_none")]
6191    pub scopes: Option<Vec<String>>,
6192    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
6193    pub source: Option<String>,
6194}
6195
6196impl OAuthRequirement {
6197    pub fn new() -> OAuthRequirement {
6198        OAuthRequirement {
6199            provider: None,
6200            scopes: None,
6201            source: None,
6202        }
6203    }
6204}
6205
6206/*
6207 * HELM Kernel API
6208 *
6209 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6210 *
6211 * The version of the OpenAPI document: 0.5.19
6212 *
6213 * Generated by: https://openapi-generator.tech
6214 */
6215
6216
6217#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6218pub struct OnboardingEvidenceExport {
6219    #[serde(rename = "evidence_pack_ref")]
6220    pub evidence_pack_ref: String,
6221    #[serde(rename = "sha256")]
6222    pub sha256: String,
6223    #[serde(rename = "receipt_refs")]
6224    pub receipt_refs: std::collections::HashMap<String, String>,
6225    #[serde(rename = "steps")]
6226    pub steps: Vec<OnboardingStep>,
6227}
6228
6229impl OnboardingEvidenceExport {
6230    pub fn new(evidence_pack_ref: String, sha256: String, receipt_refs: std::collections::HashMap<String, String>, steps: Vec<OnboardingStep>) -> OnboardingEvidenceExport {
6231        OnboardingEvidenceExport {
6232            evidence_pack_ref,
6233            sha256,
6234            receipt_refs,
6235            steps,
6236        }
6237    }
6238}
6239
6240/*
6241 * HELM Kernel API
6242 *
6243 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6244 *
6245 * The version of the OpenAPI document: 0.5.19
6246 *
6247 * Generated by: https://openapi-generator.tech
6248 */
6249
6250
6251#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6252pub struct OnboardingRunStepRequest {
6253    #[serde(rename = "step_id")]
6254    pub step_id: OnboardingRunStepRequestStepId,
6255}
6256
6257impl OnboardingRunStepRequest {
6258    pub fn new(step_id: OnboardingRunStepRequestStepId) -> OnboardingRunStepRequest {
6259        OnboardingRunStepRequest {
6260            step_id,
6261        }
6262    }
6263}
6264///
6265#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6266pub enum OnboardingRunStepRequestStepId {
6267    #[serde(rename = "health")]
6268    Health,
6269    #[serde(rename = "policy")]
6270    Policy,
6271    #[serde(rename = "allow")]
6272    Allow,
6273    #[serde(rename = "deny")]
6274    Deny,
6275    #[serde(rename = "mcp")]
6276    Mcp,
6277    #[serde(rename = "verify")]
6278    Verify,
6279}
6280
6281impl Default for OnboardingRunStepRequestStepId {
6282    fn default() -> OnboardingRunStepRequestStepId {
6283        Self::Health
6284    }
6285}
6286
6287/*
6288 * HELM Kernel API
6289 *
6290 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6291 *
6292 * The version of the OpenAPI document: 0.5.19
6293 *
6294 * Generated by: https://openapi-generator.tech
6295 */
6296
6297
6298#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6299pub struct OnboardingState {
6300    #[serde(rename = "mode")]
6301    pub mode: OnboardingStateMode,
6302    #[serde(rename = "entitlements")]
6303    pub entitlements: Vec<OnboardingStateEntitlements>,
6304    #[serde(rename = "profile")]
6305    pub profile: String,
6306    #[serde(rename = "policy_path", skip_serializing_if = "Option::is_none")]
6307    pub policy_path: Option<String>,
6308    #[serde(rename = "evidence_pack_ref", skip_serializing_if = "Option::is_none")]
6309    pub evidence_pack_ref: Option<String>,
6310    #[serde(rename = "steps")]
6311    pub steps: Vec<OnboardingStep>,
6312}
6313
6314impl OnboardingState {
6315    pub fn new(mode: OnboardingStateMode, entitlements: Vec<OnboardingStateEntitlements>, profile: String, steps: Vec<OnboardingStep>) -> OnboardingState {
6316        OnboardingState {
6317            mode,
6318            entitlements,
6319            profile,
6320            policy_path: None,
6321            evidence_pack_ref: None,
6322            steps,
6323        }
6324    }
6325}
6326///
6327#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6328pub enum OnboardingStateMode {
6329    #[serde(rename = "self-hosted-oss")]
6330    SelfHostedOss,
6331}
6332
6333impl Default for OnboardingStateMode {
6334    fn default() -> OnboardingStateMode {
6335        Self::SelfHostedOss
6336    }
6337}
6338///
6339#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6340pub enum OnboardingStateEntitlements {
6341    #[serde(rename = "OSS_CORE")]
6342    OssCore,
6343}
6344
6345impl Default for OnboardingStateEntitlements {
6346    fn default() -> OnboardingStateEntitlements {
6347        Self::OssCore
6348    }
6349}
6350
6351/*
6352 * HELM Kernel API
6353 *
6354 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6355 *
6356 * The version of the OpenAPI document: 0.5.19
6357 *
6358 * Generated by: https://openapi-generator.tech
6359 */
6360
6361
6362#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6363pub struct OnboardingStep {
6364    #[serde(rename = "id")]
6365    pub id: OnboardingStepId,
6366    #[serde(rename = "title")]
6367    pub title: String,
6368    #[serde(rename = "description")]
6369    pub description: String,
6370    #[serde(rename = "status")]
6371    pub status: OnboardingStepStatus,
6372    #[serde(rename = "verdict")]
6373    pub verdict: OnboardingStepVerdict,
6374    #[serde(rename = "reason_code")]
6375    pub reason_code: String,
6376    #[serde(rename = "receipt_ref", skip_serializing_if = "Option::is_none")]
6377    pub receipt_ref: Option<String>,
6378}
6379
6380impl OnboardingStep {
6381    pub fn new(id: OnboardingStepId, title: String, description: String, status: OnboardingStepStatus, verdict: OnboardingStepVerdict, reason_code: String) -> OnboardingStep {
6382        OnboardingStep {
6383            id,
6384            title,
6385            description,
6386            status,
6387            verdict,
6388            reason_code,
6389            receipt_ref: None,
6390        }
6391    }
6392}
6393///
6394#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6395pub enum OnboardingStepId {
6396    #[serde(rename = "health")]
6397    Health,
6398    #[serde(rename = "policy")]
6399    Policy,
6400    #[serde(rename = "allow")]
6401    Allow,
6402    #[serde(rename = "deny")]
6403    Deny,
6404    #[serde(rename = "mcp")]
6405    Mcp,
6406    #[serde(rename = "verify")]
6407    Verify,
6408}
6409
6410impl Default for OnboardingStepId {
6411    fn default() -> OnboardingStepId {
6412        Self::Health
6413    }
6414}
6415///
6416#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6417pub enum OnboardingStepStatus {
6418    #[serde(rename = "pending")]
6419    Pending,
6420    #[serde(rename = "pass")]
6421    Pass,
6422}
6423
6424impl Default for OnboardingStepStatus {
6425    fn default() -> OnboardingStepStatus {
6426        Self::Pending
6427    }
6428}
6429///
6430#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6431pub enum OnboardingStepVerdict {
6432    #[serde(rename = "ALLOW")]
6433    Allow,
6434    #[serde(rename = "DENY")]
6435    Deny,
6436    #[serde(rename = "ESCALATE")]
6437    Escalate,
6438}
6439
6440impl Default for OnboardingStepVerdict {
6441    fn default() -> OnboardingStepVerdict {
6442        Self::Allow
6443    }
6444}
6445
6446/*
6447 * HELM Kernel API
6448 *
6449 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6450 *
6451 * The version of the OpenAPI document: 0.5.19
6452 *
6453 * Generated by: https://openapi-generator.tech
6454 */
6455
6456
6457/// PdpRequest : Request to the Policy Decision Point
6458#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6459pub struct PdpRequest {
6460    #[serde(rename = "boundary")]
6461    pub boundary: Box<EffectBoundary>,
6462}
6463
6464impl PdpRequest {
6465    /// Request to the Policy Decision Point
6466    pub fn new(boundary: EffectBoundary) -> PdpRequest {
6467        PdpRequest {
6468            boundary: Box::new(boundary),
6469        }
6470    }
6471}
6472
6473/*
6474 * HELM Kernel API
6475 *
6476 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6477 *
6478 * The version of the OpenAPI document: 0.5.19
6479 *
6480 * Generated by: https://openapi-generator.tech
6481 */
6482
6483
6484/// PdpResponse : Response from the Policy Decision Point
6485#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6486pub struct PdpResponse {
6487    #[serde(rename = "decision")]
6488    pub decision: Box<GovernanceDecision>,
6489}
6490
6491impl PdpResponse {
6492    /// Response from the Policy Decision Point
6493    pub fn new(decision: GovernanceDecision) -> PdpResponse {
6494        PdpResponse {
6495            decision: Box::new(decision),
6496        }
6497    }
6498}
6499
6500/*
6501 * HELM Kernel API
6502 *
6503 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6504 *
6505 * The version of the OpenAPI document: 0.5.19
6506 *
6507 * Generated by: https://openapi-generator.tech
6508 */
6509
6510
6511#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6512pub struct PlanTransaction {
6513    #[serde(rename = "plan_transaction_id")]
6514    pub plan_transaction_id: String,
6515    #[serde(rename = "plan_hash")]
6516    pub plan_hash: String,
6517    #[serde(rename = "read_set")]
6518    pub read_set: Vec<String>,
6519    #[serde(rename = "write_set")]
6520    pub write_set: Vec<String>,
6521    #[serde(rename = "assumption_set")]
6522    pub assumption_set: Vec<String>,
6523    #[serde(rename = "version_dependencies", skip_serializing_if = "Option::is_none")]
6524    pub version_dependencies: Option<Vec<String>>,
6525    #[serde(rename = "verification_obligations")]
6526    pub verification_obligations: Vec<String>,
6527    #[serde(rename = "conflict_policy")]
6528    pub conflict_policy: PlanTransactionConflictPolicy,
6529    #[serde(rename = "rollback_policy", skip_serializing_if = "Option::is_none")]
6530    pub rollback_policy: Option<std::collections::HashMap<String, serde_json::Value>>,
6531    #[serde(rename = "rollback_or_compensation_policy", skip_serializing_if = "Option::is_none")]
6532    pub rollback_or_compensation_policy: Option<String>,
6533    #[serde(rename = "approval_state", skip_serializing_if = "Option::is_none")]
6534    pub approval_state: Option<PlanTransactionApprovalState>,
6535    #[serde(rename = "human_review_state", skip_serializing_if = "Option::is_none")]
6536    pub human_review_state: Option<String>,
6537    #[serde(rename = "transaction_hash", skip_serializing_if = "Option::is_none")]
6538    pub transaction_hash: Option<String>,
6539}
6540
6541impl PlanTransaction {
6542    pub fn new(plan_transaction_id: String, plan_hash: String, read_set: Vec<String>, write_set: Vec<String>, assumption_set: Vec<String>, verification_obligations: Vec<String>, conflict_policy: PlanTransactionConflictPolicy) -> PlanTransaction {
6543        PlanTransaction {
6544            plan_transaction_id,
6545            plan_hash,
6546            read_set,
6547            write_set,
6548            assumption_set,
6549            version_dependencies: None,
6550            verification_obligations,
6551            conflict_policy,
6552            rollback_policy: None,
6553            rollback_or_compensation_policy: None,
6554            approval_state: None,
6555            human_review_state: None,
6556            transaction_hash: None,
6557        }
6558    }
6559}
6560///
6561#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6562pub enum PlanTransactionConflictPolicy {
6563    #[serde(rename = "deny")]
6564    Deny,
6565    #[serde(rename = "escalate")]
6566    Escalate,
6567    #[serde(rename = "last_writer_forbidden")]
6568    LastWriterForbidden,
6569}
6570
6571impl Default for PlanTransactionConflictPolicy {
6572    fn default() -> PlanTransactionConflictPolicy {
6573        Self::Deny
6574    }
6575}
6576///
6577#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6578pub enum PlanTransactionApprovalState {
6579    #[serde(rename = "none")]
6580    None,
6581    #[serde(rename = "required")]
6582    Required,
6583    #[serde(rename = "approved")]
6584    Approved,
6585    #[serde(rename = "denied")]
6586    Denied,
6587    #[serde(rename = "expired")]
6588    Expired,
6589}
6590
6591impl Default for PlanTransactionApprovalState {
6592    fn default() -> PlanTransactionApprovalState {
6593        Self::None
6594    }
6595}
6596
6597/*
6598 * HELM Kernel API
6599 *
6600 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6601 *
6602 * The version of the OpenAPI document: 0.5.19
6603 *
6604 * Generated by: https://openapi-generator.tech
6605 */
6606
6607
6608/// PolicyBundle : A loaded policy bundle (jurisdiction, industry, or business pack)
6609#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6610pub struct PolicyBundle {
6611    #[serde(rename = "name")]
6612    pub name: String,
6613    #[serde(rename = "version")]
6614    pub version: String,
6615    /// SHA-256 of the bundle contents
6616    #[serde(rename = "content_hash")]
6617    pub content_hash: String,
6618    /// Ed25519 signature over content_hash
6619    #[serde(rename = "signature", default, skip_serializing_if = "Option::is_none")]
6620    pub signature: Option<Option<String>>,
6621    #[serde(rename = "pack_type", skip_serializing_if = "Option::is_none")]
6622    pub pack_type: Option<PolicyBundlePackType>,
6623}
6624
6625impl PolicyBundle {
6626    /// A loaded policy bundle (jurisdiction, industry, or business pack)
6627    pub fn new(name: String, version: String, content_hash: String) -> PolicyBundle {
6628        PolicyBundle {
6629            name,
6630            version,
6631            content_hash,
6632            signature: None,
6633            pack_type: None,
6634        }
6635    }
6636}
6637///
6638#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6639pub enum PolicyBundlePackType {
6640    #[serde(rename = "jurisdiction")]
6641    Jurisdiction,
6642    #[serde(rename = "industry")]
6643    Industry,
6644    #[serde(rename = "business")]
6645    Business,
6646    #[serde(rename = "custom")]
6647    Custom,
6648}
6649
6650impl Default for PolicyBundlePackType {
6651    fn default() -> PolicyBundlePackType {
6652        Self::Jurisdiction
6653    }
6654}
6655
6656/*
6657 * HELM Kernel API
6658 *
6659 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6660 *
6661 * The version of the OpenAPI document: 0.5.19
6662 *
6663 * Generated by: https://openapi-generator.tech
6664 */
6665
6666
6667#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6668pub struct PreflightCheck {
6669    #[serde(rename = "id")]
6670    pub id: String,
6671    #[serde(rename = "status")]
6672    pub status: String,
6673    #[serde(rename = "summary")]
6674    pub summary: String,
6675    #[serde(rename = "evidence_ref", skip_serializing_if = "Option::is_none")]
6676    pub evidence_ref: Option<String>,
6677    #[serde(rename = "fix_actions", skip_serializing_if = "Option::is_none")]
6678    pub fix_actions: Option<Vec<String>>,
6679}
6680
6681impl PreflightCheck {
6682    pub fn new(id: String, status: String, summary: String) -> PreflightCheck {
6683        PreflightCheck {
6684            id,
6685            status,
6686            summary,
6687            evidence_ref: None,
6688            fix_actions: None,
6689        }
6690    }
6691}
6692
6693/*
6694 * HELM Kernel API
6695 *
6696 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6697 *
6698 * The version of the OpenAPI document: 0.5.19
6699 *
6700 * Generated by: https://openapi-generator.tech
6701 */
6702
6703
6704#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6705pub struct PreflightLaunchpadImport202Response {
6706    #[serde(rename = "import")]
6707    pub import: Box<LaunchpadImportRecord>,
6708    #[serde(rename = "preflight")]
6709    pub preflight: Box<ImportPreflightResult>,
6710    #[serde(rename = "cli_equivalent", skip_serializing_if = "Option::is_none")]
6711    pub cli_equivalent: Option<String>,
6712}
6713
6714impl PreflightLaunchpadImport202Response {
6715    pub fn new(import: LaunchpadImportRecord, preflight: ImportPreflightResult) -> PreflightLaunchpadImport202Response {
6716        PreflightLaunchpadImport202Response {
6717            import: Box::new(import),
6718            preflight: Box::new(preflight),
6719            cli_equivalent: None,
6720        }
6721    }
6722}
6723
6724/*
6725 * HELM Kernel API
6726 *
6727 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6728 *
6729 * The version of the OpenAPI document: 0.5.19
6730 *
6731 * Generated by: https://openapi-generator.tech
6732 */
6733
6734
6735#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6736pub struct Receipt {
6737    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
6738    pub receipt_id: Option<String>,
6739    #[serde(rename = "decision_id", skip_serializing_if = "Option::is_none")]
6740    pub decision_id: Option<String>,
6741    #[serde(rename = "effect_id", skip_serializing_if = "Option::is_none")]
6742    pub effect_id: Option<String>,
6743    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
6744    pub status: Option<String>,
6745    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
6746    pub reason_code: Option<String>,
6747    #[serde(rename = "output_hash", skip_serializing_if = "Option::is_none")]
6748    pub output_hash: Option<String>,
6749    #[serde(rename = "blob_hash", skip_serializing_if = "Option::is_none")]
6750    pub blob_hash: Option<String>,
6751    #[serde(rename = "prev_hash", skip_serializing_if = "Option::is_none")]
6752    pub prev_hash: Option<String>,
6753    #[serde(rename = "lamport_clock", skip_serializing_if = "Option::is_none")]
6754    pub lamport_clock: Option<i32>,
6755    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
6756    pub signature: Option<String>,
6757    #[serde(rename = "timestamp", skip_serializing_if = "Option::is_none")]
6758    pub timestamp: Option<String>,
6759    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
6760    pub principal: Option<String>,
6761    #[serde(rename = "executor_id", skip_serializing_if = "Option::is_none")]
6762    pub executor_id: Option<String>,
6763    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
6764    pub args_hash: Option<String>,
6765    #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
6766    pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
6767}
6768
6769impl Receipt {
6770    pub fn new() -> Receipt {
6771        Receipt {
6772            receipt_id: None,
6773            decision_id: None,
6774            effect_id: None,
6775            status: None,
6776            reason_code: None,
6777            output_hash: None,
6778            blob_hash: None,
6779            prev_hash: None,
6780            lamport_clock: None,
6781            signature: None,
6782            timestamp: None,
6783            principal: None,
6784            executor_id: None,
6785            args_hash: None,
6786            metadata: None,
6787        }
6788    }
6789}
6790
6791/*
6792 * HELM Kernel API
6793 *
6794 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6795 *
6796 * The version of the OpenAPI document: 0.5.19
6797 *
6798 * Generated by: https://openapi-generator.tech
6799 */
6800
6801
6802#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6803pub struct ReceiptListResponse {
6804    #[serde(rename = "receipts", skip_serializing_if = "Option::is_none")]
6805    pub receipts: Option<Vec<Receipt>>,
6806    #[serde(rename = "count", skip_serializing_if = "Option::is_none")]
6807    pub count: Option<i32>,
6808    #[serde(rename = "next_cursor", skip_serializing_if = "Option::is_none")]
6809    pub next_cursor: Option<String>,
6810    #[serde(rename = "has_more", skip_serializing_if = "Option::is_none")]
6811    pub has_more: Option<bool>,
6812}
6813
6814impl ReceiptListResponse {
6815    pub fn new() -> ReceiptListResponse {
6816        ReceiptListResponse {
6817            receipts: None,
6818            count: None,
6819            next_cursor: None,
6820            has_more: None,
6821        }
6822    }
6823}
6824
6825/*
6826 * HELM Kernel API
6827 *
6828 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6829 *
6830 * The version of the OpenAPI document: 0.5.19
6831 *
6832 * Generated by: https://openapi-generator.tech
6833 */
6834
6835
6836#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6837pub struct RevokeMcpRegistryRecordRequest {
6838    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
6839    pub reason: Option<String>,
6840}
6841
6842impl RevokeMcpRegistryRecordRequest {
6843    pub fn new() -> RevokeMcpRegistryRecordRequest {
6844        RevokeMcpRegistryRecordRequest {
6845            reason: None,
6846        }
6847    }
6848}
6849
6850/*
6851 * HELM Kernel API
6852 *
6853 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6854 *
6855 * The version of the OpenAPI document: 0.5.19
6856 *
6857 * Generated by: https://openapi-generator.tech
6858 */
6859
6860
6861#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6862pub struct RevokeTrustKeyRequest {
6863    #[serde(rename = "tenant_id")]
6864    pub tenant_id: String,
6865    #[serde(rename = "key_id")]
6866    pub key_id: String,
6867}
6868
6869impl RevokeTrustKeyRequest {
6870    pub fn new(tenant_id: String, key_id: String) -> RevokeTrustKeyRequest {
6871        RevokeTrustKeyRequest {
6872            tenant_id,
6873            key_id,
6874        }
6875    }
6876}
6877
6878/*
6879 * HELM Kernel API
6880 *
6881 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6882 *
6883 * The version of the OpenAPI document: 0.5.19
6884 *
6885 * Generated by: https://openapi-generator.tech
6886 */
6887
6888
6889#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6890pub struct RunAgentUiRuntimeRequest {
6891    #[serde(rename = "threadId", skip_serializing_if = "Option::is_none")]
6892    pub thread_id: Option<String>,
6893    #[serde(rename = "runId", skip_serializing_if = "Option::is_none")]
6894    pub run_id: Option<String>,
6895    #[serde(rename = "workspaceId", skip_serializing_if = "Option::is_none")]
6896    pub workspace_id: Option<String>,
6897    #[serde(rename = "currentSurface", skip_serializing_if = "Option::is_none")]
6898    pub current_surface: Option<String>,
6899    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
6900    pub state: Option<std::collections::HashMap<String, serde_json::Value>>,
6901    #[serde(rename = "messages", default, skip_serializing_if = "Option::is_none")]
6902    pub messages: Option<Option<serde_json::Value>>,
6903}
6904
6905impl RunAgentUiRuntimeRequest {
6906    pub fn new() -> RunAgentUiRuntimeRequest {
6907        RunAgentUiRuntimeRequest {
6908            thread_id: None,
6909            run_id: None,
6910            workspace_id: None,
6911            current_surface: None,
6912            state: None,
6913            messages: None,
6914        }
6915    }
6916}
6917
6918/*
6919 * HELM Kernel API
6920 *
6921 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6922 *
6923 * The version of the OpenAPI document: 0.5.19
6924 *
6925 * Generated by: https://openapi-generator.tech
6926 */
6927
6928
6929#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6930pub struct RunPublicDemo200Response {
6931    #[serde(rename = "verdict")]
6932    pub verdict: RunPublicDemo200ResponseVerdict,
6933    #[serde(rename = "reason_code")]
6934    pub reason_code: String,
6935    #[serde(rename = "receipt")]
6936    pub receipt: Box<Receipt>,
6937    #[serde(rename = "proof_refs")]
6938    pub proof_refs: Box<RunPublicDemo200ResponseProofRefs>,
6939    #[serde(rename = "verification_hint")]
6940    pub verification_hint: String,
6941    #[serde(rename = "sandbox_label")]
6942    pub sandbox_label: String,
6943    #[serde(rename = "helm_ai_kernel_version")]
6944    pub helm_ai_kernel_version: String,
6945}
6946
6947impl RunPublicDemo200Response {
6948    pub fn new(verdict: RunPublicDemo200ResponseVerdict, reason_code: String, receipt: Receipt, proof_refs: RunPublicDemo200ResponseProofRefs, verification_hint: String, sandbox_label: String, helm_ai_kernel_version: String) -> RunPublicDemo200Response {
6949        RunPublicDemo200Response {
6950            verdict,
6951            reason_code,
6952            receipt: Box::new(receipt),
6953            proof_refs: Box::new(proof_refs),
6954            verification_hint,
6955            sandbox_label,
6956            helm_ai_kernel_version,
6957        }
6958    }
6959}
6960///
6961#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
6962pub enum RunPublicDemo200ResponseVerdict {
6963    #[serde(rename = "ALLOW")]
6964    Allow,
6965    #[serde(rename = "DENY")]
6966    Deny,
6967    #[serde(rename = "ESCALATE")]
6968    Escalate,
6969}
6970
6971impl Default for RunPublicDemo200ResponseVerdict {
6972    fn default() -> RunPublicDemo200ResponseVerdict {
6973        Self::Allow
6974    }
6975}
6976
6977/*
6978 * HELM Kernel API
6979 *
6980 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
6981 *
6982 * The version of the OpenAPI document: 0.5.19
6983 *
6984 * Generated by: https://openapi-generator.tech
6985 */
6986
6987
6988#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
6989pub struct RunPublicDemo200ResponseProofRefs {
6990    #[serde(rename = "decision_id")]
6991    pub decision_id: String,
6992    #[serde(rename = "receipt_id")]
6993    pub receipt_id: String,
6994    #[serde(rename = "receipt_hash")]
6995    pub receipt_hash: String,
6996}
6997
6998impl RunPublicDemo200ResponseProofRefs {
6999    pub fn new(decision_id: String, receipt_id: String, receipt_hash: String) -> RunPublicDemo200ResponseProofRefs {
7000        RunPublicDemo200ResponseProofRefs {
7001            decision_id,
7002            receipt_id,
7003            receipt_hash,
7004        }
7005    }
7006}
7007
7008/*
7009 * HELM Kernel API
7010 *
7011 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7012 *
7013 * The version of the OpenAPI document: 0.5.19
7014 *
7015 * Generated by: https://openapi-generator.tech
7016 */
7017
7018
7019#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7020pub struct RunPublicDemoRequest {
7021    #[serde(rename = "action_id")]
7022    pub action_id: RunPublicDemoRequestActionId,
7023    #[serde(rename = "policy_id", skip_serializing_if = "Option::is_none")]
7024    pub policy_id: Option<String>,
7025    #[serde(rename = "args", skip_serializing_if = "Option::is_none")]
7026    pub args: Option<std::collections::HashMap<String, serde_json::Value>>,
7027}
7028
7029impl RunPublicDemoRequest {
7030    pub fn new(action_id: RunPublicDemoRequestActionId) -> RunPublicDemoRequest {
7031        RunPublicDemoRequest {
7032            action_id,
7033            policy_id: None,
7034            args: None,
7035        }
7036    }
7037}
7038///
7039#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7040pub enum RunPublicDemoRequestActionId {
7041    #[serde(rename = "read_ticket")]
7042    ReadTicket,
7043    #[serde(rename = "draft_reply")]
7044    DraftReply,
7045    #[serde(rename = "small_refund")]
7046    SmallRefund,
7047    #[serde(rename = "large_refund")]
7048    LargeRefund,
7049    #[serde(rename = "dangerous_shell")]
7050    DangerousShell,
7051    #[serde(rename = "export_customer_list")]
7052    ExportCustomerList,
7053    #[serde(rename = "modify_policy")]
7054    ModifyPolicy,
7055}
7056
7057impl Default for RunPublicDemoRequestActionId {
7058    fn default() -> RunPublicDemoRequestActionId {
7059        Self::ReadTicket
7060    }
7061}
7062
7063/*
7064 * HELM Kernel API
7065 *
7066 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7067 *
7068 * The version of the OpenAPI document: 0.5.19
7069 *
7070 * Generated by: https://openapi-generator.tech
7071 */
7072
7073
7074#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7075pub struct SandboxBackendProfile {
7076    #[serde(rename = "name")]
7077    pub name: String,
7078    #[serde(rename = "kind")]
7079    pub kind: SandboxBackendProfileKind,
7080    #[serde(rename = "runtime")]
7081    pub runtime: String,
7082    #[serde(rename = "hosted")]
7083    pub hosted: bool,
7084    #[serde(rename = "deny_network_by_default")]
7085    pub deny_network_by_default: bool,
7086    #[serde(rename = "native_isolation")]
7087    pub native_isolation: bool,
7088    #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")]
7089    pub experimental: Option<bool>,
7090}
7091
7092impl SandboxBackendProfile {
7093    pub fn new(name: String, kind: SandboxBackendProfileKind, runtime: String, hosted: bool, deny_network_by_default: bool, native_isolation: bool) -> SandboxBackendProfile {
7094        SandboxBackendProfile {
7095            name,
7096            kind,
7097            runtime,
7098            hosted,
7099            deny_network_by_default,
7100            native_isolation,
7101            experimental: None,
7102        }
7103    }
7104}
7105///
7106#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7107pub enum SandboxBackendProfileKind {
7108    #[serde(rename = "wasi-wazero")]
7109    WasiWazero,
7110    #[serde(rename = "wasi-wasmtime")]
7111    WasiWasmtime,
7112    #[serde(rename = "native-nsjail")]
7113    NativeNsjail,
7114    #[serde(rename = "native-gvisor")]
7115    NativeGvisor,
7116    #[serde(rename = "native-firecracker")]
7117    NativeFirecracker,
7118    #[serde(rename = "hosted-adapter")]
7119    HostedAdapter,
7120}
7121
7122impl Default for SandboxBackendProfileKind {
7123    fn default() -> SandboxBackendProfileKind {
7124        Self::WasiWazero
7125    }
7126}
7127
7128/*
7129 * HELM Kernel API
7130 *
7131 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7132 *
7133 * The version of the OpenAPI document: 0.5.19
7134 *
7135 * Generated by: https://openapi-generator.tech
7136 */
7137
7138
7139#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7140pub struct SandboxGrant {
7141    #[serde(rename = "grant_id")]
7142    pub grant_id: String,
7143    #[serde(rename = "runtime")]
7144    pub runtime: String,
7145    #[serde(rename = "runtime_version", skip_serializing_if = "Option::is_none")]
7146    pub runtime_version: Option<String>,
7147    #[serde(rename = "profile")]
7148    pub profile: String,
7149    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
7150    pub image_digest: Option<String>,
7151    #[serde(rename = "template_digest", skip_serializing_if = "Option::is_none")]
7152    pub template_digest: Option<String>,
7153    #[serde(rename = "filesystem_preopens", skip_serializing_if = "Option::is_none")]
7154    pub filesystem_preopens: Option<Vec<FilesystemPreopen>>,
7155    #[serde(rename = "env")]
7156    pub env: Box<EnvExposurePolicy>,
7157    #[serde(rename = "network")]
7158    pub network: Box<NetworkGrant>,
7159    #[serde(rename = "limits", skip_serializing_if = "Option::is_none")]
7160    pub limits: Option<Box<SandboxGrantLimits>>,
7161    #[serde(rename = "declared_at")]
7162    pub declared_at: String,
7163    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
7164    pub policy_epoch: Option<String>,
7165    #[serde(rename = "grant_hash", skip_serializing_if = "Option::is_none")]
7166    pub grant_hash: Option<String>,
7167}
7168
7169impl SandboxGrant {
7170    pub fn new(grant_id: String, runtime: String, profile: String, env: EnvExposurePolicy, network: NetworkGrant, declared_at: String) -> SandboxGrant {
7171        SandboxGrant {
7172            grant_id,
7173            runtime,
7174            runtime_version: None,
7175            profile,
7176            image_digest: None,
7177            template_digest: None,
7178            filesystem_preopens: None,
7179            env: Box::new(env),
7180            network: Box::new(network),
7181            limits: None,
7182            declared_at,
7183            policy_epoch: None,
7184            grant_hash: None,
7185        }
7186    }
7187}
7188
7189/*
7190 * HELM Kernel API
7191 *
7192 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7193 *
7194 * The version of the OpenAPI document: 0.5.19
7195 *
7196 * Generated by: https://openapi-generator.tech
7197 */
7198
7199
7200#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
7201#[serde(untagged)]
7202pub enum SandboxGrantInspection {
7203    SandboxBackendProfileList(Vec<SandboxBackendProfile>),
7204    SandboxGrant(Box<SandboxGrant>),
7205}
7206
7207impl Default for SandboxGrantInspection {
7208    fn default() -> Self {
7209        Self::SandboxBackendProfileList(Default::default())
7210    }
7211}
7212
7213/*
7214 * HELM Kernel API
7215 *
7216 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7217 *
7218 * The version of the OpenAPI document: 0.5.19
7219 *
7220 * Generated by: https://openapi-generator.tech
7221 */
7222
7223
7224#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7225pub struct SandboxGrantLimits {
7226    #[serde(rename = "memory_bytes", skip_serializing_if = "Option::is_none")]
7227    pub memory_bytes: Option<i64>,
7228    /// Go duration in nanoseconds.
7229    #[serde(rename = "cpu_time", skip_serializing_if = "Option::is_none")]
7230    pub cpu_time: Option<i64>,
7231    #[serde(rename = "output_bytes", skip_serializing_if = "Option::is_none")]
7232    pub output_bytes: Option<i64>,
7233    #[serde(rename = "open_files", skip_serializing_if = "Option::is_none")]
7234    pub open_files: Option<i32>,
7235}
7236
7237impl SandboxGrantLimits {
7238    pub fn new() -> SandboxGrantLimits {
7239        SandboxGrantLimits {
7240            memory_bytes: None,
7241            cpu_time: None,
7242            output_bytes: None,
7243            open_files: None,
7244        }
7245    }
7246}
7247
7248/*
7249 * HELM Kernel API
7250 *
7251 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7252 *
7253 * The version of the OpenAPI document: 0.5.19
7254 *
7255 * Generated by: https://openapi-generator.tech
7256 */
7257
7258
7259#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7260pub struct SandboxPreflightRequest {
7261    #[serde(rename = "runtime", skip_serializing_if = "Option::is_none")]
7262    pub runtime: Option<String>,
7263    #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
7264    pub profile: Option<String>,
7265    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
7266    pub image_digest: Option<String>,
7267    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
7268    pub policy_epoch: Option<String>,
7269    #[serde(rename = "requested_grant", skip_serializing_if = "Option::is_none")]
7270    pub requested_grant: Option<Box<SandboxGrant>>,
7271    #[serde(rename = "expected_grant_hash", skip_serializing_if = "Option::is_none")]
7272    pub expected_grant_hash: Option<String>,
7273}
7274
7275impl SandboxPreflightRequest {
7276    pub fn new() -> SandboxPreflightRequest {
7277        SandboxPreflightRequest {
7278            runtime: None,
7279            profile: None,
7280            image_digest: None,
7281            policy_epoch: None,
7282            requested_grant: None,
7283            expected_grant_hash: None,
7284        }
7285    }
7286}
7287
7288/*
7289 * HELM Kernel API
7290 *
7291 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7292 *
7293 * The version of the OpenAPI document: 0.5.19
7294 *
7295 * Generated by: https://openapi-generator.tech
7296 */
7297
7298
7299#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7300pub struct SandboxPreflightResult {
7301    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
7302    pub verdict: Option<SandboxPreflightResultVerdict>,
7303    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
7304    pub reason_code: Option<String>,
7305    #[serde(rename = "grant_id", skip_serializing_if = "Option::is_none")]
7306    pub grant_id: Option<String>,
7307    #[serde(rename = "grant_hash", skip_serializing_if = "Option::is_none")]
7308    pub grant_hash: Option<String>,
7309    #[serde(rename = "dispatch_ready", skip_serializing_if = "Option::is_none")]
7310    pub dispatch_ready: Option<bool>,
7311    #[serde(rename = "findings", skip_serializing_if = "Option::is_none")]
7312    pub findings: Option<Vec<String>>,
7313    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
7314    pub checked_at: Option<String>,
7315}
7316
7317impl SandboxPreflightResult {
7318    pub fn new() -> SandboxPreflightResult {
7319        SandboxPreflightResult {
7320            verdict: None,
7321            reason_code: None,
7322            grant_id: None,
7323            grant_hash: None,
7324            dispatch_ready: None,
7325            findings: None,
7326            checked_at: None,
7327        }
7328    }
7329}
7330///
7331#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7332pub enum SandboxPreflightResultVerdict {
7333    #[serde(rename = "ALLOW")]
7334    Allow,
7335    #[serde(rename = "DENY")]
7336    Deny,
7337    #[serde(rename = "ESCALATE")]
7338    Escalate,
7339}
7340
7341impl Default for SandboxPreflightResultVerdict {
7342    fn default() -> SandboxPreflightResultVerdict {
7343        Self::Allow
7344    }
7345}
7346
7347/*
7348 * HELM Kernel API
7349 *
7350 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7351 *
7352 * The version of the OpenAPI document: 0.5.19
7353 *
7354 * Generated by: https://openapi-generator.tech
7355 */
7356
7357
7358#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7359pub struct SecretContract {
7360    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
7361    pub name: Option<String>,
7362    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
7363    pub source: Option<String>,
7364    #[serde(rename = "required", skip_serializing_if = "Option::is_none")]
7365    pub required: Option<bool>,
7366    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
7367    pub reason: Option<String>,
7368    #[serde(rename = "targets", skip_serializing_if = "Option::is_none")]
7369    pub targets: Option<Vec<String>>,
7370}
7371
7372impl SecretContract {
7373    pub fn new() -> SecretContract {
7374        SecretContract {
7375            name: None,
7376            source: None,
7377            required: None,
7378            reason: None,
7379            targets: None,
7380        }
7381    }
7382}
7383
7384/*
7385 * HELM Kernel API
7386 *
7387 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7388 *
7389 * The version of the OpenAPI document: 0.5.19
7390 *
7391 * Generated by: https://openapi-generator.tech
7392 */
7393
7394
7395#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7396pub struct Session {
7397    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
7398    pub session_id: Option<String>,
7399    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
7400    pub created_at: Option<String>,
7401    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
7402    pub receipt_count: Option<i32>,
7403    #[serde(rename = "last_lamport_clock", skip_serializing_if = "Option::is_none")]
7404    pub last_lamport_clock: Option<i32>,
7405}
7406
7407impl Session {
7408    pub fn new() -> Session {
7409        Session {
7410            session_id: None,
7411            created_at: None,
7412            receipt_count: None,
7413            last_lamport_clock: None,
7414        }
7415    }
7416}
7417
7418/*
7419 * HELM Kernel API
7420 *
7421 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7422 *
7423 * The version of the OpenAPI document: 0.5.19
7424 *
7425 * Generated by: https://openapi-generator.tech
7426 */
7427
7428
7429#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7430pub struct SourceFileSummary {
7431    #[serde(rename = "path")]
7432    pub path: String,
7433    #[serde(rename = "kind")]
7434    pub kind: String,
7435    #[serde(rename = "size", skip_serializing_if = "Option::is_none")]
7436    pub size: Option<i32>,
7437    #[serde(rename = "sha", skip_serializing_if = "Option::is_none")]
7438    pub sha: Option<String>,
7439    #[serde(rename = "language", skip_serializing_if = "Option::is_none")]
7440    pub language: Option<String>,
7441    #[serde(rename = "content", skip_serializing_if = "Option::is_none")]
7442    pub content: Option<String>,
7443}
7444
7445impl SourceFileSummary {
7446    pub fn new(path: String, kind: String) -> SourceFileSummary {
7447        SourceFileSummary {
7448            path,
7449            kind,
7450            size: None,
7451            sha: None,
7452            language: None,
7453            content: None,
7454        }
7455    }
7456}
7457
7458/*
7459 * HELM Kernel API
7460 *
7461 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7462 *
7463 * The version of the OpenAPI document: 0.5.19
7464 *
7465 * Generated by: https://openapi-generator.tech
7466 */
7467
7468
7469#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7470pub struct SourceSnapshot {
7471    #[serde(rename = "repo_url")]
7472    pub repo_url: String,
7473    #[serde(rename = "provider")]
7474    pub provider: String,
7475    #[serde(rename = "owner", skip_serializing_if = "Option::is_none")]
7476    pub owner: Option<String>,
7477    #[serde(rename = "repo", skip_serializing_if = "Option::is_none")]
7478    pub repo: Option<String>,
7479    #[serde(rename = "ref", skip_serializing_if = "Option::is_none")]
7480    pub r#ref: Option<String>,
7481    #[serde(rename = "commit", skip_serializing_if = "Option::is_none")]
7482    pub commit: Option<String>,
7483    #[serde(rename = "license_spdx", skip_serializing_if = "Option::is_none")]
7484    pub license_spdx: Option<String>,
7485    #[serde(rename = "license_state")]
7486    pub license_state: String,
7487    #[serde(rename = "fetched_at", skip_serializing_if = "Option::is_none")]
7488    pub fetched_at: Option<String>,
7489    #[serde(rename = "files")]
7490    pub files: Vec<SourceFileSummary>,
7491    #[serde(rename = "api_source", skip_serializing_if = "Option::is_none")]
7492    pub api_source: Option<String>,
7493}
7494
7495impl SourceSnapshot {
7496    pub fn new(repo_url: String, provider: String, license_state: String, files: Vec<SourceFileSummary>) -> SourceSnapshot {
7497        SourceSnapshot {
7498            repo_url,
7499            provider,
7500            owner: None,
7501            repo: None,
7502            r#ref: None,
7503            commit: None,
7504            license_spdx: None,
7505            license_state,
7506            fetched_at: None,
7507            files,
7508            api_source: None,
7509        }
7510    }
7511}
7512
7513/*
7514 * HELM Kernel API
7515 *
7516 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7517 *
7518 * The version of the OpenAPI document: 0.5.19
7519 *
7520 * Generated by: https://openapi-generator.tech
7521 */
7522
7523
7524#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7525pub struct TamperPublicDemoReceipt200Response {
7526    #[serde(rename = "valid")]
7527    pub valid: bool,
7528    #[serde(rename = "signature_valid")]
7529    pub signature_valid: bool,
7530    #[serde(rename = "hash_matches")]
7531    pub hash_matches: bool,
7532    #[serde(rename = "reason")]
7533    pub reason: String,
7534    #[serde(rename = "receipt_hash")]
7535    pub receipt_hash: String,
7536    #[serde(rename = "expected_receipt_hash")]
7537    pub expected_receipt_hash: String,
7538    #[serde(rename = "original_hash")]
7539    pub original_hash: String,
7540    #[serde(rename = "tampered_hash")]
7541    pub tampered_hash: String,
7542}
7543
7544impl TamperPublicDemoReceipt200Response {
7545    pub fn new(valid: bool, signature_valid: bool, hash_matches: bool, reason: String, receipt_hash: String, expected_receipt_hash: String, original_hash: String, tampered_hash: String) -> TamperPublicDemoReceipt200Response {
7546        TamperPublicDemoReceipt200Response {
7547            valid,
7548            signature_valid,
7549            hash_matches,
7550            reason,
7551            receipt_hash,
7552            expected_receipt_hash,
7553            original_hash,
7554            tampered_hash,
7555        }
7556    }
7557}
7558
7559/*
7560 * HELM Kernel API
7561 *
7562 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7563 *
7564 * The version of the OpenAPI document: 0.5.19
7565 *
7566 * Generated by: https://openapi-generator.tech
7567 */
7568
7569
7570#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7571pub struct TamperPublicDemoReceiptRequest {
7572    #[serde(rename = "receipt")]
7573    pub receipt: Box<Receipt>,
7574    /// Receipt hash returned in /api/demo/run proof_refs.receipt_hash.
7575    #[serde(rename = "expected_receipt_hash")]
7576    pub expected_receipt_hash: String,
7577    #[serde(rename = "mutation", skip_serializing_if = "Option::is_none")]
7578    pub mutation: Option<String>,
7579}
7580
7581impl TamperPublicDemoReceiptRequest {
7582    pub fn new(receipt: Receipt, expected_receipt_hash: String) -> TamperPublicDemoReceiptRequest {
7583        TamperPublicDemoReceiptRequest {
7584            receipt: Box::new(receipt),
7585            expected_receipt_hash,
7586            mutation: None,
7587        }
7588    }
7589}
7590
7591/*
7592 * HELM Kernel API
7593 *
7594 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7595 *
7596 * The version of the OpenAPI document: 0.5.19
7597 *
7598 * Generated by: https://openapi-generator.tech
7599 */
7600
7601
7602#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7603pub struct TargetPlan {
7604    #[serde(rename = "target_id")]
7605    pub target_id: String,
7606    #[serde(rename = "kind")]
7607    pub kind: String,
7608    #[serde(rename = "substrate_id", skip_serializing_if = "Option::is_none")]
7609    pub substrate_id: Option<String>,
7610    #[serde(rename = "deployable")]
7611    pub deployable: bool,
7612    #[serde(rename = "requires_approval", skip_serializing_if = "Option::is_none")]
7613    pub requires_approval: Option<bool>,
7614    #[serde(rename = "commands", skip_serializing_if = "Option::is_none")]
7615    pub commands: Option<Vec<Vec<String>>>,
7616    #[serde(rename = "artifacts", skip_serializing_if = "Option::is_none")]
7617    pub artifacts: Option<Vec<String>>,
7618    #[serde(rename = "secrets_backend", skip_serializing_if = "Option::is_none")]
7619    pub secrets_backend: Option<String>,
7620    #[serde(rename = "healthcheck", skip_serializing_if = "Option::is_none")]
7621    pub healthcheck: Option<std::collections::HashMap<String, String>>,
7622    #[serde(rename = "rollback", skip_serializing_if = "Option::is_none")]
7623    pub rollback: Option<Vec<String>>,
7624    #[serde(rename = "risk")]
7625    pub risk: String,
7626    #[serde(rename = "reason")]
7627    pub reason: String,
7628}
7629
7630impl TargetPlan {
7631    pub fn new(target_id: String, kind: String, deployable: bool, risk: String, reason: String) -> TargetPlan {
7632        TargetPlan {
7633            target_id,
7634            kind,
7635            substrate_id: None,
7636            deployable,
7637            requires_approval: None,
7638            commands: None,
7639            artifacts: None,
7640            secrets_backend: None,
7641            healthcheck: None,
7642            rollback: None,
7643            risk,
7644            reason,
7645        }
7646    }
7647}
7648
7649/*
7650 * HELM Kernel API
7651 *
7652 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7653 *
7654 * The version of the OpenAPI document: 0.5.19
7655 *
7656 * Generated by: https://openapi-generator.tech
7657 */
7658
7659
7660#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7661pub struct TeardownLaunchpadRuntimeRunRequest {
7662    #[serde(rename = "cascade", skip_serializing_if = "Option::is_none")]
7663    pub cascade: Option<bool>,
7664}
7665
7666impl TeardownLaunchpadRuntimeRunRequest {
7667    pub fn new() -> TeardownLaunchpadRuntimeRunRequest {
7668        TeardownLaunchpadRuntimeRunRequest {
7669            cascade: None,
7670        }
7671    }
7672}
7673
7674/*
7675 * HELM Kernel API
7676 *
7677 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7678 *
7679 * The version of the OpenAPI document: 0.5.19
7680 *
7681 * Generated by: https://openapi-generator.tech
7682 */
7683
7684
7685#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7686pub struct TelemetryExportRequest {
7687    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
7688    pub format: Option<String>,
7689    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
7690    pub receipt_id: Option<String>,
7691    #[serde(rename = "record_hash", skip_serializing_if = "Option::is_none")]
7692    pub record_hash: Option<String>,
7693    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
7694    pub policy_epoch: Option<String>,
7695    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
7696    pub verdict: Option<String>,
7697    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
7698    pub reason_code: Option<String>,
7699    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
7700    pub sandbox_grant_hash: Option<String>,
7701    #[serde(rename = "authz_snapshot_hash", skip_serializing_if = "Option::is_none")]
7702    pub authz_snapshot_hash: Option<String>,
7703    #[serde(rename = "attributes", skip_serializing_if = "Option::is_none")]
7704    pub attributes: Option<std::collections::HashMap<String, String>>,
7705}
7706
7707impl TelemetryExportRequest {
7708    pub fn new() -> TelemetryExportRequest {
7709        TelemetryExportRequest {
7710            format: None,
7711            receipt_id: None,
7712            record_hash: None,
7713            policy_epoch: None,
7714            verdict: None,
7715            reason_code: None,
7716            sandbox_grant_hash: None,
7717            authz_snapshot_hash: None,
7718            attributes: None,
7719        }
7720    }
7721}
7722
7723/*
7724 * HELM Kernel API
7725 *
7726 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7727 *
7728 * The version of the OpenAPI document: 0.5.19
7729 *
7730 * Generated by: https://openapi-generator.tech
7731 */
7732
7733
7734#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7735pub struct TelemetryExportResult {
7736    #[serde(rename = "export_id", skip_serializing_if = "Option::is_none")]
7737    pub export_id: Option<String>,
7738    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
7739    pub format: Option<String>,
7740    #[serde(rename = "authoritative", skip_serializing_if = "Option::is_none")]
7741    pub authoritative: Option<bool>,
7742    #[serde(rename = "attributes", skip_serializing_if = "Option::is_none")]
7743    pub attributes: Option<std::collections::HashMap<String, String>>,
7744    #[serde(rename = "exported_at", skip_serializing_if = "Option::is_none")]
7745    pub exported_at: Option<String>,
7746}
7747
7748impl TelemetryExportResult {
7749    pub fn new() -> TelemetryExportResult {
7750        TelemetryExportResult {
7751            export_id: None,
7752            format: None,
7753            authoritative: None,
7754            attributes: None,
7755            exported_at: None,
7756        }
7757    }
7758}
7759
7760/*
7761 * HELM Kernel API
7762 *
7763 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7764 *
7765 * The version of the OpenAPI document: 0.5.19
7766 *
7767 * Generated by: https://openapi-generator.tech
7768 */
7769
7770
7771#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7772pub struct TelemetryOTelConfig {
7773    #[serde(rename = "service_name", skip_serializing_if = "Option::is_none")]
7774    pub service_name: Option<String>,
7775    #[serde(rename = "signal_type", skip_serializing_if = "Option::is_none")]
7776    pub signal_type: Option<String>,
7777    #[serde(rename = "authoritative", skip_serializing_if = "Option::is_none")]
7778    pub authoritative: Option<bool>,
7779    #[serde(rename = "span_attributes", skip_serializing_if = "Option::is_none")]
7780    pub span_attributes: Option<std::collections::HashMap<String, String>>,
7781    #[serde(rename = "exported_signals", skip_serializing_if = "Option::is_none")]
7782    pub exported_signals: Option<Vec<String>>,
7783}
7784
7785impl TelemetryOTelConfig {
7786    pub fn new() -> TelemetryOTelConfig {
7787        TelemetryOTelConfig {
7788            service_name: None,
7789            signal_type: None,
7790            authoritative: None,
7791            span_attributes: None,
7792            exported_signals: None,
7793        }
7794    }
7795}
7796
7797/*
7798 * HELM Kernel API
7799 *
7800 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7801 *
7802 * The version of the OpenAPI document: 0.5.19
7803 *
7804 * Generated by: https://openapi-generator.tech
7805 */
7806
7807
7808#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7809pub struct TransitionApprovalCeremonyRequest {
7810    #[serde(rename = "actor", skip_serializing_if = "Option::is_none")]
7811    pub actor: Option<String>,
7812    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
7813    pub receipt_id: Option<String>,
7814    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
7815    pub reason: Option<String>,
7816}
7817
7818impl TransitionApprovalCeremonyRequest {
7819    pub fn new() -> TransitionApprovalCeremonyRequest {
7820        TransitionApprovalCeremonyRequest {
7821            actor: None,
7822            receipt_id: None,
7823            reason: None,
7824        }
7825    }
7826}
7827
7828/*
7829 * HELM Kernel API
7830 *
7831 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7832 *
7833 * The version of the OpenAPI document: 0.5.19
7834 *
7835 * Generated by: https://openapi-generator.tech
7836 */
7837
7838
7839#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7840pub struct VerificationResult {
7841    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
7842    pub verdict: Option<VerificationResultVerdict>,
7843    #[serde(rename = "checks", skip_serializing_if = "Option::is_none")]
7844    pub checks: Option<Box<VerificationResultChecks>>,
7845    #[serde(rename = "roots", skip_serializing_if = "Option::is_none")]
7846    pub roots: Option<Box<VerificationResultRoots>>,
7847    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
7848    pub errors: Option<Vec<String>>,
7849}
7850
7851impl VerificationResult {
7852    pub fn new() -> VerificationResult {
7853        VerificationResult {
7854            verdict: None,
7855            checks: None,
7856            roots: None,
7857            errors: None,
7858        }
7859    }
7860}
7861///
7862#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7863pub enum VerificationResultVerdict {
7864    #[serde(rename = "PASS")]
7865    Pass,
7866    #[serde(rename = "FAIL")]
7867    Fail,
7868}
7869
7870impl Default for VerificationResultVerdict {
7871    fn default() -> VerificationResultVerdict {
7872        Self::Pass
7873    }
7874}
7875
7876/*
7877 * HELM Kernel API
7878 *
7879 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7880 *
7881 * The version of the OpenAPI document: 0.5.19
7882 *
7883 * Generated by: https://openapi-generator.tech
7884 */
7885
7886
7887#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7888pub struct VerificationResultChecks {
7889    #[serde(rename = "signatures", skip_serializing_if = "Option::is_none")]
7890    pub signatures: Option<VerificationResultChecksSignatures>,
7891    #[serde(rename = "causal_chain", skip_serializing_if = "Option::is_none")]
7892    pub causal_chain: Option<VerificationResultChecksCausalChain>,
7893    #[serde(rename = "policy_compliance", skip_serializing_if = "Option::is_none")]
7894    pub policy_compliance: Option<VerificationResultChecksPolicyCompliance>,
7895}
7896
7897impl VerificationResultChecks {
7898    pub fn new() -> VerificationResultChecks {
7899        VerificationResultChecks {
7900            signatures: None,
7901            causal_chain: None,
7902            policy_compliance: None,
7903        }
7904    }
7905}
7906///
7907#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7908pub enum VerificationResultChecksSignatures {
7909    #[serde(rename = "PASS")]
7910    Pass,
7911    #[serde(rename = "FAIL")]
7912    Fail,
7913}
7914
7915impl Default for VerificationResultChecksSignatures {
7916    fn default() -> VerificationResultChecksSignatures {
7917        Self::Pass
7918    }
7919}
7920///
7921#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7922pub enum VerificationResultChecksCausalChain {
7923    #[serde(rename = "PASS")]
7924    Pass,
7925    #[serde(rename = "FAIL")]
7926    Fail,
7927}
7928
7929impl Default for VerificationResultChecksCausalChain {
7930    fn default() -> VerificationResultChecksCausalChain {
7931        Self::Pass
7932    }
7933}
7934///
7935#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
7936pub enum VerificationResultChecksPolicyCompliance {
7937    #[serde(rename = "PASS")]
7938    Pass,
7939    #[serde(rename = "FAIL")]
7940    Fail,
7941}
7942
7943impl Default for VerificationResultChecksPolicyCompliance {
7944    fn default() -> VerificationResultChecksPolicyCompliance {
7945        Self::Pass
7946    }
7947}
7948
7949/*
7950 * HELM Kernel API
7951 *
7952 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7953 *
7954 * The version of the OpenAPI document: 0.5.19
7955 *
7956 * Generated by: https://openapi-generator.tech
7957 */
7958
7959
7960#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7961pub struct VerificationResultRoots {
7962    #[serde(rename = "manifest_root_hash", skip_serializing_if = "Option::is_none")]
7963    pub manifest_root_hash: Option<String>,
7964    #[serde(rename = "merkle_root", skip_serializing_if = "Option::is_none")]
7965    pub merkle_root: Option<String>,
7966    #[serde(rename = "entry_count", skip_serializing_if = "Option::is_none")]
7967    pub entry_count: Option<i32>,
7968}
7969
7970impl VerificationResultRoots {
7971    pub fn new() -> VerificationResultRoots {
7972        VerificationResultRoots {
7973            manifest_root_hash: None,
7974            merkle_root: None,
7975            entry_count: None,
7976        }
7977    }
7978}
7979
7980/*
7981 * HELM Kernel API
7982 *
7983 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
7984 *
7985 * The version of the OpenAPI document: 0.5.19
7986 *
7987 * Generated by: https://openapi-generator.tech
7988 */
7989
7990
7991#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
7992pub struct VerificationScope {
7993    #[serde(rename = "verification_scope_id")]
7994    pub verification_scope_id: String,
7995    #[serde(rename = "subject_hash")]
7996    pub subject_hash: String,
7997    #[serde(rename = "risk_class", skip_serializing_if = "Option::is_none")]
7998    pub risk_class: Option<VerificationScopeRiskClass>,
7999    #[serde(rename = "checks_performed")]
8000    pub checks_performed: Vec<String>,
8001    #[serde(rename = "assumptions", skip_serializing_if = "Option::is_none")]
8002    pub assumptions: Option<Vec<String>>,
8003    #[serde(rename = "untested_regions", skip_serializing_if = "Option::is_none")]
8004    pub untested_regions: Option<Vec<String>>,
8005    #[serde(rename = "known_limits", skip_serializing_if = "Option::is_none")]
8006    pub known_limits: Option<Vec<String>>,
8007    #[serde(rename = "remaining_risks", skip_serializing_if = "Option::is_none")]
8008    pub remaining_risks: Option<Vec<String>>,
8009    #[serde(rename = "required_followup", skip_serializing_if = "Option::is_none")]
8010    pub required_followup: Option<Vec<String>>,
8011    #[serde(rename = "verifier_hash")]
8012    pub verifier_hash: String,
8013    #[serde(rename = "policy_hash")]
8014    pub policy_hash: String,
8015    #[serde(rename = "created_at")]
8016    pub created_at: String,
8017    #[serde(rename = "scope_hash", skip_serializing_if = "Option::is_none")]
8018    pub scope_hash: Option<String>,
8019}
8020
8021impl VerificationScope {
8022    pub fn new(verification_scope_id: String, subject_hash: String, checks_performed: Vec<String>, verifier_hash: String, policy_hash: String, created_at: String) -> VerificationScope {
8023        VerificationScope {
8024            verification_scope_id,
8025            subject_hash,
8026            risk_class: None,
8027            checks_performed,
8028            assumptions: None,
8029            untested_regions: None,
8030            known_limits: None,
8031            remaining_risks: None,
8032            required_followup: None,
8033            verifier_hash,
8034            policy_hash,
8035            created_at,
8036            scope_hash: None,
8037        }
8038    }
8039}
8040///
8041#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
8042pub enum VerificationScopeRiskClass {
8043    #[serde(rename = "T0")]
8044    T0,
8045    #[serde(rename = "T1")]
8046    T1,
8047    #[serde(rename = "T2")]
8048    T2,
8049    #[serde(rename = "T3")]
8050    T3,
8051}
8052
8053impl Default for VerificationScopeRiskClass {
8054    fn default() -> VerificationScopeRiskClass {
8055        Self::T0
8056    }
8057}
8058
8059/*
8060 * HELM Kernel API
8061 *
8062 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
8063 *
8064 * The version of the OpenAPI document: 0.5.19
8065 *
8066 * Generated by: https://openapi-generator.tech
8067 */
8068
8069
8070#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
8071pub struct VerifyPublicDemoReceipt200Response {
8072    #[serde(rename = "valid")]
8073    pub valid: bool,
8074    #[serde(rename = "signature_valid")]
8075    pub signature_valid: bool,
8076    #[serde(rename = "hash_matches")]
8077    pub hash_matches: bool,
8078    #[serde(rename = "reason")]
8079    pub reason: String,
8080    #[serde(rename = "verified_fields")]
8081    pub verified_fields: Vec<String>,
8082    #[serde(rename = "receipt_hash")]
8083    pub receipt_hash: String,
8084    #[serde(rename = "expected_receipt_hash")]
8085    pub expected_receipt_hash: String,
8086}
8087
8088impl VerifyPublicDemoReceipt200Response {
8089    pub fn new(valid: bool, signature_valid: bool, hash_matches: bool, reason: String, verified_fields: Vec<String>, receipt_hash: String, expected_receipt_hash: String) -> VerifyPublicDemoReceipt200Response {
8090        VerifyPublicDemoReceipt200Response {
8091            valid,
8092            signature_valid,
8093            hash_matches,
8094            reason,
8095            verified_fields,
8096            receipt_hash,
8097            expected_receipt_hash,
8098        }
8099    }
8100}
8101
8102/*
8103 * HELM Kernel API
8104 *
8105 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
8106 *
8107 * The version of the OpenAPI document: 0.5.19
8108 *
8109 * Generated by: https://openapi-generator.tech
8110 */
8111
8112
8113#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
8114pub struct VerifyPublicDemoReceiptRequest {
8115    #[serde(rename = "receipt")]
8116    pub receipt: Box<Receipt>,
8117    /// Receipt hash returned in /api/demo/run proof_refs.receipt_hash.
8118    #[serde(rename = "expected_receipt_hash")]
8119    pub expected_receipt_hash: String,
8120}
8121
8122impl VerifyPublicDemoReceiptRequest {
8123    pub fn new(receipt: Receipt, expected_receipt_hash: String) -> VerifyPublicDemoReceiptRequest {
8124        VerifyPublicDemoReceiptRequest {
8125            receipt: Box::new(receipt),
8126            expected_receipt_hash,
8127        }
8128    }
8129}
8130
8131/*
8132 * HELM Kernel API
8133 *
8134 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs.
8135 *
8136 * The version of the OpenAPI document: 0.5.19
8137 *
8138 * Generated by: https://openapi-generator.tech
8139 */
8140
8141
8142#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
8143pub struct VersionInfo {
8144    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
8145    pub version: Option<String>,
8146    #[serde(rename = "commit", skip_serializing_if = "Option::is_none")]
8147    pub commit: Option<String>,
8148    #[serde(rename = "build_time", skip_serializing_if = "Option::is_none")]
8149    pub build_time: Option<String>,
8150    #[serde(rename = "go_version", skip_serializing_if = "Option::is_none")]
8151    pub go_version: Option<String>,
8152}
8153
8154impl VersionInfo {
8155    pub fn new() -> VersionInfo {
8156        VersionInfo {
8157            version: None,
8158            commit: None,
8159            build_time: None,
8160            go_version: None,
8161        }
8162    }
8163}
8164
8165
8166pub type ReasonCode = HelmErrorErrorReasonCode;
helm_sdk/types_gen.rs

helm_sdk/
types_gen.rs
