Skip to main content

helm_sdk/
types_gen.rs

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