helm_sdk/
types_gen.rs

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

helm_sdk/
types_gen.rs
