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

helm_sdk/
types_gen.rs
