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