helm-sdk 0.5.1

// 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCard {
    #[serde(rename = "agent_id")]
    pub agent_id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "endpoint")]
    pub endpoint: String,
    #[serde(rename = "provider", skip_serializing_if = "Option::is_none")]
    pub provider: Option<Box<A2AAgentCardProvider>>,
    #[serde(rename = "supported_versions")]
    pub supported_versions: Vec<String>,
    #[serde(rename = "skills")]
    pub skills: Vec<A2AAgentCardSkillsInner>,
    #[serde(rename = "auth_methods", skip_serializing_if = "Option::is_none")]
    pub auth_methods: Option<Vec<String>>,
    #[serde(rename = "features", skip_serializing_if = "Option::is_none")]
    pub features: Option<Vec<String>>,
    #[serde(rename = "defaultInputModes", skip_serializing_if = "Option::is_none")]
    pub default_input_modes: Option<Vec<String>>,
    #[serde(rename = "defaultOutputModes", skip_serializing_if = "Option::is_none")]
    pub default_output_modes: Option<Vec<String>>,
    #[serde(rename = "capabilities", skip_serializing_if = "Option::is_none")]
    pub capabilities: Option<Box<A2AAgentCardCapabilities>>,
    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(rename = "content_hash", skip_serializing_if = "Option::is_none")]
    pub content_hash: Option<String>,
    #[serde(rename = "created_at")]
    pub created_at: String,
    #[serde(rename = "updated_at")]
    pub updated_at: String,
}

