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

helm_sdk/
types_gen.rs
