helm-sdk 0.4.0

// AUTO-GENERATED from api/openapi/helm.openapi.yaml — DO NOT EDIT
// Regenerate: bash scripts/sdk/gen.sh

use serde::{Deserialize, Serialize};
/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AddTrustKey200Response {
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "tenant_id", skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "key_id", skip_serializing_if = "Option::is_none")]
    pub key_id: Option<String>,
}

impl AddTrustKey200Response {
    pub fn new() -> AddTrustKey200Response {
        AddTrustKey200Response {
            status: None,
            tenant_id: None,
            key_id: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AddTrustKeyRequest {
    #[serde(rename = "tenant_id")]
    pub tenant_id: String,
    #[serde(rename = "key_id")]
    pub key_id: String,
    /// Hex-encoded Ed25519 public key
    #[serde(rename = "public_key")]
    pub public_key: String,
}

impl AddTrustKeyRequest {
    pub fn new(tenant_id: String, key_id: String, public_key: String) -> AddTrustKeyRequest {
        AddTrustKeyRequest {
            tenant_id,
            key_id,
            public_key,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApprovalRequest {
    /// SHA-256 hash of the intent to approve
    #[serde(rename = "intent_hash")]
    pub intent_hash: String,
    /// Base64-encoded Ed25519 signature
    #[serde(rename = "signature_b64")]
    pub signature_b64: String,
    /// Base64-encoded Ed25519 public key
    #[serde(rename = "public_key_b64")]
    pub public_key_b64: String,
    /// Optional challenge/response for ceremony
    #[serde(rename = "challenge_response", skip_serializing_if = "Option::is_none")]
    pub challenge_response: Option<String>,
}

impl ApprovalRequest {
    pub fn new(intent_hash: String, signature_b64: String, public_key_b64: String) -> ApprovalRequest {
        ApprovalRequest {
            intent_hash,
            signature_b64,
            public_key_b64,
            challenge_response: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequest {
    #[serde(rename = "model")]
    pub model: String,
    #[serde(rename = "messages")]
    pub messages: Vec<ChatCompletionRequestMessagesInner>,
    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<ChatCompletionRequestToolsInner>>,
    #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
    #[serde(rename = "max_tokens", skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<i32>,
    #[serde(rename = "stream", skip_serializing_if = "Option::is_none")]
    pub stream: Option<bool>,
}

impl ChatCompletionRequest {
    pub fn new(model: String, messages: Vec<ChatCompletionRequestMessagesInner>) -> ChatCompletionRequest {
        ChatCompletionRequest {
            model,
            messages,
            tools: None,
            temperature: None,
            max_tokens: None,
            stream: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestMessagesInner {
    #[serde(rename = "role")]
    pub role: Role,
    #[serde(rename = "content")]
    pub content: String,
    #[serde(rename = "tool_call_id", skip_serializing_if = "Option::is_none")]
    pub tool_call_id: Option<String>,
}

impl ChatCompletionRequestMessagesInner {
    pub fn new(role: Role, content: String) -> ChatCompletionRequestMessagesInner {
        ChatCompletionRequestMessagesInner {
            role,
            content,
            tool_call_id: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Role {
    #[serde(rename = "system")]
    System,
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    #[serde(rename = "tool")]
    Tool,
}

impl Default for Role {
    fn default() -> Role {
        Self::System
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestToolsInner {
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub r#type: Option<Type>,
    #[serde(rename = "function", skip_serializing_if = "Option::is_none")]
    pub function: Option<Box<ChatCompletionRequestToolsInnerFunction>>,
}

impl ChatCompletionRequestToolsInner {
    pub fn new() -> ChatCompletionRequestToolsInner {
        ChatCompletionRequestToolsInner {
            r#type: None,
            function: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Type {
    #[serde(rename = "function")]
    Function,
}

impl Default for Type {
    fn default() -> Type {
        Self::Function
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestToolsInnerFunction {
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "parameters", skip_serializing_if = "Option::is_none")]
    pub parameters: Option<serde_json::Value>,
}

impl ChatCompletionRequestToolsInnerFunction {
    pub fn new() -> ChatCompletionRequestToolsInnerFunction {
        ChatCompletionRequestToolsInnerFunction {
            name: None,
            description: None,
            parameters: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionResponse {
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "object", skip_serializing_if = "Option::is_none")]
    pub object: Option<String>,
    #[serde(rename = "created", skip_serializing_if = "Option::is_none")]
    pub created: Option<i32>,
    #[serde(rename = "model", skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(rename = "choices", skip_serializing_if = "Option::is_none")]
    pub choices: Option<Vec<ChatCompletionResponseChoicesInner>>,
    #[serde(rename = "usage", skip_serializing_if = "Option::is_none")]
    pub usage: Option<Box<ChatCompletionResponseUsage>>,
}

impl ChatCompletionResponse {
    pub fn new() -> ChatCompletionResponse {
        ChatCompletionResponse {
            id: None,
            object: None,
            created: None,
            model: None,
            choices: None,
            usage: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionResponseChoicesInner {
    #[serde(rename = "index", skip_serializing_if = "Option::is_none")]
    pub index: Option<i32>,
    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
    pub message: Option<Box<ChatCompletionResponseChoicesInnerMessage>>,
    #[serde(rename = "finish_reason", skip_serializing_if = "Option::is_none")]
    pub finish_reason: Option<String>,
}

impl ChatCompletionResponseChoicesInner {
    pub fn new() -> ChatCompletionResponseChoicesInner {
        ChatCompletionResponseChoicesInner {
            index: None,
            message: None,
            finish_reason: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionResponseChoicesInnerMessage {
    #[serde(rename = "role", skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,
    #[serde(rename = "content", default, skip_serializing_if = "Option::is_none")]
    pub content: Option<Option<String>>,
    #[serde(rename = "tool_calls", skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<ChatCompletionResponseChoicesInnerMessageToolCallsInner>>,
}

impl ChatCompletionResponseChoicesInnerMessage {
    pub fn new() -> ChatCompletionResponseChoicesInnerMessage {
        ChatCompletionResponseChoicesInnerMessage {
            role: None,
            content: None,
            tool_calls: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionResponseChoicesInnerMessageToolCallsInner {
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(rename = "function", skip_serializing_if = "Option::is_none")]
    pub function: Option<Box<ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction>>,
}

impl ChatCompletionResponseChoicesInnerMessageToolCallsInner {
    pub fn new() -> ChatCompletionResponseChoicesInnerMessageToolCallsInner {
        ChatCompletionResponseChoicesInnerMessageToolCallsInner {
            id: None,
            r#type: None,
            function: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "arguments", skip_serializing_if = "Option::is_none")]
    pub arguments: Option<String>,
}

impl ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
    pub fn new() -> ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
        ChatCompletionResponseChoicesInnerMessageToolCallsInnerFunction {
            name: None,
            arguments: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionResponseUsage {
    #[serde(rename = "prompt_tokens", skip_serializing_if = "Option::is_none")]
    pub prompt_tokens: Option<i32>,
    #[serde(rename = "completion_tokens", skip_serializing_if = "Option::is_none")]
    pub completion_tokens: Option<i32>,
    #[serde(rename = "total_tokens", skip_serializing_if = "Option::is_none")]
    pub total_tokens: Option<i32>,
}

impl ChatCompletionResponseUsage {
    pub fn new() -> ChatCompletionResponseUsage {
        ChatCompletionResponseUsage {
            prompt_tokens: None,
            completion_tokens: None,
            total_tokens: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConformanceRequest {
    #[serde(rename = "level")]
    pub level: Level,
    #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
    pub profile: Option<String>,
}

impl ConformanceRequest {
    pub fn new(level: Level) -> ConformanceRequest {
        ConformanceRequest {
            level,
            profile: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Level {
    #[serde(rename = "L1")]
    L1,
    #[serde(rename = "L2")]
    L2,
}

impl Default for Level {
    fn default() -> Level {
        Self::L1
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConformanceResult {
    #[serde(rename = "report_id", skip_serializing_if = "Option::is_none")]
    pub report_id: Option<String>,
    #[serde(rename = "level", skip_serializing_if = "Option::is_none")]
    pub level: Option<String>,
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<Verdict>,
    #[serde(rename = "gates", skip_serializing_if = "Option::is_none")]
    pub gates: Option<i32>,
    #[serde(rename = "failed", skip_serializing_if = "Option::is_none")]
    pub failed: Option<i32>,
    #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
    pub details: Option<std::collections::HashMap<String, String>>,
}

impl ConformanceResult {
    pub fn new() -> ConformanceResult {
        ConformanceResult {
            report_id: None,
            level: None,
            verdict: None,
            gates: None,
            failed: None,
            details: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Verdict {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

impl Default for Verdict {
    fn default() -> Verdict {
        Self::Pass
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// Effect : An effect submitted for governance evaluation
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Effect {
    /// Category of the effect (file_read, api_call, exec, etc.)
    #[serde(rename = "effect_type")]
    pub effect_type: String,
    /// Unique identifier for this effect instance
    #[serde(rename = "effect_id")]
    pub effect_id: String,
    /// Effect-specific parameters
    #[serde(rename = "params")]
    pub params: std::collections::HashMap<String, serde_json::Value>,
    /// Optional budget to charge against
    #[serde(rename = "budget_id", skip_serializing_if = "Option::is_none")]
    pub budget_id: Option<String>,
}

impl Effect {
    /// An effect submitted for governance evaluation
    pub fn new(effect_type: String, effect_id: String, params: std::collections::HashMap<String, serde_json::Value>) -> Effect {
        Effect {
            effect_type,
            effect_id,
            params,
            budget_id: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// EffectBoundary : The boundary contract for submitting effects to the kernel
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EffectBoundary {
    #[serde(rename = "effect")]
    pub effect: Box<Effect>,
    /// Agent/user identity (e.g. agent:analyst)
    #[serde(rename = "principal")]
    pub principal: String,
    /// Additional context (jurisdiction, industry, budget state)
    #[serde(rename = "context", skip_serializing_if = "Option::is_none")]
    pub context: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl EffectBoundary {
    /// The boundary contract for submitting effects to the kernel
    pub fn new(effect: Effect, principal: String) -> EffectBoundary {
        EffectBoundary {
            effect: Box::new(effect),
            principal,
            context: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExportRequest {
    /// Session to export (omit for all)
    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
    pub format: Option<Format>,
}

impl ExportRequest {
    pub fn new() -> ExportRequest {
        ExportRequest {
            session_id: None,
            format: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Format {
    #[serde(rename = "tar.gz")]
    TarPeriodGz,
}

impl Default for Format {
    fn default() -> Format {
        Self::TarPeriodGz
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// GovernanceDecision : PDP decision for an effect
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GovernanceDecision {
    #[serde(rename = "decision_id")]
    pub decision_id: String,
    #[serde(rename = "effect_id")]
    pub effect_id: String,
    #[serde(rename = "verdict")]
    pub verdict: GovernanceVerdict,
    /// Null for ALLOW. Registered code from reason-codes-v1.json for DENY/ESCALATE.
    #[serde(rename = "reason_code", default, skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<Option<String>>,
    #[serde(rename = "receipt", skip_serializing_if = "Option::is_none")]
    pub receipt: Option<Box<Receipt>>,
    /// Names of policy bundles active during evaluation
    #[serde(rename = "active_packs", skip_serializing_if = "Option::is_none")]
    pub active_packs: Option<Vec<String>>,
}

impl GovernanceDecision {
    /// PDP decision for an effect
    pub fn new(decision_id: String, effect_id: String, verdict: GovernanceVerdict) -> GovernanceDecision {
        GovernanceDecision {
            decision_id,
            effect_id,
            verdict,
            reason_code: None,
            receipt: None,
            active_packs: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum GovernanceVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

impl Default for GovernanceVerdict {
    fn default() -> GovernanceVerdict {
        Self::Allow
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct HealthCheck200Response {
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
}

impl HealthCheck200Response {
    pub fn new() -> HealthCheck200Response {
        HealthCheck200Response {
            status: None,
            version: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct HelmError {
    #[serde(rename = "error")]
    pub error: Box<HelmErrorError>,
}

impl HelmError {
    pub fn new(error: HelmErrorError) -> HelmError {
        HelmError {
            error: Box::new(error),
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct HelmErrorError {
    /// Human-readable error message
    #[serde(rename = "message")]
    pub message: String,
    #[serde(rename = "type")]
    pub r#type: ErrorType,
    /// Machine-readable error code
    #[serde(rename = "code")]
    pub code: String,
    /// HELM-specific reason code
    #[serde(rename = "reason_code")]
    pub reason_code: ReasonCode,
    /// Additional error context
    #[serde(rename = "details", skip_serializing_if = "Option::is_none")]
    pub details: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl HelmErrorError {
    pub fn new(message: String, r#type: ErrorType, code: String, reason_code: ReasonCode) -> HelmErrorError {
        HelmErrorError {
            message,
            r#type,
            code,
            reason_code,
            details: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum ErrorType {
    #[serde(rename = "invalid_request")]
    InvalidRequest,
    #[serde(rename = "authentication_error")]
    AuthenticationError,
    #[serde(rename = "permission_denied")]
    PermissionDenied,
    #[serde(rename = "not_found")]
    NotFound,
    #[serde(rename = "internal_error")]
    InternalError,
}

impl Default for ErrorType {
    fn default() -> ErrorType {
        Self::InvalidRequest
    }
}
/// HELM-specific reason code
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum ReasonCode {
    #[serde(rename = "DENY_TOOL_NOT_FOUND")]
    DenyToolNotFound,
    #[serde(rename = "DENY_SCHEMA_MISMATCH")]
    DenySchemaMismatch,
    #[serde(rename = "DENY_OUTPUT_DRIFT")]
    DenyOutputDrift,
    #[serde(rename = "DENY_BUDGET_EXCEEDED")]
    DenyBudgetExceeded,
    #[serde(rename = "DENY_APPROVAL_REQUIRED")]
    DenyApprovalRequired,
    #[serde(rename = "DENY_APPROVAL_TIMEOUT")]
    DenyApprovalTimeout,
    #[serde(rename = "DENY_SANDBOX_TRAP")]
    DenySandboxTrap,
    #[serde(rename = "DENY_GAS_EXHAUSTION")]
    DenyGasExhaustion,
    #[serde(rename = "DENY_TIME_LIMIT")]
    DenyTimeLimit,
    #[serde(rename = "DENY_MEMORY_LIMIT")]
    DenyMemoryLimit,
    #[serde(rename = "DENY_POLICY_VIOLATION")]
    DenyPolicyViolation,
    #[serde(rename = "DENY_TRUST_KEY_REVOKED")]
    DenyTrustKeyRevoked,
    #[serde(rename = "DENY_IDEMPOTENCY_DUPLICATE")]
    DenyIdempotencyDuplicate,
    #[serde(rename = "ERROR_INTERNAL")]
    ErrorInternal,
}

impl Default for ReasonCode {
    fn default() -> ReasonCode {
        Self::DenyToolNotFound
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpCapabilityManifest {
    #[serde(rename = "server_name", skip_serializing_if = "Option::is_none")]
    pub server_name: Option<String>,
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "governance", skip_serializing_if = "Option::is_none")]
    pub governance: Option<String>,
    #[serde(rename = "tools", skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<McpToolRef>>,
}

impl McpCapabilityManifest {
    pub fn new() -> McpCapabilityManifest {
        McpCapabilityManifest {
            server_name: None,
            version: None,
            governance: None,
            tools: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpProtectedResourceMetadata {
    #[serde(rename = "resource", skip_serializing_if = "Option::is_none")]
    pub resource: Option<String>,
    #[serde(rename = "authorization_servers", skip_serializing_if = "Option::is_none")]
    pub authorization_servers: Option<Vec<String>>,
    #[serde(rename = "scopes_supported", skip_serializing_if = "Option::is_none")]
    pub scopes_supported: Option<Vec<String>>,
    #[serde(rename = "bearer_methods_supported", skip_serializing_if = "Option::is_none")]
    pub bearer_methods_supported: Option<Vec<String>>,
    #[serde(rename = "resource_documentation", skip_serializing_if = "Option::is_none")]
    pub resource_documentation: Option<String>,
}

impl McpProtectedResourceMetadata {
    pub fn new() -> McpProtectedResourceMetadata {
        McpProtectedResourceMetadata {
            resource: None,
            authorization_servers: None,
            scopes_supported: None,
            bearer_methods_supported: None,
            resource_documentation: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpRemoteDiscovery {
    #[serde(rename = "server_name", skip_serializing_if = "Option::is_none")]
    pub server_name: Option<String>,
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "capabilities_url", skip_serializing_if = "Option::is_none")]
    pub capabilities_url: Option<String>,
    #[serde(rename = "execute_url", skip_serializing_if = "Option::is_none")]
    pub execute_url: Option<String>,
    #[serde(rename = "mcp_endpoint", skip_serializing_if = "Option::is_none")]
    pub mcp_endpoint: Option<String>,
    #[serde(rename = "supported_protocol_versions", skip_serializing_if = "Option::is_none")]
    pub supported_protocol_versions: Option<Vec<String>>,
    #[serde(rename = "auth_mode", skip_serializing_if = "Option::is_none")]
    pub auth_mode: Option<String>,
    #[serde(rename = "governance", skip_serializing_if = "Option::is_none")]
    pub governance: Option<String>,
}

impl McpRemoteDiscovery {
    pub fn new() -> McpRemoteDiscovery {
        McpRemoteDiscovery {
            server_name: None,
            version: None,
            capabilities_url: None,
            execute_url: None,
            mcp_endpoint: None,
            supported_protocol_versions: None,
            auth_mode: None,
            governance: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpToolCallRequest {
    #[serde(rename = "method")]
    pub method: String,
    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
    pub params: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl McpToolCallRequest {
    pub fn new(method: String) -> McpToolCallRequest {
        McpToolCallRequest {
            method,
            params: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpToolCallResponse {
    #[serde(rename = "result", skip_serializing_if = "Option::is_none")]
    pub result: Option<Box<McpToolCallResponseResult>>,
    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
    pub args_hash: Option<String>,
    #[serde(rename = "proofgraph_node", skip_serializing_if = "Option::is_none")]
    pub proofgraph_node: Option<String>,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
}

impl McpToolCallResponse {
    pub fn new() -> McpToolCallResponse {
        McpToolCallResponse {
            result: None,
            error: None,
            reason_code: None,
            args_hash: None,
            proofgraph_node: None,
            receipt_id: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// McpToolCallResponseResult : Tool output payload
/// Tool output payload
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpToolCallResponseResult {
    String(String),
    Object(std::collections::HashMap<String, serde_json::Value>),
}

impl Default for McpToolCallResponseResult {
    fn default() -> Self {
        Self::String(Default::default())
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpToolRef {
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "server_id", skip_serializing_if = "Option::is_none")]
    pub server_id: Option<String>,
    #[serde(rename = "schema", skip_serializing_if = "Option::is_none")]
    pub schema: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl McpToolRef {
    pub fn new() -> McpToolRef {
        McpToolRef {
            name: None,
            description: None,
            server_id: None,
            schema: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpjsonrpcError {
    #[serde(rename = "code", skip_serializing_if = "Option::is_none")]
    pub code: Option<i32>,
    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

impl McpjsonrpcError {
    pub fn new() -> McpjsonrpcError {
        McpjsonrpcError {
            code: None,
            message: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpjsonrpcRequest {
    #[serde(rename = "jsonrpc")]
    pub jsonrpc: Jsonrpc,
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<Box<McpjsonrpcRequestId>>,
    #[serde(rename = "method")]
    pub method: String,
    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
    pub params: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl McpjsonrpcRequest {
    pub fn new(jsonrpc: Jsonrpc, method: String) -> McpjsonrpcRequest {
        McpjsonrpcRequest {
            jsonrpc,
            id: None,
            method,
            params: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Jsonrpc {
    #[serde(rename = "2.0")]
    Variant2Period0,
}

impl Default for Jsonrpc {
    fn default() -> Jsonrpc {
        Self::Variant2Period0
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// McpjsonrpcRequestId : Request identifier. Omit for notifications.
/// Request identifier. Omit for notifications.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpjsonrpcRequestId {
    String(String),
    Integer(i32),
}

impl Default for McpjsonrpcRequestId {
    fn default() -> Self {
        Self::String(Default::default())
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpjsonrpcResponse {
    #[serde(rename = "jsonrpc", skip_serializing_if = "Option::is_none")]
    pub jsonrpc: Option<Jsonrpc>,
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<Box<McpjsonrpcResponseId>>,
    #[serde(rename = "result", skip_serializing_if = "Option::is_none")]
    pub result: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "error", skip_serializing_if = "Option::is_none")]
    pub error: Option<Box<McpjsonrpcError>>,
}

impl McpjsonrpcResponse {
    pub fn new() -> McpjsonrpcResponse {
        McpjsonrpcResponse {
            jsonrpc: None,
            id: None,
            result: None,
            error: None,
        }
    }
}
// Duplicate Jsonrpc enum removed (canonical def at line 1190)

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum McpjsonrpcResponseId {
    String(String),
    Integer(i32),
}

impl Default for McpjsonrpcResponseId {
    fn default() -> Self {
        Self::String(Default::default())
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalCapabilitiesFeatures {
    #[serde(rename = "import_run_report", skip_serializing_if = "Option::is_none")]
    pub import_run_report: Option<bool>,
    #[serde(rename = "offline_verify", skip_serializing_if = "Option::is_none")]
    pub offline_verify: Option<bool>,
    #[serde(rename = "proof_report", skip_serializing_if = "Option::is_none")]
    pub proof_report: Option<bool>,
    #[serde(rename = "pack_registry", skip_serializing_if = "Option::is_none")]
    pub pack_registry: Option<bool>,
    #[serde(rename = "workspace_collaboration", skip_serializing_if = "Option::is_none")]
    pub workspace_collaboration: Option<bool>,
}

impl OssLocalCapabilitiesFeatures {
    pub fn new() -> OssLocalCapabilitiesFeatures {
        OssLocalCapabilitiesFeatures {
            import_run_report: None,
            offline_verify: None,
            proof_report: None,
            pack_registry: None,
            workspace_collaboration: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalCapabilitiesMcp {
    #[serde(rename = "stdio", skip_serializing_if = "Option::is_none")]
    pub stdio: Option<bool>,
    #[serde(rename = "http", skip_serializing_if = "Option::is_none")]
    pub http: Option<bool>,
    #[serde(rename = "auth_modes", skip_serializing_if = "Option::is_none")]
    pub auth_modes: Option<std::collections::HashMap<String, bool>>,
}

impl OssLocalCapabilitiesMcp {
    pub fn new() -> OssLocalCapabilitiesMcp {
        OssLocalCapabilitiesMcp {
            stdio: None,
            http: None,
            auth_modes: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalCapabilitiesProxy {
    #[serde(rename = "receipts_endpoint", skip_serializing_if = "Option::is_none")]
    pub receipts_endpoint: Option<bool>,
    #[serde(rename = "proofgraph_endpoint", skip_serializing_if = "Option::is_none")]
    pub proofgraph_endpoint: Option<bool>,
}

impl OssLocalCapabilitiesProxy {
    pub fn new() -> OssLocalCapabilitiesProxy {
        OssLocalCapabilitiesProxy {
            receipts_endpoint: None,
            proofgraph_endpoint: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalCapabilitiesResponse {
    #[serde(rename = "studio_mode")]
    pub studio_mode: StudioMode,
    #[serde(rename = "read_only")]
    pub read_only: bool,
    #[serde(rename = "http_api")]
    pub http_api: bool,
    #[serde(rename = "mcp")]
    pub mcp: Box<OssLocalCapabilitiesMcp>,
    #[serde(rename = "proxy")]
    pub proxy: Box<OssLocalCapabilitiesProxy>,
    #[serde(rename = "features")]
    pub features: Box<OssLocalCapabilitiesFeatures>,
}

impl OssLocalCapabilitiesResponse {
    pub fn new(studio_mode: StudioMode, read_only: bool, http_api: bool, mcp: OssLocalCapabilitiesMcp, proxy: OssLocalCapabilitiesProxy, features: OssLocalCapabilitiesFeatures) -> OssLocalCapabilitiesResponse {
        OssLocalCapabilitiesResponse {
            studio_mode,
            read_only,
            http_api,
            mcp: Box::new(mcp),
            proxy: Box::new(proxy),
            features: Box::new(features),
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum StudioMode {
    #[serde(rename = "oss_local")]
    OssLocal,
}

impl Default for StudioMode {
    fn default() -> StudioMode {
        Self::OssLocal
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalDecision {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "source")]
    pub source: String,
    #[serde(rename = "timestamp")]
    pub timestamp: String,
    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
    pub principal: Option<String>,
    #[serde(rename = "action", skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    #[serde(rename = "tool", skip_serializing_if = "Option::is_none")]
    pub tool: Option<String>,
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "hash", skip_serializing_if = "Option::is_none")]
    pub hash: Option<String>,
    #[serde(rename = "prev_hash", skip_serializing_if = "Option::is_none")]
    pub prev_hash: Option<String>,
    #[serde(rename = "lamport_clock", skip_serializing_if = "Option::is_none")]
    pub lamport_clock: Option<i32>,
}

impl OssLocalDecision {
    pub fn new(id: String, source: String, timestamp: String) -> OssLocalDecision {
        OssLocalDecision {
            id,
            source,
            timestamp,
            principal: None,
            action: None,
            tool: None,
            verdict: None,
            status: None,
            reason_code: None,
            hash: None,
            prev_hash: None,
            lamport_clock: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalPathsView {
    #[serde(rename = "evidence_dir", skip_serializing_if = "Option::is_none")]
    pub evidence_dir: Option<String>,
    #[serde(rename = "receipts_dir", skip_serializing_if = "Option::is_none")]
    pub receipts_dir: Option<String>,
    #[serde(rename = "run_report_json", skip_serializing_if = "Option::is_none")]
    pub run_report_json: Option<String>,
    #[serde(rename = "run_report_html", skip_serializing_if = "Option::is_none")]
    pub run_report_html: Option<String>,
    #[serde(rename = "proofgraph", skip_serializing_if = "Option::is_none")]
    pub proofgraph: Option<String>,
}

impl OssLocalPathsView {
    pub fn new() -> OssLocalPathsView {
        OssLocalPathsView {
            evidence_dir: None,
            receipts_dir: None,
            run_report_json: None,
            run_report_html: None,
            proofgraph: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// OssLocalProofgraphResponse : Local proofgraph payload. When the file is unavailable, `status` is `unavailable` and `nodes` is empty.
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalProofgraphResponse {
    #[serde(rename = "nodes", default, skip_serializing_if = "Option::is_none")]
    pub nodes: Option<Option<serde_json::Value>>,
    #[serde(rename = "path", skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "message", skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

impl OssLocalProofgraphResponse {
    /// Local proofgraph payload. When the file is unavailable, `status` is `unavailable` and `nodes` is empty.
    pub fn new() -> OssLocalProofgraphResponse {
        OssLocalProofgraphResponse {
            nodes: None,
            path: None,
            status: None,
            message: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalReplayReport {
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "schema_version", skip_serializing_if = "Option::is_none")]
    pub schema_version: Option<String>,
    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
    pub generated_at: Option<String>,
    #[serde(rename = "template", skip_serializing_if = "Option::is_none")]
    pub template: Option<String>,
    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(rename = "summary")]
    pub summary: Box<OssLocalRunSummary>,
    #[serde(rename = "receipts")]
    pub receipts: Vec<OssLocalDecision>,
}

impl OssLocalReplayReport {
    pub fn new(summary: OssLocalRunSummary, receipts: Vec<OssLocalDecision>) -> OssLocalReplayReport {
        OssLocalReplayReport {
            version: None,
            schema_version: None,
            generated_at: None,
            template: None,
            provider: None,
            summary: Box::new(summary),
            receipts,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalReportMeta {
    #[serde(rename = "template", skip_serializing_if = "Option::is_none")]
    pub template: Option<String>,
    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
    pub generated_at: Option<String>,
    #[serde(rename = "summary", skip_serializing_if = "Option::is_none")]
    pub summary: Option<Box<OssLocalRunSummary>>,
}

impl OssLocalReportMeta {
    pub fn new() -> OssLocalReportMeta {
        OssLocalReportMeta {
            template: None,
            provider: None,
            generated_at: None,
            summary: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalRunSummary {
    #[serde(rename = "total", skip_serializing_if = "Option::is_none")]
    pub total: Option<i32>,
    #[serde(rename = "lamport_final", skip_serializing_if = "Option::is_none")]
    pub lamport_final: Option<i32>,
    #[serde(rename = "root_hash", skip_serializing_if = "Option::is_none")]
    pub root_hash: Option<String>,
    #[serde(rename = "chain_verified", skip_serializing_if = "Option::is_none")]
    pub chain_verified: Option<bool>,
    #[serde(rename = "lamport_monotonic", skip_serializing_if = "Option::is_none")]
    pub lamport_monotonic: Option<bool>,
    #[serde(rename = "deny_path_tested", skip_serializing_if = "Option::is_none")]
    pub deny_path_tested: Option<bool>,
    #[serde(rename = "is_demo", skip_serializing_if = "Option::is_none")]
    pub is_demo: Option<bool>,
}

impl OssLocalRunSummary {
    pub fn new() -> OssLocalRunSummary {
        OssLocalRunSummary {
            total: None,
            lamport_final: None,
            root_hash: None,
            chain_verified: None,
            lamport_monotonic: None,
            deny_path_tested: None,
            is_demo: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalRuntimeStatus {
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "build_time", skip_serializing_if = "Option::is_none")]
    pub build_time: Option<String>,
}

impl OssLocalRuntimeStatus {
    pub fn new() -> OssLocalRuntimeStatus {
        OssLocalRuntimeStatus {
            status: None,
            version: None,
            build_time: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalStats {
    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
    pub receipt_count: Option<i32>,
    #[serde(rename = "allow_count", skip_serializing_if = "Option::is_none")]
    pub allow_count: Option<i32>,
    #[serde(rename = "deny_count", skip_serializing_if = "Option::is_none")]
    pub deny_count: Option<i32>,
    #[serde(rename = "pending_count", skip_serializing_if = "Option::is_none")]
    pub pending_count: Option<i32>,
    #[serde(rename = "proofgraph_nodes", skip_serializing_if = "Option::is_none")]
    pub proofgraph_nodes: Option<i32>,
    #[serde(rename = "last_receipt_id", skip_serializing_if = "Option::is_none")]
    pub last_receipt_id: Option<String>,
    #[serde(rename = "last_reason_code", skip_serializing_if = "Option::is_none")]
    pub last_reason_code: Option<String>,
}

impl OssLocalStats {
    pub fn new() -> OssLocalStats {
        OssLocalStats {
            receipt_count: None,
            allow_count: None,
            deny_count: None,
            pending_count: None,
            proofgraph_nodes: None,
            last_receipt_id: None,
            last_reason_code: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalSummaryResponse {
    #[serde(rename = "mode")]
    pub mode: Mode,
    #[serde(rename = "connected")]
    pub connected: bool,
    #[serde(rename = "generated_at")]
    pub generated_at: String,
    #[serde(rename = "runtime")]
    pub runtime: Box<OssLocalRuntimeStatus>,
    #[serde(rename = "paths")]
    pub paths: Box<OssLocalPathsView>,
    #[serde(rename = "latest_report", skip_serializing_if = "Option::is_none")]
    pub latest_report: Option<Box<OssLocalReportMeta>>,
    #[serde(rename = "stats")]
    pub stats: Box<OssLocalStats>,
}

impl OssLocalSummaryResponse {
    pub fn new(mode: Mode, connected: bool, generated_at: String, runtime: OssLocalRuntimeStatus, paths: OssLocalPathsView, stats: OssLocalStats) -> OssLocalSummaryResponse {
        OssLocalSummaryResponse {
            mode,
            connected,
            generated_at,
            runtime: Box::new(runtime),
            paths: Box::new(paths),
            latest_report: None,
            stats: Box::new(stats),
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Mode {
    #[serde(rename = "oss_local")]
    OssLocal,
}

impl Default for Mode {
    fn default() -> Mode {
        Self::OssLocal
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct OssLocalTimelineResponse {
    #[serde(rename = "decisions")]
    pub decisions: Vec<OssLocalDecision>,
    #[serde(rename = "total")]
    pub total: i32,
    #[serde(rename = "source", skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
}

impl OssLocalTimelineResponse {
    pub fn new(decisions: Vec<OssLocalDecision>, total: i32) -> OssLocalTimelineResponse {
        OssLocalTimelineResponse {
            decisions,
            total,
            source: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// PdpRequest : Request to the Policy Decision Point
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PdpRequest {
    #[serde(rename = "boundary")]
    pub boundary: Box<EffectBoundary>,
}

impl PdpRequest {
    /// Request to the Policy Decision Point
    pub fn new(boundary: EffectBoundary) -> PdpRequest {
        PdpRequest {
            boundary: Box::new(boundary),
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// PdpResponse : Response from the Policy Decision Point
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PdpResponse {
    #[serde(rename = "decision")]
    pub decision: Box<GovernanceDecision>,
}

impl PdpResponse {
    /// Response from the Policy Decision Point
    pub fn new(decision: GovernanceDecision) -> PdpResponse {
        PdpResponse {
            decision: Box::new(decision),
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


/// PolicyBundle : A loaded policy bundle (jurisdiction, industry, or business pack)
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct PolicyBundle {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "version")]
    pub version: String,
    /// SHA-256 of the bundle contents
    #[serde(rename = "content_hash")]
    pub content_hash: String,
    /// Ed25519 signature over content_hash
    #[serde(rename = "signature", default, skip_serializing_if = "Option::is_none")]
    pub signature: Option<Option<String>>,
    #[serde(rename = "pack_type", skip_serializing_if = "Option::is_none")]
    pub pack_type: Option<PackType>,
}

impl PolicyBundle {
    /// A loaded policy bundle (jurisdiction, industry, or business pack)
    pub fn new(name: String, version: String, content_hash: String) -> PolicyBundle {
        PolicyBundle {
            name,
            version,
            content_hash,
            signature: None,
            pack_type: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum PackType {
    #[serde(rename = "jurisdiction")]
    Jurisdiction,
    #[serde(rename = "industry")]
    Industry,
    #[serde(rename = "business")]
    Business,
    #[serde(rename = "custom")]
    Custom,
}

impl Default for PackType {
    fn default() -> PackType {
        Self::Jurisdiction
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Receipt {
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(rename = "decision_id", skip_serializing_if = "Option::is_none")]
    pub decision_id: Option<String>,
    #[serde(rename = "effect_id", skip_serializing_if = "Option::is_none")]
    pub effect_id: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<Status>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "output_hash", skip_serializing_if = "Option::is_none")]
    pub output_hash: Option<String>,
    #[serde(rename = "blob_hash", skip_serializing_if = "Option::is_none")]
    pub blob_hash: Option<String>,
    #[serde(rename = "prev_hash", skip_serializing_if = "Option::is_none")]
    pub prev_hash: Option<String>,
    #[serde(rename = "lamport_clock", skip_serializing_if = "Option::is_none")]
    pub lamport_clock: Option<i32>,
    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(rename = "timestamp", skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(rename = "principal", skip_serializing_if = "Option::is_none")]
    pub principal: Option<String>,
}

impl Receipt {
    pub fn new() -> Receipt {
        Receipt {
            receipt_id: None,
            decision_id: None,
            effect_id: None,
            status: None,
            reason_code: None,
            output_hash: None,
            blob_hash: None,
            prev_hash: None,
            lamport_clock: None,
            signature: None,
            timestamp: None,
            principal: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Status {
    #[serde(rename = "APPROVED")]
    Approved,
    #[serde(rename = "DENIED")]
    Denied,
    #[serde(rename = "PENDING")]
    Pending,
}

impl Default for Status {
    fn default() -> Status {
        Self::Approved
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct RevokeTrustKeyRequest {
    #[serde(rename = "tenant_id")]
    pub tenant_id: String,
    #[serde(rename = "key_id")]
    pub key_id: String,
}

impl RevokeTrustKeyRequest {
    pub fn new(tenant_id: String, key_id: String) -> RevokeTrustKeyRequest {
        RevokeTrustKeyRequest {
            tenant_id,
            key_id,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Session {
    #[serde(rename = "session_id", skip_serializing_if = "Option::is_none")]
    pub session_id: Option<String>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
    pub receipt_count: Option<i32>,
    #[serde(rename = "last_lamport_clock", skip_serializing_if = "Option::is_none")]
    pub last_lamport_clock: Option<i32>,
}

impl Session {
    pub fn new() -> Session {
        Session {
            session_id: None,
            created_at: None,
            receipt_count: None,
            last_lamport_clock: None,
        }
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerificationResult {
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<Verdict>,
    #[serde(rename = "checks", skip_serializing_if = "Option::is_none")]
    pub checks: Option<Box<VerificationResultChecks>>,
    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
    pub errors: Option<Vec<String>>,
}

impl VerificationResult {
    pub fn new() -> VerificationResult {
        VerificationResult {
            verdict: None,
            checks: None,
            errors: None,
        }
    }
}
// Duplicate Verdict enum removed (canonical def at line 541)

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerificationResultChecks {
    #[serde(rename = "signatures", skip_serializing_if = "Option::is_none")]
    pub signatures: Option<Signatures>,
    #[serde(rename = "causal_chain", skip_serializing_if = "Option::is_none")]
    pub causal_chain: Option<CausalChain>,
    #[serde(rename = "policy_compliance", skip_serializing_if = "Option::is_none")]
    pub policy_compliance: Option<PolicyCompliance>,
}

impl VerificationResultChecks {
    pub fn new() -> VerificationResultChecks {
        VerificationResultChecks {
            signatures: None,
            causal_chain: None,
            policy_compliance: None,
        }
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Signatures {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

impl Default for Signatures {
    fn default() -> Signatures {
        Self::Pass
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum CausalChain {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

impl Default for CausalChain {
    fn default() -> CausalChain {
        Self::Pass
    }
}
/// 
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum PolicyCompliance {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

impl Default for PolicyCompliance {
    fn default() -> PolicyCompliance {
        Self::Pass
    }
}

/*
 * HELM Kernel API
 *
 * Deterministic execution kernel for AI tool calls. Drop-in OpenAI proxy + cryptographic receipts + offline-verifiable evidence packs. 
 *
 * The version of the OpenAPI document: 0.1.1
 * 
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VersionInfo {
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "commit", skip_serializing_if = "Option::is_none")]
    pub commit: Option<String>,
    #[serde(rename = "build_time", skip_serializing_if = "Option::is_none")]
    pub build_time: Option<String>,
    #[serde(rename = "go_version", skip_serializing_if = "Option::is_none")]
    pub go_version: Option<String>,
}

impl VersionInfo {
    pub fn new() -> VersionInfo {
        VersionInfo {
            version: None,
            commit: None,
            build_time: None,
            go_version: None,
        }
    }
}