Skip to main content

helm_sdk/
types_gen.rs

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