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.1.1
11 * 
12 * Generated by: https://openapi-generator.tech
13 */
14
15
16#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
17pub struct AddTrustKey200Response {
18    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
19    pub status: Option<String>,
20    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
21    pub tenant_id: Option<String>,
22    #[serde(rename = "key_id", skip_serializing_if = "Option::is_none")]
23    pub key_id: Option<String>,
24}
25
26impl AddTrustKey200Response {
27    pub fn new() -> AddTrustKey200Response {
28        AddTrustKey200Response {
29            status: None,
30            tenant_id: None,
31            key_id: None,
32        }
33    }
34}
35
36/*
37 * HELM Kernel API
38 *
39 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
40 *
41 * The version of the OpenAPI document: 0.1.1
42 * 
43 * Generated by: https://openapi-generator.tech
44 */
45
46
47#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
48pub struct AddTrustKeyRequest {
49    #[serde(rename = "tenant_id")]
50    pub tenant_id: String,
51    #[serde(rename = "key_id")]
52    pub key_id: String,
53    /// Hex-encoded Ed25519 public key
54    #[serde(rename = "public_key")]
55    pub public_key: String,
56}
57
58impl AddTrustKeyRequest {
59    pub fn new(tenant_id: String, key_id: String, public_key: String) -> AddTrustKeyRequest {
60        AddTrustKeyRequest {
61            tenant_id,
62            key_id,
63            public_key,
64        }
65    }
66}
67
68/*
69 * HELM Kernel API
70 *
71 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
72 *
73 * The version of the OpenAPI document: 0.1.1
74 * 
75 * Generated by: https://openapi-generator.tech
76 */
77
78
79#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
80pub struct ApprovalRequest {
81    /// SHA-256 hash of the intent to approve
82    #[serde(rename = "intent_hash")]
83    pub intent_hash: String,
84    /// Base64-encoded Ed25519 signature
85    #[serde(rename = "signature_b64")]
86    pub signature_b64: String,
87    /// Base64-encoded Ed25519 public key
88    #[serde(rename = "public_key_b64")]
89    pub public_key_b64: String,
90    /// Optional challenge/response for ceremony
91    #[serde(rename = "challenge_response", skip_serializing_if = "Option::is_none")]
92    pub challenge_response: Option<String>,
93}
94
95impl ApprovalRequest {
96    pub fn new(intent_hash: String, signature_b64: String, public_key_b64: String) -> ApprovalRequest {
97        ApprovalRequest {
98            intent_hash,
99            signature_b64,
100            public_key_b64,
101            challenge_response: 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.1.1
112 * 
113 * Generated by: https://openapi-generator.tech
114 */
115
116
117#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
118pub struct ChatCompletionRequest {
119    #[serde(rename = "model")]
120    pub model: String,
121    #[serde(rename = "messages")]
122    pub messages: Vec<ChatCompletionRequestMessagesInner>,
123    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
124    pub tools: Option<Vec<ChatCompletionRequestToolsInner>>,
125    #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")]
126    pub temperature: Option<f64>,
127    #[serde(rename = "max_tokens", skip_serializing_if = "Option::is_none")]
128    pub max_tokens: Option<i32>,
129    #[serde(rename = "stream", skip_serializing_if = "Option::is_none")]
130    pub stream: Option<bool>,
131}
132
133impl ChatCompletionRequest {
134    pub fn new(model: String, messages: Vec<ChatCompletionRequestMessagesInner>) -> ChatCompletionRequest {
135        ChatCompletionRequest {
136            model,
137            messages,
138            tools: None,
139            temperature: None,
140            max_tokens: None,
141            stream: None,
142        }
143    }
144}
145
146/*
147 * HELM Kernel API
148 *
149 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
150 *
151 * The version of the OpenAPI document: 0.1.1
152 * 
153 * Generated by: https://openapi-generator.tech
154 */
155
156
157#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
158pub struct ChatCompletionRequestMessagesInner {
159    #[serde(rename = "role")]
160    pub role: Role,
161    #[serde(rename = "content")]
162    pub content: String,
163    #[serde(rename = "tool_call_id", skip_serializing_if = "Option::is_none")]
164    pub tool_call_id: Option<String>,
165}
166
167impl ChatCompletionRequestMessagesInner {
168    pub fn new(role: Role, content: String) -> ChatCompletionRequestMessagesInner {
169        ChatCompletionRequestMessagesInner {
170            role,
171            content,
172            tool_call_id: None,
173        }
174    }
175}
176/// 
177#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
178pub enum Role {
179    #[serde(rename = "system")]
180    System,
181    #[serde(rename = "user")]
182    User,
183    #[serde(rename = "assistant")]
184    Assistant,
185    #[serde(rename = "tool")]
186    Tool,
187}
188
189impl Default for Role {
190    fn default() -> Role {
191        Self::System
192    }
193}
194
195/*
196 * HELM Kernel API
197 *
198 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
199 *
200 * The version of the OpenAPI document: 0.1.1
201 * 
202 * Generated by: https://openapi-generator.tech
203 */
204
205
206#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
207pub struct ChatCompletionRequestToolsInner {
208    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
209    pub r#type: Option<Type>,
210    #[serde(rename = "function", skip_serializing_if = "Option::is_none")]
211    pub function: Option<Box<ChatCompletionRequestToolsInnerFunction>>,
212}
213
214impl ChatCompletionRequestToolsInner {
215    pub fn new() -> ChatCompletionRequestToolsInner {
216        ChatCompletionRequestToolsInner {
217            r#type: None,
218            function: None,
219        }
220    }
221}
222/// 
223#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
224pub enum Type {
225    #[serde(rename = "function")]
226    Function,
227}
228
229impl Default for Type {
230    fn default() -> Type {
231        Self::Function
232    }
233}
234
235/*
236 * HELM Kernel API
237 *
238 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
239 *
240 * The version of the OpenAPI document: 0.1.1
241 * 
242 * Generated by: https://openapi-generator.tech
243 */
244
245
246#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
247pub struct ChatCompletionRequestToolsInnerFunction {
248    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
249    pub name: Option<String>,
250    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
251    pub description: Option<String>,
252    #[serde(rename = "parameters", skip_serializing_if = "Option::is_none")]
253    pub parameters: Option<serde_json::Value>,
254}
255
256impl ChatCompletionRequestToolsInnerFunction {
257    pub fn new() -> ChatCompletionRequestToolsInnerFunction {
258        ChatCompletionRequestToolsInnerFunction {
259            name: None,
260            description: None,
261            parameters: None,
262        }
263    }
264}
265
266/*
267 * HELM Kernel API
268 *
269 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
270 *
271 * The version of the OpenAPI document: 0.1.1
272 * 
273 * Generated by: https://openapi-generator.tech
274 */
275
276
277#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
278pub struct ChatCompletionResponse {
279    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
280    pub id: Option<String>,
281    #[serde(rename = "object", skip_serializing_if = "Option::is_none")]
282    pub object: Option<String>,
283    #[serde(rename = "created", skip_serializing_if = "Option::is_none")]
284    pub created: Option<i32>,
285    #[serde(rename = "model", skip_serializing_if = "Option::is_none")]
286    pub model: Option<String>,
287    #[serde(rename = "choices", skip_serializing_if = "Option::is_none")]
288    pub choices: Option<Vec<ChatCompletionResponseChoicesInner>>,
289    #[serde(rename = "usage", skip_serializing_if = "Option::is_none")]
290    pub usage: Option<Box<ChatCompletionResponseUsage>>,
291}
292
293impl ChatCompletionResponse {
294    pub fn new() -> ChatCompletionResponse {
295        ChatCompletionResponse {
296            id: None,
297            object: None,
298            created: None,
299            model: None,
300            choices: None,
301            usage: None,
302        }
303    }
304}
305
306/*
307 * HELM Kernel API
308 *
309 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
310 *
311 * The version of the OpenAPI document: 0.1.1
312 * 
313 * Generated by: https://openapi-generator.tech
314 */
315
316
317#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
318pub struct ChatCompletionResponseChoicesInner {
319    #[serde(rename = "index", skip_serializing_if = "Option::is_none")]
320    pub index: Option<i32>,
321    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
322    pub message: Option<Box<ChatCompletionResponseChoicesInnerMessage>>,
323    #[serde(rename = "finish_reason", skip_serializing_if = "Option::is_none")]
324    pub finish_reason: Option<String>,
325}
326
327impl ChatCompletionResponseChoicesInner {
328    pub fn new() -> ChatCompletionResponseChoicesInner {
329        ChatCompletionResponseChoicesInner {
330            index: None,
331            message: None,
332            finish_reason: None,
333        }
334    }
335}
336
337/*
338 * HELM Kernel API
339 *
340 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
341 *
342 * The version of the OpenAPI document: 0.1.1
343 * 
344 * Generated by: https://openapi-generator.tech
345 */
346
347
348#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
349pub struct ChatCompletionResponseChoicesInnerMessage {
350    #[serde(rename = "role", skip_serializing_if = "Option::is_none")]
351    pub role: Option<String>,
352    #[serde(rename = "content", default, skip_serializing_if = "Option::is_none")]
353    pub content: Option<Option<String>>,
354    #[serde(rename = "tool_calls", skip_serializing_if = "Option::is_none")]
355    pub tool_calls: Option<Vec<ChatCompletionResponseChoicesInnerMessageToolCallsInner>>,
356}
357
358impl ChatCompletionResponseChoicesInnerMessage {
359    pub fn new() -> ChatCompletionResponseChoicesInnerMessage {
360        ChatCompletionResponseChoicesInnerMessage {
361            role: None,
362            content: None,
363            tool_calls: None,
364        }
365    }
366}
367
368/*
369 * HELM Kernel API
370 *
371 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
372 *
373 * The version of the OpenAPI document: 0.1.1
374 * 
375 * Generated by: https://openapi-generator.tech
376 */
377
378
379#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
380pub struct ChatCompletionResponseChoicesInnerMessageToolCallsInner {
381    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
382    pub id: Option<String>,
383    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
384    pub r#type: Option<String>,
385    #[serde(rename = "function", skip_serializing_if = "Option::is_none")]
386    pub function: Option<Box<ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction>>,
387}
388
389impl ChatCompletionResponseChoicesInnerMessageToolCallsInner {
390    pub fn new() -> ChatCompletionResponseChoicesInnerMessageToolCallsInner {
391        ChatCompletionResponseChoicesInnerMessageToolCallsInner {
392            id: None,
393            r#type: None,
394            function: None,
395        }
396    }
397}
398
399/*
400 * HELM Kernel API
401 *
402 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
403 *
404 * The version of the OpenAPI document: 0.1.1
405 * 
406 * Generated by: https://openapi-generator.tech
407 */
408
409
410#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
411pub struct ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
412    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
413    pub name: Option<String>,
414    #[serde(rename = "arguments", skip_serializing_if = "Option::is_none")]
415    pub arguments: Option<String>,
416}
417
418impl ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
419    pub fn new() -> ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
420        ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
421            name: None,
422            arguments: None,
423        }
424    }
425}
426
427/*
428 * HELM Kernel API
429 *
430 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
431 *
432 * The version of the OpenAPI document: 0.1.1
433 * 
434 * Generated by: https://openapi-generator.tech
435 */
436
437
438#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
439pub struct ChatCompletionResponseUsage {
440    #[serde(rename = "prompt_tokens", skip_serializing_if = "Option::is_none")]
441    pub prompt_tokens: Option<i32>,
442    #[serde(rename = "completion_tokens", skip_serializing_if = "Option::is_none")]
443    pub completion_tokens: Option<i32>,
444    #[serde(rename = "total_tokens", skip_serializing_if = "Option::is_none")]
445    pub total_tokens: Option<i32>,
446}
447
448impl ChatCompletionResponseUsage {
449    pub fn new() -> ChatCompletionResponseUsage {
450        ChatCompletionResponseUsage {
451            prompt_tokens: None,
452            completion_tokens: None,
453            total_tokens: None,
454        }
455    }
456}
457
458/*
459 * HELM Kernel API
460 *
461 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
462 *
463 * The version of the OpenAPI document: 0.1.1
464 * 
465 * Generated by: https://openapi-generator.tech
466 */
467
468
469#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
470pub struct ConformanceRequest {
471    #[serde(rename = "level")]
472    pub level: Level,
473    #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
474    pub profile: Option<String>,
475}
476
477impl ConformanceRequest {
478    pub fn new(level: Level) -> ConformanceRequest {
479        ConformanceRequest {
480            level,
481            profile: None,
482        }
483    }
484}
485/// 
486#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
487pub enum Level {
488    #[serde(rename = "L1")]
489    L1,
490    #[serde(rename = "L2")]
491    L2,
492}
493
494impl Default for Level {
495    fn default() -> Level {
496        Self::L1
497    }
498}
499
500/*
501 * HELM Kernel API
502 *
503 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
504 *
505 * The version of the OpenAPI document: 0.1.1
506 * 
507 * Generated by: https://openapi-generator.tech
508 */
509
510
511#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
512pub struct ConformanceResult {
513    #[serde(rename = "report_id", skip_serializing_if = "Option::is_none")]
514    pub report_id: Option<String>,
515    #[serde(rename = "level", skip_serializing_if = "Option::is_none")]
516    pub level: Option<String>,
517    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
518    pub verdict: Option<Verdict>,
519    #[serde(rename = "gates", skip_serializing_if = "Option::is_none")]
520    pub gates: Option<i32>,
521    #[serde(rename = "failed", skip_serializing_if = "Option::is_none")]
522    pub failed: Option<i32>,
523    #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
524    pub details: Option<std::collections::HashMap<String, String>>,
525}
526
527impl ConformanceResult {
528    pub fn new() -> ConformanceResult {
529        ConformanceResult {
530            report_id: None,
531            level: None,
532            verdict: None,
533            gates: None,
534            failed: None,
535            details: None,
536        }
537    }
538}
539/// 
540#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
541pub enum Verdict {
542    #[serde(rename = "PASS")]
543    Pass,
544    #[serde(rename = "FAIL")]
545    Fail,
546}
547
548impl Default for Verdict {
549    fn default() -> Verdict {
550        Self::Pass
551    }
552}
553
554/*
555 * HELM Kernel API
556 *
557 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
558 *
559 * The version of the OpenAPI document: 0.1.1
560 * 
561 * Generated by: https://openapi-generator.tech
562 */
563
564
565/// Effect : An effect submitted for governance evaluation
566#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
567pub struct Effect {
568    /// Category of the effect (file_read, api_call, exec, etc.)
569    #[serde(rename = "effect_type")]
570    pub effect_type: String,
571    /// Unique identifier for this effect instance
572    #[serde(rename = "effect_id")]
573    pub effect_id: String,
574    /// Effect-specific parameters
575    #[serde(rename = "params")]
576    pub params: std::collections::HashMap<String, serde_json::Value>,
577    /// Optional budget to charge against
578    #[serde(rename = "budget_id", skip_serializing_if = "Option::is_none")]
579    pub budget_id: Option<String>,
580}
581
582impl Effect {
583    /// An effect submitted for governance evaluation
584    pub fn new(effect_type: String, effect_id: String, params: std::collections::HashMap<String, serde_json::Value>) -> Effect {
585        Effect {
586            effect_type,
587            effect_id,
588            params,
589            budget_id: None,
590        }
591    }
592}
593
594/*
595 * HELM Kernel API
596 *
597 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
598 *
599 * The version of the OpenAPI document: 0.1.1
600 * 
601 * Generated by: https://openapi-generator.tech
602 */
603
604
605/// EffectBoundary : The boundary contract for submitting effects to the kernel
606#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
607pub struct EffectBoundary {
608    #[serde(rename = "effect")]
609    pub effect: Box<Effect>,
610    /// Agent/user identity (e.g. agent:analyst)
611    #[serde(rename = "principal")]
612    pub principal: String,
613    /// Additional context (jurisdiction, industry, budget state)
614    #[serde(rename = "context", skip_serializing_if = "Option::is_none")]
615    pub context: Option<std::collections::HashMap<String, serde_json::Value>>,
616}
617
618impl EffectBoundary {
619    /// The boundary contract for submitting effects to the kernel
620    pub fn new(effect: Effect, principal: String) -> EffectBoundary {
621        EffectBoundary {
622            effect: Box::new(effect),
623            principal,
624            context: None,
625        }
626    }
627}
628
629/*
630 * HELM Kernel API
631 *
632 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
633 *
634 * The version of the OpenAPI document: 0.1.1
635 * 
636 * Generated by: https://openapi-generator.tech
637 */
638
639
640#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
641pub struct ExportRequest {
642    /// Session to export (omit for all)
643    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
644    pub session_id: Option<String>,
645    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
646    pub format: Option<Format>,
647}
648
649impl ExportRequest {
650    pub fn new() -> ExportRequest {
651        ExportRequest {
652            session_id: None,
653            format: None,
654        }
655    }
656}
657/// 
658#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
659pub enum Format {
660    #[serde(rename = "tar.gz")]
661    TarPeriodGz,
662}
663
664impl Default for Format {
665    fn default() -> Format {
666        Self::TarPeriodGz
667    }
668}
669
670/*
671 * HELM Kernel API
672 *
673 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
674 *
675 * The version of the OpenAPI document: 0.1.1
676 * 
677 * Generated by: https://openapi-generator.tech
678 */
679
680
681/// GovernanceDecision : PDP decision for an effect
682#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
683pub struct GovernanceDecision {
684    #[serde(rename = "decision_id")]
685    pub decision_id: String,
686    #[serde(rename = "effect_id")]
687    pub effect_id: String,
688    #[serde(rename = "verdict")]
689    pub verdict: GovernanceVerdict,
690    /// Null for ALLOW. Registered code from reason-codes-v1.json for DENY/ESCALATE.
691    #[serde(rename = "reason_code", default, skip_serializing_if = "Option::is_none")]
692    pub reason_code: Option<Option<String>>,
693    #[serde(rename = "receipt", skip_serializing_if = "Option::is_none")]
694    pub receipt: Option<Box<Receipt>>,
695    /// Names of policy bundles active during evaluation
696    #[serde(rename = "active_packs", skip_serializing_if = "Option::is_none")]
697    pub active_packs: Option<Vec<String>>,
698}
699
700impl GovernanceDecision {
701    /// PDP decision for an effect
702    pub fn new(decision_id: String, effect_id: String, verdict: GovernanceVerdict) -> GovernanceDecision {
703        GovernanceDecision {
704            decision_id,
705            effect_id,
706            verdict,
707            reason_code: None,
708            receipt: None,
709            active_packs: None,
710        }
711    }
712}
713/// 
714#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
715pub enum GovernanceVerdict {
716    #[serde(rename = "ALLOW")]
717    Allow,
718    #[serde(rename = "DENY")]
719    Deny,
720    #[serde(rename = "ESCALATE")]
721    Escalate,
722}
723
724impl Default for GovernanceVerdict {
725    fn default() -> GovernanceVerdict {
726        Self::Allow
727    }
728}
729
730/*
731 * HELM Kernel API
732 *
733 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
734 *
735 * The version of the OpenAPI document: 0.1.1
736 * 
737 * Generated by: https://openapi-generator.tech
738 */
739
740
741#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
742pub struct HealthCheck200Response {
743    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
744    pub status: Option<String>,
745    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
746    pub version: Option<String>,
747}
748
749impl HealthCheck200Response {
750    pub fn new() -> HealthCheck200Response {
751        HealthCheck200Response {
752            status: None,
753            version: None,
754        }
755    }
756}
757
758/*
759 * HELM Kernel API
760 *
761 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
762 *
763 * The version of the OpenAPI document: 0.1.1
764 * 
765 * Generated by: https://openapi-generator.tech
766 */
767
768
769#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
770pub struct HelmError {
771    #[serde(rename = "error")]
772    pub error: Box<HelmErrorError>,
773}
774
775impl HelmError {
776    pub fn new(error: HelmErrorError) -> HelmError {
777        HelmError {
778            error: Box::new(error),
779        }
780    }
781}
782
783/*
784 * HELM Kernel API
785 *
786 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
787 *
788 * The version of the OpenAPI document: 0.1.1
789 * 
790 * Generated by: https://openapi-generator.tech
791 */
792
793
794#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
795pub struct HelmErrorError {
796    /// Human-readable error message
797    #[serde(rename = "message")]
798    pub message: String,
799    #[serde(rename = "type")]
800    pub r#type: ErrorType,
801    /// Machine-readable error code
802    #[serde(rename = "code")]
803    pub code: String,
804    /// HELM-specific reason code
805    #[serde(rename = "reason_code")]
806    pub reason_code: ReasonCode,
807    /// Additional error context
808    #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
809    pub details: Option<std::collections::HashMap<String, serde_json::Value>>,
810}
811
812impl HelmErrorError {
813    pub fn new(message: String, r#type: ErrorType, code: String, reason_code: ReasonCode) -> HelmErrorError {
814        HelmErrorError {
815            message,
816            r#type,
817            code,
818            reason_code,
819            details: None,
820        }
821    }
822}
823/// 
824#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
825pub enum ErrorType {
826    #[serde(rename = "invalid_request")]
827    InvalidRequest,
828    #[serde(rename = "authentication_error")]
829    AuthenticationError,
830    #[serde(rename = "permission_denied")]
831    PermissionDenied,
832    #[serde(rename = "not_found")]
833    NotFound,
834    #[serde(rename = "internal_error")]
835    InternalError,
836}
837
838impl Default for ErrorType {
839    fn default() -> ErrorType {
840        Self::InvalidRequest
841    }
842}
843/// HELM-specific reason code
844#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
845pub enum ReasonCode {
846    #[serde(rename = "DENY_TOOL_NOT_FOUND")]
847    DenyToolNotFound,
848    #[serde(rename = "DENY_SCHEMA_MISMATCH")]
849    DenySchemaMismatch,
850    #[serde(rename = "DENY_OUTPUT_DRIFT")]
851    DenyOutputDrift,
852    #[serde(rename = "DENY_BUDGET_EXCEEDED")]
853    DenyBudgetExceeded,
854    #[serde(rename = "DENY_APPROVAL_REQUIRED")]
855    DenyApprovalRequired,
856    #[serde(rename = "DENY_APPROVAL_TIMEOUT")]
857    DenyApprovalTimeout,
858    #[serde(rename = "DENY_SANDBOX_TRAP")]
859    DenySandboxTrap,
860    #[serde(rename = "DENY_GAS_EXHAUSTION")]
861    DenyGasExhaustion,
862    #[serde(rename = "DENY_TIME_LIMIT")]
863    DenyTimeLimit,
864    #[serde(rename = "DENY_MEMORY_LIMIT")]
865    DenyMemoryLimit,
866    #[serde(rename = "DENY_POLICY_VIOLATION")]
867    DenyPolicyViolation,
868    #[serde(rename = "DENY_TRUST_KEY_REVOKED")]
869    DenyTrustKeyRevoked,
870    #[serde(rename = "DENY_IDEMPOTENCY_DUPLICATE")]
871    DenyIdempotencyDuplicate,
872    #[serde(rename = "ERROR_INTERNAL")]
873    ErrorInternal,
874}
875
876impl Default for ReasonCode {
877    fn default() -> ReasonCode {
878        Self::DenyToolNotFound
879    }
880}
881
882/*
883 * HELM Kernel API
884 *
885 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
886 *
887 * The version of the OpenAPI document: 0.1.1
888 * 
889 * Generated by: https://openapi-generator.tech
890 */
891
892
893#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
894pub struct McpCapabilityManifest {
895    #[serde(rename = "server_name", skip_serializing_if = "Option::is_none")]
896    pub server_name: Option<String>,
897    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
898    pub version: Option<String>,
899    #[serde(rename = "governance", skip_serializing_if = "Option::is_none")]
900    pub governance: Option<String>,
901    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
902    pub tools: Option<Vec<McpToolRef>>,
903}
904
905impl McpCapabilityManifest {
906    pub fn new() -> McpCapabilityManifest {
907        McpCapabilityManifest {
908            server_name: None,
909            version: None,
910            governance: None,
911            tools: 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.1.1
922 * 
923 * Generated by: https://openapi-generator.tech
924 */
925
926
927#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
928pub struct McpProtectedResourceMetadata {
929    #[serde(rename = "resource", skip_serializing_if = "Option::is_none")]
930    pub resource: Option<String>,
931    #[serde(rename = "authorization_servers", skip_serializing_if = "Option::is_none")]
932    pub authorization_servers: Option<Vec<String>>,
933    #[serde(rename = "scopes_supported", skip_serializing_if = "Option::is_none")]
934    pub scopes_supported: Option<Vec<String>>,
935    #[serde(rename = "bearer_methods_supported", skip_serializing_if = "Option::is_none")]
936    pub bearer_methods_supported: Option<Vec<String>>,
937    #[serde(rename = "resource_documentation", skip_serializing_if = "Option::is_none")]
938    pub resource_documentation: Option<String>,
939}
940
941impl McpProtectedResourceMetadata {
942    pub fn new() -> McpProtectedResourceMetadata {
943        McpProtectedResourceMetadata {
944            resource: None,
945            authorization_servers: None,
946            scopes_supported: None,
947            bearer_methods_supported: None,
948            resource_documentation: None,
949        }
950    }
951}
952
953/*
954 * HELM Kernel API
955 *
956 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
957 *
958 * The version of the OpenAPI document: 0.1.1
959 * 
960 * Generated by: https://openapi-generator.tech
961 */
962
963
964#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
965pub struct McpRemoteDiscovery {
966    #[serde(rename = "server_name", skip_serializing_if = "Option::is_none")]
967    pub server_name: Option<String>,
968    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
969    pub version: Option<String>,
970    #[serde(rename = "capabilities_url", skip_serializing_if = "Option::is_none")]
971    pub capabilities_url: Option<String>,
972    #[serde(rename = "execute_url", skip_serializing_if = "Option::is_none")]
973    pub execute_url: Option<String>,
974    #[serde(rename = "mcp_endpoint", skip_serializing_if = "Option::is_none")]
975    pub mcp_endpoint: Option<String>,
976    #[serde(rename = "supported_protocol_versions", skip_serializing_if = "Option::is_none")]
977    pub supported_protocol_versions: Option<Vec<String>>,
978    #[serde(rename = "auth_mode", skip_serializing_if = "Option::is_none")]
979    pub auth_mode: Option<String>,
980    #[serde(rename = "governance", skip_serializing_if = "Option::is_none")]
981    pub governance: Option<String>,
982}
983
984impl McpRemoteDiscovery {
985    pub fn new() -> McpRemoteDiscovery {
986        McpRemoteDiscovery {
987            server_name: None,
988            version: None,
989            capabilities_url: None,
990            execute_url: None,
991            mcp_endpoint: None,
992            supported_protocol_versions: None,
993            auth_mode: None,
994            governance: None,
995        }
996    }
997}
998
999/*
1000 * HELM Kernel API
1001 *
1002 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1003 *
1004 * The version of the OpenAPI document: 0.1.1
1005 * 
1006 * Generated by: https://openapi-generator.tech
1007 */
1008
1009
1010#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1011pub struct McpToolCallRequest {
1012    #[serde(rename = "method")]
1013    pub method: String,
1014    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
1015    pub params: Option<std::collections::HashMap<String, serde_json::Value>>,
1016}
1017
1018impl McpToolCallRequest {
1019    pub fn new(method: String) -> McpToolCallRequest {
1020        McpToolCallRequest {
1021            method,
1022            params: None,
1023        }
1024    }
1025}
1026
1027/*
1028 * HELM Kernel API
1029 *
1030 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1031 *
1032 * The version of the OpenAPI document: 0.1.1
1033 * 
1034 * Generated by: https://openapi-generator.tech
1035 */
1036
1037
1038#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1039pub struct McpToolCallResponse {
1040    #[serde(rename = "result", skip_serializing_if = "Option::is_none")]
1041    pub result: Option<Box<McpToolCallResponseResult>>,
1042    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
1043    pub error: Option<String>,
1044    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
1045    pub reason_code: Option<String>,
1046    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
1047    pub args_hash: Option<String>,
1048    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
1049    pub proofgraph_node: Option<String>,
1050    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
1051    pub receipt_id: Option<String>,
1052}
1053
1054impl McpToolCallResponse {
1055    pub fn new() -> McpToolCallResponse {
1056        McpToolCallResponse {
1057            result: None,
1058            error: None,
1059            reason_code: None,
1060            args_hash: None,
1061            proofgraph_node: None,
1062            receipt_id: None,
1063        }
1064    }
1065}
1066
1067/*
1068 * HELM Kernel API
1069 *
1070 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1071 *
1072 * The version of the OpenAPI document: 0.1.1
1073 * 
1074 * Generated by: https://openapi-generator.tech
1075 */
1076
1077
1078/// McpToolCallResponseResult : Tool output payload
1079/// Tool output payload
1080#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1081#[serde(untagged)]
1082pub enum McpToolCallResponseResult {
1083    String(String),
1084    Object(std::collections::HashMap<String, serde_json::Value>),
1085}
1086
1087impl Default for McpToolCallResponseResult {
1088    fn default() -> Self {
1089        Self::String(Default::default())
1090    }
1091}
1092
1093/*
1094 * HELM Kernel API
1095 *
1096 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1097 *
1098 * The version of the OpenAPI document: 0.1.1
1099 * 
1100 * Generated by: https://openapi-generator.tech
1101 */
1102
1103
1104#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1105pub struct McpToolRef {
1106    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
1107    pub name: Option<String>,
1108    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
1109    pub description: Option<String>,
1110    #[serde(rename = "server_id", skip_serializing_if = "Option::is_none")]
1111    pub server_id: Option<String>,
1112    #[serde(rename = "schema", skip_serializing_if = "Option::is_none")]
1113    pub schema: Option<std::collections::HashMap<String, serde_json::Value>>,
1114}
1115
1116impl McpToolRef {
1117    pub fn new() -> McpToolRef {
1118        McpToolRef {
1119            name: None,
1120            description: None,
1121            server_id: None,
1122            schema: None,
1123        }
1124    }
1125}
1126
1127/*
1128 * HELM Kernel API
1129 *
1130 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1131 *
1132 * The version of the OpenAPI document: 0.1.1
1133 * 
1134 * Generated by: https://openapi-generator.tech
1135 */
1136
1137
1138#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1139pub struct McpjsonrpcError {
1140    #[serde(rename = "code", skip_serializing_if = "Option::is_none")]
1141    pub code: Option<i32>,
1142    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
1143    pub message: Option<String>,
1144}
1145
1146impl McpjsonrpcError {
1147    pub fn new() -> McpjsonrpcError {
1148        McpjsonrpcError {
1149            code: None,
1150            message: None,
1151        }
1152    }
1153}
1154
1155/*
1156 * HELM Kernel API
1157 *
1158 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1159 *
1160 * The version of the OpenAPI document: 0.1.1
1161 * 
1162 * Generated by: https://openapi-generator.tech
1163 */
1164
1165
1166#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1167pub struct McpjsonrpcRequest {
1168    #[serde(rename = "jsonrpc")]
1169    pub jsonrpc: Jsonrpc,
1170    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
1171    pub id: Option<Box<McpjsonrpcRequestId>>,
1172    #[serde(rename = "method")]
1173    pub method: String,
1174    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
1175    pub params: Option<std::collections::HashMap<String, serde_json::Value>>,
1176}
1177
1178impl McpjsonrpcRequest {
1179    pub fn new(jsonrpc: Jsonrpc, method: String) -> McpjsonrpcRequest {
1180        McpjsonrpcRequest {
1181            jsonrpc,
1182            id: None,
1183            method,
1184            params: None,
1185        }
1186    }
1187}
1188/// 
1189#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1190pub enum Jsonrpc {
1191    #[serde(rename = "2.0")]
1192    Variant2Period0,
1193}
1194
1195impl Default for Jsonrpc {
1196    fn default() -> Jsonrpc {
1197        Self::Variant2Period0
1198    }
1199}
1200
1201/*
1202 * HELM Kernel API
1203 *
1204 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1205 *
1206 * The version of the OpenAPI document: 0.1.1
1207 * 
1208 * Generated by: https://openapi-generator.tech
1209 */
1210
1211
1212/// McpjsonrpcRequestId : Request identifier. Omit for notifications.
1213/// Request identifier. Omit for notifications.
1214#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1215#[serde(untagged)]
1216pub enum McpjsonrpcRequestId {
1217    String(String),
1218    Integer(i32),
1219}
1220
1221impl Default for McpjsonrpcRequestId {
1222    fn default() -> Self {
1223        Self::String(Default::default())
1224    }
1225}
1226
1227/*
1228 * HELM Kernel API
1229 *
1230 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1231 *
1232 * The version of the OpenAPI document: 0.1.1
1233 * 
1234 * Generated by: https://openapi-generator.tech
1235 */
1236
1237
1238#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1239pub struct McpjsonrpcResponse {
1240    #[serde(rename = "jsonrpc", skip_serializing_if = "Option::is_none")]
1241    pub jsonrpc: Option<Jsonrpc>,
1242    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
1243    pub id: Option<Box<McpjsonrpcResponseId>>,
1244    #[serde(rename = "result", skip_serializing_if = "Option::is_none")]
1245    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
1246    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
1247    pub error: Option<Box<McpjsonrpcError>>,
1248}
1249
1250impl McpjsonrpcResponse {
1251    pub fn new() -> McpjsonrpcResponse {
1252        McpjsonrpcResponse {
1253            jsonrpc: None,
1254            id: None,
1255            result: None,
1256            error: None,
1257        }
1258    }
1259}
1260// Duplicate Jsonrpc enum removed (canonical def at line 1190)
1261
1262/*
1263 * HELM Kernel API
1264 *
1265 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1266 *
1267 * The version of the OpenAPI document: 0.1.1
1268 * 
1269 * Generated by: https://openapi-generator.tech
1270 */
1271
1272
1273#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1274#[serde(untagged)]
1275pub enum McpjsonrpcResponseId {
1276    String(String),
1277    Integer(i32),
1278}
1279
1280impl Default for McpjsonrpcResponseId {
1281    fn default() -> Self {
1282        Self::String(Default::default())
1283    }
1284}
1285
1286/*
1287 * HELM Kernel API
1288 *
1289 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1290 *
1291 * The version of the OpenAPI document: 0.1.1
1292 * 
1293 * Generated by: https://openapi-generator.tech
1294 */
1295
1296
1297#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1298pub struct OssLocalCapabilitiesFeatures {
1299    #[serde(rename = "import_run_report", skip_serializing_if = "Option::is_none")]
1300    pub import_run_report: Option<bool>,
1301    #[serde(rename = "offline_verify", skip_serializing_if = "Option::is_none")]
1302    pub offline_verify: Option<bool>,
1303    #[serde(rename = "proof_report", skip_serializing_if = "Option::is_none")]
1304    pub proof_report: Option<bool>,
1305    #[serde(rename = "pack_registry", skip_serializing_if = "Option::is_none")]
1306    pub pack_registry: Option<bool>,
1307    #[serde(rename = "workspace_collaboration", skip_serializing_if = "Option::is_none")]
1308    pub workspace_collaboration: Option<bool>,
1309}
1310
1311impl OssLocalCapabilitiesFeatures {
1312    pub fn new() -> OssLocalCapabilitiesFeatures {
1313        OssLocalCapabilitiesFeatures {
1314            import_run_report: None,
1315            offline_verify: None,
1316            proof_report: None,
1317            pack_registry: None,
1318            workspace_collaboration: None,
1319        }
1320    }
1321}
1322
1323/*
1324 * HELM Kernel API
1325 *
1326 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1327 *
1328 * The version of the OpenAPI document: 0.1.1
1329 * 
1330 * Generated by: https://openapi-generator.tech
1331 */
1332
1333
1334#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1335pub struct OssLocalCapabilitiesMcp {
1336    #[serde(rename = "stdio", skip_serializing_if = "Option::is_none")]
1337    pub stdio: Option<bool>,
1338    #[serde(rename = "http", skip_serializing_if = "Option::is_none")]
1339    pub http: Option<bool>,
1340    #[serde(rename = "auth_modes", skip_serializing_if = "Option::is_none")]
1341    pub auth_modes: Option<std::collections::HashMap<String, bool>>,
1342}
1343
1344impl OssLocalCapabilitiesMcp {
1345    pub fn new() -> OssLocalCapabilitiesMcp {
1346        OssLocalCapabilitiesMcp {
1347            stdio: None,
1348            http: None,
1349            auth_modes: None,
1350        }
1351    }
1352}
1353
1354/*
1355 * HELM Kernel API
1356 *
1357 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1358 *
1359 * The version of the OpenAPI document: 0.1.1
1360 * 
1361 * Generated by: https://openapi-generator.tech
1362 */
1363
1364
1365#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1366pub struct OssLocalCapabilitiesProxy {
1367    #[serde(rename = "receipts_endpoint", skip_serializing_if = "Option::is_none")]
1368    pub receipts_endpoint: Option<bool>,
1369    #[serde(rename = "proofgraph_endpoint", skip_serializing_if = "Option::is_none")]
1370    pub proofgraph_endpoint: Option<bool>,
1371}
1372
1373impl OssLocalCapabilitiesProxy {
1374    pub fn new() -> OssLocalCapabilitiesProxy {
1375        OssLocalCapabilitiesProxy {
1376            receipts_endpoint: None,
1377            proofgraph_endpoint: None,
1378        }
1379    }
1380}
1381
1382/*
1383 * HELM Kernel API
1384 *
1385 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1386 *
1387 * The version of the OpenAPI document: 0.1.1
1388 * 
1389 * Generated by: https://openapi-generator.tech
1390 */
1391
1392
1393#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1394pub struct OssLocalCapabilitiesResponse {
1395    #[serde(rename = "studio_mode")]
1396    pub studio_mode: StudioMode,
1397    #[serde(rename = "read_only")]
1398    pub read_only: bool,
1399    #[serde(rename = "http_api")]
1400    pub http_api: bool,
1401    #[serde(rename = "mcp")]
1402    pub mcp: Box<OssLocalCapabilitiesMcp>,
1403    #[serde(rename = "proxy")]
1404    pub proxy: Box<OssLocalCapabilitiesProxy>,
1405    #[serde(rename = "features")]
1406    pub features: Box<OssLocalCapabilitiesFeatures>,
1407}
1408
1409impl OssLocalCapabilitiesResponse {
1410    pub fn new(studio_mode: StudioMode, read_only: bool, http_api: bool, mcp: OssLocalCapabilitiesMcp, proxy: OssLocalCapabilitiesProxy, features: OssLocalCapabilitiesFeatures) -> OssLocalCapabilitiesResponse {
1411        OssLocalCapabilitiesResponse {
1412            studio_mode,
1413            read_only,
1414            http_api,
1415            mcp: Box::new(mcp),
1416            proxy: Box::new(proxy),
1417            features: Box::new(features),
1418        }
1419    }
1420}
1421/// 
1422#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1423pub enum StudioMode {
1424    #[serde(rename = "oss_local")]
1425    OssLocal,
1426}
1427
1428impl Default for StudioMode {
1429    fn default() -> StudioMode {
1430        Self::OssLocal
1431    }
1432}
1433
1434/*
1435 * HELM Kernel API
1436 *
1437 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1438 *
1439 * The version of the OpenAPI document: 0.1.1
1440 * 
1441 * Generated by: https://openapi-generator.tech
1442 */
1443
1444
1445#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1446pub struct OssLocalDecision {
1447    #[serde(rename = "id")]
1448    pub id: String,
1449    #[serde(rename = "source")]
1450    pub source: String,
1451    #[serde(rename = "timestamp")]
1452    pub timestamp: String,
1453    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
1454    pub principal: Option<String>,
1455    #[serde(rename = "action", skip_serializing_if = "Option::is_none")]
1456    pub action: Option<String>,
1457    #[serde(rename = "tool", skip_serializing_if = "Option::is_none")]
1458    pub tool: Option<String>,
1459    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
1460    pub verdict: Option<String>,
1461    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
1462    pub status: Option<String>,
1463    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
1464    pub reason_code: Option<String>,
1465    #[serde(rename = "hash", skip_serializing_if = "Option::is_none")]
1466    pub hash: Option<String>,
1467    #[serde(rename = "prev_hash", skip_serializing_if = "Option::is_none")]
1468    pub prev_hash: Option<String>,
1469    #[serde(rename = "lamport_clock", skip_serializing_if = "Option::is_none")]
1470    pub lamport_clock: Option<i32>,
1471}
1472
1473impl OssLocalDecision {
1474    pub fn new(id: String, source: String, timestamp: String) -> OssLocalDecision {
1475        OssLocalDecision {
1476            id,
1477            source,
1478            timestamp,
1479            principal: None,
1480            action: None,
1481            tool: None,
1482            verdict: None,
1483            status: None,
1484            reason_code: None,
1485            hash: None,
1486            prev_hash: None,
1487            lamport_clock: None,
1488        }
1489    }
1490}
1491
1492/*
1493 * HELM Kernel API
1494 *
1495 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1496 *
1497 * The version of the OpenAPI document: 0.1.1
1498 * 
1499 * Generated by: https://openapi-generator.tech
1500 */
1501
1502
1503#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1504pub struct OssLocalPathsView {
1505    #[serde(rename = "evidence_dir", skip_serializing_if = "Option::is_none")]
1506    pub evidence_dir: Option<String>,
1507    #[serde(rename = "receipts_dir", skip_serializing_if = "Option::is_none")]
1508    pub receipts_dir: Option<String>,
1509    #[serde(rename = "run_report_json", skip_serializing_if = "Option::is_none")]
1510    pub run_report_json: Option<String>,
1511    #[serde(rename = "run_report_html", skip_serializing_if = "Option::is_none")]
1512    pub run_report_html: Option<String>,
1513    #[serde(rename = "proofgraph", skip_serializing_if = "Option::is_none")]
1514    pub proofgraph: Option<String>,
1515}
1516
1517impl OssLocalPathsView {
1518    pub fn new() -> OssLocalPathsView {
1519        OssLocalPathsView {
1520            evidence_dir: None,
1521            receipts_dir: None,
1522            run_report_json: None,
1523            run_report_html: None,
1524            proofgraph: None,
1525        }
1526    }
1527}
1528
1529/*
1530 * HELM Kernel API
1531 *
1532 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1533 *
1534 * The version of the OpenAPI document: 0.1.1
1535 * 
1536 * Generated by: https://openapi-generator.tech
1537 */
1538
1539
1540/// OssLocalProofgraphResponse : Local proofgraph payload. When the file is unavailable, `status` is `unavailable` and `nodes` is empty.
1541#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1542pub struct OssLocalProofgraphResponse {
1543    #[serde(rename = "nodes", default, skip_serializing_if = "Option::is_none")]
1544    pub nodes: Option<Option<serde_json::Value>>,
1545    #[serde(rename = "path", skip_serializing_if = "Option::is_none")]
1546    pub path: Option<String>,
1547    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
1548    pub status: Option<String>,
1549    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
1550    pub message: Option<String>,
1551}
1552
1553impl OssLocalProofgraphResponse {
1554    /// Local proofgraph payload. When the file is unavailable, `status` is `unavailable` and `nodes` is empty.
1555    pub fn new() -> OssLocalProofgraphResponse {
1556        OssLocalProofgraphResponse {
1557            nodes: None,
1558            path: None,
1559            status: None,
1560            message: None,
1561        }
1562    }
1563}
1564
1565/*
1566 * HELM Kernel API
1567 *
1568 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1569 *
1570 * The version of the OpenAPI document: 0.1.1
1571 * 
1572 * Generated by: https://openapi-generator.tech
1573 */
1574
1575
1576#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1577pub struct OssLocalReplayReport {
1578    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
1579    pub version: Option<String>,
1580    #[serde(rename = "schema_version", skip_serializing_if = "Option::is_none")]
1581    pub schema_version: Option<String>,
1582    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
1583    pub generated_at: Option<String>,
1584    #[serde(rename = "template", skip_serializing_if = "Option::is_none")]
1585    pub template: Option<String>,
1586    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
1587    pub provider: Option<String>,
1588    #[serde(rename = "summary")]
1589    pub summary: Box<OssLocalRunSummary>,
1590    #[serde(rename = "receipts")]
1591    pub receipts: Vec<OssLocalDecision>,
1592}
1593
1594impl OssLocalReplayReport {
1595    pub fn new(summary: OssLocalRunSummary, receipts: Vec<OssLocalDecision>) -> OssLocalReplayReport {
1596        OssLocalReplayReport {
1597            version: None,
1598            schema_version: None,
1599            generated_at: None,
1600            template: None,
1601            provider: None,
1602            summary: Box::new(summary),
1603            receipts,
1604        }
1605    }
1606}
1607
1608/*
1609 * HELM Kernel API
1610 *
1611 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1612 *
1613 * The version of the OpenAPI document: 0.1.1
1614 * 
1615 * Generated by: https://openapi-generator.tech
1616 */
1617
1618
1619#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1620pub struct OssLocalReportMeta {
1621    #[serde(rename = "template", skip_serializing_if = "Option::is_none")]
1622    pub template: Option<String>,
1623    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
1624    pub provider: Option<String>,
1625    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
1626    pub generated_at: Option<String>,
1627    #[serde(rename = "summary", skip_serializing_if = "Option::is_none")]
1628    pub summary: Option<Box<OssLocalRunSummary>>,
1629}
1630
1631impl OssLocalReportMeta {
1632    pub fn new() -> OssLocalReportMeta {
1633        OssLocalReportMeta {
1634            template: None,
1635            provider: None,
1636            generated_at: None,
1637            summary: None,
1638        }
1639    }
1640}
1641
1642/*
1643 * HELM Kernel API
1644 *
1645 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1646 *
1647 * The version of the OpenAPI document: 0.1.1
1648 * 
1649 * Generated by: https://openapi-generator.tech
1650 */
1651
1652
1653#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1654pub struct OssLocalRunSummary {
1655    #[serde(rename = "total", skip_serializing_if = "Option::is_none")]
1656    pub total: Option<i32>,
1657    #[serde(rename = "lamport_final", skip_serializing_if = "Option::is_none")]
1658    pub lamport_final: Option<i32>,
1659    #[serde(rename = "root_hash", skip_serializing_if = "Option::is_none")]
1660    pub root_hash: Option<String>,
1661    #[serde(rename = "chain_verified", skip_serializing_if = "Option::is_none")]
1662    pub chain_verified: Option<bool>,
1663    #[serde(rename = "lamport_monotonic", skip_serializing_if = "Option::is_none")]
1664    pub lamport_monotonic: Option<bool>,
1665    #[serde(rename = "deny_path_tested", skip_serializing_if = "Option::is_none")]
1666    pub deny_path_tested: Option<bool>,
1667    #[serde(rename = "is_demo", skip_serializing_if = "Option::is_none")]
1668    pub is_demo: Option<bool>,
1669}
1670
1671impl OssLocalRunSummary {
1672    pub fn new() -> OssLocalRunSummary {
1673        OssLocalRunSummary {
1674            total: None,
1675            lamport_final: None,
1676            root_hash: None,
1677            chain_verified: None,
1678            lamport_monotonic: None,
1679            deny_path_tested: None,
1680            is_demo: None,
1681        }
1682    }
1683}
1684
1685/*
1686 * HELM Kernel API
1687 *
1688 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1689 *
1690 * The version of the OpenAPI document: 0.1.1
1691 * 
1692 * Generated by: https://openapi-generator.tech
1693 */
1694
1695
1696#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1697pub struct OssLocalRuntimeStatus {
1698    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
1699    pub status: Option<String>,
1700    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
1701    pub version: Option<String>,
1702    #[serde(rename = "build_time", skip_serializing_if = "Option::is_none")]
1703    pub build_time: Option<String>,
1704}
1705
1706impl OssLocalRuntimeStatus {
1707    pub fn new() -> OssLocalRuntimeStatus {
1708        OssLocalRuntimeStatus {
1709            status: None,
1710            version: None,
1711            build_time: None,
1712        }
1713    }
1714}
1715
1716/*
1717 * HELM Kernel API
1718 *
1719 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1720 *
1721 * The version of the OpenAPI document: 0.1.1
1722 * 
1723 * Generated by: https://openapi-generator.tech
1724 */
1725
1726
1727#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1728pub struct OssLocalStats {
1729    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
1730    pub receipt_count: Option<i32>,
1731    #[serde(rename = "allow_count", skip_serializing_if = "Option::is_none")]
1732    pub allow_count: Option<i32>,
1733    #[serde(rename = "deny_count", skip_serializing_if = "Option::is_none")]
1734    pub deny_count: Option<i32>,
1735    #[serde(rename = "pending_count", skip_serializing_if = "Option::is_none")]
1736    pub pending_count: Option<i32>,
1737    #[serde(rename = "proofgraph_nodes", skip_serializing_if = "Option::is_none")]
1738    pub proofgraph_nodes: Option<i32>,
1739    #[serde(rename = "last_receipt_id", skip_serializing_if = "Option::is_none")]
1740    pub last_receipt_id: Option<String>,
1741    #[serde(rename = "last_reason_code", skip_serializing_if = "Option::is_none")]
1742    pub last_reason_code: Option<String>,
1743}
1744
1745impl OssLocalStats {
1746    pub fn new() -> OssLocalStats {
1747        OssLocalStats {
1748            receipt_count: None,
1749            allow_count: None,
1750            deny_count: None,
1751            pending_count: None,
1752            proofgraph_nodes: None,
1753            last_receipt_id: None,
1754            last_reason_code: None,
1755        }
1756    }
1757}
1758
1759/*
1760 * HELM Kernel API
1761 *
1762 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1763 *
1764 * The version of the OpenAPI document: 0.1.1
1765 * 
1766 * Generated by: https://openapi-generator.tech
1767 */
1768
1769
1770#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1771pub struct OssLocalSummaryResponse {
1772    #[serde(rename = "mode")]
1773    pub mode: Mode,
1774    #[serde(rename = "connected")]
1775    pub connected: bool,
1776    #[serde(rename = "generated_at")]
1777    pub generated_at: String,
1778    #[serde(rename = "runtime")]
1779    pub runtime: Box<OssLocalRuntimeStatus>,
1780    #[serde(rename = "paths")]
1781    pub paths: Box<OssLocalPathsView>,
1782    #[serde(rename = "latest_report", skip_serializing_if = "Option::is_none")]
1783    pub latest_report: Option<Box<OssLocalReportMeta>>,
1784    #[serde(rename = "stats")]
1785    pub stats: Box<OssLocalStats>,
1786}
1787
1788impl OssLocalSummaryResponse {
1789    pub fn new(mode: Mode, connected: bool, generated_at: String, runtime: OssLocalRuntimeStatus, paths: OssLocalPathsView, stats: OssLocalStats) -> OssLocalSummaryResponse {
1790        OssLocalSummaryResponse {
1791            mode,
1792            connected,
1793            generated_at,
1794            runtime: Box::new(runtime),
1795            paths: Box::new(paths),
1796            latest_report: None,
1797            stats: Box::new(stats),
1798        }
1799    }
1800}
1801/// 
1802#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1803pub enum Mode {
1804    #[serde(rename = "oss_local")]
1805    OssLocal,
1806}
1807
1808impl Default for Mode {
1809    fn default() -> Mode {
1810        Self::OssLocal
1811    }
1812}
1813
1814/*
1815 * HELM Kernel API
1816 *
1817 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1818 *
1819 * The version of the OpenAPI document: 0.1.1
1820 * 
1821 * Generated by: https://openapi-generator.tech
1822 */
1823
1824
1825#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1826pub struct OssLocalTimelineResponse {
1827    #[serde(rename = "decisions")]
1828    pub decisions: Vec<OssLocalDecision>,
1829    #[serde(rename = "total")]
1830    pub total: i32,
1831    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
1832    pub source: Option<String>,
1833}
1834
1835impl OssLocalTimelineResponse {
1836    pub fn new(decisions: Vec<OssLocalDecision>, total: i32) -> OssLocalTimelineResponse {
1837        OssLocalTimelineResponse {
1838            decisions,
1839            total,
1840            source: None,
1841        }
1842    }
1843}
1844
1845/*
1846 * HELM Kernel API
1847 *
1848 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1849 *
1850 * The version of the OpenAPI document: 0.1.1
1851 * 
1852 * Generated by: https://openapi-generator.tech
1853 */
1854
1855
1856/// PdpRequest : Request to the Policy Decision Point
1857#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1858pub struct PdpRequest {
1859    #[serde(rename = "boundary")]
1860    pub boundary: Box<EffectBoundary>,
1861}
1862
1863impl PdpRequest {
1864    /// Request to the Policy Decision Point
1865    pub fn new(boundary: EffectBoundary) -> PdpRequest {
1866        PdpRequest {
1867            boundary: Box::new(boundary),
1868        }
1869    }
1870}
1871
1872/*
1873 * HELM Kernel API
1874 *
1875 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1876 *
1877 * The version of the OpenAPI document: 0.1.1
1878 * 
1879 * Generated by: https://openapi-generator.tech
1880 */
1881
1882
1883/// PdpResponse : Response from the Policy Decision Point
1884#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1885pub struct PdpResponse {
1886    #[serde(rename = "decision")]
1887    pub decision: Box<GovernanceDecision>,
1888}
1889
1890impl PdpResponse {
1891    /// Response from the Policy Decision Point
1892    pub fn new(decision: GovernanceDecision) -> PdpResponse {
1893        PdpResponse {
1894            decision: Box::new(decision),
1895        }
1896    }
1897}
1898
1899/*
1900 * HELM Kernel API
1901 *
1902 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1903 *
1904 * The version of the OpenAPI document: 0.1.1
1905 * 
1906 * Generated by: https://openapi-generator.tech
1907 */
1908
1909
1910/// PolicyBundle : A loaded policy bundle (jurisdiction, industry, or business pack)
1911#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1912pub struct PolicyBundle {
1913    #[serde(rename = "name")]
1914    pub name: String,
1915    #[serde(rename = "version")]
1916    pub version: String,
1917    /// SHA-256 of the bundle contents
1918    #[serde(rename = "content_hash")]
1919    pub content_hash: String,
1920    /// Ed25519 signature over content_hash
1921    #[serde(rename = "signature", default, skip_serializing_if = "Option::is_none")]
1922    pub signature: Option<Option<String>>,
1923    #[serde(rename = "pack_type", skip_serializing_if = "Option::is_none")]
1924    pub pack_type: Option<PackType>,
1925}
1926
1927impl PolicyBundle {
1928    /// A loaded policy bundle (jurisdiction, industry, or business pack)
1929    pub fn new(name: String, version: String, content_hash: String) -> PolicyBundle {
1930        PolicyBundle {
1931            name,
1932            version,
1933            content_hash,
1934            signature: None,
1935            pack_type: None,
1936        }
1937    }
1938}
1939/// 
1940#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
1941pub enum PackType {
1942    #[serde(rename = "jurisdiction")]
1943    Jurisdiction,
1944    #[serde(rename = "industry")]
1945    Industry,
1946    #[serde(rename = "business")]
1947    Business,
1948    #[serde(rename = "custom")]
1949    Custom,
1950}
1951
1952impl Default for PackType {
1953    fn default() -> PackType {
1954        Self::Jurisdiction
1955    }
1956}
1957
1958/*
1959 * HELM Kernel API
1960 *
1961 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
1962 *
1963 * The version of the OpenAPI document: 0.1.1
1964 * 
1965 * Generated by: https://openapi-generator.tech
1966 */
1967
1968
1969#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
1970pub struct Receipt {
1971    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
1972    pub receipt_id: Option<String>,
1973    #[serde(rename = "decision_id", skip_serializing_if = "Option::is_none")]
1974    pub decision_id: Option<String>,
1975    #[serde(rename = "effect_id", skip_serializing_if = "Option::is_none")]
1976    pub effect_id: Option<String>,
1977    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
1978    pub status: Option<Status>,
1979    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
1980    pub reason_code: Option<String>,
1981    #[serde(rename = "output_hash", skip_serializing_if = "Option::is_none")]
1982    pub output_hash: Option<String>,
1983    #[serde(rename = "blob_hash", skip_serializing_if = "Option::is_none")]
1984    pub blob_hash: Option<String>,
1985    #[serde(rename = "prev_hash", skip_serializing_if = "Option::is_none")]
1986    pub prev_hash: Option<String>,
1987    #[serde(rename = "lamport_clock", skip_serializing_if = "Option::is_none")]
1988    pub lamport_clock: Option<i32>,
1989    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
1990    pub signature: Option<String>,
1991    #[serde(rename = "timestamp", skip_serializing_if = "Option::is_none")]
1992    pub timestamp: Option<String>,
1993    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
1994    pub principal: Option<String>,
1995}
1996
1997impl Receipt {
1998    pub fn new() -> Receipt {
1999        Receipt {
2000            receipt_id: None,
2001            decision_id: None,
2002            effect_id: None,
2003            status: None,
2004            reason_code: None,
2005            output_hash: None,
2006            blob_hash: None,
2007            prev_hash: None,
2008            lamport_clock: None,
2009            signature: None,
2010            timestamp: None,
2011            principal: None,
2012        }
2013    }
2014}
2015/// 
2016#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2017pub enum Status {
2018    #[serde(rename = "APPROVED")]
2019    Approved,
2020    #[serde(rename = "DENIED")]
2021    Denied,
2022    #[serde(rename = "PENDING")]
2023    Pending,
2024}
2025
2026impl Default for Status {
2027    fn default() -> Status {
2028        Self::Approved
2029    }
2030}
2031
2032/*
2033 * HELM Kernel API
2034 *
2035 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
2036 *
2037 * The version of the OpenAPI document: 0.1.1
2038 * 
2039 * Generated by: https://openapi-generator.tech
2040 */
2041
2042
2043#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2044pub struct RevokeTrustKeyRequest {
2045    #[serde(rename = "tenant_id")]
2046    pub tenant_id: String,
2047    #[serde(rename = "key_id")]
2048    pub key_id: String,
2049}
2050
2051impl RevokeTrustKeyRequest {
2052    pub fn new(tenant_id: String, key_id: String) -> RevokeTrustKeyRequest {
2053        RevokeTrustKeyRequest {
2054            tenant_id,
2055            key_id,
2056        }
2057    }
2058}
2059
2060/*
2061 * HELM Kernel API
2062 *
2063 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
2064 *
2065 * The version of the OpenAPI document: 0.1.1
2066 * 
2067 * Generated by: https://openapi-generator.tech
2068 */
2069
2070
2071#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2072pub struct Session {
2073    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
2074    pub session_id: Option<String>,
2075    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
2076    pub created_at: Option<String>,
2077    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
2078    pub receipt_count: Option<i32>,
2079    #[serde(rename = "last_lamport_clock", skip_serializing_if = "Option::is_none")]
2080    pub last_lamport_clock: Option<i32>,
2081}
2082
2083impl Session {
2084    pub fn new() -> Session {
2085        Session {
2086            session_id: None,
2087            created_at: None,
2088            receipt_count: None,
2089            last_lamport_clock: None,
2090        }
2091    }
2092}
2093
2094/*
2095 * HELM Kernel API
2096 *
2097 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
2098 *
2099 * The version of the OpenAPI document: 0.1.1
2100 * 
2101 * Generated by: https://openapi-generator.tech
2102 */
2103
2104
2105#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2106pub struct VerificationResult {
2107    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
2108    pub verdict: Option<Verdict>,
2109    #[serde(rename = "checks", skip_serializing_if = "Option::is_none")]
2110    pub checks: Option<Box<VerificationResultChecks>>,
2111    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
2112    pub errors: Option<Vec<String>>,
2113}
2114
2115impl VerificationResult {
2116    pub fn new() -> VerificationResult {
2117        VerificationResult {
2118            verdict: None,
2119            checks: None,
2120            errors: None,
2121        }
2122    }
2123}
2124// Duplicate Verdict enum removed (canonical def at line 541)
2125
2126/*
2127 * HELM Kernel API
2128 *
2129 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
2130 *
2131 * The version of the OpenAPI document: 0.1.1
2132 * 
2133 * Generated by: https://openapi-generator.tech
2134 */
2135
2136
2137#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2138pub struct VerificationResultChecks {
2139    #[serde(rename = "signatures", skip_serializing_if = "Option::is_none")]
2140    pub signatures: Option<Signatures>,
2141    #[serde(rename = "causal_chain", skip_serializing_if = "Option::is_none")]
2142    pub causal_chain: Option<CausalChain>,
2143    #[serde(rename = "policy_compliance", skip_serializing_if = "Option::is_none")]
2144    pub policy_compliance: Option<PolicyCompliance>,
2145}
2146
2147impl VerificationResultChecks {
2148    pub fn new() -> VerificationResultChecks {
2149        VerificationResultChecks {
2150            signatures: None,
2151            causal_chain: None,
2152            policy_compliance: None,
2153        }
2154    }
2155}
2156/// 
2157#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2158pub enum Signatures {
2159    #[serde(rename = "PASS")]
2160    Pass,
2161    #[serde(rename = "FAIL")]
2162    Fail,
2163}
2164
2165impl Default for Signatures {
2166    fn default() -> Signatures {
2167        Self::Pass
2168    }
2169}
2170/// 
2171#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2172pub enum CausalChain {
2173    #[serde(rename = "PASS")]
2174    Pass,
2175    #[serde(rename = "FAIL")]
2176    Fail,
2177}
2178
2179impl Default for CausalChain {
2180    fn default() -> CausalChain {
2181        Self::Pass
2182    }
2183}
2184/// 
2185#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
2186pub enum PolicyCompliance {
2187    #[serde(rename = "PASS")]
2188    Pass,
2189    #[serde(rename = "FAIL")]
2190    Fail,
2191}
2192
2193impl Default for PolicyCompliance {
2194    fn default() -> PolicyCompliance {
2195        Self::Pass
2196    }
2197}
2198
2199/*
2200 * HELM Kernel API
2201 *
2202 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
2203 *
2204 * The version of the OpenAPI document: 0.1.1
2205 * 
2206 * Generated by: https://openapi-generator.tech
2207 */
2208
2209
2210#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
2211pub struct VersionInfo {
2212    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
2213    pub version: Option<String>,
2214    #[serde(rename = "commit", skip_serializing_if = "Option::is_none")]
2215    pub commit: Option<String>,
2216    #[serde(rename = "build_time", skip_serializing_if = "Option::is_none")]
2217    pub build_time: Option<String>,
2218    #[serde(rename = "go_version", skip_serializing_if = "Option::is_none")]
2219    pub go_version: Option<String>,
2220}
2221
2222impl VersionInfo {
2223    pub fn new() -> VersionInfo {
2224        VersionInfo {
2225            version: None,
2226            commit: None,
2227            build_time: None,
2228            go_version: None,
2229        }
2230    }
2231}
2232
helm_sdk/types_gen.rs

helm_sdk/
types_gen.rs