impl A2AAgentCard {
    pub fn new(agent_id: String, name: String, endpoint: String, supported_versions: Vec<String>, skills: Vec<A2AAgentCardSkillsInner>, created_at: String, updated_at: String) -> A2AAgentCard {
        A2AAgentCard {
            agent_id,
            name,
            description: None,
            endpoint,
            provider: None,
            supported_versions,
            skills,
            auth_methods: None,
            features: None,
            default_input_modes: None,
            default_output_modes: None,
            capabilities: None,
            signature: None,
            content_hash: None,
            created_at,
            updated_at,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCardCapabilities {
    #[serde(rename = "streaming", skip_serializing_if = "Option::is_none")]
    pub streaming: Option<bool>,
    #[serde(rename = "pushNotifications", skip_serializing_if = "Option::is_none")]
    pub push_notifications: Option<bool>,
    #[serde(rename = "stateTransitionHistory", skip_serializing_if = "Option::is_none")]
    pub state_transition_history: Option<bool>,
}

impl A2AAgentCardCapabilities {
    pub fn new() -> A2AAgentCardCapabilities {
        A2AAgentCardCapabilities {
            streaming: None,
            push_notifications: None,
            state_transition_history: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl A2AAgentCardProvider {
    pub fn new() -> A2AAgentCardProvider {
        A2AAgentCardProvider {
            organization: None,
            url: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct A2AAgentCardSkillsInner {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "description", skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "examples", skip_serializing_if = "Option::is_none")]
    pub examples: Option<Vec<String>>,
    #[serde(rename = "input_modes", skip_serializing_if = "Option::is_none")]
    pub input_modes: Option<Vec<String>>,
    #[serde(rename = "output_modes", skip_serializing_if = "Option::is_none")]
    pub output_modes: Option<Vec<String>>,
}

impl A2AAgentCardSkillsInner {
    pub fn new(id: String, name: String) -> A2AAgentCardSkillsInner {
        A2AAgentCardSkillsInner {
            id,
            name,
            description: None,
            examples: None,
            input_modes: None,
            output_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.5.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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AgentIdentityProfile {
    #[serde(rename = "agent_id", skip_serializing_if = "Option::is_none")]
    pub agent_id: Option<String>,
    #[serde(rename = "identity_type", skip_serializing_if = "Option::is_none")]
    pub identity_type: Option<String>,
    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,
    #[serde(rename = "issuer", skip_serializing_if = "Option::is_none")]
    pub issuer: Option<String>,
    #[serde(rename = "jwks_uri", skip_serializing_if = "Option::is_none")]
    pub jwks_uri: Option<String>,
    #[serde(rename = "spiffe_id", skip_serializing_if = "Option::is_none")]
    pub spiffe_id: Option<String>,
    #[serde(rename = "scopes", skip_serializing_if = "Option::is_none")]
    pub scopes: Option<Vec<String>>,
    #[serde(rename = "anonymous_dev_mode", skip_serializing_if = "Option::is_none")]
    pub anonymous_dev_mode: Option<bool>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

impl AgentIdentityProfile {
    pub fn new() -> AgentIdentityProfile {
        AgentIdentityProfile {
            agent_id: None,
            identity_type: None,
            subject: None,
            issuer: None,
            jwks_uri: None,
            spiffe_id: None,
            scopes: None,
            anonymous_dev_mode: None,
            created_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApprovalCeremony {
    #[serde(rename = "approval_id", skip_serializing_if = "Option::is_none")]
    pub approval_id: Option<String>,
    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,
    #[serde(rename = "action", skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
    pub state: Option<ApprovalCeremonyState>,
    #[serde(rename = "requested_by", skip_serializing_if = "Option::is_none")]
    pub requested_by: Option<String>,
    #[serde(rename = "approvers", skip_serializing_if = "Option::is_none")]
    pub approvers: Option<Vec<String>>,
    #[serde(rename = "quorum", skip_serializing_if = "Option::is_none")]
    pub quorum: Option<i32>,
    #[serde(rename = "timelock_until", skip_serializing_if = "Option::is_none")]
    pub timelock_until: Option<String>,
    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    #[serde(rename = "break_glass", skip_serializing_if = "Option::is_none")]
    pub break_glass: Option<bool>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(rename = "ceremony_hash", skip_serializing_if = "Option::is_none")]
    pub ceremony_hash: Option<String>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(rename = "updated_at", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
}

impl ApprovalCeremony {
    pub fn new() -> ApprovalCeremony {
        ApprovalCeremony {
            approval_id: None,
            subject: None,
            action: None,
            state: None,
            requested_by: None,
            approvers: None,
            quorum: None,
            timelock_until: None,
            expires_at: None,
            break_glass: None,
            reason: None,
            receipt_id: None,
            ceremony_hash: None,
            created_at: None,
            updated_at: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum ApprovalCeremonyState {
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "denied")]
    Denied,
    #[serde(rename = "revoked")]
    Revoked,
    #[serde(rename = "expired")]
    Expired,
}

impl Default for ApprovalCeremonyState {
    fn default() -> ApprovalCeremonyState {
        Self::Pending
    }
}

/*
 * 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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AssertApprovalWebAuthnChallengeRequest {
    #[serde(rename = "challenge_id")]
    pub challenge_id: String,
    #[serde(rename = "actor")]
    pub actor: String,
    #[serde(rename = "assertion")]
    pub assertion: String,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

impl AssertApprovalWebAuthnChallengeRequest {
    pub fn new(challenge_id: String, actor: String, assertion: String) -> AssertApprovalWebAuthnChallengeRequest {
        AssertApprovalWebAuthnChallengeRequest {
            challenge_id,
            actor,
            assertion,
            receipt_id: None,
            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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl AuthzHealth {
    pub fn new() -> AuthzHealth {
        AuthzHealth {
            status: None,
            resolver: None,
            model_id: None,
            relationship_hash: None,
            checked_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct AuthzSnapshot {
    #[serde(rename = "snapshot_id", skip_serializing_if = "Option::is_none")]
    pub snapshot_id: Option<String>,
    #[serde(rename = "model_id", skip_serializing_if = "Option::is_none")]
    pub model_id: Option<String>,
    #[serde(rename = "relationship_hash", skip_serializing_if = "Option::is_none")]
    pub relationship_hash: Option<String>,
    #[serde(rename = "tuple_count", skip_serializing_if = "Option::is_none")]
    pub tuple_count: Option<i32>,
    #[serde(rename = "resolver", skip_serializing_if = "Option::is_none")]
    pub resolver: Option<String>,
    #[serde(rename = "stale", skip_serializing_if = "Option::is_none")]
    pub stale: Option<bool>,
    #[serde(rename = "snapshot_token", skip_serializing_if = "Option::is_none")]
    pub snapshot_token: Option<String>,
    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
    pub checked_at: Option<String>,
    #[serde(rename = "snapshot_hash", skip_serializing_if = "Option::is_none")]
    pub snapshot_hash: Option<String>,
}

impl AuthzSnapshot {
    pub fn new() -> AuthzSnapshot {
        AuthzSnapshot {
            snapshot_id: None,
            model_id: None,
            relationship_hash: None,
            tuple_count: None,
            resolver: None,
            stale: None,
            snapshot_token: None,
            checked_at: None,
            snapshot_hash: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoundaryCapabilitySummary {
    #[serde(rename = "capability_id", skip_serializing_if = "Option::is_none")]
    pub capability_id: Option<String>,
    #[serde(rename = "category", skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "authority", skip_serializing_if = "Option::is_none")]
    pub authority: Option<String>,
    #[serde(rename = "public_routes", skip_serializing_if = "Option::is_none")]
    pub public_routes: Option<Vec<String>>,
    #[serde(rename = "cli_commands", skip_serializing_if = "Option::is_none")]
    pub cli_commands: Option<Vec<String>>,
    #[serde(rename = "receipt_bindings", skip_serializing_if = "Option::is_none")]
    pub receipt_bindings: Option<Vec<String>>,
    #[serde(rename = "conformance_level", skip_serializing_if = "Option::is_none")]
    pub conformance_level: Option<String>,
}

impl BoundaryCapabilitySummary {
    pub fn new() -> BoundaryCapabilitySummary {
        BoundaryCapabilitySummary {
            capability_id: None,
            category: None,
            status: None,
            authority: None,
            public_routes: None,
            cli_commands: None,
            receipt_bindings: None,
            conformance_level: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoundaryCheckpoint {
    #[serde(rename = "checkpoint_id", skip_serializing_if = "Option::is_none")]
    pub checkpoint_id: Option<String>,
    #[serde(rename = "sequence", skip_serializing_if = "Option::is_none")]
    pub sequence: Option<i64>,
    #[serde(rename = "previous_checkpoint_hash", skip_serializing_if = "Option::is_none")]
    pub previous_checkpoint_hash: Option<String>,
    #[serde(rename = "receipt_count", skip_serializing_if = "Option::is_none")]
    pub receipt_count: Option<i32>,
    #[serde(rename = "record_count", skip_serializing_if = "Option::is_none")]
    pub record_count: Option<i32>,
    #[serde(rename = "root_hash", skip_serializing_if = "Option::is_none")]
    pub root_hash: Option<String>,
    #[serde(rename = "checkpoint_hash", skip_serializing_if = "Option::is_none")]
    pub checkpoint_hash: Option<String>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

impl BoundaryCheckpoint {
    pub fn new() -> BoundaryCheckpoint {
        BoundaryCheckpoint {
            checkpoint_id: None,
            sequence: None,
            previous_checkpoint_hash: None,
            receipt_count: None,
            record_count: None,
            root_hash: None,
            checkpoint_hash: None,
            created_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoundaryRecordVerification {
    #[serde(rename = "record_id", skip_serializing_if = "Option::is_none")]
    pub record_id: Option<String>,
    #[serde(rename = "record_hash", skip_serializing_if = "Option::is_none")]
    pub record_hash: Option<String>,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(rename = "verified", skip_serializing_if = "Option::is_none")]
    pub verified: Option<bool>,
    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
    pub errors: Option<Vec<String>>,
    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
    pub checked_at: Option<String>,
}

impl BoundaryRecordVerification {
    pub fn new() -> BoundaryRecordVerification {
        BoundaryRecordVerification {
            record_id: None,
            record_hash: None,
            receipt_id: None,
            verified: None,
            errors: None,
            checked_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BoundaryStatus {
    #[serde(rename = "version", skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,
    #[serde(rename = "status", skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(rename = "receipt_store_ready", skip_serializing_if = "Option::is_none")]
    pub receipt_store_ready: Option<bool>,
    #[serde(rename = "signer_ready", skip_serializing_if = "Option::is_none")]
    pub signer_ready: Option<bool>,
    #[serde(rename = "open_approvals", skip_serializing_if = "Option::is_none")]
    pub open_approvals: Option<i32>,
    #[serde(rename = "quarantined_mcp_servers", skip_serializing_if = "Option::is_none")]
    pub quarantined_mcp_servers: Option<i32>,
    #[serde(rename = "last_checkpoint_id", skip_serializing_if = "Option::is_none")]
    pub last_checkpoint_id: Option<String>,
    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
    pub checked_at: Option<String>,
}

impl BoundaryStatus {
    pub fn new() -> BoundaryStatus {
        BoundaryStatus {
            version: None,
            status: None,
            receipt_store_ready: None,
            signer_ready: None,
            open_approvals: None,
            quarantined_mcp_servers: None,
            last_checkpoint_id: None,
            checked_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct BudgetCeiling {
    #[serde(rename = "budget_id", skip_serializing_if = "Option::is_none")]
    pub budget_id: Option<String>,
    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,
    #[serde(rename = "window", skip_serializing_if = "Option::is_none")]
    pub window: Option<String>,
    #[serde(rename = "max_tool_calls", skip_serializing_if = "Option::is_none")]
    pub max_tool_calls: Option<i32>,
    #[serde(rename = "max_spend_minor", skip_serializing_if = "Option::is_none")]
    pub max_spend_minor: Option<i64>,
    #[serde(rename = "max_egress_bytes", skip_serializing_if = "Option::is_none")]
    pub max_egress_bytes: Option<i64>,
    #[serde(rename = "max_write_ops", skip_serializing_if = "Option::is_none")]
    pub max_write_ops: Option<i32>,
    #[serde(rename = "approval_required_after", skip_serializing_if = "Option::is_none")]
    pub approval_required_after: Option<i32>,
    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
    pub policy_epoch: Option<String>,
}

impl BudgetCeiling {
    pub fn new() -> BudgetCeiling {
        BudgetCeiling {
            budget_id: None,
            subject: None,
            window: None,
            max_tool_calls: None,
            max_spend_minor: None,
            max_egress_bytes: None,
            max_write_ops: None,
            approval_required_after: None,
            policy_epoch: 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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ChatCompletionRequestMessagesInner {
    #[serde(rename = "role")]
    pub role: ChatCompletionRequestMessagesInnerRole,
    #[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: ChatCompletionRequestMessagesInnerRole, content: String) -> ChatCompletionRequestMessagesInner {
        ChatCompletionRequestMessagesInner {
            role,
            content,
            tool_call_id: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum ChatCompletionRequestMessagesInnerRole {
    #[serde(rename = "system")]
    System,
    #[serde(rename = "user")]
    User,
    #[serde(rename = "assistant")]
    Assistant,
    #[serde(rename = "tool")]
    Tool,
}

impl Default for ChatCompletionRequestMessagesInnerRole {
    fn default() -> ChatCompletionRequestMessagesInnerRole {
        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.5.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<ChatCompletionRequestToolsInnerType>,
    #[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 ChatCompletionRequestToolsInnerType {
    #[serde(rename = "function")]
    Function,
}

impl Default for ChatCompletionRequestToolsInnerType {
    fn default() -> ChatCompletionRequestToolsInnerType {
        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.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct CoexistenceCapabilityManifest {
    #[serde(rename = "manifest_id", skip_serializing_if = "Option::is_none")]
    pub manifest_id: Option<String>,
    #[serde(rename = "authority", skip_serializing_if = "Option::is_none")]
    pub authority: Option<String>,
    #[serde(rename = "boundary_role", skip_serializing_if = "Option::is_none")]
    pub boundary_role: Option<String>,
    #[serde(rename = "supported_inputs", skip_serializing_if = "Option::is_none")]
    pub supported_inputs: Option<Vec<String>>,
    #[serde(rename = "export_surfaces", skip_serializing_if = "Option::is_none")]
    pub export_surfaces: Option<Vec<String>>,
    #[serde(rename = "receipt_bindings", skip_serializing_if = "Option::is_none")]
    pub receipt_bindings: Option<Vec<String>>,
    #[serde(rename = "generated_at", skip_serializing_if = "Option::is_none")]
    pub generated_at: Option<String>,
}

impl CoexistenceCapabilityManifest {
    pub fn new() -> CoexistenceCapabilityManifest {
        CoexistenceCapabilityManifest {
            manifest_id: None,
            authority: None,
            boundary_role: None,
            supported_inputs: None,
            export_surfaces: None,
            receipt_bindings: None,
            generated_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

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

impl Default for ConformanceRequestLevel {
    fn default() -> ConformanceRequestLevel {
        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.5.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<ConformanceResultVerdict>,
    #[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 ConformanceResultVerdict {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

impl Default for ConformanceResultVerdict {
    fn default() -> ConformanceResultVerdict {
        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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleBootstrap {
    #[serde(rename = "version")]
    pub version: Box<VersionInfo>,
    #[serde(rename = "workspace")]
    pub workspace: Box<ConsoleBootstrapWorkspace>,
    #[serde(rename = "health")]
    pub health: Box<ConsoleBootstrapHealth>,
    #[serde(rename = "counts")]
    pub counts: Box<ConsoleBootstrapCounts>,
    #[serde(rename = "receipts")]
    pub receipts: Vec<Receipt>,
    #[serde(rename = "conformance")]
    pub conformance: Box<ConsoleBootstrapConformance>,
    #[serde(rename = "mcp")]
    pub mcp: Box<ConsoleBootstrapMcp>,
}

impl ConsoleBootstrap {
    pub fn new(version: VersionInfo, workspace: ConsoleBootstrapWorkspace, health: ConsoleBootstrapHealth, counts: ConsoleBootstrapCounts, receipts: Vec<Receipt>, conformance: ConsoleBootstrapConformance, mcp: ConsoleBootstrapMcp) -> ConsoleBootstrap {
        ConsoleBootstrap {
            version: Box::new(version),
            workspace: Box::new(workspace),
            health: Box::new(health),
            counts: Box::new(counts),
            receipts,
            conformance: Box::new(conformance),
            mcp: Box::new(mcp),
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl ConsoleBootstrapConformance {
    pub fn new(level: String, status: String) -> ConsoleBootstrapConformance {
        ConsoleBootstrapConformance {
            level,
            status,
            report_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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleBootstrapCounts {
    #[serde(rename = "receipts")]
    pub receipts: i32,
    #[serde(rename = "pending_approvals")]
    pub pending_approvals: i32,
    #[serde(rename = "open_incidents")]
    pub open_incidents: i32,
    #[serde(rename = "mcp_tools")]
    pub mcp_tools: i32,
}

impl ConsoleBootstrapCounts {
    pub fn new(receipts: i32, pending_approvals: i32, open_incidents: i32, mcp_tools: i32) -> ConsoleBootstrapCounts {
        ConsoleBootstrapCounts {
            receipts,
            pending_approvals,
            open_incidents,
            mcp_tools,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleBootstrapHealth {
    #[serde(rename = "kernel")]
    pub kernel: String,
    #[serde(rename = "policy")]
    pub policy: String,
    #[serde(rename = "store")]
    pub store: String,
    #[serde(rename = "conformance")]
    pub conformance: String,
}

impl ConsoleBootstrapHealth {
    pub fn new(kernel: String, policy: String, store: String, conformance: String) -> ConsoleBootstrapHealth {
        ConsoleBootstrapHealth {
            kernel,
            policy,
            store,
            conformance,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleBootstrapMcp {
    #[serde(rename = "authorization")]
    pub authorization: String,
    #[serde(rename = "scopes")]
    pub scopes: Vec<String>,
}

impl ConsoleBootstrapMcp {
    pub fn new(authorization: String, scopes: Vec<String>) -> ConsoleBootstrapMcp {
        ConsoleBootstrapMcp {
            authorization,
            scopes,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleBootstrapWorkspace {
    #[serde(rename = "organization")]
    pub organization: String,
    #[serde(rename = "project")]
    pub project: String,
    #[serde(rename = "environment")]
    pub environment: String,
    #[serde(rename = "mode")]
    pub mode: String,
}

impl ConsoleBootstrapWorkspace {
    pub fn new(organization: String, project: String, environment: String, mode: String) -> ConsoleBootstrapWorkspace {
        ConsoleBootstrapWorkspace {
            organization,
            project,
            environment,
            mode,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleSurfaceRef {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "source")]
    pub source: String,
}

impl ConsoleSurfaceRef {
    pub fn new(id: String, source: String) -> ConsoleSurfaceRef {
        ConsoleSurfaceRef {
            id,
            source,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConsoleSurfaceState {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "source")]
    pub source: String,
    #[serde(rename = "generated_at")]
    pub generated_at: String,
    #[serde(rename = "summary", skip_serializing_if = "Option::is_none")]
    pub summary: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "records", skip_serializing_if = "Option::is_none")]
    pub records: Option<Vec<std::collections::HashMap<String, serde_json::Value>>>,
}

impl ConsoleSurfaceState {
    pub fn new(id: String, status: String, source: String, generated_at: String) -> ConsoleSurfaceState {
        ConsoleSurfaceState {
            id,
            status,
            source,
            generated_at,
            summary: None,
            records: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl CreateApprovalWebAuthnChallengeRequest {
    pub fn new() -> CreateApprovalWebAuthnChallengeRequest {
        CreateApprovalWebAuthnChallengeRequest {
            method: None,
            ttl_ms: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl CreateSandboxGrantRequest {
    pub fn new() -> CreateSandboxGrantRequest {
        CreateSandboxGrantRequest {
            runtime: None,
            profile: None,
            image_digest: None,
            policy_epoch: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct DecisionRecord {
    #[serde(rename = "id", skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "action", skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    #[serde(rename = "resource", skip_serializing_if = "Option::is_none")]
    pub resource: Option<String>,
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<String>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
    #[serde(rename = "policy_version", skip_serializing_if = "Option::is_none")]
    pub policy_version: Option<String>,
    #[serde(rename = "policy_decision_hash", skip_serializing_if = "Option::is_none")]
    pub policy_decision_hash: Option<String>,
    #[serde(rename = "signature", skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
}

impl DecisionRecord {
    pub fn new() -> DecisionRecord {
        DecisionRecord {
            id: None,
            action: None,
            resource: None,
            verdict: None,
            reason: None,
            policy_version: None,
            policy_decision_hash: None,
            signature: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl DecisionRequest {
    pub fn new(action: String, resource: String) -> DecisionRequest {
        DecisionRequest {
            principal: None,
            action,
            resource,
            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.5.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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EnvExposurePolicy {
    #[serde(rename = "mode")]
    pub mode: EnvExposurePolicyMode,
    #[serde(rename = "names", skip_serializing_if = "Option::is_none")]
    pub names: Option<Vec<String>>,
    #[serde(rename = "names_hash", skip_serializing_if = "Option::is_none")]
    pub names_hash: Option<String>,
    #[serde(rename = "redacted", skip_serializing_if = "Option::is_none")]
    pub redacted: Option<bool>,
}

impl EnvExposurePolicy {
    pub fn new(mode: EnvExposurePolicyMode) -> EnvExposurePolicy {
        EnvExposurePolicy {
            mode,
            names: None,
            names_hash: None,
            redacted: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum EnvExposurePolicyMode {
    #[serde(rename = "deny-all")]
    DenyAll,
    #[serde(rename = "allowlist")]
    Allowlist,
    #[serde(rename = "redacted")]
    Redacted,
}

impl Default for EnvExposurePolicyMode {
    fn default() -> EnvExposurePolicyMode {
        Self::DenyAll
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EvidenceEnvelopeExportRequest {
    #[serde(rename = "manifest_id")]
    pub manifest_id: String,
    #[serde(rename = "envelope")]
    pub envelope: EvidenceEnvelopeExportRequestEnvelope,
    /// HELM-native EvidencePack root hash.
    #[serde(rename = "native_evidence_hash")]
    pub native_evidence_hash: String,
    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,
    /// Must be true for experimental SCITT or COSE exports.
    #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")]
    pub experimental: Option<bool>,
}

impl EvidenceEnvelopeExportRequest {
    pub fn new(manifest_id: String, envelope: EvidenceEnvelopeExportRequestEnvelope, native_evidence_hash: String) -> EvidenceEnvelopeExportRequest {
        EvidenceEnvelopeExportRequest {
            manifest_id,
            envelope,
            native_evidence_hash,
            subject: None,
            experimental: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum EvidenceEnvelopeExportRequestEnvelope {
    #[serde(rename = "dsse")]
    Dsse,
    #[serde(rename = "jws")]
    Jws,
    #[serde(rename = "in-toto")]
    InToto,
    #[serde(rename = "slsa")]
    Slsa,
    #[serde(rename = "sigstore")]
    Sigstore,
    #[serde(rename = "scitt")]
    Scitt,
    #[serde(rename = "cose")]
    Cose,
}

impl Default for EvidenceEnvelopeExportRequestEnvelope {
    fn default() -> EvidenceEnvelopeExportRequestEnvelope {
        Self::Dsse
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EvidenceEnvelopeManifest {
    #[serde(rename = "manifest_id")]
    pub manifest_id: String,
    #[serde(rename = "envelope")]
    pub envelope: EvidenceEnvelopeManifestEnvelope,
    #[serde(rename = "native_evidence_hash")]
    pub native_evidence_hash: String,
    #[serde(rename = "native_authority")]
    pub native_authority: bool,
    #[serde(rename = "subject", skip_serializing_if = "Option::is_none")]
    pub subject: Option<String>,
    #[serde(rename = "statement_hash", skip_serializing_if = "Option::is_none")]
    pub statement_hash: Option<String>,
    #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")]
    pub experimental: Option<bool>,
    #[serde(rename = "created_at")]
    pub created_at: String,
    #[serde(rename = "manifest_hash", skip_serializing_if = "Option::is_none")]
    pub manifest_hash: Option<String>,
}

impl EvidenceEnvelopeManifest {
    pub fn new(manifest_id: String, envelope: EvidenceEnvelopeManifestEnvelope, native_evidence_hash: String, native_authority: bool, created_at: String) -> EvidenceEnvelopeManifest {
        EvidenceEnvelopeManifest {
            manifest_id,
            envelope,
            native_evidence_hash,
            native_authority,
            subject: None,
            statement_hash: None,
            experimental: None,
            created_at,
            manifest_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum EvidenceEnvelopeManifestEnvelope {
    #[serde(rename = "dsse")]
    Dsse,
    #[serde(rename = "jws")]
    Jws,
    #[serde(rename = "in-toto")]
    InToto,
    #[serde(rename = "slsa")]
    Slsa,
    #[serde(rename = "sigstore")]
    Sigstore,
    #[serde(rename = "scitt")]
    Scitt,
    #[serde(rename = "cose")]
    Cose,
}

impl Default for EvidenceEnvelopeManifestEnvelope {
    fn default() -> EvidenceEnvelopeManifestEnvelope {
        Self::Dsse
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct EvidenceEnvelopeVerification {
    #[serde(rename = "manifest_id", skip_serializing_if = "Option::is_none")]
    pub manifest_id: Option<String>,
    #[serde(rename = "manifest_hash", skip_serializing_if = "Option::is_none")]
    pub manifest_hash: Option<String>,
    #[serde(rename = "native_evidence_hash", skip_serializing_if = "Option::is_none")]
    pub native_evidence_hash: Option<String>,
    #[serde(rename = "verified", skip_serializing_if = "Option::is_none")]
    pub verified: Option<bool>,
    #[serde(rename = "authoritative", skip_serializing_if = "Option::is_none")]
    pub authoritative: Option<bool>,
    #[serde(rename = "errors", skip_serializing_if = "Option::is_none")]
    pub errors: Option<Vec<String>>,
    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
    pub checked_at: Option<String>,
}

impl EvidenceEnvelopeVerification {
    pub fn new() -> EvidenceEnvelopeVerification {
        EvidenceEnvelopeVerification {
            manifest_id: None,
            manifest_hash: None,
            native_evidence_hash: None,
            verified: None,
            authoritative: None,
            errors: None,
            checked_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExecutionBoundaryRecord {
    #[serde(rename = "record_id", skip_serializing_if = "Option::is_none")]
    pub record_id: Option<String>,
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<ExecutionBoundaryRecordVerdict>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "tool_name", skip_serializing_if = "Option::is_none")]
    pub tool_name: Option<String>,
    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
    pub args_hash: Option<String>,
    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
    pub policy_epoch: Option<String>,
    #[serde(rename = "mcp_server_id", skip_serializing_if = "Option::is_none")]
    pub mcp_server_id: Option<String>,
    #[serde(rename = "oauth_resource", skip_serializing_if = "Option::is_none")]
    pub oauth_resource: Option<String>,
    #[serde(rename = "oauth_scopes", skip_serializing_if = "Option::is_none")]
    pub oauth_scopes: Option<Vec<String>>,
    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
    pub sandbox_grant_hash: Option<String>,
    #[serde(rename = "authz_snapshot_hash", skip_serializing_if = "Option::is_none")]
    pub authz_snapshot_hash: Option<String>,
    #[serde(rename = "approval_receipt_id", skip_serializing_if = "Option::is_none")]
    pub approval_receipt_id: Option<String>,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(rename = "record_hash", skip_serializing_if = "Option::is_none")]
    pub record_hash: Option<String>,
    #[serde(rename = "created_at", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
}

impl ExecutionBoundaryRecord {
    pub fn new() -> ExecutionBoundaryRecord {
        ExecutionBoundaryRecord {
            record_id: None,
            verdict: None,
            reason_code: None,
            tool_name: None,
            args_hash: None,
            policy_epoch: None,
            mcp_server_id: None,
            oauth_resource: None,
            oauth_scopes: None,
            sandbox_grant_hash: None,
            authz_snapshot_hash: None,
            approval_receipt_id: None,
            receipt_id: None,
            record_hash: None,
            created_at: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum ExecutionBoundaryRecordVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

impl Default for ExecutionBoundaryRecordVerdict {
    fn default() -> ExecutionBoundaryRecordVerdict {
        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.5.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<ExportRequestFormat>,
}

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 ExportRequestFormat {
    #[serde(rename = "tar.gz")]
    TarPeriodGz,
}

impl Default for ExportRequestFormat {
    fn default() -> ExportRequestFormat {
        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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct FilesystemPreopen {
    #[serde(rename = "path")]
    pub path: String,
    #[serde(rename = "mode")]
    pub mode: FilesystemPreopenMode,
    #[serde(rename = "content_hash", skip_serializing_if = "Option::is_none")]
    pub content_hash: Option<String>,
}

impl FilesystemPreopen {
    pub fn new(path: String, mode: FilesystemPreopenMode) -> FilesystemPreopen {
        FilesystemPreopen {
            path,
            mode,
            content_hash: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum FilesystemPreopenMode {
    #[serde(rename = "ro")]
    Ro,
    #[serde(rename = "rw")]
    Rw,
}

impl Default for FilesystemPreopenMode {
    fn default() -> FilesystemPreopenMode {
        Self::Ro
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GetAgentUiRuntimeInfo200Response {
    #[serde(rename = "runtime")]
    pub runtime: String,
    #[serde(rename = "protocol", deserialize_with = "Option::deserialize")]
    pub protocol: Option<serde_json::Value>,
    #[serde(rename = "transport", deserialize_with = "Option::deserialize")]
    pub transport: Option<serde_json::Value>,
    #[serde(rename = "tools", deserialize_with = "Option::deserialize")]
    pub tools: Option<serde_json::Value>,
}

impl GetAgentUiRuntimeInfo200Response {
    pub fn new(runtime: String, protocol: Option<serde_json::Value>, transport: Option<serde_json::Value>, tools: Option<serde_json::Value>) -> GetAgentUiRuntimeInfo200Response {
        GetAgentUiRuntimeInfo200Response {
            runtime,
            protocol,
            transport,
            tools,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct GetPublicDemoHealth200Response {
    #[serde(rename = "version")]
    pub version: String,
    #[serde(rename = "commit")]
    pub commit: String,
    #[serde(rename = "helm_ai_kernel_version")]
    pub helm_ai_kernel_version: String,
    #[serde(rename = "status")]
    pub status: String,
    #[serde(rename = "build_time")]
    pub build_time: String,
    #[serde(rename = "git_sha")]
    pub git_sha: String,
    #[serde(rename = "deployment_id")]
    pub deployment_id: String,
}

impl GetPublicDemoHealth200Response {
    pub fn new(version: String, commit: String, helm_ai_kernel_version: String, status: String, build_time: String, git_sha: String, deployment_id: String) -> GetPublicDemoHealth200Response {
        GetPublicDemoHealth200Response {
            version,
            commit,
            helm_ai_kernel_version,
            status,
            build_time,
            git_sha,
            deployment_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.5.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: GovernanceDecisionVerdict,
    /// 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: GovernanceDecisionVerdict) -> 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 GovernanceDecisionVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

impl Default for GovernanceDecisionVerdict {
    fn default() -> GovernanceDecisionVerdict {
        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.5.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.5.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.5.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: HelmErrorErrorType,
    /// Machine-readable error code
    #[serde(rename = "code")]
    pub code: String,
    /// HELM-specific reason code
    #[serde(rename = "reason_code")]
    pub reason_code: HelmErrorErrorReasonCode,
    /// 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: HelmErrorErrorType, code: String, reason_code: HelmErrorErrorReasonCode) -> HelmErrorError {
        HelmErrorError {
            message,
            r#type,
            code,
            reason_code,
            details: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum HelmErrorErrorType {
    #[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 HelmErrorErrorType {
    fn default() -> HelmErrorErrorType {
        Self::InvalidRequest
    }
}
/// HELM-specific reason code
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum HelmErrorErrorReasonCode {
    #[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 HelmErrorErrorReasonCode {
    fn default() -> HelmErrorErrorReasonCode {
        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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ListConsoleSurfaces200Response {
    #[serde(rename = "surfaces", skip_serializing_if = "Option::is_none")]
    pub surfaces: Option<Vec<ConsoleSurfaceRef>>,
}

impl ListConsoleSurfaces200Response {
    pub fn new() -> ListConsoleSurfaces200Response {
        ListConsoleSurfaces200Response {
            surfaces: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpAuthorizationProfile {
    #[serde(rename = "profile_id", skip_serializing_if = "Option::is_none")]
    pub profile_id: Option<String>,
    #[serde(rename = "protocol_version", skip_serializing_if = "Option::is_none")]
    pub protocol_version: Option<String>,
    #[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 = "tool_scopes", skip_serializing_if = "Option::is_none")]
    pub tool_scopes: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "required_audience", skip_serializing_if = "Option::is_none")]
    pub required_audience: Option<String>,
    #[serde(rename = "stale_after", skip_serializing_if = "Option::is_none")]
    pub stale_after: Option<String>,
    #[serde(rename = "profile_hash", skip_serializing_if = "Option::is_none")]
    pub profile_hash: Option<String>,
}

impl McpAuthorizationProfile {
    pub fn new() -> McpAuthorizationProfile {
        McpAuthorizationProfile {
            profile_id: None,
            protocol_version: None,
            resource: None,
            authorization_servers: None,
            scopes_supported: None,
            tool_scopes: None,
            required_audience: None,
            stale_after: None,
            profile_hash: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpAuthorizeCallRequest {
    #[serde(rename = "server_id")]
    pub server_id: String,
    #[serde(rename = "tool_name")]
    pub tool_name: String,
    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
    pub args_hash: Option<String>,
    #[serde(rename = "granted_scopes", skip_serializing_if = "Option::is_none")]
    pub granted_scopes: Option<Vec<String>>,
    #[serde(rename = "pinned_schema_hash", skip_serializing_if = "Option::is_none")]
    pub pinned_schema_hash: Option<String>,
    #[serde(rename = "tool_schema", skip_serializing_if = "Option::is_none")]
    pub tool_schema: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "output_schema", skip_serializing_if = "Option::is_none")]
    pub output_schema: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "oauth_resource", skip_serializing_if = "Option::is_none")]
    pub oauth_resource: Option<String>,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
}

impl McpAuthorizeCallRequest {
    pub fn new(server_id: String, tool_name: String) -> McpAuthorizeCallRequest {
        McpAuthorizeCallRequest {
            server_id,
            tool_name,
            args_hash: None,
            granted_scopes: None,
            pinned_schema_hash: None,
            tool_schema: None,
            output_schema: None,
            oauth_resource: 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.5.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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpQuarantineRecord {
    #[serde(rename = "server_id")]
    pub server_id: String,
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
    pub transport: Option<String>,
    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(rename = "tool_names", skip_serializing_if = "Option::is_none")]
    pub tool_names: Option<Vec<String>>,
    #[serde(rename = "risk")]
    pub risk: McpQuarantineRecordRisk,
    #[serde(rename = "state")]
    pub state: McpQuarantineRecordState,
    #[serde(rename = "discovered_at")]
    pub discovered_at: String,
    #[serde(rename = "approved_at", skip_serializing_if = "Option::is_none")]
    pub approved_at: Option<String>,
    #[serde(rename = "approved_by", skip_serializing_if = "Option::is_none")]
    pub approved_by: Option<String>,
    #[serde(rename = "approval_receipt_id", skip_serializing_if = "Option::is_none")]
    pub approval_receipt_id: Option<String>,
    #[serde(rename = "revoked_at", skip_serializing_if = "Option::is_none")]
    pub revoked_at: Option<String>,
    #[serde(rename = "expires_at", skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<String>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

impl McpQuarantineRecord {
    pub fn new(server_id: String, risk: McpQuarantineRecordRisk, state: McpQuarantineRecordState, discovered_at: String) -> McpQuarantineRecord {
        McpQuarantineRecord {
            server_id,
            name: None,
            transport: None,
            endpoint: None,
            tool_names: None,
            risk,
            state,
            discovered_at,
            approved_at: None,
            approved_by: None,
            approval_receipt_id: None,
            revoked_at: None,
            expires_at: None,
            reason: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum McpQuarantineRecordRisk {
    #[serde(rename = "unknown")]
    Unknown,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "critical")]
    Critical,
}

impl Default for McpQuarantineRecordRisk {
    fn default() -> McpQuarantineRecordRisk {
        Self::Unknown
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum McpQuarantineRecordState {
    #[serde(rename = "discovered")]
    Discovered,
    #[serde(rename = "quarantined")]
    Quarantined,
    #[serde(rename = "approved")]
    Approved,
    #[serde(rename = "revoked")]
    Revoked,
    #[serde(rename = "expired")]
    Expired,
}

impl Default for McpQuarantineRecordState {
    fn default() -> McpQuarantineRecordState {
        Self::Discovered
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpRegistryApprovalRequest {
    #[serde(rename = "server_id")]
    pub server_id: String,
    #[serde(rename = "approver_id")]
    pub approver_id: String,
    #[serde(rename = "approval_receipt_id")]
    pub approval_receipt_id: String,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

impl McpRegistryApprovalRequest {
    pub fn new(server_id: String, approver_id: String, approval_receipt_id: String) -> McpRegistryApprovalRequest {
        McpRegistryApprovalRequest {
            server_id,
            approver_id,
            approval_receipt_id,
            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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpRegistryDiscoverRequest {
    #[serde(rename = "server_id")]
    pub server_id: String,
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
    pub transport: Option<String>,
    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(rename = "tool_names", skip_serializing_if = "Option::is_none")]
    pub tool_names: Option<Vec<String>>,
    #[serde(rename = "risk", skip_serializing_if = "Option::is_none")]
    pub risk: Option<McpRegistryDiscoverRequestRisk>,
    #[serde(rename = "reason", skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

impl McpRegistryDiscoverRequest {
    pub fn new(server_id: String) -> McpRegistryDiscoverRequest {
        McpRegistryDiscoverRequest {
            server_id,
            name: None,
            transport: None,
            endpoint: None,
            tool_names: None,
            risk: None,
            reason: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum McpRegistryDiscoverRequestRisk {
    #[serde(rename = "unknown")]
    Unknown,
    #[serde(rename = "low")]
    Low,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "critical")]
    Critical,
}

impl Default for McpRegistryDiscoverRequestRisk {
    fn default() -> McpRegistryDiscoverRequestRisk {
        Self::Unknown
    }
}

/*
 * 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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpScanRequest {
    #[serde(rename = "server_id")]
    pub server_id: String,
    #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "transport", skip_serializing_if = "Option::is_none")]
    pub transport: Option<String>,
    #[serde(rename = "endpoint", skip_serializing_if = "Option::is_none")]
    pub endpoint: Option<String>,
    #[serde(rename = "tool_names", skip_serializing_if = "Option::is_none")]
    pub tool_names: Option<Vec<String>>,
    #[serde(rename = "manifest", skip_serializing_if = "Option::is_none")]
    pub manifest: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl McpScanRequest {
    pub fn new(server_id: String) -> McpScanRequest {
        McpScanRequest {
            server_id,
            name: None,
            transport: None,
            endpoint: None,
            tool_names: None,
            manifest: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpScanResult {
    #[serde(rename = "server_id", skip_serializing_if = "Option::is_none")]
    pub server_id: Option<String>,
    #[serde(rename = "risk", skip_serializing_if = "Option::is_none")]
    pub risk: Option<String>,
    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(rename = "tool_count", skip_serializing_if = "Option::is_none")]
    pub tool_count: Option<i32>,
    #[serde(rename = "findings", skip_serializing_if = "Option::is_none")]
    pub findings: Option<Vec<String>>,
    #[serde(rename = "recommended_action", skip_serializing_if = "Option::is_none")]
    pub recommended_action: Option<String>,
    #[serde(rename = "quarantine_record_id", skip_serializing_if = "Option::is_none")]
    pub quarantine_record_id: Option<String>,
    #[serde(rename = "requires_approval", skip_serializing_if = "Option::is_none")]
    pub requires_approval: Option<bool>,
    #[serde(rename = "schema_pin_required", skip_serializing_if = "Option::is_none")]
    pub schema_pin_required: Option<bool>,
    #[serde(rename = "authorization_needed", skip_serializing_if = "Option::is_none")]
    pub authorization_needed: Option<bool>,
    #[serde(rename = "scanned_at", skip_serializing_if = "Option::is_none")]
    pub scanned_at: Option<String>,
}

impl McpScanResult {
    pub fn new() -> McpScanResult {
        McpScanResult {
            server_id: None,
            risk: None,
            state: None,
            tool_count: None,
            findings: None,
            recommended_action: None,
            quarantine_record_id: None,
            requires_approval: None,
            schema_pin_required: None,
            authorization_needed: None,
            scanned_at: 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.5.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.5.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.5.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.5.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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct McpjsonrpcRequest {
    #[serde(rename = "jsonrpc")]
    pub jsonrpc: McpjsonrpcRequestJsonrpc,
    #[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: McpjsonrpcRequestJsonrpc, method: String) -> McpjsonrpcRequest {
        McpjsonrpcRequest {
            jsonrpc,
            id: None,
            method,
            params: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum McpjsonrpcRequestJsonrpc {
    #[serde(rename = "2.0")]
    Variant2Period0,
}

impl Default for McpjsonrpcRequestJsonrpc {
    fn default() -> McpjsonrpcRequestJsonrpc {
        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.5.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.5.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<McpjsonrpcResponseJsonrpc>,
    #[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,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum McpjsonrpcResponseJsonrpc {
    #[serde(rename = "2.0")]
    Variant2Period0,
}

impl Default for McpjsonrpcResponseJsonrpc {
    fn default() -> McpjsonrpcResponseJsonrpc {
        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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct NegativeBoundaryVector {
    #[serde(rename = "id")]
    pub id: String,
    #[serde(rename = "category")]
    pub category: String,
    #[serde(rename = "trigger")]
    pub trigger: String,
    #[serde(rename = "expected_verdict")]
    pub expected_verdict: NegativeBoundaryVectorExpectedVerdict,
    #[serde(rename = "expected_reason_code")]
    pub expected_reason_code: String,
    #[serde(rename = "must_emit_receipt")]
    pub must_emit_receipt: bool,
    #[serde(rename = "must_not_dispatch")]
    pub must_not_dispatch: bool,
    #[serde(rename = "must_bind_evidence", skip_serializing_if = "Option::is_none")]
    pub must_bind_evidence: Option<Vec<String>>,
}

impl NegativeBoundaryVector {
    pub fn new(id: String, category: String, trigger: String, expected_verdict: NegativeBoundaryVectorExpectedVerdict, expected_reason_code: String, must_emit_receipt: bool, must_not_dispatch: bool) -> NegativeBoundaryVector {
        NegativeBoundaryVector {
            id,
            category,
            trigger,
            expected_verdict,
            expected_reason_code,
            must_emit_receipt,
            must_not_dispatch,
            must_bind_evidence: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum NegativeBoundaryVectorExpectedVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

impl Default for NegativeBoundaryVectorExpectedVerdict {
    fn default() -> NegativeBoundaryVectorExpectedVerdict {
        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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct NetworkGrant {
    #[serde(rename = "mode")]
    pub mode: NetworkGrantMode,
    #[serde(rename = "destinations", skip_serializing_if = "Option::is_none")]
    pub destinations: Option<Vec<String>>,
    #[serde(rename = "cidrs", skip_serializing_if = "Option::is_none")]
    pub cidrs: Option<Vec<String>>,
}

impl NetworkGrant {
    pub fn new(mode: NetworkGrantMode) -> NetworkGrant {
        NetworkGrant {
            mode,
            destinations: None,
            cidrs: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum NetworkGrantMode {
    #[serde(rename = "deny-all")]
    DenyAll,
    #[serde(rename = "allowlist")]
    Allowlist,
}

impl Default for NetworkGrantMode {
    fn default() -> NetworkGrantMode {
        Self::DenyAll
    }
}

/*
 * 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.5.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.5.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.5.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<PolicyBundlePackType>,
}

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 PolicyBundlePackType {
    #[serde(rename = "jurisdiction")]
    Jurisdiction,
    #[serde(rename = "industry")]
    Industry,
    #[serde(rename = "business")]
    Business,
    #[serde(rename = "custom")]
    Custom,
}

impl Default for PolicyBundlePackType {
    fn default() -> PolicyBundlePackType {
        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.5.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<String>,
    #[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>,
    #[serde(rename = "executor_id", skip_serializing_if = "Option::is_none")]
    pub executor_id: Option<String>,
    #[serde(rename = "args_hash", skip_serializing_if = "Option::is_none")]
    pub args_hash: Option<String>,
    #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")]
    pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
}

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,
            executor_id: None,
            args_hash: None,
            metadata: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct ReceiptListResponse {
    #[serde(rename = "receipts", skip_serializing_if = "Option::is_none")]
    pub receipts: Option<Vec<Receipt>>,
    #[serde(rename = "count", skip_serializing_if = "Option::is_none")]
    pub count: Option<i32>,
    #[serde(rename = "next_cursor", skip_serializing_if = "Option::is_none")]
    pub next_cursor: Option<String>,
    #[serde(rename = "has_more", skip_serializing_if = "Option::is_none")]
    pub has_more: Option<bool>,
}

impl ReceiptListResponse {
    pub fn new() -> ReceiptListResponse {
        ReceiptListResponse {
            receipts: None,
            count: None,
            next_cursor: None,
            has_more: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl RevokeMcpRegistryRecordRequest {
    pub fn new() -> RevokeMcpRegistryRecordRequest {
        RevokeMcpRegistryRecordRequest {
            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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct RunAgentUiRuntimeRequest {
    #[serde(rename = "threadId", skip_serializing_if = "Option::is_none")]
    pub thread_id: Option<String>,
    #[serde(rename = "runId", skip_serializing_if = "Option::is_none")]
    pub run_id: Option<String>,
    #[serde(rename = "workspaceId", skip_serializing_if = "Option::is_none")]
    pub workspace_id: Option<String>,
    #[serde(rename = "currentSurface", skip_serializing_if = "Option::is_none")]
    pub current_surface: Option<String>,
    #[serde(rename = "state", skip_serializing_if = "Option::is_none")]
    pub state: Option<std::collections::HashMap<String, serde_json::Value>>,
    #[serde(rename = "messages", default, skip_serializing_if = "Option::is_none")]
    pub messages: Option<Option<serde_json::Value>>,
}

impl RunAgentUiRuntimeRequest {
    pub fn new() -> RunAgentUiRuntimeRequest {
        RunAgentUiRuntimeRequest {
            thread_id: None,
            run_id: None,
            workspace_id: None,
            current_surface: None,
            state: None,
            messages: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct RunPublicDemo200Response {
    #[serde(rename = "verdict")]
    pub verdict: RunPublicDemo200ResponseVerdict,
    #[serde(rename = "reason_code")]
    pub reason_code: String,
    #[serde(rename = "receipt")]
    pub receipt: Box<Receipt>,
    #[serde(rename = "proof_refs")]
    pub proof_refs: Box<RunPublicDemo200ResponseProofRefs>,
    #[serde(rename = "verification_hint")]
    pub verification_hint: String,
    #[serde(rename = "sandbox_label")]
    pub sandbox_label: String,
    #[serde(rename = "helm_ai_kernel_version")]
    pub helm_ai_kernel_version: String,
}

impl RunPublicDemo200Response {
    pub fn new(verdict: RunPublicDemo200ResponseVerdict, reason_code: String, receipt: Receipt, proof_refs: RunPublicDemo200ResponseProofRefs, verification_hint: String, sandbox_label: String, helm_ai_kernel_version: String) -> RunPublicDemo200Response {
        RunPublicDemo200Response {
            verdict,
            reason_code,
            receipt: Box::new(receipt),
            proof_refs: Box::new(proof_refs),
            verification_hint,
            sandbox_label,
            helm_ai_kernel_version,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum RunPublicDemo200ResponseVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

impl Default for RunPublicDemo200ResponseVerdict {
    fn default() -> RunPublicDemo200ResponseVerdict {
        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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct RunPublicDemo200ResponseProofRefs {
    #[serde(rename = "decision_id")]
    pub decision_id: String,
    #[serde(rename = "receipt_id")]
    pub receipt_id: String,
    #[serde(rename = "receipt_hash")]
    pub receipt_hash: String,
}

impl RunPublicDemo200ResponseProofRefs {
    pub fn new(decision_id: String, receipt_id: String, receipt_hash: String) -> RunPublicDemo200ResponseProofRefs {
        RunPublicDemo200ResponseProofRefs {
            decision_id,
            receipt_id,
            receipt_hash,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl RunPublicDemoRequest {
    pub fn new(action_id: RunPublicDemoRequestActionId) -> RunPublicDemoRequest {
        RunPublicDemoRequest {
            action_id,
            policy_id: None,
            args: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum RunPublicDemoRequestActionId {
    #[serde(rename = "read_ticket")]
    ReadTicket,
    #[serde(rename = "draft_reply")]
    DraftReply,
    #[serde(rename = "small_refund")]
    SmallRefund,
    #[serde(rename = "large_refund")]
    LargeRefund,
    #[serde(rename = "dangerous_shell")]
    DangerousShell,
    #[serde(rename = "export_customer_list")]
    ExportCustomerList,
    #[serde(rename = "modify_policy")]
    ModifyPolicy,
}

impl Default for RunPublicDemoRequestActionId {
    fn default() -> RunPublicDemoRequestActionId {
        Self::ReadTicket
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SandboxBackendProfile {
    #[serde(rename = "name")]
    pub name: String,
    #[serde(rename = "kind")]
    pub kind: SandboxBackendProfileKind,
    #[serde(rename = "runtime")]
    pub runtime: String,
    #[serde(rename = "hosted")]
    pub hosted: bool,
    #[serde(rename = "deny_network_by_default")]
    pub deny_network_by_default: bool,
    #[serde(rename = "native_isolation")]
    pub native_isolation: bool,
    #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")]
    pub experimental: Option<bool>,
}

impl SandboxBackendProfile {
    pub fn new(name: String, kind: SandboxBackendProfileKind, runtime: String, hosted: bool, deny_network_by_default: bool, native_isolation: bool) -> SandboxBackendProfile {
        SandboxBackendProfile {
            name,
            kind,
            runtime,
            hosted,
            deny_network_by_default,
            native_isolation,
            experimental: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum SandboxBackendProfileKind {
    #[serde(rename = "wasi-wazero")]
    WasiWazero,
    #[serde(rename = "wasi-wasmtime")]
    WasiWasmtime,
    #[serde(rename = "native-nsjail")]
    NativeNsjail,
    #[serde(rename = "native-gvisor")]
    NativeGvisor,
    #[serde(rename = "native-firecracker")]
    NativeFirecracker,
    #[serde(rename = "hosted-adapter")]
    HostedAdapter,
}

impl Default for SandboxBackendProfileKind {
    fn default() -> SandboxBackendProfileKind {
        Self::WasiWazero
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SandboxGrant {
    #[serde(rename = "grant_id")]
    pub grant_id: String,
    #[serde(rename = "runtime")]
    pub runtime: String,
    #[serde(rename = "runtime_version", skip_serializing_if = "Option::is_none")]
    pub runtime_version: Option<String>,
    #[serde(rename = "profile")]
    pub profile: String,
    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
    pub image_digest: Option<String>,
    #[serde(rename = "template_digest", skip_serializing_if = "Option::is_none")]
    pub template_digest: Option<String>,
    #[serde(rename = "filesystem_preopens", skip_serializing_if = "Option::is_none")]
    pub filesystem_preopens: Option<Vec<FilesystemPreopen>>,
    #[serde(rename = "env")]
    pub env: Box<EnvExposurePolicy>,
    #[serde(rename = "network")]
    pub network: Box<NetworkGrant>,
    #[serde(rename = "limits", skip_serializing_if = "Option::is_none")]
    pub limits: Option<Box<SandboxGrantLimits>>,
    #[serde(rename = "declared_at")]
    pub declared_at: String,
    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
    pub policy_epoch: Option<String>,
    #[serde(rename = "grant_hash", skip_serializing_if = "Option::is_none")]
    pub grant_hash: Option<String>,
}

impl SandboxGrant {
    pub fn new(grant_id: String, runtime: String, profile: String, env: EnvExposurePolicy, network: NetworkGrant, declared_at: String) -> SandboxGrant {
        SandboxGrant {
            grant_id,
            runtime,
            runtime_version: None,
            profile,
            image_digest: None,
            template_digest: None,
            filesystem_preopens: None,
            env: Box::new(env),
            network: Box::new(network),
            limits: None,
            declared_at,
            policy_epoch: None,
            grant_hash: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SandboxGrantInspection {
    SandboxBackendProfileList(Vec<SandboxBackendProfile>),
    SandboxGrant(Box<SandboxGrant>),
}

impl Default for SandboxGrantInspection {
    fn default() -> Self {
        Self::SandboxBackendProfileList(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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SandboxGrantLimits {
    #[serde(rename = "memory_bytes", skip_serializing_if = "Option::is_none")]
    pub memory_bytes: Option<i64>,
    /// Go duration in nanoseconds.
    #[serde(rename = "cpu_time", skip_serializing_if = "Option::is_none")]
    pub cpu_time: Option<i64>,
    #[serde(rename = "output_bytes", skip_serializing_if = "Option::is_none")]
    pub output_bytes: Option<i64>,
    #[serde(rename = "open_files", skip_serializing_if = "Option::is_none")]
    pub open_files: Option<i32>,
}

impl SandboxGrantLimits {
    pub fn new() -> SandboxGrantLimits {
        SandboxGrantLimits {
            memory_bytes: None,
            cpu_time: None,
            output_bytes: None,
            open_files: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SandboxPreflightRequest {
    #[serde(rename = "runtime", skip_serializing_if = "Option::is_none")]
    pub runtime: Option<String>,
    #[serde(rename = "profile", skip_serializing_if = "Option::is_none")]
    pub profile: Option<String>,
    #[serde(rename = "image_digest", skip_serializing_if = "Option::is_none")]
    pub image_digest: Option<String>,
    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
    pub policy_epoch: Option<String>,
    #[serde(rename = "requested_grant", skip_serializing_if = "Option::is_none")]
    pub requested_grant: Option<Box<SandboxGrant>>,
    #[serde(rename = "expected_grant_hash", skip_serializing_if = "Option::is_none")]
    pub expected_grant_hash: Option<String>,
}

impl SandboxPreflightRequest {
    pub fn new() -> SandboxPreflightRequest {
        SandboxPreflightRequest {
            runtime: None,
            profile: None,
            image_digest: None,
            policy_epoch: None,
            requested_grant: None,
            expected_grant_hash: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct SandboxPreflightResult {
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<SandboxPreflightResultVerdict>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "grant_id", skip_serializing_if = "Option::is_none")]
    pub grant_id: Option<String>,
    #[serde(rename = "grant_hash", skip_serializing_if = "Option::is_none")]
    pub grant_hash: Option<String>,
    #[serde(rename = "dispatch_ready", skip_serializing_if = "Option::is_none")]
    pub dispatch_ready: Option<bool>,
    #[serde(rename = "findings", skip_serializing_if = "Option::is_none")]
    pub findings: Option<Vec<String>>,
    #[serde(rename = "checked_at", skip_serializing_if = "Option::is_none")]
    pub checked_at: Option<String>,
}

impl SandboxPreflightResult {
    pub fn new() -> SandboxPreflightResult {
        SandboxPreflightResult {
            verdict: None,
            reason_code: None,
            grant_id: None,
            grant_hash: None,
            dispatch_ready: None,
            findings: None,
            checked_at: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum SandboxPreflightResultVerdict {
    #[serde(rename = "ALLOW")]
    Allow,
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ESCALATE")]
    Escalate,
}

impl Default for SandboxPreflightResultVerdict {
    fn default() -> SandboxPreflightResultVerdict {
        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.5.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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TamperPublicDemoReceipt200Response {
    #[serde(rename = "valid")]
    pub valid: bool,
    #[serde(rename = "signature_valid")]
    pub signature_valid: bool,
    #[serde(rename = "hash_matches")]
    pub hash_matches: bool,
    #[serde(rename = "reason")]
    pub reason: String,
    #[serde(rename = "receipt_hash")]
    pub receipt_hash: String,
    #[serde(rename = "expected_receipt_hash")]
    pub expected_receipt_hash: String,
    #[serde(rename = "original_hash")]
    pub original_hash: String,
    #[serde(rename = "tampered_hash")]
    pub tampered_hash: String,
}

impl TamperPublicDemoReceipt200Response {
    pub fn new(valid: bool, signature_valid: bool, hash_matches: bool, reason: String, receipt_hash: String, expected_receipt_hash: String, original_hash: String, tampered_hash: String) -> TamperPublicDemoReceipt200Response {
        TamperPublicDemoReceipt200Response {
            valid,
            signature_valid,
            hash_matches,
            reason,
            receipt_hash,
            expected_receipt_hash,
            original_hash,
            tampered_hash,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TamperPublicDemoReceiptRequest {
    #[serde(rename = "receipt")]
    pub receipt: Box<Receipt>,
    /// Receipt hash returned in /api/demo/run proof_refs.receipt_hash.
    #[serde(rename = "expected_receipt_hash")]
    pub expected_receipt_hash: String,
    #[serde(rename = "mutation", skip_serializing_if = "Option::is_none")]
    pub mutation: Option<String>,
}

impl TamperPublicDemoReceiptRequest {
    pub fn new(receipt: Receipt, expected_receipt_hash: String) -> TamperPublicDemoReceiptRequest {
        TamperPublicDemoReceiptRequest {
            receipt: Box::new(receipt),
            expected_receipt_hash,
            mutation: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TelemetryExportRequest {
    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
    pub format: Option<String>,
    #[serde(rename = "receipt_id", skip_serializing_if = "Option::is_none")]
    pub receipt_id: Option<String>,
    #[serde(rename = "record_hash", skip_serializing_if = "Option::is_none")]
    pub record_hash: Option<String>,
    #[serde(rename = "policy_epoch", skip_serializing_if = "Option::is_none")]
    pub policy_epoch: Option<String>,
    #[serde(rename = "verdict", skip_serializing_if = "Option::is_none")]
    pub verdict: Option<String>,
    #[serde(rename = "reason_code", skip_serializing_if = "Option::is_none")]
    pub reason_code: Option<String>,
    #[serde(rename = "sandbox_grant_hash", skip_serializing_if = "Option::is_none")]
    pub sandbox_grant_hash: Option<String>,
    #[serde(rename = "authz_snapshot_hash", skip_serializing_if = "Option::is_none")]
    pub authz_snapshot_hash: Option<String>,
    #[serde(rename = "attributes", skip_serializing_if = "Option::is_none")]
    pub attributes: Option<std::collections::HashMap<String, String>>,
}

impl TelemetryExportRequest {
    pub fn new() -> TelemetryExportRequest {
        TelemetryExportRequest {
            format: None,
            receipt_id: None,
            record_hash: None,
            policy_epoch: None,
            verdict: None,
            reason_code: None,
            sandbox_grant_hash: None,
            authz_snapshot_hash: None,
            attributes: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TelemetryExportResult {
    #[serde(rename = "export_id", skip_serializing_if = "Option::is_none")]
    pub export_id: Option<String>,
    #[serde(rename = "format", skip_serializing_if = "Option::is_none")]
    pub format: Option<String>,
    #[serde(rename = "authoritative", skip_serializing_if = "Option::is_none")]
    pub authoritative: Option<bool>,
    #[serde(rename = "attributes", skip_serializing_if = "Option::is_none")]
    pub attributes: Option<std::collections::HashMap<String, String>>,
    #[serde(rename = "exported_at", skip_serializing_if = "Option::is_none")]
    pub exported_at: Option<String>,
}

impl TelemetryExportResult {
    pub fn new() -> TelemetryExportResult {
        TelemetryExportResult {
            export_id: None,
            format: None,
            authoritative: None,
            attributes: None,
            exported_at: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct TelemetryOTelConfig {
    #[serde(rename = "service_name", skip_serializing_if = "Option::is_none")]
    pub service_name: Option<String>,
    #[serde(rename = "signal_type", skip_serializing_if = "Option::is_none")]
    pub signal_type: Option<String>,
    #[serde(rename = "authoritative", skip_serializing_if = "Option::is_none")]
    pub authoritative: Option<bool>,
    #[serde(rename = "span_attributes", skip_serializing_if = "Option::is_none")]
    pub span_attributes: Option<std::collections::HashMap<String, String>>,
    #[serde(rename = "exported_signals", skip_serializing_if = "Option::is_none")]
    pub exported_signals: Option<Vec<String>>,
}

impl TelemetryOTelConfig {
    pub fn new() -> TelemetryOTelConfig {
        TelemetryOTelConfig {
            service_name: None,
            signal_type: None,
            authoritative: None,
            span_attributes: None,
            exported_signals: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl TransitionApprovalCeremonyRequest {
    pub fn new() -> TransitionApprovalCeremonyRequest {
        TransitionApprovalCeremonyRequest {
            actor: None,
            receipt_id: None,
            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.5.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<VerificationResultVerdict>,
    #[serde(rename = "checks", skip_serializing_if = "Option::is_none")]
    pub checks: Option<Box<VerificationResultChecks>>,
    #[serde(rename = "roots", skip_serializing_if = "Option::is_none")]
    pub roots: Option<Box<VerificationResultRoots>>,
    #[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,
            roots: None,
            errors: None,
        }
    }
}
///
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum VerificationResultVerdict {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

impl Default for VerificationResultVerdict {
    fn default() -> VerificationResultVerdict {
        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.5.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<VerificationResultChecksSignatures>,
    #[serde(rename = "causal_chain", skip_serializing_if = "Option::is_none")]
    pub causal_chain: Option<VerificationResultChecksCausalChain>,
    #[serde(rename = "policy_compliance", skip_serializing_if = "Option::is_none")]
    pub policy_compliance: Option<VerificationResultChecksPolicyCompliance>,
}

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 VerificationResultChecksSignatures {
    #[serde(rename = "PASS")]
    Pass,
    #[serde(rename = "FAIL")]
    Fail,
}

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

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

impl Default for VerificationResultChecksPolicyCompliance {
    fn default() -> VerificationResultChecksPolicyCompliance {
        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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


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

impl VerificationResultRoots {
    pub fn new() -> VerificationResultRoots {
        VerificationResultRoots {
            manifest_root_hash: None,
            merkle_root: None,
            entry_count: 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerifyPublicDemoReceipt200Response {
    #[serde(rename = "valid")]
    pub valid: bool,
    #[serde(rename = "signature_valid")]
    pub signature_valid: bool,
    #[serde(rename = "hash_matches")]
    pub hash_matches: bool,
    #[serde(rename = "reason")]
    pub reason: String,
    #[serde(rename = "verified_fields")]
    pub verified_fields: Vec<String>,
    #[serde(rename = "receipt_hash")]
    pub receipt_hash: String,
    #[serde(rename = "expected_receipt_hash")]
    pub expected_receipt_hash: String,
}

impl VerifyPublicDemoReceipt200Response {
    pub fn new(valid: bool, signature_valid: bool, hash_matches: bool, reason: String, verified_fields: Vec<String>, receipt_hash: String, expected_receipt_hash: String) -> VerifyPublicDemoReceipt200Response {
        VerifyPublicDemoReceipt200Response {
            valid,
            signature_valid,
            hash_matches,
            reason,
            verified_fields,
            receipt_hash,
            expected_receipt_hash,
        }
    }
}

/*
 * 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.5.1
 *
 * Generated by: https://openapi-generator.tech
 */


#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerifyPublicDemoReceiptRequest {
    #[serde(rename = "receipt")]
    pub receipt: Box<Receipt>,
    /// Receipt hash returned in /api/demo/run proof_refs.receipt_hash.
    #[serde(rename = "expected_receipt_hash")]
    pub expected_receipt_hash: String,
}

impl VerifyPublicDemoReceiptRequest {
    pub fn new(receipt: Receipt, expected_receipt_hash: String) -> VerifyPublicDemoReceiptRequest {
        VerifyPublicDemoReceiptRequest {
            receipt: Box::new(receipt),
            expected_receipt_hash,
        }
    }
}

/*
 * 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.5.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,
        }
    }
}


pub type ReasonCode = HelmErrorErrorReasonCode;