Skip to main content

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