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